@visulima/packem 2.0.0-alpha.6 → 2.0.0-alpha.60

package/dist/config/preset/react.d.ts

@@ -0,0 +1,59 @@
+import type { BabelPluginConfig } from "@visulima/packem-rollup/babel";
+import type { BuildConfig } from "../../types.d.ts";
+export interface ReactPresetOptions {
+    /**
+     * Enable React Compiler optimization
+     * @default false
+     */
+    compiler?: boolean | {
+        /**
+         * React Compiler compilation mode
+         * @default "infer"
+         */
+        compilationMode?: "infer" | "annotation";
+        /**
+         * React Compiler panic threshold
+         * @default "critical_errors"
+         */
+        panicThreshold?: "critical_errors" | "all_errors";
+    };
+    /**
+     * Custom Babel plugins to add
+     */
+    plugins?: BabelPluginConfig["plugins"];
+    /**
+     * Custom Babel presets to add
+     */
+    presets?: BabelPluginConfig["presets"];
+}
+/**
+ * React preset for Packem. Configures Babel with React presets and optionally React Compiler.
+ * @description This preset configures Babel to run before your main transformer (esbuild/SWC/etc.).
+ * Babel handles JSX transformation, while TypeScript is handled by the transformer via parser plugins.
+ * This matches the approach used by @vitejs/plugin-react.
+ * @example
+ * ```typescript
+ * // Basic usage
+ * export default defineConfig({
+ *   preset: "react"
+ * });
+ *
+ * // With React Compiler
+ * import { createReactPreset } from "@visulima/packem/config/preset/react";
+ * export default defineConfig({
+ *   preset: createReactPreset({
+ *     compiler: true
+ *   })
+ * });
+ *
+ * // With custom options
+ * export default defineConfig({
+ *   preset: createReactPreset({
+ *     compiler: {
+ *       compilationMode: "annotation"
+ *     }
+ *   })
+ * });
+ * ```
+ */
+export declare const createReactPreset: (options?: ReactPresetOptions) => BuildConfig;

package/dist/config/preset/react.js

@@ -0,0 +1 @@
+var f=Object.defineProperty;var d=(o,e)=>f(o,"name",{value:e,configurable:!0});var m=Object.defineProperty,b=d((o,e)=>m(o,"name",{value:e,configurable:!0}),"s");const v=b((o={})=>{const{compiler:e=!1,plugins:a=[],presets:l=[]}=o,i=[],p=[];if(e){const s=typeof e=="object"?e:{};i.push(["babel-plugin-react-compiler",{compilationMode:s.compilationMode??"infer",panicThreshold:s.panicThreshold??"critical_errors"}])}p.push(["@babel/preset-react",{runtime:"automatic"}]);const c=[...i,...Array.isArray(a)?a:[]],u=[...p,...Array.isArray(l)?l:[]];return{hooks:{"rollup:options":b((s,h)=>{const r=s.options.rollup.babel;if(r&&typeof r=="object"&&r.presets){const n=r.presets.findIndex(t=>Array.isArray(t)&&t[0]==="@babel/preset-react");if(n!==-1){const t=r.presets[n];r.presets[n]=[t[0],{...typeof t[1]=="object"&&t[1]!==null?t[1]:{},development:s.environment==="development"}]}}},"rollup:options")},rollup:{babel:{plugins:c.length>0?c:void 0,presets:u.length>0?u:void 0}},validation:{dependencies:{hoisted:{exclude:[]},unused:{exclude:["react","react-dom"]}}}}},"createReactPreset");export{v as createReactPreset};

package/dist/config/preset/solid.d.ts

