pkgbld 1.35.1 → 2.0.0

package/src/process-pkg.js

@@ -0,0 +1,237 @@
+import path from 'node:path';
+
+import { createLogger, LogLevel } from '@niceties/logger';
+
+import { resolveBuildEntries } from './build-entries.js';
+
+/**
+ * @typedef {import('type-fest').JsonObject} JsonObject
+ * @typedef {import('type-fest').JsonValue} JsonValue
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ * @typedef {import('./types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {import('./types.js').PackageProcessingResult} PackageProcessingResult
+ * @typedef {ReturnType<typeof import('./build-plugin-lifecycle.js').createBuildPluginLifecycle>} BuildPluginLifecycle
+ */
+
+/** @type {Set<string>} */
+const emptySet = new Set();
+/**
+ * @param {JsonObject} pkg
+ * @param {BuildConfiguration} configuration
+ * @param {BuildPluginLifecycle} pluginLifecycle
+ * @returns {Promise<PackageProcessingResult>}
+ */
+export async function processPackage(pkg, configuration, pluginLifecycle) {
+    const indexId = 'index';
+    const { outputs, packageJson, paths } = configuration;
+
+    const logger = createLogger();
+    /** @type {string[]} */
+    let executableOutputs = [];
+    const allowEsm = outputs.formats.includes('es');
+    const allowCjs = outputs.formats.includes('cjs');
+    const allowUmd = outputs.formats.includes('umd');
+
+    if (typeof pkg !== 'object' || Array.isArray(pkg) || pkg == null) {
+        logger.finish('expecting object on top level of package.json', LogLevel.error);
+        process.exit(-1);
+    }
+
+    if (typeof pkg.name !== 'string' && outputs.umdEntries.length > 0) {
+        logger.finish('expecting name to be a string in package.json', LogLevel.error);
+        process.exit(-1);
+    }
+
+    if (!Array.isArray(pkg.files)) {
+        pkg.files = [];
+    }
+
+    if (!pkg.files.includes(paths.outputDir)) {
+        /** @type {string[]} */ (pkg.files).push(paths.outputDir);
+    }
+
+    if (typeof pkg.scripts !== 'object' && pkg.scripts !== null) {
+        pkg.scripts = {};
+    }
+
+    if (packageJson.pack && !('prepack' in /** @type {Record<string, JsonObject>} */ (pkg.scripts))) {
+        /** @type {Record<string, JsonValue>} */ (pkg.scripts).prepack = 'pkgprn';
+    }
+
+    /** @type {string[]} */
+    const entryNames = [];
+    if (packageJson.exports) {
+        if (typeof pkg.exports === 'object' && pkg.exports != null && !Array.isArray(pkg.exports)) {
+            for (const id in pkg.exports) {
+                if (id !== './package.json') entryNames.push(exportIdToEntryName(id));
+            }
+        }
+        if (!entryNames.includes(indexId)) entryNames.unshift(indexId);
+    } else {
+        entryNames.push(indexId);
+    }
+
+    const entries = await resolveBuildEntries(entryNames, configuration, contributions =>
+        pluginLifecycle.contributeEntries(contributions, configuration)
+    );
+    const indexEntry = entries.require(indexId);
+
+    if (allowEsm && !allowCjs && typeof pkg.type !== 'string') {
+        pkg.type = 'module';
+    }
+
+    const exportsFields = new Set([
+        'svelte',
+        pkg.type === 'module' ? 'require' : 'import',
+        pkg.type === 'module' ? 'import' : 'require',
+        'default',
+    ]);
+
+    if (allowUmd && typeof pkg.umd === 'string') {
+        if (outputs.umdEntries.includes(indexId)) {
+            pkg.umd = /** @type {string} */ (indexEntry.outputPaths.umd);
+        }
+    }
+
+    if (allowCjs) {
+        pkg.main = /** @type {string} */ (indexEntry.outputPaths.cjs);
+    }
+
+    if (allowEsm && !allowCjs) {
+        pkg.main = /** @type {string} */ (indexEntry.outputPaths.es);
+    }
+
+    if (allowCjs && allowEsm && typeof pkg.module !== 'string') {
+        pkg.module = /** @type {string} */ (indexEntry.outputPaths.es);
+    }
+
+    if (allowUmd && outputs.umdEntries.includes(indexId)) {
+        pkg.unpkg = /** @type {string} */ (indexEntry.outputPaths.umd);
+    }
+
+    if (packageJson.exports) {
+        if (typeof pkg.exports !== 'object' || pkg.exports == null || Array.isArray(pkg.exports)) {
+            pkg.exports = {};
+        }
+        if (/** @type {Record<string, JsonValue>} */ (pkg.exports)['.'] == null) {
+            /** @type {Record<string, JsonValue>} */ (pkg.exports)['.'] = {};
+        }
+        /** @type {Record<string, JsonValue>} */ (pkg.exports)['./package.json'] = './package.json';
+
+        if (
+            allowCjs &&
+            pkg.main !== /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)['.']).require
+        ) {
+            /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)['.']).require =
+                /** @type {JsonValue} */ (pkg.main);
+        }
+
+        if (
+            pkg.module !== /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)['.'])?.default
+        ) {
+            /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)['.']).default =
+                /** @type {JsonValue} */ (pkg.module);
+        }
+
+        for (const id in /** @type {object} */ (pkg.exports)) {
+            if (id === './package.json') continue;
+
+            const basename = exportIdToEntryName(id);
+            const entry = entries.require(basename);
+
+            if (typeof (/** @type {Record<string, JsonValue>} */ (pkg.exports)[id]) !== 'object') {
+                /** @type {Record<string, JsonValue>} */ (pkg.exports)[id] = {};
+            }
+
+            const cjsFieldName = pkg.type === 'module' ? 'require' : 'default';
+            const esmFieldName = pkg.type === 'module' ? 'default' : 'import';
+
+            if (allowEsm) {
+                /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)[id])[esmFieldName] =
+                    /** @type {string} */ (entry.outputPaths.es);
+            }
+
+            if (allowCjs) {
+                /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)[id])[cjsFieldName] =
+                    /** @type {string} */ (entry.outputPaths.cjs);
+            }
+
+            /** @type {Record<string, JsonValue>} */ (pkg.exports)[id] = orderFields(
+                exportsFields,
+                /** @type {Record<string, JsonValue>} */ (/** @type {Record<string, JsonValue>} */ (pkg.exports)[id])
+            );
+        }
+    }
+
+    pluginLifecycle.processPackageJson(/** @type {PackageJson} */ (pkg), entries, configuration);
+
+    if (packageJson.executables.mode === 'explicit') {
+        executableOutputs = [...packageJson.executables.values];
+        if (executableOutputs.length > 0) {
+            pkg.bin = /** @type {string} */ (executableOutputs[0]);
+        }
+    } else if (packageJson.executables.mode === 'infer' && allowCjs && entries.values.length > 0) {
+        if (typeof pkg.bin === 'string') {
+            if (entries.values.some(entry => pkg.bin === entry.outputPaths.cjs)) {
+                executableOutputs = [pkg.bin];
+            }
+        } else if (typeof pkg.bin === 'object' && pkg.bin !== null) {
+            executableOutputs = /** @type {string[]} */ (
+                Object.values(pkg.bin).filter(
+                    value => typeof value === 'string' && entries.values.some(entry => value === entry.outputPaths.cjs)
+                )
+            );
+        }
+        if (
+            typeof pkg.directories === 'object' &&
+            pkg.directories != null &&
+            'bin' in pkg.directories &&
+            typeof pkg.directories.bin === 'string'
+        ) {
+            if (path.resolve(pkg.directories.bin) === path.resolve(paths.outputDir)) {
+                executableOutputs.push(...entries.values.flatMap(entry => (entry.outputPaths.cjs == null ? [] : [entry.outputPaths.cjs])));
+                executableOutputs = Array.from(new Set(executableOutputs));
+            }
+        }
+    }
+
+    return { entries, executableOutputs };
+}
+
+/**
+ * @param {string} id
+ */
+function exportIdToEntryName(id) {
+    return id === '.' ? 'index' : id.replace(/^\.\//, '').replaceAll('\\', '/');
+}
+
+/**
+ * @template {object} T
+ * @param {Set<string>} firstFields
+ * @param {T} exports
+ * @param {Set<string>} [lastFields]
+ * @returns {T}
+ */
+function orderFields(firstFields, exports, lastFields = emptySet) {
+    const ordered = /** @type {T} */ ({});
+
+    for (const key of firstFields) {
+        if (/** @type {keyof T} */ (key) in exports) {
+            /** @type {Record<string, unknown>} */ (ordered)[key] = /** @type {Record<string, unknown>} */ (exports)[key];
+        }
+    }
+
+    for (const key in exports) {
+        if (!firstFields.has(key) && !lastFields.has(key)) {
+            /** @type {Record<string, unknown>} */ (ordered)[key] = /** @type {Record<string, unknown>} */ (exports)[key];
+        }
+    }
+
+    for (const key of lastFields) {
+        if (/** @type {keyof T} */ (key) in exports) {
+            /** @type {Record<string, unknown>} */ (ordered)[key] = /** @type {Record<string, unknown>} */ (exports)[key];
+        }
+    }
+
+    return ordered;
+}

package/src/process-ts-config.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+
+import { fastIsEqual } from 'fast-is-equal';
+
+import { getJson } from './get-json.js';
+import { writeJson } from './write-json.js';
+
+/**
+ * @typedef {import('@niceties/logger').Logger} Logger
+ * @typedef {import('type-fest').JsonObject} JsonObject
+ * @typedef {import('./types.js').BuildConfiguration} BuildConfiguration
+ * @typedef {ReturnType<typeof import('./build-plugin-lifecycle.js').createBuildPluginLifecycle>} BuildPluginLifecycle
+ */
+
+/**
+ * @param {string} sourceDir
+ * @returns {Record<string, unknown>}
+ */
+function createDefaultTsConfig(sourceDir) {
+    return {
+        include: [sourceDir, 'types'],
+        compilerOptions: {
+            lib: ['dom', 'esnext'],
+            target: 'esnext',
+            module: 'esnext',
+            esModuleInterop: true,
+            allowJs: true,
+            skipLibCheck: true,
+            strict: true,
+            sourceMap: true,
+            noUncheckedIndexedAccess: true,
+            declaration: true,
+            moduleResolution: 'bundler',
+            rootDir: `./${sourceDir}`,
+        },
+    };
+}
+
+/**
+ * @param {BuildConfiguration} configuration
+ * @param {Logger} mainLogger
+ * @param {BuildPluginLifecycle} pluginLifecycle
+ * @returns {Promise<JsonObject | undefined>}
+ */
+export async function checkTsConfig(configuration, mainLogger, pluginLifecycle) {
+    if (!configuration.typescript.updateConfig) {
+        return;
+    }
+    /** @type {JsonObject | undefined} */
+    let config,
+        needWrite = false;
+    try {
+        [, config] = await getJson('tsconfig.json');
+    } catch {
+        /*ignore*/
+    }
+    try {
+        [, config] = await getJson('jsconfig.json');
+        if (config && typeof config === 'object' && !Array.isArray(config)) {
+            config.allowJs = true;
+        }
+    } catch {
+        /*ignore*/
+    }
+    if (!config) {
+        config = /** @type {JsonObject} */ (createDefaultTsConfig(configuration.paths.sourceDir || 'src'));
+        needWrite = true;
+    }
+    const originalConfig = structuredClone(config);
+    pluginLifecycle.processTsConfig(config, configuration);
+    if (!fastIsEqual(originalConfig, config)) {
+        needWrite = true;
+    }
+    if (needWrite) {
+        mainLogger('no tsconfig.json or jsconfig.json and --no-ts-config not specified, writing tsconfig...');
+        await writeJson(path.resolve('tsconfig.json'), config);
+        mainLogger('done');
+    }
+    return config;
+}

package/src/rollup-plugin-preprocess.d.ts

@@ -0,0 +1 @@
+declare module 'rollup-plugin-preprocess';

package/src/types.js

@@ -0,0 +1,170 @@
+/**
+ * @typedef {import('rollup').InternalModuleFormat} InternalModuleFormat
+ * @typedef {import('rollup').OutputOptions} OutputOptions
+ * @typedef {import('rollup').Plugin} Plugin
+ * @typedef {import('type-fest').JsonObject} JsonObject
+ * @typedef {import('type-fest').PackageJson} PackageJson
+ */
+
+/** @typedef {null | string | number | boolean | JsonArray | JsonRecord} Json */
+/** @typedef {Json[]} JsonArray */
+/** @typedef {{ [name: string]: Json }} JsonRecord */
+
+/**
+ * @typedef {(
+ *   factory: () => Plugin,
+ *   priority: number,
+ *   options?: {
+ *     format?: InternalModuleFormat | InternalModuleFormat[];
+ *     inputs?: string[];
+ *     outputPlugin?: true;
+ *   }
+ * ) => void} ProvideFunction
+ */
+
+/**
+ * @typedef {{
+ *   provide: ProvideFunction;
+ *   import: (module: string, exportName?: string) => Promise<(...args: unknown[]) => Plugin>;
+ *   globalImport: (module: string, exportName?: string | string[]) => void;
+ *   globalSetup: (code: ((...args: any[]) => any) | string) => ((...args: any[]) => any) | undefined;
+ * }} Provider
+ */
+
+/**
+ * @typedef {{
+ *   plugin: () => Plugin;
+ *   priority: number;
+ *   format?: InternalModuleFormat | InternalModuleFormat[];
+ *   inputs?: string[];
+ *   outputPlugin?: true;
+ * }} PkgbldRollupPlugin
+ */
+
+/** @typedef {'infer' | 'disabled' | 'explicit'} ExecutableMode */
+/** @typedef {'es' | 'cjs' | 'umd'} BuildFormat */
+/** @typedef {'ts' | 'tsx' | 'js' | 'jsx' | 'cjs' | 'mjs'} BuildEntryExtension */
+
+/**
+ * @typedef {{
+ *   paths: { sourceDir: string; outputDir: string };
+ *   outputs: {
+ *     formats: BuildFormat[];
+ *     patterns: { es: string; cjs: string; umd: string };
+ *     umdEntries: string[];
+ *     sourcemaps: BuildFormat[];
+ *   };
+ *   transforms: {
+ *     compress: BuildFormat[];
+ *     preprocess: string[];
+ *     includeExternals: boolean | string[];
+ *     removeLegalComments: boolean;
+ *   };
+ *   packageJson: {
+ *     update: boolean;
+ *     format: boolean;
+ *     exports: boolean;
+ *     pack: boolean;
+ *     executables: { mode: ExecutableMode; values: string[] };
+ *   };
+ *   typescript: { updateConfig: boolean };
+ *   execution: { clean: boolean; bundle: boolean; eject: boolean };
+ * }} BuildConfigurationDraft
+ */
+
+/**
+ * @typedef {Readonly<{
+ *   paths: Readonly<{ sourceDir: string; outputDir: string }>;
+ *   outputs: Readonly<{
+ *     formats: readonly BuildFormat[];
+ *     patterns: Readonly<{ es: string; cjs: string; umd: string }>;
+ *     umdEntries: readonly string[];
+ *     sourcemaps: readonly BuildFormat[];
+ *   }>;
+ *   transforms: Readonly<{
+ *     compress: readonly BuildFormat[];
+ *     preprocess: readonly string[];
+ *     includeExternals: boolean | readonly string[];
+ *     removeLegalComments: boolean;
+ *   }>;
+ *   packageJson: Readonly<{
+ *     update: boolean;
+ *     format: boolean;
+ *     exports: boolean;
+ *     pack: boolean;
+ *     executables: Readonly<{ mode: ExecutableMode; values: readonly string[] }>;
+ *   }>;
+ *   typescript: Readonly<{ updateConfig: boolean }>;
+ *   execution: Readonly<{ clean: boolean; bundle: boolean; eject: boolean }>;
+ * }>} BuildConfiguration
+ */
+
+/** @typedef {Record<string, string | number | string[] | number[] | boolean | undefined>} ParsedOptions */
+
+/**
+ * @typedef {Readonly<{
+ *   defaults: BuildConfiguration;
+ *   package: Readonly<PackageJson>;
+ *   cli: Readonly<{
+ *     values: Readonly<ParsedOptions>;
+ *     provided: Readonly<Record<string, boolean>>;
+ *   }>;
+ * }>} BuildConfigurationSources
+ */
+
+/** @typedef {Map<unknown, unknown>} PluginSharedState */
+
+/**
+ * @typedef {Readonly<{
+ *   name: string;
+ *   sourcePath: string;
+ *   extension: BuildEntryExtension;
+ *   outputPaths: Readonly<Partial<Record<BuildFormat, string>>>;
+ * }>} BuildEntry
+ */
+
+/** @typedef {{ name: string; sourcePath?: string }} BuildEntryContribution */
+/** @typedef {{ add(contribution: BuildEntryContribution): void }} BuildEntryContributions */
+/** @typedef {{ code: 'INVALID_BUILD_ENTRY_NAME' | 'DUPLICATE_BUILD_ENTRY' | 'SOURCE_NOT_FOUND' | 'SELECTED_BUILD_ENTRY_NOT_FOUND' | 'OUTPUT_PATH_COLLISION'; path: string; message: string; name?: string }} BuildEntryIssue */
+
+/**
+ * @typedef {Readonly<{
+ *   values: readonly BuildEntry[];
+ *   require(name: string): BuildEntry;
+ * }>} BuildEntries
+ */
+
+/**
+ * @typedef {Readonly<{
+ *   entries: BuildEntries;
+ *   executableOutputs: readonly string[];
+ * }>} PackageProcessingResult
+ */
+
+/** @typedef {{ draft: BuildConfigurationDraft; sources: BuildConfigurationSources; shared: PluginSharedState }} PluginConfigureContext */
+/** @typedef {{ entries: BuildEntryContributions; configuration: BuildConfiguration; shared: PluginSharedState }} PluginContributeEntriesContext */
+/** @typedef {{ packageJson: PackageJson; entries: BuildEntries; configuration: BuildConfiguration; shared: PluginSharedState }} PluginPackageContext */
+/** @typedef {{ config: JsonObject; configuration: BuildConfiguration; shared: PluginSharedState }} PluginTsConfigContext */
+/** @typedef {{ provider: Provider; configuration: BuildConfiguration; packageResult: PackageProcessingResult; shared: PluginSharedState }} PluginRollupContext */
+/** @typedef {{ format: InternalModuleFormat; inputs: string[]; configuration: BuildConfiguration; shared: PluginSharedState }} PluginOutputContext */
+/** @typedef {{ configuration: BuildConfiguration; shared: PluginSharedState }} PluginBuildEndContext */
+
+/**
+ * @typedef {{
+ *   create(): Promise<Partial<PkgbldPlugin>>;
+ * }} PkgbldPluginFactory
+ */
+
+/**
+ * @typedef {{
+ *   configure(context: PluginConfigureContext): void;
+ *   contributeEntries(context: PluginContributeEntriesContext): void;
+ *   processPackageJson(context: PluginPackageContext): void;
+ *   processTsConfig(context: PluginTsConfigContext): void;
+ *   providePlugins(context: PluginRollupContext): Promise<void>;
+ *   getExtraOutputSettings(context: PluginOutputContext): Partial<OutputOptions>;
+ *   buildEnd(context: PluginBuildEndContext): Promise<void>;
+ * }} PkgbldPlugin
+ */
+
+export {};

package/src/write-json.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+
+import { toFormattedJson } from './options/index.js';
+
+/**
+ * @typedef {import('type-fest').JsonObject} JsonObject
+ */
+
+/**
+ * @param {string} path
+ * @param {JsonObject} json
+ */
+export async function writeJson(path, json) {
+    let current;
+    try {
+        current = await fs.readFile(path, 'utf8');
+    } catch (/** @type {any} */ error) {
+        if (error.code !== 'ENOENT') throw error;
+    }
+    await fs.writeFile(path, toFormattedJson(json, current));
+}