@visulima/packem 2.0.0-alpha.32 → 2.0.0-alpha.33

package/dist/types.d.ts

@@ -0,0 +1,328 @@
+import type { CheckPackageOptions } from "@arethetypeswrong/core";
+import type { IsolatedDeclarationsTransformer, PackemRollupOptions, TransformerFn, TransformerName } from "@visulima/packem-rollup";
+import type { InternalOXCTransformPluginConfig } from "@visulima/packem-rollup/oxc";
+import type { BuildContext, BuildHooks, Environment, Format, Mode, Runtime } from "@visulima/packem-share/types";
+import type { FileCache } from "@visulima/packem-share/utils";
+import type { StyleOptions } from "@visulima/rollup-plugin-css";
+import type { JitiOptions } from "jiti";
+import type { Plugin } from "rollup";
+import type { TypeDocOptions as BaseTypeDocumentOptions } from "typedoc";
+import type { Node10CompatibilityOptions } from './packem/node10-compatibility.d.ts';
+import type { ResolveExternalsPluginOptions } from './rollup/plugins/resolve-externals-plugin.d.ts';
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export interface AttwOptions extends CheckPackageOptions {
+    /**
+     * Ignore the scripts on pack
+     * @default false
+     */
+    ignoreScripts?: boolean;
+    /**
+     * The level of the check.
+     *
+     * The available levels are:
+     * - `error`: fails the build
+     * - `warn`: warns the build
+     * @default 'warn'
+     */
+    level?: "error" | "warn";
+    /**
+     * Specify the package manager to use for --pack
+     * Bun does not support --json option on the pack command, if you choose bun you will get a error.
+     * @default 'auto'
+     */
+    pm?: "pnpm" | "yarn" | "npm" | "bun" | "auto";
+    /**
+     * Profiles select a set of resolution modes to require/ignore. All are evaluated but failures outside
+     * of those required are ignored.
+     *
+     * The available profiles are:
+     * - `strict`: requires all resolutions
+     * - `node16`: ignores node10 resolution failures
+     * - `esmOnly`: ignores CJS resolution failures
+     * @default 'strict'
+     */
+    profile?: "strict" | "node16" | "esmOnly";
+}
+/**
+ * In addition to basic `entries`, `presets`, and `hooks`,
+ * there are also all the properties of `BuildOptions` except for BuildOption's `entries`.
+ */
+export interface BuildConfig extends DeepPartial<Omit<BuildOptions, "entries">> {
+    entries?: (BuildEntry | string)[];
+    hooks?: Partial<BuildHooks<InternalBuildOptions>>;
+    preset?: BuildPreset | "auto" | "none" | (NonNullable<unknown> & string);
+}
+export type BuildPreset = BuildConfig | (() => BuildConfig);
+/**
+ * Function type for dynamic build configuration.
+ * Allows configuration to be generated based on environment and mode.
+ * @param environment The build environment (development/production)
+ * @param mode The build mode (build/watch)
+ * @returns Build configuration object or Promise resolving to one
+ * @public
+ */
+export type BuildConfigFunction = (environment: Environment, mode: Mode) => BuildConfig | Promise<BuildConfig>;
+export type BuildEntry = {
+    /** Whether to generate CommonJS output for this entry */
+    cjs?: boolean;
+    /** TypeScript declaration file generation mode */
+    declaration?: boolean | "compatible" | "node16";
+    /** Build environment for this entry */
+    environment?: Environment;
+    /** Whether to generate ESM output for this entry */
+    esm?: boolean;
+    /** Whether this entry should be marked as executable */
+    executable?: true;
+    /** Set of export keys to include for this entry */
+    exportKey?: Set<string>;
+    /** Alternative filename for the output file */
+    fileAlias?: string;
+    /** Input file path for this entry */
+    input: string;
+    /** Whether the input is a glob pattern */
+    isGlob?: boolean;
+    /** Name identifier for this entry */
+    name?: string;
+    /** Output directory for this entry */
+    outDir?: string;
+    /** Runtime environment for this entry */
+    runtime?: Runtime;
+};
+export type InferEntriesResult = {
+    /** Inferred build entries */
+    entries: BuildEntry[];
+    /** Warning messages from the inference process */
+    warnings: string[];
+};
+export interface BuildOptions {
+    /** Path alias mappings for module resolution */
+    alias: Record<string, string>;
+    /** Whether to analyze bundle size and dependencies */
+    analyze?: boolean;
+    /** Browser targets for transpilation (e.g., ['chrome 58', 'firefox 57']) */
+    browserTargets?: string[];
+    /** Custom builder functions for different build types */
+    builder?: Record<string, (context: BuildContext<BuildOptions>, cachePath: string | undefined, fileCache: FileCache, logged: boolean) => Promise<void>>;
+    /** Whether to enable CommonJS interop for ESM modules */
+    cjsInterop?: boolean;
+    /** Whether to clean the output directory before building */
+    clean: boolean;
+    /** Whether to enable debug mode with verbose logging */
+    debug: boolean;
+    /**
+     * `compatible` means "src/gather.ts" will generate "dist/index.d.mts", "dist/index.d.cts" and "dist/index.d.ts".
+     * `node16` means "src/gather.ts" will generate "dist/index.d.mts" and "dist/index.d.cts".
+     * `true` is equivalent to `compatible`.
+     * `false` will disable declaration generation.
+     * `undefined` will auto-detect based on "package.json". If "package.json" has "types" field, it will be `"compatible"`, otherwise `false`.
+     */
+    declaration?: boolean | "compatible" | "node16" | undefined;
+    /**
+     * If `true`, only generate declaration files.
+     * If `false` or `undefined`, generate both declaration and source files.
+     */
+    dtsOnly?: boolean;
+    /** Whether to emit CommonJS output */
+    emitCJS?: boolean;
+    /** Whether to emit ESM output */
+    emitESM?: boolean;
+    /** Build entry points */
+    entries: BuildEntry[];
+    /** Experimental features configuration */
+    experimental?: {
+        /**
+         * If `true`, the `oxc resolve` plugin will be used instead of the default `@rollup/plugin-node-resolve` and `@rollup/plugin-alias`.
+         */
+        oxcResolve?: boolean;
+    };
+    /** External dependencies that should not be bundled */
+    externals: (RegExp | string)[];
+    /** Whether to fail the build on warnings */
+    failOnWarn?: boolean;
+    /** Whether to enable file caching for faster rebuilds */
+    fileCache?: boolean;
+    /**
+     * Array of export keys to ignore during entry inference.
+     * Useful for excluding exports that only contain images or other non-JavaScript assets.
+     * @example ["images", "assets", "icons"]
+     */
+    ignoreExportKeys?: string[];
+    /**
+     * Isolated declaration transformer for TypeScript declaration generation
+     * @experimental
+     */
+    isolatedDeclarationTransformer?: IsolatedDeclarationsTransformer;
+    /**
+     * Jiti options, where [jiti](https://github.com/unjs/jiti) is used to load the entry files.
+     * @default { alias: {}, debug: false, interopDefault: true }
+     */
+    jiti: Omit<JitiOptions & {
+        absoluteJitiPath?: boolean;
+    }, "onError" | "transform">;
+    /** Signal to use when killing child processes */
+    killSignal?: KillSignal;
+    /** Whether to minify the output */
+    minify?: boolean | undefined;
+    /** Name of the build */
+    name: string;
+    /** Node.js 10 compatibility options */
+    node10Compatibility?: Node10CompatibilityOptions | false;
+    /** Command to run or function to execute after successful build */
+    onSuccess?: string | (() => Promise<(() => Promise<void> | void) | undefined | void>);
+    /** Timeout for the onSuccess command in milliseconds */
+    onSuccessTimeout?: number;
+    /** Output directory for build artifacts */
+    outDir: string;
+    /** Custom file extensions for different output formats */
+    outputExtensionMap?: Record<Format, string>;
+    /** Rollup-specific build options */
+    rollup: RollupBuildOptions;
+    /** Root directory of the project */
+    rootDir: string;
+    /** Target runtime environment */
+    runtime?: "browser" | "node";
+    /** Source directory containing the source files */
+    sourceDir: string;
+    /** Whether to generate source maps */
+    sourcemap: boolean;
+    /** Transformer function for processing source files */
+    transformer: TransformerFn;
+    /** TypeDoc configuration for generating documentation */
+    typedoc: TypeDocumentOptions | false;
+    /**
+     * If `true`, enables unbundle mode which preserves the source file structure.
+     * Instead of bundling everything into a single file, each module is output as a separate file
+     * maintaining the original directory structure.
+     * @default false
+     * @example
+     * ```typescript
+     * // With unbundle: true
+     * // src/index.ts exports from './a/indexA', '.d.ts';
+     * // Output: dist/index.js, dist/a/indexA.js, dist/b/indexB.js
+     * ```
+     */
+    unbundle?: boolean;
+    /** Validation options for the build */
+    validation?: ValidationOptions | false;
+}
+export interface InternalBuildOptions extends BuildOptions {
+    /** Rollup options with internal OXC configuration */
+    rollup: BuildOptions["rollup"] & {
+        nativeModules?: NativeModulesOptions | false;
+        oxc?: InternalOXCTransformPluginConfig;
+    };
+    /** Name of the transformer being used */
+    transformerName: TransformerName | undefined;
+}
+/** Valid kill signals for terminating child processes */
+export type KillSignal = "SIGKILL" | "SIGTERM";
+export interface RollupBuildOptions extends PackemRollupOptions {
+    /** CSS processing options or false to disable */
+    css?: StyleOptions | false;
+    /** External dependency resolution plugin options */
+    resolveExternals?: ResolveExternalsPluginOptions;
+}
+export type RollupPlugins = {
+    /** Plugin enforcement order ('pre' or 'post') */
+    enforce?: "post" | "pre";
+    /** The Rollup plugin instance */
+    plugin: Plugin;
+    /** Type of build this plugin applies to */
+    type?: "build" | "dts";
+}[];
+export type TypeDocumentOptions = Partial<Omit<BaseTypeDocumentOptions, "entryPoints" | "hideGenerator" | "out" | "preserveWatchOutput" | "watch">> & {
+    /**
+     * The format of the output.
+     * @default "html"
+     */
+    format?: "html" | "inline" | "json" | "markdown";
+    /**
+     * The name of the JSON file.
+     */
+    jsonFileName?: string;
+    /**
+     * A marker to replace the content within the file on the correct location.
+     * @default "TYPEDOC" This marker need to be placed in the readme &lt;!-- TYPEDOC -->&lt;!-- TYPEDOC -->
+     */
+    marker?: string;
+    /**
+     * The path of the output directory.
+     */
+    output?: string;
+    /**
+     * The path of the README file.
+     */
+    readmePath?: string;
+};
+export type ValidationOptions = {
+    /**
+     * Run `arethetypeswrong` after bundling.
+     * Requires `@arethetypeswrong/core` to be installed.
+     * @default false
+     * @see https://github.com/arethetypeswrong/arethetypeswrong.github.io
+     */
+    attw?: boolean | AttwOptions;
+    /** Bundle size validation options */
+    bundleLimit?: {
+        /** Allow the build to succeed even if limits are exceeded */
+        allowFail?: boolean;
+        /**
+         * Bundle size limit in bytes, or string with unit (e.g., "1MB", "500KB")
+         * @example
+         * - "1MB"
+         * - "500KB"
+         * - 1048576 // 1MB in bytes
+         */
+        limit?: number | `${number}${"B" | "GB" | "KB" | "MB" | "TB"}`;
+        /** Size limits for specific files or globs */
+        limits?: Record<string, number | `${number}${"B" | "GB" | "KB" | "MB" | "TB"}`>;
+    };
+    /** Dependency validation options */
+    dependencies: {
+        /** Hoisted dependency validation with exclusions */
+        hoisted: {
+            exclude: string[];
+        } | false;
+        /** Unused dependency validation with exclusions */
+        unused: {
+            exclude: string[];
+        } | false;
+    } | false;
+    /** Package.json validation options */
+    packageJson?: {
+        /** Allowed file extensions in exports field */
+        allowedExportExtensions?: string[];
+        /** Whether to validate the bin field */
+        bin?: boolean;
+        /** Whether to validate dependencies */
+        dependencies?: boolean;
+        /** Whether to validate the engines field */
+        engines?: boolean;
+        /** Whether to validate the exports field */
+        exports?: boolean;
+        /**
+         * Additional custom conditions to consider valid in exports field validation.
+         * These will be added to the standard and community conditions.
+         * @example ["custom", "my-bundler"]
+         */
+        extraConditions?: string[];
+        /** Whether to validate the files field */
+        files?: boolean;
+        /** Whether to validate the main field */
+        main?: boolean;
+        /** Whether to validate the module field */
+        module?: boolean;
+        /** Whether to validate the name field */
+        name?: boolean;
+        /** Whether to validate the sideEffects field */
+        sideEffects?: boolean;
+        /** Whether to validate the types field */
+        types?: boolean;
+        /** Whether to validate the typesVersions field */
+        typesVersions?: boolean;
+    };
+};
+export type { Environment, Format, Mode, Runtime } from "@visulima/packem-share/types";
+export type { InjectOptions, StyleOptions } from "@visulima/rollup-plugin-css";