@@ -0,0 +1,101 @@
+import type { BabelPluginConfig } from "@visulima/packem-rollup/babel";
+import type { BuildConfig } from "../../types.d.ts";
+export interface SolidPresetOptions {
+    /**
+     * Pass any additional babel transform options. They will be merged with
+     * the transformations required by Solid.
+     */
+    babel?: BabelPluginConfig | ((source: string, id: string) => BabelPluginConfig | Promise<BabelPluginConfig>);
+    /**
+     * Custom Babel plugins to add
+     */
+    plugins?: BabelPluginConfig["plugins"];
+    /**
+     * Custom Babel presets to add
+     */
+    presets?: BabelPluginConfig["presets"];
+    /**
+     * SolidJS-specific options for babel-preset-solid
+     */
+    solidOptions?: {
+        /**
+         * Array of Component exports from module, that aren't included by default with the library.
+         * This plugin will automatically import them if it comes across them in the JSX.
+         * @default ["For","Show","Switch","Match","Suspense","SuspenseList","Portal","Index","Dynamic","ErrorBoundary"]
+         */
+        builtIns?: string[];
+        /**
+         * Boolean indicates whether to set current render context on Custom Elements and slots.
+         * Useful for seemless Context API with Web Components.
+         * @default true
+         */
+        contextToCustomElements?: boolean;
+        /**
+         * Boolean to indicate whether to enable automatic event delegation on camelCase.
+         * @default true
+         */
+        delegateEvents?: boolean;
+        /**
+         * The output mode of the compiler.
+         * Can be:
+         * - "dom" is standard output
+         * - "ssr" is for server side rendering of strings.
+         * - "universal" is for using custom renderers from solid-js/universal
+         * @default "dom"
+         */
+        generate?: "ssr" | "dom" | "universal";
+        /**
+         * Indicate whether the output should contain hydratable markers.
+         * @default false
+         */
+        hydratable?: boolean;
+        /**
+         * The name of the runtime module to import the methods from.
+         * @default "solid-js/web"
+         */
+        moduleName?: string;
+        /**
+         * Boolean indicates whether smart conditional detection should be used.
+         * This optimizes simple boolean expressions and ternaries in JSX.
+         * @default true
+         */
+        wrapConditionals?: boolean;
+    };
+}
+/**
+ * SolidJS preset for Packem. Configures Babel with babel-preset-solid.
+ * @description This preset configures Babel to run before your main transformer (esbuild/SWC/etc.).
+ * Babel handles JSX transformation for SolidJS using babel-preset-solid. TypeScript is handled
+ * automatically via parser plugins based on file extensions (no preset needed).
+ * @example
+ * ```typescript
+ * // Basic usage
+ * export default defineConfig({
+ *   preset: "solid"
+ * });
+ *
+ * // With custom Solid options
+ * import { createSolidPreset } from "@visulima/packem/config/preset/solid";
+ * export default defineConfig({
+ *   preset: createSolidPreset({
+ *     solidOptions: {
+ *       generate: "ssr",
+ *       hydratable: true
+ *     }
+ *   })
+ * });
+ *
+ * // With custom Babel options
+ * export default defineConfig({
+ *   preset: createSolidPreset({
+ *     solidOptions: {
+ *       moduleName: "solid-js/web"
+ *     },
+ *     babel: {
+ *       // Additional babel options
+ *     }
+ *   })
+ * });
+ * ```
+ */
+export declare const createSolidPreset: (options?: SolidPresetOptions) => BuildConfig;

package/dist/config/preset/solid.js

