@leyman/nx-plugin 0.0.0-stage → 0.1.0

package/dist/generators/package.js

@@ -0,0 +1,208 @@
+import Path from 'node:path';
+import { getProjects, installPackagesTask, joinPathFragments, normalizePath, readJson, readNxJson, writeJson } from '@nx/devkit';
+import { inferencePaths, inferTargets } from '../lib/infer.js';
+import { resolveOptions } from '../lib/options.js';
+import { name as pluginName } from '../lib/plugin.js';
+import { assertOptions, defaultFloor } from '../lib/schema.js';
+import { readWorkspaceVersions, resolveVersion } from '../lib/versions.js';
+const readPluginOptions = (tree, config)=>{
+    if (config !== undefined) {
+        const options = readJson(tree, config);
+        assertOptions(options, config);
+        return options;
+    }
+    const plugin = readNxJson(tree)?.plugins?.find((entry)=>(typeof entry === 'string' ? entry : entry.plugin) === pluginName);
+    const options = typeof plugin === 'object' ? plugin.options ?? {} : {};
+    assertOptions(options, 'nx.json');
+    return options;
+};
+const projectSchema = (tree, directory)=>{
+    let schema;
+    for (const { root } of getProjects(tree).values()){
+        const path = joinPathFragments(root, 'project.json');
+        const $schema = tree.exists(path) ? readJson(tree, path).$schema : undefined;
+        if ($schema !== undefined && !/^[a-z]+:/v.test($schema)) {
+            schema = joinPathFragments(root, $schema);
+            break;
+        }
+    }
+    if (schema === undefined && tree.exists('node_modules/nx/package.json')) {
+        schema = 'node_modules/nx/schemas/project-schema.json';
+    }
+    return schema === undefined ? undefined : Path.posix.relative(directory, schema);
+};
+const repositoryFields = (url, directory)=>{
+    const base = url.replace(/^git\+/v, '').replace(/\.git$/v, '');
+    return {
+        repository: {
+            type: 'git',
+            url: `git+${base}.git`,
+            directory
+        },
+        homepage: `${base}/tree/main/${directory}#readme`,
+        bugs: {
+            url: `${base}/issues`
+        }
+    };
+};
+const sourceFile = (name)=>`/**
+ * A placeholder export, for the first test to import until the package has an API.
+ */
+export const packageName = '${name}';
+`;
+const mochaSpec = (name)=>`import { expect } from '@leyman/expect';
+import { suite, test } from 'mocha-chain';
+import { packageName } from '${name}';
+
+suite('${name}', () => {
+    test('Exports its name', () => {
+        expect(packageName).to.equal('${name}');
+    });
+});
+`;
+const vitestSpec = (name)=>`import { expect, suite, test } from 'vitest';
+import { packageName } from '${name}';
+
+suite('${name}', () => {
+    test('Exports its name', () => {
+        expect(packageName).toBe('${name}');
+    });
+});
+`;
+const eslintConfig = `import configGenerator from '@leyman/eslint-config';
+import packageJson from './package.json' with { type: 'json' };
+
+export default configGenerator({ configUrl: import.meta.url, node: true, packageJson });
+`;
+const testDependencies = {
+    mocha: [
+        '@leyman/expect',
+        '@types/mocha',
+        'c8',
+        'mocha',
+        'mocha-chain'
+    ],
+    vitest: [
+        'c8',
+        'vitest'
+    ],
+    none: []
+};
+const packageGenerator = async (tree, options)=>{
+    const normalized = Path.posix.normalize(normalizePath(options.directory));
+    const directory = normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
+    if ([
+        'package.json',
+        'project.json'
+    ].some((file)=>tree.exists(joinPathFragments(directory, file)))) {
+        throw new Error(`${directory} already holds a project`);
+    }
+    const name = options.name ?? Path.posix.basename(directory);
+    const { published = false, floor = defaultFloor, test = 'mocha' } = options;
+    const resolved = resolveOptions(readPluginOptions(tree, options.config));
+    const versions = await readWorkspaceVersions(tree);
+    const devDependencies = [
+        ...new Set([
+            '@biomejs/biome',
+            '@leyman/configs',
+            '@leyman/eslint-config',
+            '@swc/cli',
+            '@swc/core',
+            '@types/node',
+            'eslint',
+            "typescript",
+            ...testDependencies[test],
+            ...options.devDependencies ?? []
+        ])
+    ].toSorted((a, b)=>a.localeCompare(b));
+    const floorCatalog = `node-${floor}`;
+    const floorTypes = versions.catalogs[floorCatalog]?.['@types/node'] === undefined ? `^${floor}.0.0` : `catalog:${floorCatalog}`;
+    const packageJson = {
+        name,
+        version: '0.0.1',
+        description: options.description,
+        ...published ? {
+            engines: {
+                node: `>=${floor}`
+            }
+        } : {
+            private: true
+        },
+        type: 'module',
+        ...options.author !== undefined && {
+            author: options.author
+        },
+        ...options.license !== undefined && {
+            license: options.license
+        },
+        ...published && options.repository !== undefined && repositoryFields(options.repository, directory),
+        sideEffects: false,
+        types: './dist/index.js',
+        files: [
+            'dist',
+            '!dist/**/*.map',
+            '!dist/tsconfig.tsbuildinfo'
+        ],
+        exports: {
+            '.': './dist/index.js'
+        },
+        devDependencies: Object.fromEntries(devDependencies.map((dependency)=>[
+                dependency,
+                published && dependency === '@types/node' ? floorTypes : resolveVersion(dependency, versions)
+            ]))
+    };
+    const { floorTsconfig } = resolved.checkPackage;
+    writeJson(tree, joinPathFragments(directory, 'package.json'), packageJson);
+    writeJson(tree, joinPathFragments(directory, 'tsconfig.json'), {
+        extends: published && floorTsconfig !== false ? floorTsconfig.replaceAll('{major}', ()=>String(floor)) : '@leyman/configs/tsconfig.build.json',
+        compilerOptions: {
+            outDir: 'dist',
+            rootDir: 'src',
+            tsBuildInfoFile: 'dist/tsconfig.tsbuildinfo'
+        },
+        include: [
+            'src'
+        ]
+    });
+    tree.write(joinPathFragments(directory, 'src/index.ts'), sourceFile(name));
+    if (test !== 'none') {
+        writeJson(tree, joinPathFragments(directory, 'test/tsconfig.json'), {
+            extends: '@leyman/configs/tsconfig.test.json',
+            references: [
+                {
+                    path: '..'
+                }
+            ]
+        });
+        tree.write(joinPathFragments(directory, 'test/unit/index.spec.ts'), test === 'mocha' ? mochaSpec(name) : vitestSpec(name));
+    }
+    tree.write(joinPathFragments(directory, 'eslint.config.js'), eslintConfig);
+    tree.write(joinPathFragments(directory, 'README.md'), `# ${name}\n\n${options.description}\n`);
+    const license = tree.read('LICENSE');
+    if (published && license !== null) {
+        tree.write(joinPathFragments(directory, 'LICENSE'), license);
+    }
+    const present = new Set(inferencePaths.filter((path)=>tree.exists(joinPathFragments(directory, path))));
+    const inferred = inferTargets({
+        packageJson,
+        root: directory,
+        isDependency: false,
+        has: (path)=>present.has(path)
+    }, resolved);
+    const targets = Object.fromEntries(inferred.map((target)=>[
+            resolved.targets[target].name,
+            {}
+        ]));
+    const $schema = projectSchema(tree, directory);
+    writeJson(tree, joinPathFragments(directory, 'project.json'), {
+        ...$schema !== undefined && {
+            $schema
+        },
+        name,
+        targets
+    });
+    return options.skipInstall === true ? undefined : installPackagesTask.bind(undefined, tree, true);
+};
+export default packageGenerator;
+
+//# sourceMappingURL=package.js.map

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export type { InferencePackageJson, ProjectFacts } from './lib/infer.js';
+export { inferencePaths, inferTargets } from './lib/infer.js';
+export type { Input, NamedInputName, NxPluginOptions, ResolvedOptions, TargetName, TargetOptions, } from './lib/options.js';
+export { namedInputNames, resolveOptions, targetNames } from './lib/options.js';
+export { namedInputs, targetConfigurations } from './lib/targets.js';
+export type { WorkspaceProject } from './lib/sync.js';
+export { syncTargets } from './lib/sync.js';
+export { assertOptions, executorJsonSchema, initGeneratorJsonSchema, optionsJsonSchema, packageGeneratorJsonSchema, } from './lib/schema.js';
+export { createNodes, name } from './lib/plugin.js';
+export type { LoadedProject, WorkspacePackageJson } from './lib/projects.js';
+export { loadProjects } from './lib/projects.js';
+export type { InitGeneratorOptions } from './generators/init.js';
+export { default as initGenerator, lifecycleBindings, lifecycleStages, } from './generators/init.js';
+export type { PackageGeneratorOptions } from './generators/package.js';
+export { default as packageGenerator } from './generators/package.js';
+export type { WorkspaceVersions } from './lib/versions.js';
+export { readWorkspaceVersions, resolveVersion } from './lib/versions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+export { inferencePaths, inferTargets } from './lib/infer.js';
+export { namedInputNames, resolveOptions, targetNames } from './lib/options.js';
+export { namedInputs, targetConfigurations } from './lib/targets.js';
+export { syncTargets } from './lib/sync.js';
+export { assertOptions, executorJsonSchema, initGeneratorJsonSchema, optionsJsonSchema, packageGeneratorJsonSchema } from './lib/schema.js';
+export { createNodes, name } from './lib/plugin.js';
+export { loadProjects } from './lib/projects.js';
+export { default as initGenerator, lifecycleBindings, lifecycleStages } from './generators/init.js';
+export { default as packageGenerator } from './generators/package.js';
+export { readWorkspaceVersions, resolveVersion } from './lib/versions.js';
+
+//# sourceMappingURL=index.js.map

