projectz

  • Version 4.2.0
  • Published
  • 193 kB
  • 14 dependencies
  • Artistic-2.0 license

Install

npm i projectz
yarn add projectz
pnpm add projectz

Overview

Stop wasting time syncing and updating your project's README and Package Files!

Index

Classes

class Projectz

class Projectz {}
  • Projectz, use to merge data files and render meta files.

constructor

constructor(opts?: Partial<Pick<Projectz, 'cwd' | 'offline' | 'log'>>);
  • Configure our instance.

property cwd

readonly cwd: string;
  • The directory to process, defaults to the current working directory

property dataForPackageFiles

protected readonly dataForPackageFiles: DataForPackageFiles;
  • Resolved data for the package files

property dataForReadmeFiles

protected readonly dataForReadmeFiles: DataForReadmeFiles;
  • Resolved data for the readme files

property filenamesForPackageFiles

protected readonly filenamesForPackageFiles: FilenamesForPackageFiles;
  • Resolved absolute paths for the package files. Should be arranged in the order of merging preference.

property filenamesForReadmeFiles

protected readonly filenamesForReadmeFiles: FilenamesForReadmeFiles;
  • Resolved absolute paths for the readme files

property log

readonly log: Function;
  • The log function to use, first argument being the log level

property offline

readonly offline: boolean;
  • If enabled, then remote updates will be not performed (such as fetching latest backers).

method compile

compile: () => Promise<void>;
  • Use the configuration to compile the project.

method enhanceDataForPackageFiles

protected enhanceDataForPackageFiles: () => Promise<EnhancedPackageData>;
  • Merge and enhance the data for the package files.

method enhanceDataForReadmeFiles

protected enhanceDataForReadmeFiles: (
data: EnhancedPackageData
) => Promise<DataForReadmeFiles>;
  • Merge and enhance the metadata from the meta files.

method loadPaths

protected loadPaths: () => Promise<void>;
  • Resolve the paths and metdata for the data and meta files.

method save

protected save: (
enhancedPackageData: EnhancedPackageData,
enhancedReadmeData: EnhancedReadmeData
) => Promise<void>;
  • Save the data and meta files with our enhancements.

Interfaces

interface BackerOptions