@@ -0,0 +1 @@
+var j=Object.defineProperty;var g=(o,e)=>j(o,"name",{value:e,configurable:!0});var O=Object.defineProperty,a=g((o,e)=>O(o,"name",{value:e,configurable:!0}),"a");const N=a(o=>{const e={contextToCustomElements:o?.contextToCustomElements??!0,delegateEvents:o?.delegateEvents??!0,generate:o?.generate??"dom",hydratable:o?.hydratable??!1,moduleName:o?.moduleName??"solid-js/web",wrapConditionals:o?.wrapConditionals??!0};return o?.builtIns!==void 0&&(e.builtIns=o.builtIns),e},"buildSolidPresetOptions"),E=a((o,e,n,l)=>{if(!e||typeof e=="function")return o;let s=n;if(e.plugins){const i=Array.isArray(e.plugins)?e.plugins:[];s=[...n||[],...i]}let r=l;if(e.presets){const i=Array.isArray(e.presets)?e.presets:[];r=[...l||[],...i]}return{...o,...e,plugins:s&&s.length>0?s:void 0,presets:r&&r.length>0?r:void 0}},"mergeUserBabelOptions"),x=a((o={})=>{const{babel:e,plugins:n=[],presets:l=[],solidOptions:s={}}=o,r=[],i=[],m=["babel-preset-solid",N(s)];i.push(m);const u=[...r,...Array.isArray(n)?n:[]],d=[...i,...Array.isArray(l)?l:[]],b={ast:!1,babelrc:!1,configFile:!1,plugins:u.length>0?u:void 0,presets:d.length>0?d:void 0,sourceMaps:!0},f={babel:E(b,e,u,d),resolve:{exportConditions:["solid"]}};return{externals:["solid-js","solid-js/web","solid-js/store"],hooks:{"rollup:options":a((t,h)=>{const c=t.environment==="development"?"development":"production",p=c==="development",{runtime:y}=t.options,v=y==="node";t.options.rollup.replace||(t.options.rollup.replace={preventAssignment:!0,values:{}}),t.options.rollup.replace.values||(t.options.rollup.replace.values={});const S={[["import","meta","env","DEV"].join(".")]:p,[["import","meta","env","NODE_ENV"].join(".")]:JSON.stringify(c),[["import","meta","env","PROD"].join(".")]:!p,[["import","meta","env","SSR"].join(".")]:v,[["process","env","DEV"].join(".")]:JSON.stringify(String(p)),[["process","env","NODE_ENV"].join(".")]:JSON.stringify(c),[["process","env","PROD"].join(".")]:JSON.stringify(String(!p)),[["process","env","SSR"].join(".")]:JSON.stringify(String(v))};Object.assign(t.options.rollup.replace.values,S)},"rollup:options")},rollup:f,validation:{dependencies:{hoisted:{exclude:[]},unused:{exclude:["solid-js"]}}}}},"createSolidPreset");export{x as createSolidPreset};

package/dist/config/preset/svelte.d.ts

@@ -0,0 +1,71 @@
+import type { BuildConfig } from "../../types.d.ts";
+export interface SveltePresetOptions {
+    /**
+     * Svelte plugin options
+     */
+    pluginOptions?: {
+        /**
+         * Svelte compiler options
+         */
+        compilerOptions?: {
+            [key: string]: unknown;
+            /**
+             * Custom element mode
+             * @default false
+             */
+            customElement?: boolean;
+            /**
+             * Enable dev mode
+             * @default false
+             */
+            dev?: boolean;
+            /**
+             * Generate mode: "client" for client-side rendering, "server" for SSR
+             * @default "client"
+             */
+            generate?: "client" | "server" | false;
+            /**
+             * Enable hydratable output
+             * @default false
+             */
+            hydratable?: boolean;
+        };
+        /**
+         * Exclude patterns for Svelte files
+         */
+        exclude?: RegExp | RegExp[];
+        /**
+         * Include patterns for Svelte files
+         * @default [/\.svelte$/]
+         */
+        include?: RegExp | RegExp[];
+        /**
+         * Preprocessor options
+         */
+        preprocess?: unknown;
+    };
+}
+/**
+ * Svelte preset for Packem. Configures Rollup with rollup-plugin-svelte.
+ * @description This preset configures the Svelte plugin to handle .svelte file compilation.
+ * @example
+ * ```typescript
+ * // Basic usage
+ * export default defineConfig({
+ *   preset: "svelte"
+ * });
+ *
+ * // With custom options
+ * import { createSveltePreset } from "@visulima/packem/config/preset/svelte";
+ * export default defineConfig({
+ *   preset: createSveltePreset({
+ *     pluginOptions: {
+ *       compilerOptions: {
+ *         hydratable: true
+ *       }
+ *     }
+ *   })
+ * });
+ * ```
+ */
+export declare const createSveltePreset: (options?: SveltePresetOptions) => BuildConfig;

package/dist/config/preset/svelte.js