package/dist/lib/infer.d.ts

@@ -0,0 +1,45 @@
+import type { ResolvedOptions, TargetName } from './options.js';
+/**
+ * The fields of a project's `package.json` inference reads.
+ */
+export interface InferencePackageJson {
+    readonly private?: boolean;
+    readonly devDependencies?: Readonly<Record<string, string>>;
+}
+/**
+ * Every path, relative to a project, whose presence inference reads.
+ */
+export declare const inferencePaths: readonly ['eslint.config.js', 'src', 'test/integration', 'test/tsconfig.json', 'test/unit', 'tsconfig.json'];
+/**
+ * What inference knows of a project.
+ */
+export interface ProjectFacts {
+    /**
+     * Root of the project, relative to the workspace, with `/` separators.
+     */
+    readonly root: string;
+    /**
+     * Its `package.json`, if it has one.
+     */
+    readonly packageJson: InferencePackageJson | undefined;
+    /**
+     * Whether another package of the workspace depends on it.
+     */
+    readonly isDependency: boolean;
+    /**
+     * Whether a file or directory exists in the project.
+     *
+     * @param path - one of {@link inferencePaths}
+     */
+    readonly has: (path: (typeof inferencePaths)[number]) => boolean;
+}
+/**
+ * Which of the plugin's targets a project gets: those its files call for, plus those it is included in, minus those it
+ * is excluded from or turned off.
+ *
+ * @param project - its root, files, `package.json` and dependents
+ * @param options - resolved options
+ * @returns each target's own name, in the order a `project.json` lists them
+ */
+export declare const inferTargets: (project: ProjectFacts, options: ResolvedOptions) => TargetName[];
+//# sourceMappingURL=infer.d.ts.map

