pkgbld 1.35.1 → 2.0.0

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 */

package/src/load-plugins.js

@@ -0,0 +1,37 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+/**
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ */
+
+import { isPluginPackageName } from './plugin-name.js';
+
+/**
+ * @param {PackageJson} pkg
+ * @param {Set<string>} loaded
+ * @param {string} packageJsonPath
+ */
+export async function loadPlugins(pkg, loaded, packageJsonPath) {
+    const resolveFromPackage = createRequire(packageJsonPath).resolve;
+    return await Promise.all(
+        [
+            ...new Set([
+                ...Object.keys(pkg.devDependencies || {}),
+                ...Object.keys(pkg.dependencies || {}),
+                ...Object.keys(pkg.peerDependencies || {}),
+            ]),
+        ]
+            .filter(packageName => isPluginPackageName(packageName) && !loaded.has(packageName))
+            .map(async packageName => {
+                loaded.add(packageName);
+                try {
+                    const pluginPath = resolveFromPackage(packageName);
+                    const pluginFactory = await import(pathToFileURL(pluginPath).href);
+                    return await pluginFactory.create();
+                } catch (cause) {
+                    throw new Error(`Failed to load Build plugin ${JSON.stringify(packageName)} from ${packageJsonPath}`, { cause });
+                }
+            })
+    );
+}

package/src/messages.js

@@ -0,0 +1,13 @@
+import { getTimeDiff } from './helpers.js';
+
+/**
+ * @param {string} sourceDir
+ * @param {string} dir
+ * @param {number} configsCount
+ * @param {number} startingTime
+ * @param {number} [finishedCount]
+ */
+export const mainLoggerText =
+    (sourceDir, dir, configsCount, startingTime, finishedCount = 0) =>
+    (final = false) =>
+        `${sourceDir} → ${dir} ${final ? configsCount : finishedCount++} / ${configsCount}${final ? ` in ${getTimeDiff(startingTime)}` : ''}`;

package/src/options/index.js

