@visulima/packem 2.0.0-alpha.4 → 2.0.0-alpha.43

package/dist/config/index.d.ts

@@ -1,28 +1,48 @@
-import { B as BuildConfig, c as BuildConfigFunction, d as BuildPreset } from '../packem_shared/types-CaBbG-vU.js';
-export { d as BuildHooks } from '../packem_shared/index-DySckW0r.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';
-
-declare const defineConfig: (config: BuildConfig | BuildConfigFunction) => BuildConfig | BuildConfigFunction;
-declare const definePreset: (preset: BuildPreset) => BuildPreset;
-
-export { BuildConfig, BuildConfigFunction, BuildPreset, defineConfig, definePreset };
+import type { BuildConfig, BuildConfigFunction, BuildPreset } from "../types.d.ts";
+export type { BuildConfig, BuildConfigFunction, BuildPreset } from "../types.d.ts";
+export type { BuildHooks } from "@visulima/packem-share/types";
+/**
+ * Defines a build configuration for Packem.
+ * Supports both static configuration objects and dynamic configuration functions.
+ * @param config Static build configuration object or function returning configuration
+ * @returns The provided configuration
+ * @example
+ * ```typescript
+ * // Static configuration
+ * export default defineConfig({
+ *   entries: ['./src/index.ts'],
+ *   outDir: './dist'
+ * });
+ *
+ * // Dynamic configuration
+ * export default defineConfig((env, mode) => ({
+ *   entries: ['./src/index.ts'],
+ *   outDir: env === 'production' ? './dist' : './dev'
+ * }));
+ * ```
+ * @public
+ */
+export declare const defineConfig: (config: BuildConfig | BuildConfigFunction) => BuildConfig | BuildConfigFunction;
+/**
+ * Defines a build preset for Packem.
+ * Build presets provide reusable configuration templates that can be shared across projects.
+ * @param preset Build preset configuration
+ * @returns The provided preset configuration
+ * @example
+ * ```typescript
+ * export default definePreset({
+ *   name: 'my-preset',
+ *   defaults: {
+ *     entries: ['./src/index.ts'],
+ *     outDir: './dist'
+ *   },
+ *   hooks: {
+ *     'build:before': (context) => {
+ *       // Custom build preparation logic
+ *     }
+ *   }
+ * });
+ * ```
+ * @public
+ */
+export declare const definePreset: (preset: BuildPreset) => BuildPreset;

package/dist/config/index.js