package/dist/utils/clean-distribution-directories.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+declare const cleanDistributionDirectories: (context: BuildContext<InternalBuildOptions>) => Promise<void>;
+export default cleanDistributionDirectories;

package/dist/utils/create-or-update-key-storage.d.ts

@@ -0,0 +1,3 @@
+import type { Pail } from "@visulima/pail";
+declare const createOrUpdateKeyStorage: (hashKey: string, storePath: string, logger: Pail, shouldUpdate?: true) => void;
+export default createOrUpdateKeyStorage;

package/dist/utils/extract-export-filenames.d.ts

@@ -0,0 +1,16 @@
+import type { PackageJson } from "@visulima/package";
+import type { BuildOptions, Format } from "../types.d.ts";
+declare const runtimeExportConventions: Set<string>;
+export type OutputDescriptor = {
+    exportKey?: string;
+    fieldName?: string;
+    file: string;
+    /** Whether this output was from an ignored export key */
+    ignored?: boolean;
+    isExecutable?: true;
+    key: "bin" | "exports" | "main" | "module" | "types";
+    subKey?: typeof runtimeExportConventions | (NonNullable<unknown> & string);
+    type?: Format;
+};
+export declare const extractExportFilenames: (packageExports: PackageJson["exports"], packageType: "cjs" | "esm", declaration: BuildOptions["declaration"], conditions?: string[], ignoreExportKeys?: string[]) => OutputDescriptor[];
+export {};