package/dist/lib/infer.js

@@ -0,0 +1,66 @@
+import { targetNames } from './options.js';
+export const inferencePaths = [
+    'eslint.config.js',
+    'src',
+    'test/integration',
+    'test/tsconfig.json',
+    'test/unit',
+    'tsconfig.json'
+];
+const targetsFromFiles = ({ has, isDependency, packageJson })=>{
+    const targets = new Set([
+        'biome'
+    ]);
+    if (packageJson === undefined) {
+        return targets;
+    }
+    if (isDependency) {
+        targets.add('sync-injected');
+    }
+    if (has('tsconfig.json')) {
+        targets.add('update-ts-references');
+        if (has('src')) {
+            targets.add('tsc');
+        }
+    }
+    if (has('test/tsconfig.json')) {
+        targets.add('tsc-test');
+    }
+    const devDependencies = packageJson.devDependencies ?? {};
+    if (Object.hasOwn(devDependencies, 'mocha')) {
+        if (has('test/unit')) {
+            targets.add('mocha-unit-test');
+        }
+        if (has('test/integration')) {
+            targets.add('mocha-integration-test');
+        }
+    } else if (Object.hasOwn(devDependencies, 'vitest') && has('test/unit')) {
+        targets.add('vitest-unit-test');
+    }
+    if (has('eslint.config.js')) {
+        targets.add('eslint');
+    }
+    if (targets.has('tsc')) {
+        const tested = [
+            'mocha-unit-test',
+            'mocha-integration-test',
+            'vitest-unit-test'
+        ];
+        if (tested.some((target)=>targets.has(target))) {
+            targets.add('coverage-report');
+        }
+        if (packageJson.private !== true) {
+            targets.add('check-package');
+        }
+    }
+    return targets;
+};
+export const inferTargets = (project, options)=>{
+    const fromFiles = targetsFromFiles(project);
+    return targetNames.filter((target)=>{
+        const targetOptions = options.targets[target];
+        return targetOptions !== false && !targetOptions.exclude.includes(project.root) && (fromFiles.has(target) || targetOptions.include.includes(project.root));
+    });
+};
+
+//# sourceMappingURL=infer.js.map