interface BackerOptions {}

    property author

    author: Fellow[];

      property authors

      authors: Fellow[];

        property badges

        badges: BadgesField;

          property contributors

          contributors: Fellow[];

            property donors

            donors: Fellow[];

              property filenamesForReadmeFiles

              filenamesForReadmeFiles: FilenamesForReadmeFiles;

                property funders

                funders: Fellow[];

                  property github

                  github: Github;

                    property maintainers

                    maintainers: Fellow[];

                      property sponsors

                      sponsors: Fellow[];

                        interface BowerEnhanced

                        interface BowerEnhanced {}

                          property authors

                          authors?: string[];

                            property description

                            description?: string;

                              property keywords

                              keywords?: string[];

                                property license

                                license?: string;

                                  property main

                                  main?: string;

                                    property name

                                    name?: string;

                                      property version

                                      version?: string;

                                        interface ComponentEnhanced

                                        interface ComponentEnhanced {}

                                          property demo

                                          demo?: string;

                                            property description

                                            description?: string;

                                              property keywords

                                              keywords?: string[];

                                                property license

                                                license?: string;

                                                  property main

                                                  main?: string;

                                                    property name

                                                    name?: string;

                                                      property scripts

                                                      scripts?: string;

                                                        property version

                                                        version?: string;

                                                          interface DataForPackageFiles

                                                          interface DataForPackageFiles {}

                                                            index signature

                                                            [key: string]: Record<string, any>;

                                                              interface DataForReadmeFiles

                                                              interface DataForReadmeFiles {}

                                                                index signature

                                                                [key: string]: string;

                                                                  interface EnhancedPackageData

                                                                  interface EnhancedPackageData {}

                                                                    property author

                                                                    author: Fellow[];

                                                                      property authors

                                                                      authors: Fellow[];

                                                                        property badges

                                                                        badges: BadgesField;

                                                                          property bower

                                                                          bower: BowerEnhanced;

                                                                            property browser

                                                                            browser?: any;

                                                                              property browsers

                                                                              browsers: boolean;

                                                                                property component

                                                                                component: ComponentEnhanced;

                                                                                  property contributor

                                                                                  contributor?: never;

                                                                                    property contributors

                                                                                    contributors: Fellow[];

                                                                                      property dependencies

                                                                                      dependencies: Record<string, string>;

                                                                                        property description

                                                                                        description: string;

                                                                                          property devDependencies

                                                                                          devDependencies: Record<string, string>;

                                                                                            property donor

                                                                                            donor?: never;

                                                                                              property donors

                                                                                              donors: Fellow[];

                                                                                                property editions

                                                                                                editions: Edition[];

                                                                                                  property filenamesForPackageFiles

                                                                                                  filenamesForPackageFiles: FilenamesForPackageFiles;

                                                                                                    property filenamesForReadmeFiles

                                                                                                    filenamesForReadmeFiles: FilenamesForReadmeFiles;

                                                                                                      property funder

                                                                                                      funder?: never;

                                                                                                        property funders

                                                                                                        funders: Fellow[];

                                                                                                          property github

                                                                                                          github?: Github;

                                                                                                            property homepage

                                                                                                            homepage?: string;

                                                                                                              property jquery

                                                                                                              jquery: Record<string, any>;

                                                                                                                property jspm

                                                                                                                jspm?: any;

                                                                                                                  property keywords

                                                                                                                  keywords: string[];

                                                                                                                    property license

                                                                                                                    license?: string;

                                                                                                                      property licenses

                                                                                                                      licenses?: never;

                                                                                                                        property maintainer

                                                                                                                        maintainer?: never;

                                                                                                                          property maintainers

                                                                                                                          maintainers: Fellow[];

                                                                                                                            property name

                                                                                                                            name: string;

                                                                                                                              property package

                                                                                                                              package: PackageEnhanced;

                                                                                                                                property packages

                                                                                                                                packages: Record<string, any>;

                                                                                                                                  property projectz

                                                                                                                                  projectz: Record<string, any>;

                                                                                                                                    property repository

                                                                                                                                    repository?: {
                                                                                                                                    url: string;
                                                                                                                                    };

                                                                                                                                      property sponsor

                                                                                                                                      sponsor?: never;

                                                                                                                                        property sponsors

                                                                                                                                        sponsors: Fellow[];

                                                                                                                                          property title

                                                                                                                                          title: string;

                                                                                                                                            property version

                                                                                                                                            version: string;

                                                                                                                                              index signature

                                                                                                                                              [key: string]: any;

                                                                                                                                                interface EnhancedPackageDataWithGitHub

                                                                                                                                                interface EnhancedPackageDataWithGitHub extends EnhancedPackageData {}

                                                                                                                                                  property github

                                                                                                                                                  github: Github;

                                                                                                                                                    interface FilenamesForPackageFiles

                                                                                                                                                    interface FilenamesForPackageFiles {}

                                                                                                                                                      property bower

                                                                                                                                                      bower: string | null;

                                                                                                                                                        property component

                                                                                                                                                        component: string | null;

                                                                                                                                                          property jquery

                                                                                                                                                          jquery: string | null;

                                                                                                                                                            property package

                                                                                                                                                            package: string | null;

                                                                                                                                                              property projectz

                                                                                                                                                              projectz: string | null;

                                                                                                                                                                index signature

                                                                                                                                                                [key: string]: string | null;

                                                                                                                                                                  interface FilenamesForReadmeFiles

                                                                                                                                                                  interface FilenamesForReadmeFiles {}

                                                                                                                                                                    property backers

                                                                                                                                                                    backers: string | null;

                                                                                                                                                                      property contributing

                                                                                                                                                                      contributing: string | null;

                                                                                                                                                                        property history

                                                                                                                                                                        history: string | null;

                                                                                                                                                                          property license

                                                                                                                                                                          license: string | null;

                                                                                                                                                                            property readme

                                                                                                                                                                            readme: string | null;

                                                                                                                                                                              index signature

                                                                                                                                                                              [key: string]: string | null;

                                                                                                                                                                                interface Github

                                                                                                                                                                                interface Github {}

                                                                                                                                                                                  property repository

                                                                                                                                                                                  repository: string;

                                                                                                                                                                                    property repositoryUrl

                                                                                                                                                                                    repositoryUrl: string;

                                                                                                                                                                                      property slug

                                                                                                                                                                                      slug: string;

                                                                                                                                                                                        property url

                                                                                                                                                                                        url: string;

                                                                                                                                                                                          property username

                                                                                                                                                                                          username: string;

                                                                                                                                                                                            interface LicenseConfig

                                                                                                                                                                                            interface LicenseConfig extends LicenseOptions {}

                                                                                                                                                                                              property license

                                                                                                                                                                                              license: string;

                                                                                                                                                                                                interface LicenseOptions

                                                                                                                                                                                                interface LicenseOptions {}

                                                                                                                                                                                                  property authors

                                                                                                                                                                                                  authors: Fellow[];

                                                                                                                                                                                                    property license

                                                                                                                                                                                                    license?: string;

                                                                                                                                                                                                      interface PackageEnhanced

                                                                                                                                                                                                      interface PackageEnhanced {}

                                                                                                                                                                                                        property author

                                                                                                                                                                                                        author?: string;

                                                                                                                                                                                                          property bugs

                                                                                                                                                                                                          bugs?: {
                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            property contributors

                                                                                                                                                                                                            contributors?: string[];

                                                                                                                                                                                                              property dependencies

                                                                                                                                                                                                              dependencies?: Record<string, string>;

                                                                                                                                                                                                                property description

                                                                                                                                                                                                                description?: string;

                                                                                                                                                                                                                  property devDependencies

                                                                                                                                                                                                                  devDependencies?: Record<string, string>;

                                                                                                                                                                                                                    property engines

                                                                                                                                                                                                                    engines?: Record<string, string>;

                                                                                                                                                                                                                      property keywords

                                                                                                                                                                                                                      keywords?: string[];

                                                                                                                                                                                                                        property license

                                                                                                                                                                                                                        license?: string;

                                                                                                                                                                                                                          property main

                                                                                                                                                                                                                          main?: string;

                                                                                                                                                                                                                            property maintainers

                                                                                                                                                                                                                            maintainers?: string[];

                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                              name?: string;

                                                                                                                                                                                                                                property repository

                                                                                                                                                                                                                                repository?: {
                                                                                                                                                                                                                                type: string;
                                                                                                                                                                                                                                url: string;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  property version

                                                                                                                                                                                                                                  version?: string;

                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                    type Editions

                                                                                                                                                                                                                                    type Editions = Edition[];

                                                                                                                                                                                                                                      type EnhancedReadmeData

                                                                                                                                                                                                                                      type EnhancedReadmeData = DataForReadmeFiles;

                                                                                                                                                                                                                                        Package Files (2)

                                                                                                                                                                                                                                        Dependencies (14)

                                                                                                                                                                                                                                        Dev Dependencies (15)

                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/projectz.

                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/projectz)
                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/projectz"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>