package/dist/utils/find-alternatives.d.ts

@@ -0,0 +1,2 @@
+declare const findAlternatives: (string: string, array: string[]) => string[];
+export default findAlternatives;

package/dist/utils/get-package-side-effect.d.ts

@@ -0,0 +1,3 @@
+import type { PackageJson } from "@visulima/package";
+declare const getPackageSideEffect: (cwd: string, packageJson: PackageJson) => (id: string) => boolean | undefined;
+export default getPackageSideEffect;

package/dist/utils/infer-export-type.d.ts

@@ -0,0 +1,3 @@
+import type { Format } from "../types.d.ts";
+export declare const inferExportTypeFromFileName: (filename: string) => Format | undefined;
+export declare const inferExportType: (condition: string, previousConditions: string[], packageType: Format, filename?: string) => Format;

package/dist/utils/kill-process.d.ts

@@ -0,0 +1,14 @@
+import type { KillSignal } from "../types.d.ts";
+/**
+ * Terminates a process with the specified signal.
+ * @param params The parameters object
+ * @param params.pid Process ID to terminate
+ * @param params.signal Signal to send ('SIGTERM', 'SIGKILL', etc.)
+ * @throws {Error} If pid is invalid or process termination fails
+ * @returns Resolves when process is terminated
+ */
+declare const killProcess: ({ pid, signal }: {
+    pid: number;
+    signal: KillSignal;
+}) => Promise<void>;
+export default killProcess;