package/dist/lib/options.d.ts

@@ -0,0 +1,154 @@
+import type { TargetConfiguration } from '@nx/devkit';
+/**
+ * The targets the plugin infers, in the order a `project.json` lists them.
+ */
+export declare const targetNames: readonly ['biome', 'eslint', 'check-package', 'update-ts-references', 'tsc', 'tsc-test', 'mocha-unit-test', 'mocha-integration-test', 'vitest-unit-test', 'coverage-report', 'sync-injected'];
+export type TargetName = (typeof targetNames)[number];
+/**
+ * The named inputs the plugin's targets use, and defines.
+ */
+export declare const namedInputNames: readonly ['dependency-files', 'package-files', 'eslint-input', 'ts-source', 'dependency-builds', 'test-source'];
+export type NamedInputName = (typeof namedInputNames)[number];
+/**
+ * An entry of a target's `inputs` or of a named input.
+ */
+export type Input = NonNullable<TargetConfiguration['inputs']>[number];
+/**
+ * How one target is inferred.
+ */
+export interface TargetOptions {
+    /**
+     * Name of the target in the project graph.
+     *
+     * @default the target's own name, e.g. `tsc`
+     */
+    readonly name?: string;
+    /**
+     * Roots of projects (`packages/a`) that get the target whatever their files.
+     */
+    readonly include?: readonly string[];
+    /**
+     * Roots of projects that never get the target.
+     */
+    readonly exclude?: readonly string[];
+}
+/**
+ * Options of the plugin, in `nx.json` (plugin mode) or in the file the `targets` executor reads.
+ */
+export interface NxPluginOptions {
+    /**
+     * Each target's options, or `false` to infer it nowhere.
+     */
+    readonly targets?: Readonly<Partial<Record<TargetName, false | TargetOptions>>>;
+    /**
+     * Paths of the shared configs, relative to each project.
+     */
+    readonly configs?: {
+        /**
+         * @default 'node_modules/@leyman/configs/swcrc.jsonc'
+         */
+        readonly swc?: string;
+        /**
+         * @default 'node_modules/@leyman/configs/c8rc.json'
+         */
+        readonly c8?: string;
+        /**
+         * @default 'node_modules/@leyman/configs/vitest.config.js'
+         */
+        readonly vitest?: string;
+    };
+    /**
+     * Directory to run the plugin's scripts from, such as `$NX_WORKSPACE_ROOT/tools/nx-plugin/scripts` for a copy kept
+     * in the workspace. By default, they run as the package's bins (`leyman-swc-compile`...).
+     */
+    readonly scripts?: string;
+    /**
+     * Coverage thresholds `coverage-report` passes to c8, over the c8 config's.
+     */
+    readonly coverage?: {
+        readonly branches?: number;
+        readonly functions?: number;
+        readonly lines?: number;
+        readonly statements?: number;
+    };
+    /**
+     * Options of `check-package`.
+     */
+    readonly checkPackage?: {
+        /**
+         * The module resolutions every entry point must work under.
+         *
+         * @default check-package's own, `strict`
+         */
+        readonly profile?: 'esm-only' | 'node16' | 'strict';
+        /**
+         * The config a package's `tsconfig.json` must extend, with `{major}` for its support floor, or `false`
+         * not to check it.
+         *
+         * @default '@leyman/configs/tsconfig.node-{major}.json'
+         */
+        readonly floorTsconfig?: false | string;
+        /**
+         * What a change of check-package itself is hashed by.
+         *
+         * @default [{ externalDependencies: ['@leyman/check-package', 'typescript'] }]
+         */
+        readonly inputs?: readonly Input[];
+    };
+    /**
+     * What changes of the shared tools are hashed by.
+     */
+    readonly inputs?: {
+        /**
+         * The shared configs, for every target that reads one.
+         *
+         * @default [{ externalDependencies: ['@leyman/configs'] }]
+         */
+        readonly configs?: readonly Input[];
+        /**
+         * This plugin's scripts, for every target that runs one.
+         *
+         * @default [{ externalDependencies: ['@leyman/nx-plugin'] }]
+         */
+        readonly tools?: readonly Input[];
+    };
+    /**
+     * Inputs added to the end of each named input, such as a file the tests read.
+     */
+    readonly namedInputs?: Readonly<Partial<Record<NamedInputName, readonly Input[]>>>;
+}
+/**
+ * The options with every default filled in.
+ */
+export interface ResolvedOptions {
+    readonly targets: Readonly<Record<TargetName, false | {
+        name: string;
+        include: readonly string[];
+        exclude: readonly string[];
+    }>>;
+    readonly configs: {
+        readonly swc: string;
+        readonly c8: string;
+        readonly vitest: string;
+    };
+    readonly scripts: string | undefined;
+    readonly coverage: NonNullable<NxPluginOptions['coverage']>;
+    readonly checkPackage: {
+        readonly profile: 'esm-only' | 'node16' | 'strict' | undefined;
+        readonly floorTsconfig: false | string;
+        readonly inputs: readonly Input[];
+    };
+    readonly inputs: {
+        readonly configs: readonly Input[];
+        readonly tools: readonly Input[];
+    };
+    readonly namedInputs: Readonly<Record<NamedInputName, readonly Input[]>>;
+}
+/**
+ * Fills in the default of every option.
+ *
+ * @param options - the plugin's options
+ * @returns every option
+ */
+export declare const resolveOptions: (options?: NxPluginOptions) => ResolvedOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/lib/options.js