@@ -0,0 +1,266 @@
+/** @typedef {import('./types.js').PackageJson} PackageJson */
+
+/**
+ * @param {unknown} value
+ * @returns {value is PackageJson}
+ */
+export function isPackageJson(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const obj = /** @type {Record<string, unknown>} */ (value);
+    if (obj.private !== undefined && typeof obj.private !== 'boolean') return false;
+    if (obj.version !== undefined && typeof obj.version !== 'string') return false;
+    if (obj.name !== undefined && typeof obj.name !== 'string') return false;
+    if (obj.main !== undefined && typeof obj.main !== 'string') return false;
+    if (obj.license !== undefined && typeof obj.license !== 'string') return false;
+    if (obj.readme !== undefined && typeof obj.readme !== 'string') return false;
+    if (obj.description !== undefined && typeof obj.description !== 'string') return false;
+    if (obj.bugs !== undefined && typeof obj.bugs !== 'string') return false;
+    if (obj.homepage !== undefined && typeof obj.homepage !== 'string') return false;
+    if (obj.bin !== undefined && typeof obj.bin !== 'string' && (typeof obj.bin !== 'object' || obj.bin === null || Array.isArray(obj.bin)))
+        return false;
+    if (
+        obj.author !== undefined &&
+        typeof obj.author !== 'string' &&
+        (typeof obj.author !== 'object' || obj.author === null || Array.isArray(obj.author))
+    )
+        return false;
+    return true;
+}
+
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
+function CommaSeparatedString(value) {
+    if (value === '') return [];
+    return value.split(',').map((/** @type {string} */ arg) => arg.trim());
+}
+
+/**
+ * @param {string} value
+ * @returns {true | string[]}
+ */
+function CommaSeparatedStringOrBoolean(value) {
+    if (value === '') {
+        return true;
+    }
+    return CommaSeparatedString(value);
+}
+
+export const cliFlagsDefaults = {
+    formats: /** @type {string[]} */ (['es', 'cjs']),
+    umd: /** @type {string[]} */ ([]),
+    compress: /** @type {string[]} */ (['umd']),
+    sourcemaps: /** @type {string[]} */ (['umd']),
+    preprocess: /** @type {string[]} */ ([]),
+    dest: 'dist',
+    src: 'src',
+    bin: /** @type {string[] | undefined} */ (undefined),
+    includeExternals: /** @type {boolean | string[]} */ (false),
+    eject: false,
+    tsConfig: false,
+    updatePackageJson: true,
+    commonjsPattern: '[name].cjs',
+    esmPattern: '[name].mjs',
+    umdPattern: '[name].umd.js',
+    formatPackageJson: false,
+};
+
+/**
+ * @typedef {{
+ *   type: 'string' | 'boolean' | ((value: string) => unknown);
+ *   description: string;
+ *   default?: string | boolean | string[] | boolean[];
+ *   optionalValue?: boolean;
+ * }} CliFlag
+ */
+
+/** @type {Record<string, CliFlag>} */
+export const cliFlags = {
+    umd: {
+        type: /** @type {(value: string) => string[]} */ (CommaSeparatedString),
+        description: 'Package subpath exports in UMD format',
+    },
+    compress: {
+        type: /** @type {(value: string) => string[]} */ (CommaSeparatedString),
+        description: 'Compress formats using terser',
+    },
+    sourcemaps: {
+        type: /** @type {(value: string) => string[]} */ (CommaSeparatedString),
+        description: 'Emit sourcemaps for the specified formats',
+    },
+    formats: {
+        type: /** @type {(value: string) => string[]} */ (CommaSeparatedString),
+        description: 'Formats to emit',
+    },
+    preprocess: {
+        type: /** @type {(value: string) => string[]} */ (CommaSeparatedString),
+        description: 'Preprocess entry points / subpath exports',
+    },
+    dest: {
+        type: /** @type {'string'} */ ('string'),
+        description: 'Output directory',
+        default: cliFlagsDefaults.dest,
+    },
+    src: {
+        type: /** @type {'string'} */ ('string'),
+        description: 'Source directory',
+        default: cliFlagsDefaults.src,
+    },
+    bin: {
+        type: /** @type {(value: string) => string[]} */ (CommaSeparatedString),
+        description: 'Executable files',
+    },
+    includeExternals: {
+        type: /** @type {(value: string) => true | string[]} */ (CommaSeparatedStringOrBoolean),
+        description: 'Include all/specified externals into the result bundle(s)',
+        optionalValue: true,
+    },
+    eject: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Eject config',
+        default: cliFlagsDefaults.eject,
+    },
+    tsConfig: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Create / update tsconfig.json',
+        default: cliFlagsDefaults.tsConfig,
+    },
+    updatePackageJson: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Create / update package.json',
+        default: cliFlagsDefaults.updatePackageJson,
+    },
+    commonjsPattern: {
+        type: /** @type {'string'} */ ('string'),
+        description: 'CommonJS output file name pattern',
+        default: cliFlagsDefaults.commonjsPattern,
+    },
+    esmPattern: {
+        type: /** @type {'string'} */ ('string'),
+        description: 'ES output file name pattern',
+        default: cliFlagsDefaults.esmPattern,
+    },
+    umdPattern: {
+        type: /** @type {'string'} */ ('string'),
+        description: 'UMD output file name pattern',
+        default: cliFlagsDefaults.umdPattern,
+    },
+    formatPackageJson: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Format package.json',
+        default: cliFlagsDefaults.formatPackageJson,
+    },
+    pack: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Pack',
+        default: true,
+    },
+    exports: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Add exports field to package.json',
+        default: true,
+    },
+    clean: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Clean the output directory',
+        default: true,
+    },
+    bundle: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Bundle',
+        default: true,
+    },
+    removeLegalComments: {
+        type: /** @type {'boolean'} */ ('boolean'),
+        description: 'Remove legal comments',
+        default: false,
+    },
+};
+
+export const packageJsonFieldsOrder = new Set([
+    'private',
+    'type',
+    'version',
+    'name',
+    'scope', // custom
+    'description',
+    'license',
+    'author',
+    'contributors',
+    'funding',
+    'bin',
+    'main',
+    'browser',
+    'unpkg',
+    'module',
+    'svelte',
+    'exports',
+    'imports',
+    'types',
+    'typings',
+    'typesVersions', // non standard but required for typescript with resolution other than nodenext
+    'files',
+    'packageManager',
+    'sideEffects',
+    'engines',
+    'os',
+    'cpu',
+    'man',
+    'directories',
+    'repository',
+    'bugs',
+    'homepage',
+    'readme',
+    'keywords',
+    'scripts',
+    'config',
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'peerDependenciesMeta',
+    'bundleDependencies',
+    'bundledDependencies',
+    'optionalDependencies',
+    'overrides',
+    'publishConfig',
+    'workspaces',
+]);
+
+/**
+ * @param {PackageJson} pkg
+ * @param {(key: string) => boolean} needTreatment
+ * @param {(key: string) => unknown} treatKey
+ * @returns {PackageJson}
+ */
+export function processPackageJson(pkg, needTreatment, treatKey) {
+    /** @type {PackageJson} */
+    const newPkg = {};
+
+    for (const key of packageJsonFieldsOrder) {
+        if (needTreatment(key)) {
+            /** @type {Record<string, unknown>} */ (newPkg)[key] = treatKey(key);
+        }
+    }
+
+    for (const key in pkg) {
+        if (!packageJsonFieldsOrder.has(key)) {
+            /** @type {Record<string, unknown>} */ (newPkg)[key] = /** @type {Record<string, unknown>} */ (pkg)[key];
+        }
+    }
+
+    return newPkg;
+}
+
+/**
+ * @template {object | null | number | string | boolean} T
+ * @param {T} json
+ * @param {string | null} [current] Existing file contents used to detect indentation.
+ * @returns {string}
+ */
+export function toFormattedJson(json, current) {
+    const indent = current?.match(/^[ \t]+(?=\S)/m)?.[0] ?? 2;
+    return `${JSON.stringify(json, null, indent)}\n`;
+}