package/dist/utils/log-build-errors.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+declare const logBuildErrors: (context: BuildContext<InternalBuildOptions>, hasOtherLogs: boolean) => void;
+export default logBuildErrors;

package/dist/utils/remove-old-cache-folders.d.ts

@@ -0,0 +1,3 @@
+import type { Pail } from "@visulima/pail";
+declare const removeOldCacheFolders: (cachePath: string | undefined, logger: Pail, logged: boolean) => Promise<void>;
+export default removeOldCacheFolders;

package/dist/utils/warn-legacy-cjs.d.ts

@@ -0,0 +1,8 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+/**
+ * Warns when building CommonJS for Node targets that have deprecated CJS.
+ * Triggers for Node >= 23.0.0 or >= 22.12.0.
+ */
+declare const warnLegacyCJS: (context: BuildContext<InternalBuildOptions>) => void;
+export default warnLegacyCJS;

package/dist/validator/attw.d.ts

@@ -0,0 +1,7 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+/**
+ * End.
+ */
+declare const attw: (context: BuildContext<InternalBuildOptions>, logged: boolean) => Promise<void>;
+export default attw;

package/dist/validator/package-json/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../../types.d.ts";
+declare const validator: (context: BuildContext<InternalBuildOptions>) => void;
+export default validator;