@@ -0,0 +1,75 @@
+export const targetNames = [
+    'biome',
+    'eslint',
+    'check-package',
+    'update-ts-references',
+    'tsc',
+    'tsc-test',
+    'mocha-unit-test',
+    'mocha-integration-test',
+    'vitest-unit-test',
+    'coverage-report',
+    'sync-injected'
+];
+export const namedInputNames = [
+    'dependency-files',
+    'package-files',
+    'eslint-input',
+    'ts-source',
+    'dependency-builds',
+    'test-source'
+];
+export const resolveOptions = (options = {})=>({
+        targets: Object.fromEntries(targetNames.map((target)=>{
+            const targetOptions = options.targets?.[target] ?? {};
+            return [
+                target,
+                targetOptions === false ? false : {
+                    name: targetOptions.name ?? target,
+                    include: targetOptions.include ?? [],
+                    exclude: targetOptions.exclude ?? []
+                }
+            ];
+        })),
+        configs: {
+            swc: options.configs?.swc ?? 'node_modules/@leyman/configs/swcrc.jsonc',
+            c8: options.configs?.c8 ?? 'node_modules/@leyman/configs/c8rc.json',
+            vitest: options.configs?.vitest ?? 'node_modules/@leyman/configs/vitest.config.js'
+        },
+        scripts: options.scripts,
+        coverage: options.coverage ?? {},
+        checkPackage: {
+            profile: options.checkPackage?.profile,
+            floorTsconfig: options.checkPackage?.floorTsconfig ?? '@leyman/configs/tsconfig.node-{major}.json',
+            inputs: options.checkPackage?.inputs ?? [
+                {
+                    externalDependencies: [
+                        '@leyman/check-package',
+                        "typescript"
+                    ]
+                }
+            ]
+        },
+        inputs: {
+            configs: options.inputs?.configs ?? [
+                {
+                    externalDependencies: [
+                        '@leyman/configs'
+                    ]
+                }
+            ],
+            tools: options.inputs?.tools ?? [
+                {
+                    externalDependencies: [
+                        '@leyman/nx-plugin'
+                    ]
+                }
+            ]
+        },
+        namedInputs: Object.fromEntries(namedInputNames.map((name)=>[
+                name,
+                options.namedInputs?.[name] ?? []
+            ]))
+    });
+
+//# sourceMappingURL=options.js.map

