pkgbld 1.36.0 → 2.1.0

package/src/build-plugin-lifecycle.js

@@ -0,0 +1,100 @@
+/**
+ * @typedef {import('rollup').InternalModuleFormat} InternalModuleFormat
+ * @typedef {import('rollup').OutputOptions} OutputOptions
+ * @typedef {import('type-fest').JsonObject} JsonObject
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ * @typedef {import('./types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('./types.js').BuildConfigurationDraft} BuildConfigurationDraft
+ * @typedef {import('./types.js').BuildConfigurationSources} BuildConfigurationSources
+ * @typedef {import('./types.js').BuildEntries} BuildEntries
+ * @typedef {import('./types.js').BuildEntryContributions} BuildEntryContributions
+ * @typedef {import('./types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('./types.js').PkgbldPlugin} PkgbldPlugin
+ * @typedef {import('./types.js').PluginSharedState} PluginSharedState
+ * @typedef {import('./types.js').Provider} Provider
+ */
+
+/**
+ * Owns Build plugin invocation and shared state for one build.
+ *
+ * The lifecycle preserves phase boundaries, but does not guarantee plugin order
+ * within a phase. Asynchronous hooks in the same phase run concurrently.
+ * Build plugins must not rely on same-phase shared-state reads and writes.
+ *
+ * @param {Partial<PkgbldPlugin>[]} plugins
+ */
+export function createBuildPluginLifecycle(plugins) {
+    /** @type {PluginSharedState} */
+    const shared = new Map();
+
+    return {
+        /**
+         * @param {BuildConfigurationDraft} draft
+         * @param {BuildConfigurationSources} sources
+         */
+        configure(draft, sources) {
+            for (const plugin of plugins) {
+                plugin.configure?.({ draft, sources, shared });
+            }
+        },
+
+        /**
+         * @param {BuildEntryContributions} entries
+         * @param {BuildConfiguration} configuration
+         */
+        contributeEntries(entries, configuration) {
+            for (const plugin of plugins) {
+                plugin.contributeEntries?.({ entries, configuration, shared });
+            }
+        },
+
+        /**
+         * @param {JsonObject} config
+         * @param {BuildConfiguration} configuration
+         */
+        processTsConfig(config, configuration) {
+            for (const plugin of plugins) {
+                plugin.processTsConfig?.({ config, configuration, shared });
+            }
+        },
+
+        /**
+         * @param {PackageJson} packageJson
+         * @param {BuildEntries} entries
+         * @param {BuildConfiguration} configuration
+         */
+        processPackageJson(packageJson, entries, configuration) {
+            for (const plugin of plugins) {
+                plugin.processPackageJson?.({ packageJson, entries, configuration, shared });
+            }
+        },
+
+        /**
+         * @param {Provider} provider
+         * @param {BuildConfiguration} configuration
+         * @param {PackageProcessingResult} packageResult
+         */
+        async provideRollupPlugins(provider, configuration, packageResult) {
+            await Promise.all(plugins.map(plugin => plugin.providePlugins?.({ provider, configuration, packageResult, shared })));
+        },
+
+        /**
+         * @param {Partial<OutputOptions>} settings
+         * @param {InternalModuleFormat} format
+         * @param {string[]} inputs
+         * @param {BuildConfiguration} configuration
+         */
+        extendOutputSettings(settings, format, inputs, configuration) {
+            for (const plugin of plugins) {
+                if (plugin.getExtraOutputSettings) {
+                    Object.assign(settings, plugin.getExtraOutputSettings({ format, inputs, configuration, shared }));
+                }
+            }
+        },
+
+        /** @param {BuildConfiguration} configuration */
+        async buildEnd(configuration) {
+            await Promise.all(plugins.map(plugin => plugin.buildEnd?.({ configuration, shared })));
+        },
+    };
+}

package/src/builtin-plugins/binify.js