@@ -1 +1,4 @@
-var i=Object.defineProperty;var r=(e,n)=>i(e,"name",{value:n,configurable:!0});var t=Object.defineProperty,f=r((e,n)=>t(e,"name",{value:n,configurable:!0}),"e");const a=f(e=>e,"defineConfig"),d=f(e=>e,"definePreset");export{a as defineConfig,d as definePreset};
+const defineConfig = (config) => config;
+const definePreset = (preset) => preset;
+
+export { defineConfig, definePreset };

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,43 @@
+const createReactPreset = (options = {}) => {
+  const { compiler = false, plugins = [], presets = [] } = options;
+  const babelPlugins = [];
+  const babelPresets = [];
+  if (compiler) {
+    const compilerOptions = typeof compiler === "object" ? compiler : {};
+    babelPlugins.push([
+      "babel-plugin-react-compiler",
+      {
+        compilationMode: compilerOptions.compilationMode ?? "infer",
+        panicThreshold: compilerOptions.panicThreshold ?? "critical_errors"
+      }
+    ]);
+  }
+  babelPresets.push([
+    "@babel/preset-react",
+    {
+      runtime: "automatic"
+    }
+  ]);
+  const finalPlugins = [...babelPlugins, ...Array.isArray(plugins) ? plugins : []];
+  const finalPresets = [...babelPresets, ...Array.isArray(presets) ? presets : []];
+  return {
+    rollup: {
+      babel: {
+        plugins: finalPlugins.length > 0 ? finalPlugins : void 0,
+        presets: finalPresets.length > 0 ? finalPresets : void 0
+      }
+    },
+    validation: {
+      dependencies: {
+        hoisted: {
+          exclude: []
+        },
+        unused: {
+          exclude: ["react", "react-dom"]
+        }
+      }
+    }
+  };
+};
+
+export { 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,72 @@
+const buildSolidPresetOptions = (solidOptions) => {
+  const presetOptions = {
+    contextToCustomElements: solidOptions?.contextToCustomElements ?? true,
+    delegateEvents: solidOptions?.delegateEvents ?? true,
+    generate: solidOptions?.generate ?? "dom",
+    hydratable: solidOptions?.hydratable ?? false,
+    moduleName: solidOptions?.moduleName ?? "solid-js/web",
+    wrapConditionals: solidOptions?.wrapConditionals ?? true
+  };
+  if (solidOptions?.builtIns !== void 0) {
+    presetOptions.builtIns = solidOptions.builtIns;
+  }
+  return presetOptions;
+};
+const mergeUserBabelOptions = (baseConfig, userBabelOptions, basePlugins, basePresets) => {
+  if (!userBabelOptions || typeof userBabelOptions === "function") {
+    return baseConfig;
+  }
+  let mergedPlugins = basePlugins;
+  if (userBabelOptions.plugins) {
+    const userPluginsArray = Array.isArray(userBabelOptions.plugins) ? userBabelOptions.plugins : [];
+    mergedPlugins = [...basePlugins || [], ...userPluginsArray];
+  }
+  let mergedPresets = basePresets;
+  if (userBabelOptions.presets) {
+    const userPresetsArray = Array.isArray(userBabelOptions.presets) ? userBabelOptions.presets : [];
+    mergedPresets = [...basePresets || [], ...userPresetsArray];
+  }
+  return {
+    ...baseConfig,
+    ...userBabelOptions,
+    plugins: mergedPlugins && mergedPlugins.length > 0 ? mergedPlugins : void 0,
+    presets: mergedPresets && mergedPresets.length > 0 ? mergedPresets : void 0
+  };
+};
+const createSolidPreset = (options = {}) => {
+  const { babel: userBabelOptions, plugins = [], presets = [], solidOptions = {} } = options;
+  const babelPlugins = [];
+  const babelPresets = [];
+  const solidPresetOptions = buildSolidPresetOptions(solidOptions);
+  const solidPreset = ["babel-preset-solid", solidPresetOptions];
+  babelPresets.push(solidPreset);
+  const finalPlugins = [...babelPlugins, ...Array.isArray(plugins) ? plugins : []];
+  const finalPresets = [...babelPresets, ...Array.isArray(presets) ? presets : []];
+  const babelConfig = {
+    ast: false,
+    babelrc: false,
+    configFile: false,
+    plugins: finalPlugins.length > 0 ? finalPlugins : void 0,
+    presets: finalPresets.length > 0 ? finalPresets : void 0,
+    sourceMaps: true
+  };
+  const mergedBabelConfig = mergeUserBabelOptions(babelConfig, userBabelOptions, finalPlugins, finalPresets);
+  return {
+    externals: ["solid-js", "solid-js/web", "solid-js/store"],
+    rollup: {
+      babel: mergedBabelConfig
+    },
+    validation: {
+      dependencies: {
+        hoisted: {
+          exclude: []
+        },
+        unused: {
+          exclude: ["solid-js"]
+        }
+      }
+    }
+  };
+};
+
+export { 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?: {
+            /**
+             * 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;
+            [key: string]: unknown;
+        };
+        /**
+         * 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,44 @@
+import svelte from 'rollup-plugin-svelte';
+import { D as DEFAULT_EXTENSIONS } from '../../packem_shared/index-CTIRxV2x.js';
+
+const createSveltePreset = (options = {}) => {
+  const { pluginOptions = {} } = options;
+  return {
+    rollup: {
+      plugins: [
+        {
+          enforce: "pre",
+          plugin: svelte({
+            compilerOptions: {
+              generate: "client",
+              runes: true,
+              ...pluginOptions.compilerOptions
+            },
+            emitCss: false,
+            extensions: [".svelte"],
+            exclude: pluginOptions.exclude,
+            include: pluginOptions.include ?? [/\.svelte$/],
+            preprocess: pluginOptions.preprocess
+          })
+        }
+      ],
+      resolve: {
+        browser: true,
+        exportConditions: ["svelte"],
+        extensions: [...DEFAULT_EXTENSIONS, ".svelte"]
+      }
+    },
+    validation: {
+      dependencies: {
+        hoisted: {
+          exclude: []
+        },
+        unused: {
+          exclude: ["svelte"]
+        }
+      }
+    }
+  };
+};
+
+export { createSveltePreset };

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,33 @@
+import Vue from 'unplugin-vue/rollup';
+
+const createVuePreset = (options = {}) => {
+  const { pluginOptions = {} } = options;
+  return {
+    rollup: {
+      plugins: [
+        {
+          enforce: "pre",
+          plugin: Vue({
+            customElement: pluginOptions.customElement ?? false,
+            exclude: pluginOptions.exclude,
+            include: pluginOptions.include ?? [/\.vue$/],
+            template: pluginOptions.template,
+            exportMode: "default"
+          })
+        }
+      ]
+    },
+    validation: {
+      dependencies: {
+        hoisted: {
+          exclude: []
+        },
+        unused: {
+          exclude: ["vue"]
+        }
+      }
+    }
+  };
+};
+
+export { createVuePreset };

package/dist/index.d.ts

@@ -1,36 +1,49 @@
-import { ConstructorOptions } from '@visulima/pail';
-import { B as BuildConfig } from './packem_shared/types-CaBbG-vU.js';
-export { a as BuildEntry, b as BuildOptions, R as RollupBuildOptions } from './packem_shared/types-CaBbG-vU.js';
-import { E as Environment, M as Mode } from './packem_shared/index-DySckW0r.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-DySckW0r.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,30 @@
-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-VKZ7e6tb.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};
+import { createPail } from '@visulima/pail';
+import { SimpleReporter } from '@visulima/pail/reporter';
+import { p as packem$1 } from './packem_shared/index-DzTDn4ad.js';
+
+const packem = async (rootDirectory, options = {}) => {
+  const { debug, environment, logger, mode, tsconfigPath, ...inputConfig } = {
+    debug: false,
+    environment: "production",
+    logger: {},
+    mode: "build",
+    tsconfigPath: void 0,
+    ...options
+  };
+  const pail = createPail({
+    reporters: [
+      new SimpleReporter({
+        error: {
+          hideErrorCauseCodeView: true,
+          hideErrorCodeView: true,
+          hideErrorErrorsCodeView: true
+        }
+      })
+    ],
+    scope: "packem",
+    ...logger
+  });
+  await packem$1(rootDirectory, mode, environment, pail, debug, inputConfig, tsconfigPath);
+};
+
+export { packem };