pkgbld 1.36.0 → 2.1.0

package/src/get-plugins.js

@@ -0,0 +1,44 @@
+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 packageImports from './builtin-plugins/package-imports.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, packageImports, 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,261 @@
+import path from 'node:path';
+
+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 publicEntries = packageResult.entries.values.filter(entry => entry.origin !== 'import');
+    const privateEntries = packageResult.entries.values.filter(entry => entry.origin === 'import');
+    const inputs = publicEntries.map(entry => entry.sourcePath);
+    const publicInputSet = new Set(inputs);
+    const entriesBySourcePath = new Map(publicEntries.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?.some(input => publicInputSet.has(input)) && !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 publicPluginInputs = plugin.inputs?.filter(input => publicInputSet.has(input));
+            if (plugin.inputs && publicPluginInputs?.length === 0) continue;
+            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 /** @type {string[]} */ (publicPluginInputs)) {
+                        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)] });
+    }
+
+    const publicConfigs = 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),
+        };
+    });
+
+    const privateConfigs = privateEntries.map(entry => {
+        const [[format, outputPath]] = Object.entries(entry.outputPaths);
+        const input = entry.sourcePath;
+        const selectedFormat = /** @type {InternalModuleFormat} */ (format);
+        return {
+            input,
+            output: [
+                {
+                    format: selectedFormat,
+                    dir: configuration.paths.outputDir,
+                    entryFileNames: path
+                        .relative(path.resolve(configuration.paths.outputDir), path.resolve(outputPath))
+                        .replaceAll('\\', '/'),
+                    plugins: getPlugins([selectedFormat], [input], true, true),
+                    sourcemap: configuration.outputs.sourcemaps.includes(/** @type {import('./types.js').BuildFormat} */ (selectedFormat)),
+                    ...getExtraOutputSettings(selectedFormat, [input]),
+                },
+            ],
+            plugins: getPlugins([selectedFormat], [input], false, true),
+        };
+    });
+
+    return [...publicConfigs, ...privateConfigs];
+
+    /**
+     * @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
+     * @param {boolean} [privateOutput]
+     */
+    function getPlugins(formats, inputs, outputPlugin, privateOutput = false) {
+        const filteredPlugins = [];
+        for (const plugin of plugins) {
+            if (!!plugin.outputPlugin === outputPlugin) {
+                const publicPluginInputs = plugin.inputs?.filter(input => publicInputSet.has(input));
+                if (
+                    (!plugin.format || toArray(plugin.format).some(format => formats.includes(format))) &&
+                    (!plugin.inputs ||
+                        plugin.inputs.length === 0 ||
+                        (privateOutput
+                            ? plugin.inputs.some(input => inputs.includes(input))
+                            : publicPluginInputs?.length > 0 && publicPluginInputs.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;
+}

package/src/index.js

@@ -0,0 +1,133 @@
+/// <reference path="./rollup-plugin-preprocess.d.ts" />
+import '@niceties/draftlog-appender';
+import { dirname, join } from 'node:path';
+
+import { rollup } from 'rollup';
+
+import { green } from '@niceties/ansi';
+import { createLogger, LogLevel } from '@niceties/logger';
+
+import { resolveBuildConfiguration } from './build-configuration.js';
+import { createBuildPluginLifecycle } from './build-plugin-lifecycle.js';
+import { createEjectProvider, ejectConfig } from './eject.js';
+import { getJson } from './get-json.js';
+import { createProvider } from './get-plugins.js';
+import { getRollupConfigs } from './get-rollup-configs.js';
+import { formatInput, formatOutput, formatPackageJson, getHelpers, getTimeDiff, searchForWorkspaceRoot, toArray } from './helpers.js';
+import { loadPlugins } from './load-plugins.js';
+import { mainLoggerText } from './messages.js';
+import { processPackage } from './process-pkg.js';
+import { checkTsConfig } from './process-ts-config.js';
+import { writeJson } from './write-json.js';
+
+/**
+ * @typedef {import('rollup').RollupOptions} RollupOptions
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ * @typedef {import('./types.js').PkgbldPlugin} PkgbldPlugin
+ */
+
+execute();
+
+async function execute() {
+    const time = Date.now();
+    const mainLogger = createLogger();
+    mainLogger.update('preparing..');
+    try {
+        /** @type {PackageJson} */
+        let pkg;
+        /** @type {string} */
+        let pkgPath;
+        [pkgPath, pkg] = /** @type {[string, PackageJson]} */ (await getJson('package.json'));
+        /** @type {Set<string>} */
+        const loadedPlugins = new Set();
+        const plugins = await loadPlugins(pkg, loadedPlugins, pkgPath);
+        const [rootPackagePath, rootPkg] = await getJson(join(await searchForWorkspaceRoot(dirname(pkgPath)), 'package.json'));
+        if (rootPackagePath !== pkgPath) {
+            plugins.push(...(await loadPlugins(rootPkg, loadedPlugins, rootPackagePath)));
+        }
+        const pluginLifecycle = createBuildPluginLifecycle(plugins);
+        mainLogger.update('');
+        process.stdout.moveCursor?.(0, -1);
+        const configuration = resolveBuildConfiguration({ packageJson: pkg, pluginLifecycle });
+        process.stdout.moveCursor?.(0, 1);
+        mainLogger.update('preparing...');
+        await checkTsConfig(configuration, mainLogger, pluginLifecycle);
+        const packageResult = await processPackage(pkg, configuration, pluginLifecycle);
+        if (configuration.packageJson.format) {
+            pkg = formatPackageJson(pkg);
+        }
+        const helpers = getHelpers(/** @type {{ name: string }} */ (pkg).name);
+        const provider = configuration.execution.eject ? await createEjectProvider() : createProvider();
+        const rollupConfigs = await getRollupConfigs(provider, packageResult, configuration, helpers, pluginLifecycle);
+
+        if (!configuration.execution.bundle) {
+            rollupConfigs.length = 0;
+        }
+
+        if (configuration.execution.eject) {
+            await ejectConfig(rollupConfigs, pkgPath, configuration, packageResult, helpers, pkg);
+            mainLogger.finish(`ejected config in ${getTimeDiff(time)}`);
+            if (configuration.packageJson.update) {
+                await writeJson(pkgPath, pkg);
+            }
+        } else {
+            const updater = mainLoggerText(configuration.paths.sourceDir, configuration.paths.outputDir, rollupConfigs.length, time);
+            mainLogger.start(updater());
+
+            await Promise.all(rollupConfigs.map(config => buildConfig(config, updater)));
+
+            if (configuration.packageJson.update) {
+                await writeJson(pkgPath, pkg);
+            }
+            await pluginLifecycle.buildEnd(configuration);
+
+            mainLogger.finish(updater(true));
+        }
+    } catch (e) {
+        mainLogger.finish(String(e), LogLevel.error);
+        process.exit(-1);
+    }
+
+    /**
+     * @param {RollupOptions} config
+     * @param {() => string} updater
+     */
+    async function buildConfig(config, updater) {
+        const bundle = await rollup(config);
+        await Promise.all(toArray(config.output).map(config => bundle.write(config)));
+        await bundle.close();
+        mainLogger(
+            `${green('✓')} ${formatInput(
+                /** @type {string | string[]} */ (
+                    typeof config.input === 'object' && !Array.isArray(config.input) ? Object.values(config.input) : config.input
+                )
+            )} [${formatOutput(config.output, 'format')}]`
+        );
+        mainLogger.update(updater());
+    }
+}
+
+/** @typedef {import('./types.js').Json} Json */
+/** @typedef {import('./types.js').BuildConfiguration} BuildConfiguration */
+/** @typedef {import('./types.js').BuildFormat} BuildFormat */
+/** @typedef {import('./types.js').BuildConfigurationDraft} BuildConfigurationDraft */
+/** @typedef {import('./types.js').BuildConfigurationSources} BuildConfigurationSources */
+/** @typedef {import('./types.js').BuildEntry} BuildEntry */
+/** @typedef {import('./types.js').BuildEntries} BuildEntries */
+/** @typedef {import('./types.js').BuildEntryContribution} BuildEntryContribution */
+/** @typedef {import('./types.js').BuildEntryContributions} BuildEntryContributions */
+/** @typedef {import('./types.js').BuildEntryIssue} BuildEntryIssue */
+/** @typedef {import('./types.js').ParsedOptions} ParsedOptions */
+/** @typedef {import('./types.js').PackageProcessingResult} PackageProcessingResult */
+/** @typedef {import('./types.js').PluginSharedState} PluginSharedState */
+/** @typedef {import('./types.js').PluginConfigureContext} PluginConfigureContext */
+/** @typedef {import('./types.js').PluginContributeEntriesContext} PluginContributeEntriesContext */
+/** @typedef {import('./types.js').PluginPackageContext} PluginPackageContext */
+/** @typedef {import('./types.js').PluginTsConfigContext} PluginTsConfigContext */
+/** @typedef {import('./types.js').PluginRollupContext} PluginRollupContext */
+/** @typedef {import('./types.js').PluginOutputContext} PluginOutputContext */
+/** @typedef {import('./types.js').PluginBuildEndContext} PluginBuildEndContext */
+/** @typedef {import('./types.js').PkgbldPluginFactory} PkgbldPluginFactory */
+/** @typedef {import('./types.js').Provider} Provider */
+/** @typedef {import('./types.js').ProvideFunction} ProvideFunction */
+/** @typedef {import('./types.js').PkgbldRollupPlugin} PkgbldRollupPlugin */