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

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.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{x as g}from"./packem_shared/index-DFigeRU2.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};
+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 };

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

@@ -0,0 +1,36 @@
+import { writeJsonSync, isAccessibleSync, readJsonSync } from '@visulima/fs';
+import { join } from '@visulima/path';
+
+const replaceContentWithinMarker = (content, marker, replacement) => {
+  const regex = new RegExp(`(<!-- ${marker} -->)[\\s\\S]*?(<!-- /${marker} -->)`, "g");
+  if (!regex.test(content)) {
+    return void 0;
+  }
+  return content.replace(regex, `$1
+${replacement}
+$2`);
+};
+
+const createOrUpdateKeyStorage = (hashKey, storePath, logger, shouldUpdate) => {
+  try {
+    let keyStore = {};
+    const keyStorePath = join(storePath, "keystore.json");
+    if (shouldUpdate && isAccessibleSync(keyStorePath)) {
+      keyStore = readJsonSync(keyStorePath);
+    }
+    if (keyStore[hashKey] === void 0) {
+      keyStore[hashKey] = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    writeJsonSync(keyStorePath, keyStore, {
+      overwrite: true
+    });
+  } catch (error) {
+    logger.debug({
+      context: [error],
+      message: error.message,
+      prefix: "cache-key-store"
+    });
+  }
+};
+
+export { createOrUpdateKeyStorage as c, replaceContentWithinMarker as r };

package/dist/packem_shared/default-79SPobLI.js

@@ -0,0 +1,12 @@
+import { isolatedDeclaration } from 'oxc-transform';
+
+const isolatedDeclarationsOxcTransformer = (id, code, sourceMap, transformOptions) => {
+  const result = isolatedDeclaration(id, code, { ...transformOptions, sourcemap: sourceMap });
+  return {
+    errors: result.errors.map((error) => error.message),
+    map: result.map?.mappings,
+    sourceText: result.code
+  };
+};
+
+export { isolatedDeclarationsOxcTransformer as default };