package/src/options/types.js

@@ -0,0 +1,24 @@
+/**
+ * @typedef {{
+ *   private?: boolean;
+ *   version?: string;
+ *   name?: string;
+ *   bin?: string | Record<string, string>;
+ *   main?: string;
+ *   license?: string;
+ *   readme?: string;
+ *   author?: string | { name?: string; email?: string; url?: string; };
+ *   description?: string;
+ *   scripts?: { [key: string]: string; };
+ *   repository?: { type?: string; url?: string; };
+ *   files?: string[];
+ *   bugs?: string;
+ *   homepage?: string;
+ *   dependencies?: Record<string, string>;
+ *   devDependencies?: Record<string, string>;
+ *   peerDependencies?: Record<string, string>;
+ *   exports?: Record<string, string | Record<string, string>>;
+ * }} PackageJson
+ */
+
+export {};

package/src/plugin-name.js

@@ -0,0 +1,6 @@
+const PLUGIN_PACKAGE_RE = /^(?:@[^/]+\/)?pkgbld-plugin-/;
+
+/** @param {string} packageName */
+export function isPluginPackageName(packageName) {
+    return PLUGIN_PACKAGE_RE.test(packageName);
+}

package/src/priorities.js

@@ -0,0 +1,10 @@
+export const Priority = /** @type {const} */ ({
+    preprocess: 1000,
+    cleanup: 1000,
+    externals: 2000,
+    resolve: 3000,
+    commonjs: 4000,
+    transpile: 6000,
+    compress: 10000,
+    finalize: 20000,
+});