pkgbld 1.36.0 → 2.0.0

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()))];
+}

package/src/get-plugins.js

@@ -0,0 +1,43 @@
+import binify from './builtin-plugins/binify.js';
+import clean from './builtin-plugins/clean.js';
+import commonjs from './builtin-plugins/commonjs.js';
+import externals from './builtin-plugins/externals.js';
+import json from './builtin-plugins/json.js';
+import preprocess from './builtin-plugins/preprocess.js';
+import resolve from './builtin-plugins/resolve.js';
+import terser from './builtin-plugins/terser.js';
+
+/**
+ * @typedef {import('./types.js').PkgbldRollupPlugin} PkgbldRollupPlugin
+ * @typedef {import('./types.js').Provider} Provider
+ */
+
+export const plugins = [clean, commonjs, externals, preprocess, resolve, terser, binify, json];
+
+const noop = () => undefined;
+
+/**
+ * @returns {[Provider, PkgbldRollupPlugin[]]}
+ */
+export function createProvider() {
+    /** @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);
+                return result[exportName ?? 'default'];
+            },
+            globalImport: noop,
+            globalSetup: code => (typeof code === 'function' ? code : undefined),
+        },
+        plugins,
+    ];
+}

package/src/get-rollup-configs.js

@@ -0,0 +1,224 @@
+import refiner from '@slimlib/refine-partition';
+
+import { plugins as pluginFactories } from './get-plugins.js';
+import { areSetsEqual, toArray } from './helpers.js';
+
+/**
+ * @typedef {import('rollup').InternalModuleFormat} InternalModuleFormat
+ * @typedef {import('rollup').OutputOptions} OutputOptions
+ * @typedef {import('./types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('./types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {import('./types.js').PkgbldRollupPlugin} PkgbldRollupPlugin
+ * @typedef {import('./types.js').Provider} Provider
+ * @typedef {ReturnType<typeof import('./build-plugin-lifecycle.js').createBuildPluginLifecycle>} BuildPluginLifecycle
+ */
+
+/**
+ * @param {[Provider, PkgbldRollupPlugin[]]} providerAndPlugins
+ * @param {PackageProcessingResult} packageResult
+ * @param {BuildConfiguration} configuration
+ * @param {ReturnType<import('./helpers.js').getHelpers>} helpers
+ * @param {BuildPluginLifecycle} pluginLifecycle
+ */
+export async function getRollupConfigs([provider, plugins], packageResult, configuration, helpers, pluginLifecycle) {
+    const inputs = packageResult.entries.values.map(entry => entry.sourcePath);
+    const entriesBySourcePath = new Map(packageResult.entries.values.map(entry => [entry.sourcePath, entry]));
+    const factoryInProgress = [];
+
+    const fileNamePatterns = /** @type {{ [key in InternalModuleFormat]: string }} */ ({
+        es: configuration.outputs.patterns.es,
+        cjs: configuration.outputs.patterns.cjs,
+        umd: configuration.outputs.patterns.umd,
+    });
+
+    for (const factory of pluginFactories) {
+        factoryInProgress.push(factory(provider, configuration, packageResult));
+    }
+
+    factoryInProgress.push(pluginLifecycle.provideRollupPlugins(provider, configuration, packageResult));
+
+    await Promise.all(factoryInProgress);
+
+    /** @type {Set<string>} */
+    const expandInputs = new Set();
+
+    for (const plugin of plugins) {
+        if (plugin.format && plugin.inputs?.length && !plugin.outputPlugin) {
+            for (const format of toArray(plugin.format)) {
+                expandInputs.add(format);
+            }
+        }
+    }
+
+    const refineNext = refiner();
+
+    refineNext(doExpandInputs(/** @type {InternalModuleFormat[]} */ ([...configuration.outputs.formats])));
+
+    for (const plugin of plugins) {
+        if (plugin.format && !plugin.outputPlugin) {
+            const formats = toArray(plugin.format);
+            if (!plugin.inputs || plugin.inputs.length === 0) {
+                refineNext(doExpandInputs(formats));
+            } else if (inputs.length === 1) {
+                refineNext(formats);
+            } else {
+                const expanded = [];
+                for (const format of formats) {
+                    for (const input of plugin.inputs) {
+                        expanded.push(`${format}.${input}`);
+                    }
+                }
+                refineNext(expanded);
+            }
+        }
+    }
+
+    const refined = refineNext();
+    /** @type {{ formats: InternalModuleFormat[]; inputs: string[] }[]} */
+    const partitions = [];
+
+    for (const partition of refined) {
+        /** @type {{ format: InternalModuleFormat; input?: string }[]} */
+        const result = [];
+        for (const format of partition) {
+            if (format.includes('.')) {
+                const [, realFormat, input] = format.split(/(.*?)\.(.*)/gm);
+                result.push({ format: /** @type {InternalModuleFormat} */ (realFormat), input });
+            } else {
+                result.push({ format: /** @type {InternalModuleFormat} */ (format) });
+            }
+        }
+        /** @type {Map<InternalModuleFormat, Set<string>>} */
+        const mapFormatInputs = new Map();
+        /** @type {Set<InternalModuleFormat>} */
+        const formatsWithoutInputs = new Set();
+        for (const { format, input } of result) {
+            if (input) {
+                if (mapFormatInputs.has(format)) {
+                    /** @type {Set<string>} */ (mapFormatInputs.get(format)).add(input);
+                } else {
+                    mapFormatInputs.set(format, new Set([input]));
+                }
+            } else {
+                formatsWithoutInputs.add(format);
+            }
+        }
+        for (const format of formatsWithoutInputs) {
+            if (mapFormatInputs.has(format)) {
+                throw new Error(
+                    `${format} is both used with inputs and without in plugins configuration and was not expanded / handled correctly. Please file an issue for pkgbld.`
+                );
+            }
+            mapFormatInputs.set(format, new Set(inputs));
+        }
+        /** @type {Set<string> | undefined} */
+        let prevInputs;
+        for (const inputs of mapFormatInputs.values()) {
+            if (prevInputs) {
+                if (!areSetsEqual(inputs, prevInputs)) {
+                    throw new Error(`unbalanced inputs for partition: ${JSON.stringify(partition)}`);
+                }
+            }
+            prevInputs = inputs;
+        }
+        partitions.push({ formats: [...mapFormatInputs.keys()], inputs: [.../** @type {Set<string>} */ (prevInputs)] });
+    }
+
+    return partitions.map(({ formats, inputs }) => {
+        return {
+            input: Object.fromEntries(
+                inputs.map(input => [/** @type {import('./types.js').BuildEntry} */ (entriesBySourcePath.get(input)).name, input])
+            ),
+
+            output: formats.map(format => ({
+                format,
+                dir: configuration.paths.outputDir,
+                entryFileNames: fileNamePatterns[format],
+                plugins: getPlugins([format], inputs, true),
+                sourcemap: configuration.outputs.sourcemaps.some(value => value === format),
+                ...getExtraOutputSettings(format, inputs),
+            })),
+
+            plugins: getPlugins(formats, inputs, false),
+        };
+    });
+
+    /**
+     * @param {InternalModuleFormat} format
+     * @param {string[]} inputs
+     * @returns {Partial<OutputOptions>}
+     */
+    function getExtraOutputSettings(format, inputs) {
+        let result = {};
+        switch (format) {
+            case 'cjs':
+            case 'es':
+                result = { chunkFileNames: fileNamePatterns[format] };
+                break;
+            case 'umd':
+                if (inputs.length <= 0) {
+                    break;
+                }
+                if (inputs.length > 1) {
+                    throw new Error(`Cannot produce global name for multiple umd inputs in one output: ${inputs}`);
+                }
+                result = {
+                    name: helpers.getGlobalName(inputs.join('_')),
+                    globals: helpers.getExternalGlobalName,
+                };
+                break;
+        }
+        pluginLifecycle.extendOutputSettings(result, format, inputs, configuration);
+        return result;
+    }
+
+    /**
+     * @param {InternalModuleFormat[]} formats
+     * @param {string[]} inputs
+     * @param {boolean} outputPlugin
+     */
+    function getPlugins(formats, inputs, outputPlugin) {
+        const filteredPlugins = [];
+        for (const plugin of plugins) {
+            if (!!plugin.outputPlugin === outputPlugin) {
+                if (
+                    (!plugin.format || toArray(plugin.format).some(format => formats.includes(format))) &&
+                    (!plugin.inputs || plugin.inputs.every(input => inputs.includes(input)))
+                ) {
+                    filteredPlugins.push({
+                        instance: plugin.plugin(),
+                        priority: plugin.priority,
+                    });
+                }
+            }
+        }
+        filteredPlugins.sort((a, b) => a.priority - b.priority);
+        return filteredPlugins.map(plugin => plugin.instance);
+    }
+
+    /**
+     * @param {InternalModuleFormat[]} formats
+     */
+    function doExpandInputs(formats) {
+        if (inputs.length === 1) {
+            return formats;
+        }
+        const expanded = [];
+        for (const format of formats) {
+            if (expandInputs.has(format)) {
+                if (format !== 'umd') {
+                    for (const input of inputs) {
+                        expanded.push(`${format}.${input}`);
+                    }
+                } else {
+                    for (const entryName of configuration.outputs.umdEntries) {
+                        expanded.push(`${format}.${packageResult.entries.require(entryName).sourcePath}`);
+                    }
+                }
+            } else {
+                expanded.push(format);
+            }
+        }
+        return expanded;
+    }
+}

package/src/helpers.js

@@ -0,0 +1,229 @@
+import { access, constants, readFile } from 'node:fs/promises';
+import path, { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { cyan, magenta } from '@niceties/ansi';
+
+import { processPackageJson } from './options/index.js';
+
+/**
+ * @typedef {import('rollup').OutputOptions} OutputOptions
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ * @typedef {import('./options/index.js').PackageJson} PackageJsonO
+ */
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function camelCase(value) {
+    const words = String(value)
+        .normalize('NFKD')
+        .replaceAll(/\p{Mark}/gu, '')
+        .replaceAll(/([\p{Ll}\d])(\p{Lu})/gu, '$1 $2')
+        .replaceAll(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, '$1 $2')
+        .match(/[\p{L}\d]+/gu);
+
+    return (words ?? [])
+        .map((word, index) => {
+            const lowerCaseWord = word.toLowerCase();
+            return index === 0 ? lowerCaseWord : lowerCaseWord[0].toUpperCase() + lowerCaseWord.slice(1);
+        })
+        .join('');
+}
+
+/**
+ * @param {string} pkgName
+ */
+export function getHelpers(pkgName) {
+    /**
+     * @param {string} anInput
+     */
+    function getGlobalName(anInput) {
+        return camelCase(
+            path.join(
+                pkgName,
+                path.basename(anInput, path.extname(anInput)) !== 'index' ? path.basename(anInput, path.extname(anInput)) : ''
+            )
+        );
+    }
+
+    /**
+     * @param {string} id
+     */
+    function getExternalGlobalName(id) {
+        if (path.isAbsolute(id)) {
+            return getGlobalName(path.relative(__dirname, id));
+        }
+        return camelCase(id);
+    }
+
+    return {
+        getGlobalName,
+        getExternalGlobalName,
+    };
+}
+
+/**
+ * @template T
+ * @param {T | T[] | undefined} object
+ * @returns {T[]}
+ */
+export function toArray(object) {
+    if (Array.isArray(object)) {
+        return object;
+    }
+    if (object == null) {
+        return [];
+    }
+    return [object];
+}
+
+/**
+ * @param {string[] | string} input
+ * @returns {string}
+ */
+export function formatInput(input) {
+    return (Array.isArray(input) ? input : [input ?? '']).map(item => magenta(path.basename(item, path.extname(item)))).join(', ');
+}
+
+/**
+ * @param {OutputOptions | OutputOptions[] | undefined} output
+ * @param {'dir' | 'format'} field
+ * @returns {string}
+ */
+export function formatOutput(output, field) {
+    if (output == null) {
+        return '';
+    }
+    return (Array.isArray(output) ? output : [output ?? '']).map(item => cyan(/** @type {string} */ (item[field]))).join(', ');
+}
+
+/**
+ * @param {number} starting
+ * @returns {string}
+ */
+export function getTimeDiff(starting) {
+    const diff = Date.now() - starting;
+    return diff >= 1000 ? `${(diff / 1000).toFixed(1)}s` : `${diff}ms`;
+}
+
+/**
+ * @template T
+ * @param {Set<T>} a
+ * @param {Set<T>} b
+ * @returns {boolean}
+ */
+export const areSetsEqual = (a, b) => (a.size === b.size ? [...a].every(value => b.has(value)) : false);
+
+/**
+ * @param {PackageJson} pkg
+ * @returns {PackageJson}
+ */
+export function formatPackageJson(pkg) {
+    return /** @type {PackageJson} */ (
+        processPackageJson(
+            /** @type {PackageJsonO} */ (pkg),
+            key => key in pkg,
+            key => /** @type {Record<string, unknown>} */ (pkg)[key]
+        )
+    );
+}
+
+/**
+ * @param {string} file
+ * @returns {Promise<string | false>}
+ */
+export async function isExists(file) {
+    try {
+        await access(file);
+    } catch (e) {
+        if (typeof e === 'object' && e != null && 'code' in e && e.code === 'ENOENT') {
+            return /** @type {const} */ (false);
+        }
+        throw e;
+    }
+    return file;
+}
+
+/**
+ * @param {string} file
+ * @returns {Promise<boolean>}
+ */
+export async function isReadable(file) {
+    try {
+        await access(file, constants.R_OK);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * @param {string} root
+ * @param {string} file
+ */
+function hasFile(root, file) {
+    const path = join(root, file);
+    return isExists(path);
+}
+
+/**
+ * @param {string} root
+ * @returns {Promise<boolean>}
+ */
+async function hasWorkspacePackageJson(root) {
+    const path = join(root, 'package.json');
+    if (!(await isReadable(path))) {
+        return false;
+    }
+    try {
+        const content = /** @type {PackageJson} */ (JSON.parse(await readFile(path, 'utf-8')) || {});
+        return !!content.workspaces;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * @param {string} current
+ * @returns {Promise<string>}
+ */
+export async function searchForPackageRoot(current) {
+    const root = current;
+    let dir = current;
+
+    while (dir) {
+        if (await hasFile(dir, 'package.json')) return dir;
+
+        const parentDir = dirname(dir);
+        if (parentDir === dir) break;
+
+        dir = parentDir;
+    }
+
+    return root;
+}
+
+/**
+ * @param {string} current
+ * @returns {Promise<string>}
+ */
+export async function searchForWorkspaceRoot(current) {
+    const root = await searchForPackageRoot(current);
+    let dir = current;
+
+    while (dir) {
+        if (await hasFile(dir, 'pnpm-workspace.yaml')) return dir;
+        if (await hasWorkspacePackageJson(dir)) return dir;
+
+        const parentDir = dirname(dir);
+        if (parentDir === dir) break;
+
+        dir = parentDir;
+    }
+
+    return root;
+}