package/dist/lib/plugin.d.ts

@@ -0,0 +1,12 @@
+import type { CreateNodes } from '@nx/devkit';
+import type { NxPluginOptions } from './options.js';
+/**
+ * Name of the plugin, as Nx reports it.
+ */
+export declare const name = "@leyman/nx-plugin";
+/**
+ * The Nx plugin: infers targets for each project with a `project.json`. A `project.json` overrides any part of a
+ * target, as Nx merges it over what plugins infer.
+ */
+export declare const createNodes: CreateNodes<NxPluginOptions>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/lib/plugin.js

@@ -0,0 +1,38 @@
+import Path from 'node:path';
+import { inferTargets } from './infer.js';
+import { resolveOptions } from './options.js';
+import { loadProjects } from './projects.js';
+import { assertOptions } from './schema.js';
+import { namedInputs, targetConfigurations } from './targets.js';
+export const name = '@leyman/nx-plugin';
+const createTypescriptNodes = async (projectJsonPaths, options, { workspaceRoot })=>{
+    assertOptions(options ?? {}, 'nx.json');
+    const resolved = resolveOptions(options);
+    const configurations = targetConfigurations(resolved);
+    const projectNamedInputs = namedInputs(resolved);
+    const projects = await loadProjects(workspaceRoot, projectJsonPaths.map((path)=>Path.dirname(path)));
+    return projects.map((project)=>{
+        const targets = {};
+        for (const target of inferTargets(project, resolved)){
+            const { name: targetName } = resolved.targets[target];
+            targets[targetName] = configurations[target];
+        }
+        return [
+            Path.join(project.root, 'project.json'),
+            {
+                projects: {
+                    [project.root]: {
+                        namedInputs: projectNamedInputs,
+                        targets
+                    }
+                }
+            }
+        ];
+    });
+};
+export const createNodes = [
+    '**/project.json',
+    createTypescriptNodes
+];
+
+//# sourceMappingURL=plugin.js.map

package/dist/lib/projects.d.ts

@@ -0,0 +1,27 @@
+import type { InferencePackageJson, ProjectFacts } from './infer.js';
+/**
+ * The fields of a workspace package's `package.json` the plugin reads.
+ */
+export interface WorkspacePackageJson extends InferencePackageJson {
+    readonly name?: string;
+    readonly dependencies?: Readonly<Record<string, string>>;
+    readonly optionalDependencies?: Readonly<Record<string, string>>;
+    readonly peerDependencies?: Readonly<Record<string, string>>;
+}
+/**
+ * A project as inference sees it, with its `project.json` if it has one.
+ */
+export interface LoadedProject extends ProjectFacts {
+    readonly projectJson: Record<string, unknown> | undefined;
+}
+export declare const readJson: (path: string) => Promise<unknown>;
+/**
+ * Reads what inference needs of each project: its files, its `package.json`, and whether another of the projects
+ * depends on it.
+ *
+ * @param workspaceRoot - absolute path the roots are relative to
+ * @param roots - root of each project, relative to the workspace root
+ * @returns each project, in the order of `roots`
+ */
+export declare const loadProjects: (workspaceRoot: string, roots: readonly string[]) => Promise<LoadedProject[]>;
+//# sourceMappingURL=projects.d.ts.map