@@ -0,0 +1 @@
+var s=Object.defineProperty;var t=(r,e)=>s(r,"name",{value:e,configurable:!0});import{DEFAULT_EXTENSIONS as n}from"@visulima/packem-share/constants";import o from"rollup-plugin-svelte";var l=Object.defineProperty,i=t((r,e)=>l(r,"name",{value:e,configurable:!0}),"t");const d=i((r={})=>{const{pluginOptions:e={}}=r;return{rollup:{plugins:[{enforce:"pre",plugin:o({compilerOptions:{generate:"client",runes:!0,...e.compilerOptions},emitCss:!1,exclude:e.exclude,extensions:[".svelte"],include:e.include??[/\.svelte$/],preprocess:e.preprocess})}],resolve:{browser:!0,exportConditions:["svelte"],extensions:[...n,".svelte"]}},validation:{dependencies:{hoisted:{exclude:[]},unused:{exclude:["svelte"]}}}}},"createSveltePreset");export{d as createSveltePreset};

package/dist/config/preset/utils/infer-entries.d.ts

@@ -0,0 +1,12 @@
+import type { PackageJson } from "@visulima/package";
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InferEntriesResult, InternalBuildOptions } from "../../../types.d.ts";
+/**
+ * Infer entries from package files.
+ * @param packageJson
+ * @param sourceFiles A list of source files to use for inferring entries.
+ * @param context
+ * @returns
+ */
+declare const inferEntries: (packageJson: PackageJson, sourceFiles: string[], context: BuildContext<InternalBuildOptions>) => Promise<InferEntriesResult>;
+export default inferEntries;

package/dist/config/preset/utils/overwrite-with-publish-config.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizedPackageJson } from "@visulima/package";
+import type { BuildConfig } from "../../../types.d.ts";
+declare const overwriteWithPublishConfig: (packageJson: NormalizedPackageJson, declaration?: BuildConfig["declaration"]) => NormalizedPackageJson;
+export default overwriteWithPublishConfig;

package/dist/config/preset/vue.d.ts

@@ -0,0 +1,53 @@
+import type { BuildConfig } from "../../types.d.ts";
+export interface VuePresetOptions {
+    /**
+     * Vue plugin options
+     */
+    pluginOptions?: {
+        /**
+         * Enable custom elements mode
+         * @default false
+         */
+        customElement?: boolean;
+        /**
+         * Exclude patterns for Vue files
+         */
+        exclude?: RegExp | RegExp[];
+        /**
+         * Include patterns for Vue files
+         * @default [/\.vue$/]
+         */
+        include?: RegExp | RegExp[];
+        /**
+         * Template compiler options
+         */
+        template?: {
+            compilerOptions?: {
+                [key: string]: unknown;
+                isCustomElement?: (tag: string) => boolean;
+            };
+        };
+    };
+}
+/**
+ * Vue preset for Packem. Configures Rollup with unplugin-vue.
+ * @description This preset configures the Vue plugin to handle .vue file compilation.
+ * @example
+ * ```typescript
+ * // Basic usage
+ * export default defineConfig({
+ *   preset: "vue"
+ * });
+ *
+ * // With custom options
+ * import { createVuePreset } from "@visulima/packem/config/preset/vue";
+ * export default defineConfig({
+ *   preset: createVuePreset({
+ *     pluginOptions: {
+ *       customElement: true
+ *     }
+ *   })
+ * });
+ * ```
+ */
+export declare const createVuePreset: (options?: VuePresetOptions) => BuildConfig;

package/dist/config/preset/vue.js

@@ -0,0 +1 @@
+var n=Object.defineProperty;var u=(t,e)=>n(t,"name",{value:e,configurable:!0});import l from"unplugin-vue/rollup";var r=Object.defineProperty,c=u((t,e)=>r(t,"name",{value:e,configurable:!0}),"n");const a=c((t={})=>{const{pluginOptions:e={}}=t;return{rollup:{plugins:[{enforce:"pre",plugin:l({customElement:e.customElement??!1,exclude:e.exclude,include:e.include??[/\.vue$/],template:e.template})}]},validation:{dependencies:{hoisted:{exclude:[]},unused:{exclude:["vue"]}}}}},"createVuePreset");export{a as createVuePreset};

package/dist/config/utils/find-packem-file.d.ts

@@ -0,0 +1,2 @@
+declare const findPackemFile: (rootDirectory: string, configPath?: string) => Promise<string>;
+export default findPackemFile;