package/dist/validator/package-json/validate-dependencies.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../../types.d.ts";
+declare const validateDependencies: (context: BuildContext<InternalBuildOptions>) => void;
+export default validateDependencies;

package/dist/validator/package-json/validate-engines.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../../types.d.ts";
+declare const validateEngines: (context: BuildContext<InternalBuildOptions>) => void;
+export default validateEngines;

package/dist/validator/package-json/validate-package-entries.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../../types.d.ts";
+declare const validatePackageEntries: (context: BuildContext<InternalBuildOptions>) => void;
+export default validatePackageEntries;

package/dist/validator/package-json/validate-package-fields.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../../types.d.ts";
+declare const validatePackageFields: (context: BuildContext<InternalBuildOptions>) => void;
+export default validatePackageFields;

package/dist/validator/validate-alias-entries.d.ts

@@ -0,0 +1,3 @@
+import type { Alias } from "@visulima/packem-rollup";
+declare const validateAliasEntries: (entries: ReadonlyArray<Alias> | Record<string, string>) => void;
+export default validateAliasEntries;

package/dist/validator/validate-bundle-size.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+declare const validateBundleSize: (context: BuildContext<InternalBuildOptions>, logged: boolean) => void;
+export default validateBundleSize;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/packem",
-  "version": "2.0.0-alpha.32",
+  "version": "2.0.0-alpha.33",
   "description": "A fast and modern bundler for Node.js and TypeScript.",
   "keywords": [
     "anolilab",
@@ -171,7 +171,7 @@
     "@visulima/fs": "3.1.8",
     "@visulima/humanizer": "1.2.2",
     "@visulima/package": "4.0.0",
-    "@visulima/packem-rollup": "1.0.0-alpha.25",
+    "@visulima/packem-rollup": "1.0.0-alpha.26",
     "@visulima/packem-share": "1.0.0-alpha.13",
     "@visulima/pail": "2.1.28",
     "@visulima/path": "1.4.0",