@vidavidorra/create-project 1.0.0

package/README.md

@@ -0,0 +1,76 @@
+# Create project <!-- omit in toc -->
+
+Interactively create a project.
+
+- Standardised project and repository setup.
+- Add TypeScript, a testing framework and code coverage as desired.
+
+---
+
+[![npm version](https://img.shields.io/npm/v/@vidavidorra/create-project?logo=npm&style=flat-square)](https://www.npmjs.com/package/@vidavidorra/create-project)
+[![npm downloads](https://img.shields.io/npm/dm/@vidavidorra/create-project?logo=npm&style=flat-square)](https://www.npmjs.com/package/@vidavidorra/create-project)
+[![Node.js version support](https://img.shields.io/node/v/@vidavidorracreate-project?logo=node.js&style=flat-square)](https://nodejs.org/en/about/releases/)
+[![Renovate enabled](https://img.shields.io/badge/Renovate-enabled-brightgreen?logo=renovatebot&logoColor&style=flat-square)](https://renovatebot.com)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079?style=flat-square)](https://github.com/semantic-release/semantic-release)
+[![Code coverage](https://img.shields.io/codecov/c/github/vidavidorra/create-project?logo=codecov&style=flat-square)](https://codecov.io/gh/vidavidorra/create-project)
+[![License](https://img.shields.io/github/license/vidavidorra/create-project?style=flat-square)](LICENSE.md)
+
+- [Install](#install)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [Security policy](#security-policy)
+- [License](#license)
+
+## Install
+
+```shell
+npm install --global @vidavidorra/create-project
+```
+
+## Usage
+
+Start the interactive CLI to create a project.
+
+```shell
+@vidavidorra/create-project
+```
+
+## Contributing
+
+Please [create an issue](https://github.com/vidavidorra/create-project/issues/new/choose) if you have a bug report or feature proposal, or [create a discussion](https://github.com/vidavidorra/create-project/discussions) if you have a question. If you like this project, please consider giving it a star ⭐
+
+Refer to the [contributing guide](https://github.com/vidavidorra/.github/blob/main/CONTRIBUTING.md) detailed information about other contributions, like pull requests.
+
+[![Conventional Commits: 1.0.0](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow?style=flat-square)](https://conventionalcommits.org)
+[![XO code style](https://shields.io/badge/code_style-5ed9c7?logo=xo&labelColor=gray&style=flat-square)](https://github.com/xojs/xo)
+[![Code style](https://img.shields.io/badge/code_style-Prettier-ff69b4?logo=prettier&style=flat-square)](https://github.com/prettier/prettier)
+
+## Security policy
+
+Please refer to the [Security Policy on GitHub](https://github.com/vidavidorra/create-project/security/) for the security policy.
+
+## License
+
+This project is licensed under the [GPLv3 license](https://www.gnu.org/licenses/gpl.html).
+
+Copyright © 2023 Jeroen de Bruijn
+
+<details><summary>License notice</summary>
+<p>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+The full text of the license is available in the [LICENSE](LICENSE.md) file in this repository and [online](https://www.gnu.org/licenses/gpl.html).
+
+</details>

package/dist/content/ci-cd.d.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+import { type Options } from '../options.js';
+import { File } from './file.js';
+declare const schema: z.ZodObject<{
+    name: z.ZodLiteral<"CI/CD">;
+    on: z.ZodObject<{
+        push: z.ZodObject<{
+            branches: z.ZodTuple<[z.ZodLiteral<"main">, z.ZodLiteral<"beta">, z.ZodLiteral<"renovate/**">], null>;
+        }, "strip", z.ZodTypeAny, {
+            branches: ["main", "beta", "renovate/**"];
+        }, {
+            branches: ["main", "beta", "renovate/**"];
+        }>;
+        pull_request: z.ZodNull;
+    }, "strip", z.ZodTypeAny, {
+        push: {
+            branches: ["main", "beta", "renovate/**"];
+        };
+        pull_request: null;
+    }, {
+        push: {
+            branches: ["main", "beta", "renovate/**"];
+        };
+        pull_request: null;
+    }>;
+    jobs: z.ZodObject<{
+        'lint-commit-messages': z.ZodObject<{
+            uses: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uses: string;
+        }, {
+            uses: string;
+        }>;
+        lint: z.ZodObject<{
+            uses: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uses: string;
+        }, {
+            uses: string;
+        }>;
+        build: z.ZodObject<{
+            uses: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uses: string;
+        }, {
+            uses: string;
+        }>;
+        test: z.ZodObject<{
+            uses: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uses: string;
+        }, {
+            uses: string;
+        }>;
+        'code-coverage': z.ZodObject<{
+            uses: z.ZodString;
+            needs: z.ZodTuple<[z.ZodLiteral<"lint">, z.ZodLiteral<"build">, z.ZodLiteral<"test">], null>;
+            secrets: z.ZodObject<{
+                codecovToken: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                codecovToken: string;
+            }, {
+                codecovToken: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            uses: string;
+            needs: ["lint", "build", "test"];
+            secrets: {
+                codecovToken: string;
+            };
+        }, {
+            uses: string;
+            needs: ["lint", "build", "test"];
+            secrets: {
+                codecovToken: string;
+            };
+        }>;
+        release: z.ZodObject<{
+            uses: z.ZodString;
+            needs: z.ZodArray<z.ZodUnion<[z.ZodLiteral<"lint-commit-messages">, z.ZodLiteral<"lint">, z.ZodLiteral<"build">, z.ZodLiteral<"test">, z.ZodLiteral<"code-coverage">]>, "many">;
+            secrets: z.ZodObject<{
+                privateKey: z.ZodString;
+                npmToken: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                privateKey: string;
+                npmToken: string;
+            }, {
+                privateKey: string;
+                npmToken: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            uses: string;
+            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
+            secrets: {
+                privateKey: string;
+                npmToken: string;
+            };
+        }, {
+            uses: string;
+            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
+            secrets: {
+                privateKey: string;
+                npmToken: string;
+            };
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        'lint-commit-messages': {
+            uses: string;
+        };
+        lint: {
+            uses: string;
+        };
+        build: {
+            uses: string;
+        };
+        test: {
+            uses: string;
+        };
+        'code-coverage': {
+            uses: string;
+            needs: ["lint", "build", "test"];
+            secrets: {
+                codecovToken: string;
+            };
+        };
+        release: {
+            uses: string;
+            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
+            secrets: {
+                privateKey: string;
+                npmToken: string;
+            };
+        };
+    }, {
+        'lint-commit-messages': {
+            uses: string;
+        };
+        lint: {
+            uses: string;
+        };
+        build: {
+            uses: string;
+        };
+        test: {
+            uses: string;
+        };
+        'code-coverage': {
+            uses: string;
+            needs: ["lint", "build", "test"];
+            secrets: {
+                codecovToken: string;
+            };
+        };
+        release: {
+            uses: string;
+            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
+            secrets: {
+                privateKey: string;
+                npmToken: string;
+            };
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    name: "CI/CD";
+    on: {
+        push: {
+            branches: ["main", "beta", "renovate/**"];
+        };
+        pull_request: null;
+    };
+    jobs: {
+        'lint-commit-messages': {
+            uses: string;
+        };
+        lint: {
+            uses: string;
+        };
+        build: {
+            uses: string;
+        };
+        test: {
+            uses: string;
+        };
+        'code-coverage': {
+            uses: string;
+            needs: ["lint", "build", "test"];
+            secrets: {
+                codecovToken: string;
+            };
+        };
+        release: {
+            uses: string;
+            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
+            secrets: {
+                privateKey: string;
+                npmToken: string;
+            };
+        };
+    };
+}, {
+    name: "CI/CD";
+    on: {
+        push: {
+            branches: ["main", "beta", "renovate/**"];
+        };
+        pull_request: null;
+    };
+    jobs: {
+        'lint-commit-messages': {
+            uses: string;
+        };
+        lint: {
+            uses: string;
+        };
+        build: {
+            uses: string;
+        };
+        test: {
+            uses: string;
+        };
+        'code-coverage': {
+            uses: string;
+            needs: ["lint", "build", "test"];
+            secrets: {
+                codecovToken: string;
+            };
+        };
+        release: {
+            uses: string;
+            needs: ("lint-commit-messages" | "lint" | "build" | "test" | "code-coverage")[];
+            secrets: {
+                privateKey: string;
+                npmToken: string;
+            };
+        };
+    };
+}>;
+type Yaml = z.infer<typeof schema>;
+declare class CiCd extends File {
+    protected readonly _yaml: Yaml;
+    constructor(path: string, options: Options);
+    process(): this;
+    protected get sha(): string;
+    protected get version(): string;
+}
+export { CiCd };

package/dist/content/ci-cd.js

@@ -0,0 +1,112 @@
+import { parse, stringify } from 'yaml';
+import { z } from 'zod';
+import { File } from './file.js';
+const job = (action) => z.object({
+    uses: z
+        .string()
+        .startsWith(`vidavidorra/.github/.github/workflows/${action}@`)
+        .regex(/.*?@[\da-f]{6,64}$/),
+});
+const schema = z
+    .object({
+    name: z.literal('CI/CD'),
+    on: z.object({
+        push: z.object({
+            branches: z.tuple([
+                z.literal('main'),
+                z.literal('beta'),
+                z.literal('renovate/**'),
+            ]),
+        }),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        pull_request: z.null(),
+    }),
+    jobs: z
+        .object({
+        'lint-commit-messages': job('lint-commit-messages.yml'),
+        lint: job('node-lint.yml'),
+        build: job('node-build.yml'),
+        test: job('node-test.yml'),
+        'code-coverage': job('node-test-coverage.yml').extend({
+            needs: z.tuple([
+                z.literal('lint'),
+                z.literal('build'),
+                z.literal('test'),
+            ]),
+            secrets: z.object({ codecovToken: z.string() }),
+        }),
+        release: job('release.yml').extend({
+            needs: z
+                .array(z.union([
+                z.literal('lint-commit-messages'),
+                z.literal('lint'),
+                z.literal('build'),
+                z.literal('test'),
+                z.literal('code-coverage'),
+            ]))
+                .length(5),
+            secrets: z.object({
+                privateKey: z.string(),
+                npmToken: z.string(),
+            }),
+        }),
+    })
+        .strict(),
+})
+    .strict();
+class CiCd extends File {
+    _yaml;
+    constructor(path, options) {
+        super(path, { ...options, format: true });
+        this._yaml = schema.parse(parse(this._content));
+    }
+    process() {
+        const data = schema.deepPartial().parse(this._yaml);
+        const removeFromRelease = [];
+        if (!this._options.typescript) {
+            delete data.jobs?.build;
+            removeFromRelease.push('build');
+        }
+        if (!this._options.typescript || !this._options.testing) {
+            delete data.jobs?.test;
+            removeFromRelease.push('test');
+        }
+        if (!this._options.typescript ||
+            !this._options.testing ||
+            !this._options.reportCodeCoverage) {
+            delete data.jobs?.['code-coverage'];
+            removeFromRelease.push('code-coverage');
+        }
+        if (data.jobs?.release?.needs !== undefined) {
+            data.jobs.release.needs = data.jobs.release.needs.filter((action) => !removeFromRelease.includes(action));
+        }
+        if (!this._options.public) {
+            delete data.jobs?.release?.secrets?.npmToken;
+        }
+        const { sha, version } = this;
+        this._content = stringify(data).replaceAll(sha, `${sha}${version}`);
+        return this;
+    }
+    get sha() {
+        const sha = this._yaml.jobs.lint.uses.split('@').at(1);
+        if (sha === undefined) {
+            throw new Error('SHA is required in YAML');
+        }
+        return sha;
+    }
+    get version() {
+        const job = 'lint';
+        const value = this._yaml.jobs[job].uses;
+        const line = this._content.split('\n').find((line) => line.includes(value));
+        if (line === undefined) {
+            throw new Error(`"${job}" job not found in content`);
+        }
+        const version = line.replace(new RegExp(`^.*${value}`), '');
+        if (!/ +# v\d+\.\d+\.\d+$/.test(version)) {
+            throw new Error(`Version is not in a valid format (version: "${version}")`);
+        }
+        return version;
+    }
+}
+export { CiCd };
+//# sourceMappingURL=ci-cd.js.map

package/dist/content/file.d.ts

@@ -0,0 +1,36 @@
+import { type Options } from '../options.js';
+type FileOptions = {
+    mode: number;
+    format: boolean;
+};
+declare class File {
+    readonly path: string;
+    protected _content: string;
+    protected readonly _options: Options & FileOptions;
+    private readonly _directory;
+    constructor(path: string, options: Options & Partial<FileOptions>);
+    get options(): {
+        project: string;
+        package: string;
+        path: string;
+        public: boolean;
+        description: string;
+        author: string;
+        typescript: boolean;
+        testing: boolean;
+        reportCodeCoverage: boolean;
+        githubOwner: string;
+        githubRepository: string;
+        dryRun: boolean;
+    } & FileOptions;
+    get content(): string;
+    write(): Promise<void>;
+    /**
+     * Process file contents.
+     *
+     * @note This function is called automatically from `write`.
+     */
+    process(): this;
+    private format;
+}
+export { File };

package/dist/content/file.js

@@ -0,0 +1,52 @@
+import { join, dirname } from 'node:path';
+import fs from 'node:fs';
+import prettier from 'prettier';
+import rootPath from '../root-path.js';
+class File {
+    path;
+    _content;
+    _options;
+    _directory;
+    constructor(path, options) {
+        this.path = path;
+        this._directory = dirname(path);
+        this._options = { mode: 0o644, format: false, ...options };
+        this._content = fs.readFileSync(join(rootPath, path), 'utf8');
+    }
+    get options() {
+        return structuredClone(this._options);
+    }
+    get content() {
+        return this._content;
+    }
+    async write() {
+        this.process();
+        const path = join(this.options.path, this.path);
+        if (!this._options.dryRun) {
+            const directory = join(this.options.path, this._directory);
+            if (!fs.existsSync(directory)) {
+                await fs.promises.mkdir(directory, { recursive: true });
+            }
+            await fs.promises.writeFile(path, await this.format(), {
+                mode: this._options.mode,
+            });
+        }
+    }
+    /**
+     * Process file contents.
+     *
+     * @note This function is called automatically from `write`.
+     */
+    process() {
+        return this;
+    }
+    async format() {
+        if (this._options.format) {
+            const config = await prettier.resolveConfig(join(rootPath, 'package.json'));
+            return prettier.format(this._content, { ...config, filepath: this.path });
+        }
+        return this._content;
+    }
+}
+export { File };
+//# sourceMappingURL=file.js.map

package/dist/content/files.d.ts

@@ -0,0 +1,4 @@
+import { type Options } from '../options.js';
+import { File } from './file.js';
+declare function files(options: Options): File[];
+export { files };

package/dist/content/files.js

@@ -0,0 +1,23 @@
+import { CiCd } from './ci-cd.js';
+import { File } from './file.js';
+import { LintStaged } from './lint-staged.js';
+import { Package } from './package.js';
+import { Readme } from './readme/index.js';
+function files(options) {
+    return [
+        new File('.github/husky/commit-msg', { ...options, mode: 0o755 }),
+        new File('.github/husky/pre-commit', { ...options, mode: 0o755 }),
+        new CiCd('.github/workflows/ci-cd.yml', options),
+        new LintStaged('.github/lint-staged.js', options),
+        new File('.github/renovate.json', options),
+        new File('.editorconfig', options),
+        new File('.gitignore', options),
+        new File('.npmrc', options),
+        new File('LICENSE.md', options),
+        new Package('package.json', options),
+        new Readme('README.md', options),
+        new File('tsconfig.json', options),
+    ];
+}
+export { files };
+//# sourceMappingURL=files.js.map

package/dist/content/index.d.ts

@@ -0,0 +1 @@
+export { files } from './files.js';

package/dist/content/index.js

@@ -0,0 +1,2 @@
+export { files } from './files.js';
+//# sourceMappingURL=index.js.map

package/dist/content/lint-staged.d.ts

@@ -0,0 +1,12 @@
+import { type Options } from '../options.js';
+import { File } from './file.js';
+declare class LintStaged extends File {
+    constructor(path: string, options: Options);
+    process(): this;
+    private xo;
+    private ava;
+    private prettier;
+    private config;
+    private sourceFile;
+}
+export { LintStaged };

package/dist/content/lint-staged.js

@@ -0,0 +1,40 @@
+import ts from 'typescript';
+import { File } from './file.js';
+class LintStaged extends File {
+    constructor(path, options) {
+        super(path, { ...options, format: true });
+    }
+    process() {
+        this._content = ts.createPrinter().printFile(this.sourceFile());
+        return this;
+    }
+    xo() {
+        return ts.factory.createStringLiteral('xo --fix');
+    }
+    ava() {
+        return ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, ts.factory.createStringLiteral('ava'));
+    }
+    prettier() {
+        return ts.factory.createStringLiteral('prettier --write');
+    }
+    config() {
+        return ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('*.{ts,tsx,js,jsx}'), ts.factory.createArrayLiteralExpression([
+                this.xo(),
+                ...(this._options.testing ? [this.ava()] : []),
+            ])),
+            ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('*.{vue,css,less,scss,html,htm,json,md,markdown,yml,yaml}'), this.prettier()),
+        ]);
+    }
+    sourceFile() {
+        const statements = [
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('config'), undefined, undefined, this.config()),
+            ], ts.NodeFlags.Const)),
+            ts.factory.createExportAssignment(undefined, undefined, ts.factory.createIdentifier('config')),
+        ];
+        return ts.factory.createSourceFile(statements, ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+    }
+}
+export { LintStaged };
+//# sourceMappingURL=lint-staged.js.map