package/dist/config/utils/load-env-file.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Loads environment variables from a .env file with optional prefix filtering.
+ * Uses Node.js built-in `util.parseEnv` to parse the file content without modifying `process.env`.
+ * @param envFilePath Path to the .env file (relative to rootDirectory or absolute)
+ * @param rootDirectory Root directory for resolving relative paths
+ * @param prefix Optional prefix to filter environment variables (e.g., "PACKEM_")
+ * @returns Record of environment variables with keys formatted as "process.env.KEY"
+ * @example
+ * ```typescript
+ * const envVars = await loadEnvFile(".env", "/path/to/project", "PACKEM_");
+ * // Returns: { "process.env.PACKEM_API_URL": "\"https://api.example.com\"" }
+ * ```
+ */
+declare const loadEnvFile: (envFilePath: string, rootDirectory: string, prefix?: string) => Promise<Record<string, string>>;
+export default loadEnvFile;

package/dist/config/utils/load-package-json.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedPackageJson } from "@visulima/package";
+declare const loadPackageJson: (rootDirectory: string) => {
+    packageJson: NormalizedPackageJson;
+    packageJsonPath: string;
+};
+export default loadPackageJson;

package/dist/config/utils/load-packem-config.d.ts

@@ -0,0 +1,7 @@
+import type { Jiti } from "jiti";
+import type { BuildConfig, Environment, Mode } from "../../types.d.ts";
+declare const loadPackemConfig: (jiti: Jiti, rootDirectory: string, environment: Environment, mode: Mode, configPath?: string) => Promise<{
+    config: BuildConfig;
+    path: string;
+}>;
+export default loadPackemConfig;

package/dist/config/utils/load-preset.d.ts

@@ -0,0 +1,4 @@
+import type { Jiti } from "jiti";
+import type { BuildConfig, BuildPreset } from "../../types.d.ts";
+declare const loadPreset: (preset: BuildPreset | string, jiti: Jiti) => Promise<BuildConfig>;
+export default loadPreset;

package/dist/config/utils/load-tsconfig.d.ts

@@ -0,0 +1,5 @@
+import type { NormalizedPackageJson } from "@visulima/package";
+import type { Pail } from "@visulima/pail";
+import type { TsConfigResult } from "@visulima/tsconfig";
+declare const loadTsconfig: (rootDirectory: string, packageJson: NormalizedPackageJson, logger: Pail, tsconfigPath?: string) => Promise<TsConfigResult | undefined>;
+export default loadTsconfig;

package/dist/config/utils/prepare-entries.d.ts

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

package/dist/index.d.ts