@@ -0,0 +1,31 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('rollup').OutputChunk} OutputChunk
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('../types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ * @param {PackageProcessingResult} packageResult
+ */
+export default async function (provider, configuration, packageResult) {
+    if (packageResult.executableOutputs.length > 0) {
+        const pluginBinify = await provider.import('@rollup-extras/plugin-binify');
+
+        provider.provide(
+            () =>
+                pluginBinify({
+                    filter: (/** @type {OutputChunk} */ item) =>
+                        item.type === 'chunk' &&
+                        item.isEntry &&
+                        packageResult.executableOutputs.some(input => input === `./${configuration.paths.outputDir}/${item.fileName}`),
+                }),
+            Priority.finalize,
+            { outputPlugin: true, format: 'cjs' }
+        );
+    }
+}

package/src/builtin-plugins/clean.js

@@ -0,0 +1,30 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ */
+export default async function (provider, configuration) {
+    if (!configuration.execution.clean) {
+        return;
+    }
+
+    const pluginClean = await provider.import('@rollup-extras/plugin-clean');
+
+    const pluginInstance = pluginClean();
+
+    provider.provide(pluginFactory, Priority.cleanup, { outputPlugin: true });
+
+    let firstPluginInstance = true;
+
+    function pluginFactory() {
+        const result = firstPluginInstance ? pluginInstance : pluginInstance.api.addInstance();
+        firstPluginInstance = false;
+        return result;
+    }
+}

package/src/builtin-plugins/commonjs.js

@@ -0,0 +1,14 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ */
+export default async function (provider) {
+    const pluginCommonjs = await provider.import('@rollup/plugin-commonjs');
+
+    provider.provide(() => pluginCommonjs(), Priority.commonjs);
+}

package/src/builtin-plugins/externals.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+
+import { Priority } from '../priorities.js';
+
+/**
+ * @param {(...args: any[]) => any} fn
+ * @param {any[]} args
+ * @returns {any}
+ */
+export function curry(fn, ...args) {
+    return args.length >= fn.length
+        ? fn(...args)
+        : /** @type {(...nextArgs: any[]) => any} */ ((...nextArgs) => curry(fn, ...args, ...nextArgs));
+}
+
+/**
+ * @typedef {import('rollup').InternalModuleFormat} InternalModuleFormat
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('../types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ * @param {PackageProcessingResult} packageResult
+ */
+export default async function (provider, configuration, packageResult) {
+    const inputs = packageResult.entries.values.filter(entry => entry.origin !== 'import').map(entry => entry.sourcePath);
+    if (configuration.transforms.includeExternals === true) {
+        return;
+    }
+
+    const pluginExternals = await provider.import('@rollup-extras/plugin-externals');
+
+    const allowGenericUmd = configuration.outputs.umdEntries.length === 1 && inputs.length === 1;
+
+    if (configuration.outputs.formats.length > 0) {
+        const format = /** @type {InternalModuleFormat[]} */ (
+            allowGenericUmd ? undefined : configuration.outputs.formats.filter(format => format !== 'umd')
+        );
+        provider.provide(
+            () =>
+                pluginExternals(
+                    configuration.transforms.includeExternals === false && !configuration.resolution.imports
+                        ? {}
+                        : (/** @type {string} */ id, /** @type {boolean} */ external, /** @type {string} */ importer) =>
+                              includeExternals(importer, external, id, configuration)
+                ),
+            Priority.externals,
+            { format }
+        );
+        provider.globalImport('path', 'path');
+        provider.globalSetup(includeExternals);
+    }
+
+    if (!allowGenericUmd && configuration.outputs.umdEntries.length > 0) {
+        const curryForConfig = /** @type {typeof curry} */ (provider.globalSetup(curry) ?? curry);
+        for (const entryName of configuration.outputs.umdEntries) {
+            const currentInput = packageResult.entries.require(entryName).sourcePath;
+            const isExternal = curryForConfig(
+                (
+                    /** @type {string} */ currentInput,
+                    /** @type {string} */ id,
+                    /** @type {boolean} */ external,
+                    /** @type {string} */ importer
+                ) => includeExternals(importer, external, id, configuration) || isExternalInput(currentInput, inputs, id)
+            )(currentInput);
+            provider.provide(() => pluginExternals(isExternal), Priority.externals, {
+                format: 'umd',
+                inputs: [currentInput],
+            });
+        }
+        if (configuration.outputs.formats.length === 0) {
+            provider.globalImport('path', 'path');
+            provider.globalSetup(includeExternals);
+        }
+        provider.globalSetup(isExternalInput);
+    }
+}
+
+/**
+ * @param {string} _importer
+ * @param {boolean} external
+ * @param {string} id
+ * @param {BuildConfiguration} configuration
+ */
+function includeExternals(_importer, external, id, configuration) {
+    if (configuration.resolution.imports && id.startsWith('#')) return false;
+    if (configuration.transforms.includeExternals === false) return external;
+    if (!external) return false;
+    const internals = /** @type {readonly string[]} */ (configuration.transforms.includeExternals);
+    if (internals.includes(id) || internals.some(internal => id.includes(internal))) {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * @param {string} currentInput
+ * @param {string | readonly string[]} inputs
+ * @param {string} id
+ */
+function isExternalInput(currentInput, inputs, id) {
+    const normalizedPath = path.isAbsolute(currentInput) ? `./${path.relative(process.cwd(), currentInput)}` : currentInput;
+    const normalizedId = path.isAbsolute(id) ? `./${path.relative(process.cwd(), id)}` : id;
+    return normalizedPath !== normalizedId && inputs.includes(normalizedPath);
+}

package/src/builtin-plugins/json.js

@@ -0,0 +1,14 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ */
+export default async function (provider) {
+    const pluginJson = await provider.import('@rollup/plugin-json');
+
+    provider.provide(() => pluginJson(), Priority.preprocess);
+}

package/src/builtin-plugins/package-imports.js

@@ -0,0 +1,79 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ */
+export default function (provider, configuration) {
+    if (!configuration.resolution.imports) return;
+
+    provider.globalImport('node:fs/promises', 'fs');
+    provider.globalImport('path', 'path');
+    const createPlugin = /** @type {typeof createPackageImportsPlugin} */ (
+        provider.globalSetup(createPackageImportsPlugin) ?? createPackageImportsPlugin
+    );
+    provider.provide(() => createPlugin(), Priority.packageImports);
+}
+
+/**
+ * Keep the package's private specifiers for runtime resolution. Each importer
+ * is assigned to its nearest real package boundary, so linked dependencies and
+ * nested workspace packages retain ownership of their own private imports.
+ */
+export function createPackageImportsPlugin() {
+    const packageRoot = fs.realpath(process.cwd());
+    /** @type {Map<string, string | null>} */
+    const owners = new Map();
+    return {
+        name: 'pkgbld:package-imports',
+        /** @param {string} id @param {string | undefined} importer */
+        async resolveId(id, importer) {
+            if (!id.startsWith('#') || !importer || importer.includes('\0')) return null;
+            let realImporter;
+            try {
+                realImporter = await fs.realpath(importer.split('?', 1)[0]);
+            } catch (error) {
+                if (['ENOENT', 'EINVAL'].includes(/** @type {NodeJS.ErrnoException} */ (error).code ?? '')) return null;
+                throw error;
+            }
+            const owner = await findOwner(path.dirname(realImporter));
+            return owner === (await packageRoot) ? { id, external: true } : null;
+        },
+    };
+
+    /** @param {string} start */
+    async function findOwner(start) {
+        let directory = start;
+        /** @type {string[]} */
+        const visited = [];
+        while (true) {
+            if (owners.has(directory)) {
+                const owner = /** @type {string | null} */ (owners.get(directory));
+                for (const visitedDirectory of visited) owners.set(visitedDirectory, owner);
+                return owner;
+            }
+            visited.push(directory);
+            try {
+                await fs.access(path.join(directory, 'package.json'));
+                for (const visitedDirectory of visited) owners.set(visitedDirectory, directory);
+                return directory;
+            } catch (error) {
+                if (/** @type {NodeJS.ErrnoException} */ (error).code !== 'ENOENT') throw error;
+            }
+            const parent = path.dirname(directory);
+            if (parent === directory) {
+                for (const visitedDirectory of visited) owners.set(visitedDirectory, null);
+                return null;
+            }
+            directory = parent;
+        }
+    }
+}

package/src/builtin-plugins/preprocess.js

@@ -0,0 +1,37 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('rollup').InternalModuleFormat} InternalModuleFormat
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('../types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ * @param {PackageProcessingResult} packageResult
+ */
+export default async function (provider, configuration, packageResult) {
+    if (configuration.transforms.preprocess.length > 0) {
+        const pluginPreprocess = /** @type {typeof import('rollup-plugin-preprocess')} */ (
+            await provider.import('rollup-plugin-preprocess')
+        );
+
+        const include = configuration.transforms.preprocess.map(name => packageResult.entries.require(name).sourcePath);
+
+        for (const format of /** @type {readonly InternalModuleFormat[]} */ (configuration.outputs.formats)) {
+            if (format !== 'umd') {
+                provider.provide(() => pluginPreprocess.default({ include, context: { [format]: true } }), Priority.preprocess, { format });
+            } else {
+                for (const entryName of configuration.outputs.umdEntries) {
+                    const currentInput = packageResult.entries.require(entryName).sourcePath;
+                    provider.provide(() => pluginPreprocess.default({ include, context: { umd: true } }), Priority.preprocess, {
+                        format,
+                        inputs: [currentInput],
+                    });
+                }
+            }
+        }
+    }
+}

package/src/builtin-plugins/resolve.js

@@ -0,0 +1,22 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('../types.js').Provider} Provider
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ */
+export default async function (provider, configuration) {
+    const pluginResolve = await provider.import('@rollup/plugin-node-resolve');
+
+    provider.provide(
+        () =>
+            configuration.resolution.conditions.length > 0
+                ? pluginResolve({ exportConditions: [...configuration.resolution.conditions] })
+                : pluginResolve(),
+        Priority.resolve
+    );
+}

package/src/builtin-plugins/terser.js

@@ -0,0 +1,50 @@
+import { Priority } from '../priorities.js';
+
+/**
+ * @typedef {import('rollup').InternalModuleFormat} InternalModuleFormat
+ * @typedef {import('../types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('../types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('../types.js').Provider} Provider
+ */
+
+/**
+ * @param {Provider} provider
+ * @param {BuildConfiguration} configuration
+ * @param {PackageProcessingResult} packageResult
+ */
+export default async function (provider, configuration, packageResult) {
+    const filteredFormats = configuration.transforms.compress.filter(format => configuration.outputs.formats.includes(format));
+
+    if (filteredFormats.length > 0) {
+        const pluginTerser = await provider.import('@rollup/plugin-terser');
+
+        const options = {
+            mangle: {
+                properties: {
+                    regex: /_$/,
+                },
+            },
+        };
+
+        if (configuration.transforms.removeLegalComments) {
+            /** @type {any} */ (options).output = {
+                comments: false,
+            };
+        }
+
+        for (const format of /** @type {InternalModuleFormat[]} */ (filteredFormats)) {
+            if (format !== 'umd') {
+                provider.provide(() => pluginTerser(options), Priority.compress, { format, outputPlugin: true });
+            } else {
+                for (const entryName of configuration.outputs.umdEntries) {
+                    const currentInput = packageResult.entries.require(entryName).sourcePath;
+                    provider.provide(() => pluginTerser(options), Priority.compress, {
+                        format,
+                        outputPlugin: true,
+                        inputs: [currentInput],
+                    });
+                }
+            }
+        }
+    }
+}

package/src/eject.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import pkgbldPkg from '../package.json' with { type: 'json' };
+import { camelCase } from './helpers.js';
+
+/**
+ * @typedef {import('rollup').RollupOptions} RollupOptions
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ * @typedef {import('./types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('./types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('./types.js').PkgbldRollupPlugin} PkgbldRollupPlugin
+ * @typedef {import('./types.js').Provider} Provider
+ */
+
+const imports = new Map();
+const setup = new Set();
+
+/** @type {<T extends object>(object: T) => string | boolean | RegExp | null | undefined} */
+let generate;
+/** @type {() => string} */
+let generateGlobals;
+
+/**
+ * @returns {Promise<[Provider, PkgbldRollupPlugin[]]>}
+ */
+export async function createEjectProvider() {
+    const createMockProvider = (await import('@slimlib/smart-mock')).default;
+    const provider = createMockProvider();
+    const createMock = provider.createMock;
+    generate = provider.generate;
+    generateGlobals = provider.generateGlobals;
+    /** @type {PkgbldRollupPlugin[]} */
+    const plugins = [];
+    return [
+        {
+            provide: (
+                /** @type {PkgbldRollupPlugin['plugin']} */ plugin,
+                /** @type {PkgbldRollupPlugin['priority']} */ priority,
+                /** @type {Omit<PkgbldRollupPlugin, 'plugin' | 'priority'>=} */ options
+            ) => {
+                plugins.push({ priority, plugin, format: options?.format, inputs: options?.inputs, outputPlugin: options?.outputPlugin });
+            },
+            import: async (/** @type {string} */ name, /** @type {string=} */ exportName) => {
+                const result = await import(name);
+                const exports = result[exportName ?? 'default'];
+                const mangledName = camelCase(name);
+                imports.set(name, mangledName);
+                return createMock(exports, mangledName);
+            },
+            globalImport: (/** @type {string} */ module, /** @type {string | string[]=} */ exportName) => {
+                imports.set(module, exportName ?? 'default');
+            },
+            globalSetup: (/** @type {((...args: any[]) => any) | string} */ code) => {
+                if (typeof code === 'function') {
+                    setup.add(code.toString());
+                    return createMock(code, code.name);
+                }
+                setup.add(String(code));
+            },
+        },
+        plugins,
+    ];
+}
+
+/**
+ * @param {RollupOptions[]} config
+ * @param {string} pkgPath
+ * @param {BuildConfiguration} configuration
+ * @param {PackageProcessingResult} packageResult
+ * @param {ReturnType<import('./helpers.js').getHelpers>} helpers
+ * @param {PackageJson} pkg
+ */
+export async function ejectConfig(config, pkgPath, configuration, packageResult, helpers, pkg) {
+    const pkgName = /** @type {{ name: string }} */ (pkg).name;
+
+    const text = generate(config);
+    setup.add(generateGlobals());
+
+    setup.add(`const configuration = ${generate(configuration)}`);
+    setup.add(`const packageResult = { executableOutputs: ${generate(packageResult.executableOutputs)} }`);
+    setup.add(`const inputs = ${generate(packageResult.entries.values.map(entry => entry.sourcePath))}`);
+
+    if (configuration.outputs.formats.includes('umd')) {
+        imports.set('path', 'path');
+        imports.set('url', 'url');
+        setup.add(`const pkgName = ${generate(/** @type {never} */ (pkgName))}`);
+        setup.add(camelCase.toString());
+        setup.add(helpers.getGlobalName.toString());
+        setup.add("const __dirname = url.fileURLToPath(new URL('.', import.meta.url));");
+    }
+
+    const importsString = Array.from(imports)
+        .map(value => `import ${value[1]} from '${value[0]}';`)
+        .join('\n');
+    const setupString = Array.from(setup).join('\n');
+
+    const { minify } = await import('terser');
+
+    const result = await minify(`${importsString}\n${setupString}\nexport default ${text};`, {
+        module: true,
+        compress: {
+            booleans: false,
+            ecma: 2020,
+            module: true,
+            passes: 3,
+            unsafe: true,
+        },
+        mangle: false,
+        output: {
+            beautify: true,
+            ecma: 2020,
+            quote_style: 1,
+        },
+    });
+    await fs.writeFile(path.join(path.dirname(pkgPath), 'rollup.config.mjs'), /** @type {string} */ (result.code));
+
+    await updatePackageJson(pkg);
+}
+
+/**
+ * @param {PackageJson} pkg
+ */
+async function updatePackageJson(pkg) {
+    if (typeof pkg.devDependencies !== 'object') {
+        pkg.devDependencies = {};
+    }
+    const devDependencies = pkg.devDependencies;
+    if ('pkgbld' in devDependencies) {
+        devDependencies.pkgbld = undefined;
+    }
+    devDependencies.rollup = /** @type {Record<string, string>} */ (pkgbldPkg.dependencies).rollup ?? '*';
+    const isBuiltin = (await import('is-builtin-module')).default;
+    for (const key of imports.keys()) {
+        const packageName = getPackageName(key);
+        if (!isBuiltin(packageName)) {
+            devDependencies[packageName] = /** @type {Record<string, string>} */ (pkgbldPkg.dependencies)[packageName] ?? '*';
+        }
+    }
+}
+
+/**
+ * @param {string} key
+ * @returns {string}
+ */
+function getPackageName(key) {
+    return key
+        .split('/')
+        .slice(0, key.startsWith('@') ? 2 : 1)
+        .join('/');
+}

package/src/get-json.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * @typedef {import('type-fest').JsonObject} JsonObject
+ */
+
+/**
+ * @param {string} fileName
+ * @returns {Promise<[string, JsonObject]>}
+ */
+export async function getJson(fileName) {
+    const pkgPath = path.resolve(fileName);
+    const buffer = await fs.readFile(pkgPath);
+    return [pkgPath, /** @type {JsonObject} */ (JSON.parse(buffer.toString()))];
+}