@@ -1,36 +1,49 @@
-import { ConstructorOptions } from '@visulima/pail';
-import { B as BuildConfig } from './packem_shared/types-Dn9KmF6u.js';
-export { a as BuildEntry, b as BuildOptions, R as RollupBuildOptions } from './packem_shared/types-Dn9KmF6u.js';
-import { E as Environment, M as Mode } from './packem_shared/index-zikl8Yu3.js';
-export { B as BuildContext, b as BuildContextBuildAssetAndChunk, c as BuildContextBuildEntry, d as BuildHooks, I as IsolatedDeclarationsTransformer, R as Runtime, T as TransformerFn, a as TransformerName } from './packem_shared/index-zikl8Yu3.js';
-import '@visulima/rollup-css-plugin';
-import 'jiti';
-import 'typedoc';
-import '@rollup/plugin-alias';
-import '@rollup/plugin-commonjs';
-import '@rollup/plugin-json';
-import '@rollup/plugin-node-resolve';
-import '@rollup/plugin-replace';
-import '@rollup/plugin-wasm';
-import '@rollup/pluginutils';
-import 'rollup';
-import 'rollup-plugin-dts';
-import 'rollup-plugin-polyfill-node';
-import 'rollup-plugin-pure';
-import 'rollup-plugin-visualizer';
-import 'esbuild';
-import '@visulima/package';
-import '@visulima/colorize';
-import 'oxc-resolver';
-import 'oxc-transform';
-import 'sucrase';
-
-interface PackemOptions extends BuildConfig {
+import type { ConstructorOptions } from "@visulima/pail";
+import type { BuildConfig, Environment, Mode } from "./types.d.ts";
+/**
+ * Configuration options for Packem bundler.
+ * @interface PackemOptions
+ * @augments {BuildConfig}
+ */
+export interface PackemOptions extends BuildConfig {
+    /**
+     * The environment to build for
+     * Determines the build environment configuration
+     * @default "production"
+     * @type {Environment}
+     * @memberof PackemOptions
+     */
     environment?: Environment;
+    /**
+     * Logger configuration options
+     * Used to customize the logging behavior and output format
+     * @type {ConstructorOptions<string, string>}
+     * @memberof PackemOptions
+     */
     logger?: ConstructorOptions<string, string>;
+    /**
+     * The mode to run Packem in
+     * Controls how the bundler processes and optimizes the code
+     * @default "build"
+     * @type {Mode}
+     * @memberof PackemOptions
+     */
     mode?: Mode;
 }
-declare const packem: (rootDirectory: string, options?: PackemOptions) => Promise<void>;
-
-export { Environment, Mode, packem };
-export type { PackemOptions };
+/**
+ * Runs the Packem bundler with the specified options
+ * @param rootDirectory The root directory of the project to bundle
+ * @param options Configuration options for the bundler
+ * @returns Promise that resolves with the build result
+ * @example
+ * ```typescript
+ * const result = await packem("./src", {
+ *   mode: "build",
+ *   environment: "production"
+ * });
+ * ```
+ */
+export declare const packem: (rootDirectory: string, options?: PackemOptions) => Promise<void>;
+export type { BuildEntry, BuildOptions, RollupBuildOptions } from "./types.d.ts";
+export type { IsolatedDeclarationsTransformer, TransformerFn, TransformerName } from "@visulima/packem-rollup";
+export type { BuildContext, BuildContextBuildAssetAndChunk, BuildContextBuildEntry, BuildHooks, Environment, Mode, Runtime, } from "@visulima/packem-share/types";

package/dist/index.js

@@ -1 +1 @@
-var c=Object.defineProperty;var o=(e,r)=>c(e,"name",{value:r,configurable:!0});import{createPail as s}from"@visulima/pail";import{SimpleReporter as u}from"@visulima/pail/reporter";import{y as g}from"./packem_shared/index-BHVpfOuE.js";var f=Object.defineProperty,l=o((e,r)=>f(e,"name",{value:r,configurable:!0}),"r");const y=l(async(e,r={})=>{const{debug:t,environment:i,logger:a,mode:n,tsconfigPath:m,...d}={debug:!1,environment:"production",logger:{},mode:"build",tsconfigPath:void 0,...r},p=s({reporters:[new u({error:{hideErrorCauseCodeView:!0,hideErrorCodeView:!0,hideErrorErrorsCodeView:!0}})],scope:"packem",...a});await g(e,n,i,p,t,d,m)},"packem");export{y as packem};
+var c=Object.defineProperty;var o=(e,r)=>c(e,"name",{value:r,configurable:!0});import{createPail as s}from"@visulima/pail";import{SimpleReporter as u}from"@visulima/pail/reporter/simple";import{S as g}from"./packem_shared/index-Bm8Oe89l.js";var f=Object.defineProperty,l=o((e,r)=>f(e,"name",{value:r,configurable:!0}),"r");const C=l(async(e,r={})=>{const{debug:t,environment:i,logger:a,mode:n,tsconfigPath:m,...d}={debug:!1,environment:"production",logger:{},mode:"build",tsconfigPath:void 0,...r},p=s({reporters:[new u({error:{hideErrorCauseCodeView:!0,hideErrorCodeView:!0,hideErrorErrorsCodeView:!0}})],scope:"packem",...a});await g(e,n,i,p,t,d,m)},"packem");export{C as packem};

package/dist/jit/create-stub.d.ts

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

package/dist/lib/concurrency.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Run async tasks with a concurrency limit to prevent memory overflow.
+ * Useful for limiting parallel rollup builds, especially DTS generation.
+ */
+declare const runWithConcurrency: <T>(tasks: (() => Promise<T>)[], limit: number) => Promise<T[]>;
+export default runWithConcurrency;

package/dist/packem/build.d.ts

@@ -0,0 +1,21 @@
+import type { FileCache } from "@visulima/packem-share";
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+/**
+ * Main build function that orchestrates the entire build process.
+ * Handles both JavaScript/TypeScript compilation and type definition generation.
+ * @param context Build context containing configuration and state
+ * @param fileCache Cache instance for file operations
+ * @returns Promise resolving to a boolean indicating build success
+ * @example
+ * ```typescript
+ * const success = await build(BuildContext<InternalBuildOptions>, new FileCache());
+ * if (success) {
+ *   console.log('Build completed successfully');
+ * }
+ * ```
+ * @throws {Error} If the build process encounters critical errors
+ * @public
+ */
+declare const build: (context: BuildContext<InternalBuildOptions>, fileCache: FileCache) => Promise<boolean>;
+export default build;

package/dist/packem/index.d.ts

@@ -0,0 +1,24 @@
+import type { Pail } from "@visulima/pail";
+import type { BuildConfig, Environment, Mode } from '../types.d.ts';
+/**
+ * Main entry point for the Packem bundler.
+ * Handles the complete build process including configuration loading, validation,
+ * and execution of the build/watch process.
+ * @param rootDirectory Root directory of the project
+ * @param mode Build mode (build/watch)
+ * @param environment Build environment (development/production)
+ * @param logger Logger instance for output
+ * @example
+ * ```typescript
+ * import packem from 'packem';
+ *
+ * await packem('/path/to/project', 'build', 'production', logger, {
+ *   debug: true,
+ *   configPath: './packem.config.js'
+ * });
+ * ```
+ * @throws {Error} If configuration validation fails or build process encounters errors
+ * @public
+ */
+declare const packem: (rootDirectory: string, mode: Mode, environment: Environment, logger: Pail, debug: boolean, config: BuildConfig, tsconfigPath?: string) => Promise<void>;
+export default packem;

package/dist/packem/node10-compatibility.d.ts

@@ -0,0 +1,7 @@
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { InternalBuildOptions } from "../types.d.ts";
+export type Node10CompatibilityOptions = {
+    typeScriptVersion?: string;
+    writeToPackageJson?: boolean;
+};
+export declare const node10Compatibility: (logger: BuildContext<InternalBuildOptions>["logger"], entries: BuildContext<InternalBuildOptions>["options"]["entries"], outDirectory: string, rootDirectory: string, mode: "console" | "file", typeScriptVersion: string) => Promise<void>;

package/dist/packem/utils/brotli-size.d.ts

@@ -0,0 +1,2 @@
+declare const brotliSize: (path: string) => Promise<number>;
+export default brotliSize;

package/dist/packem/utils/group-by-keys.d.ts

@@ -0,0 +1,12 @@
+type Key = number | string | symbol;
+/**
+ * Groups an array of objects by multiple keys, creating nested objects.
+ * Supports 2 or 3 keys for grouping.
+ * @param array Array of objects to group
+ * @param key1 First key to group by
+ * @param key2 Second key to group by
+ * @param key3 Optional third key to group by
+ * @returns Nested object grouped by the specified keys
+ */
+declare const groupByKeys: <T extends Record<Key, unknown>>(array: T[], key1: Key, key2: Key, key3?: Key) => Record<string, Record<string, T[]>> | Record<string, Record<string, Record<string, T[]>>>;
+export default groupByKeys;

package/dist/packem/utils/gzip-size.d.ts

@@ -0,0 +1,2 @@
+declare const gzipSize: (path: string) => Promise<number>;
+export default gzipSize;

package/dist/packem_shared/create-or-update-key-storage-U4wgANkm.js

@@ -0,0 +1 @@
+var s=Object.defineProperty;var a=(r,t)=>s(r,"name",{value:t,configurable:!0});import{isAccessibleSync as i,readJsonSync as y,writeJsonSync as m}from"@visulima/fs";import{join as d}from"@visulima/path";var g=Object.defineProperty,p=a((r,t)=>g(r,"name",{value:t,configurable:!0}),"i");const v=p((r,t,c,n)=>{try{let e={};const o=d(t,"keystore.json");n&&i(o)&&(e=y(o)),e[r]===void 0&&(e[r]=new Date().toISOString()),m(o,e,{overwrite:!0})}catch(e){c.debug({context:[e],message:e.message,prefix:"cache-key-store"})}},"createOrUpdateKeyStorage");export{v as d};