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

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_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 };

package/dist/packem_shared/default-DWBYeUSC.js

@@ -0,0 +1,210 @@
+import { createFilter } from '@rollup/pluginutils';
+import { a as DEFAULT_LOADERS } from './index-CTIRxV2x.js';
+import { extname, join } from '@visulima/path';
+import { transform, formatMessages, build } from 'esbuild';
+import { findCacheDirSync } from '@visulima/find-cache-dir';
+import { readFileSync } from '@visulima/fs';
+import * as rsModuleLexer from 'rs-module-lexer';
+
+import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
+const require = __cjs_mod__.createRequire(import.meta.url);
+const warn = async (pluginContext, messages) => {
+  if (messages.length > 0) {
+    const warnings = await formatMessages(messages, {
+      color: true,
+      kind: "warning"
+    });
+    warnings.forEach((warning) => pluginContext.warn(warning));
+  }
+};
+const getEsbuildFormat = (rollupFormat) => {
+  if (rollupFormat === "es") {
+    return "esm";
+  }
+  if (rollupFormat === "cjs") {
+    return rollupFormat;
+  }
+  return void 0;
+};
+const getRenderChunk = ({ sourceMap = true, ...options }) => (
+  // eslint-disable-next-line func-names
+  (async function(code, _, rollupOptions) {
+    if (options.minify || options.minifyWhitespace || options.minifyIdentifiers || options.minifySyntax) {
+      const format = getEsbuildFormat(rollupOptions.format);
+      const result = await transform(code, {
+        format,
+        loader: "js",
+        sourcemap: sourceMap,
+        ...options
+      });
+      await warn(this, result.warnings);
+      if (result.code) {
+        return {
+          code: result.code,
+          map: result.map || void 0
+        };
+      }
+    }
+    return void 0;
+  })
+);
+const slash = (p) => p.replaceAll("\\", "/");
+const { parseAsync } = rsModuleLexer;
+const optimizeDeps = async (options) => {
+  const cacheDir = findCacheDirSync("@visulima/packem/optimize-deps", {
+    create: true,
+    cwd: options.cwd
+  });
+  if (!cacheDir) {
+    throw new Error('[packem:optimize-deps]: failed to find or create cache directory "node_modules/.cache/packem/optimize_deps".');
+  }
+  await build({
+    absWorkingDir: options.cwd,
+    bundle: true,
+    entryPoints: options.include,
+    format: "esm",
+    ignoreAnnotations: true,
+    metafile: true,
+    outdir: cacheDir,
+    sourcemap: options.sourceMap,
+    splitting: true,
+    ...options.esbuildOptions,
+    plugins: [
+      {
+        name: "optimize-deps",
+        async setup(build2) {
+          build2.onResolve({ filter: /.*/ }, async (arguments_) => {
+            if (options.exclude?.includes(arguments_.path)) {
+              return {
+                external: true
+              };
+            }
+            if (arguments_.pluginData?.__resolving_dep_path__) {
+              return void 0;
+            }
+            if (options.include.includes(arguments_.path)) {
+              const resolved = await build2.resolve(arguments_.path, {
+                kind: "import-statement",
+                pluginData: { __resolving_dep_path__: true },
+                resolveDir: arguments_.resolveDir
+              });
+              if (resolved.errors.length > 0 || resolved.warnings.length > 0) {
+                return resolved;
+              }
+              return {
+                namespace: "optimize-deps",
+                path: arguments_.path,
+                pluginData: {
+                  absolute: resolved.path,
+                  resolveDir: arguments_.resolveDir
+                }
+              };
+            }
+            return void 0;
+          });
+          build2.onLoad({ filter: /.*/, namespace: "optimize-deps" }, async (arguments_) => {
+            const { absolute, resolveDir } = arguments_.pluginData;
+            const sourceCode = readFileSync(absolute);
+            const { output } = await parseAsync({ input: [{ code: sourceCode, filename: absolute }] });
+            const exported = output[0]?.exports ?? [];
+            return {
+              contents: exported.length > 0 ? `export * from '${slash(absolute)}'` : `module.exports = require('${slash(absolute)}')`,
+              resolveDir
+            };
+          });
+        }
+      },
+      ...options.esbuildOptions?.plugins ?? []
+    ]
+  });
+  const optimized = /* @__PURE__ */ new Map();
+  for (const id of options.include) {
+    optimized.set(id, { file: join(cacheDir, `${id}.js`) });
+  }
+  return {
+    cacheDir,
+    optimized
+  };
+};
+const esbuildTransformer = ({ exclude, include, loaders: _loaders, logger, optimizeDeps: optimizeDeps$1, sourceMap, ...esbuildOptions }) => {
+  const loaders = DEFAULT_LOADERS;
+  if (_loaders !== void 0) {
+    for (let [key, value] of Object.entries(_loaders)) {
+      const newKey = key.startsWith(".") ? key : `.${key}`;
+      if (typeof value === "string") {
+        loaders[newKey] = value;
+      } else if (!value) {
+        delete loaders[newKey];
+      }
+    }
+  }
+  const extensions = Object.keys(loaders);
+  const INCLUDE_REGEXP = new RegExp(String.raw`\.(${extensions.map((extension) => extension.slice(1)).join("|")})$`);
+  const filter = createFilter(include ?? INCLUDE_REGEXP, exclude);
+  let optimizeDepsResult;
+  let cwd = process.cwd();
+  return {
+    async buildStart() {
+      if (!optimizeDeps$1 || optimizeDepsResult) {
+        return;
+      }
+      optimizeDepsResult = await optimizeDeps({
+        cwd,
+        sourceMap: sourceMap ?? false,
+        ...optimizeDeps$1
+      });
+      logger.debug("optimized %O", optimizeDepsResult.optimized);
+    },
+    name: "packem:esbuild",
+    options({ context }) {
+      if (context) {
+        cwd = context;
+      }
+      return void 0;
+    },
+    renderChunk: getRenderChunk({
+      ...esbuildOptions,
+      sourceMap
+    }),
+    async resolveId(id) {
+      if (optimizeDepsResult?.optimized.has(id)) {
+        const m = optimizeDepsResult.optimized.get(id);
+        if (m) {
+          logger.debug("resolved %s to %s", id, m.file);
+          return m.file;
+        }
+      }
+      return void 0;
+    },
+    async transform(code, id) {
+      if (!filter(id) || optimizeDepsResult?.optimized.has(id)) {
+        return void 0;
+      }
+      const extension = extname(id);
+      const loader = loaders[extension];
+      logger.debug("transforming %s with %s loader", id, loader);
+      if (!loader) {
+        return void 0;
+      }
+      const result = await transform(code, {
+        format: ["base64", "binary", "dataurl", "text", "json"].includes(loader) ? "esm" : void 0,
+        loader,
+        // @see https://github.com/evanw/esbuild/issues/1932#issuecomment-1013380565
+        sourcefile: id.replace(/\.[cm]ts/, ".ts"),
+        sourcemap: sourceMap,
+        ...esbuildOptions
+      });
+      await warn(this, result.warnings);
+      if (result.code) {
+        return {
+          code: result.code,
+          map: result.map || void 0
+        };
+      }
+      return void 0;
+    }
+  };
+};
+esbuildTransformer.NAME = "esbuild";
+
+export { esbuildTransformer as default };

package/dist/packem_shared/default-DaU6CQEi.js

@@ -0,0 +1,28 @@
+import { createFilter } from '@rollup/pluginutils';
+import { transform } from '@swc/core';
+import { E as EXCLUDE_REGEXP } from './index-CTIRxV2x.js';
+
+const swcPlugin = ({ exclude, include, ...transformOptions }) => {
+  const filter = createFilter(include, exclude ?? EXCLUDE_REGEXP);
+  return {
+    name: "packem:swc",
+    async transform(sourcecode, id) {
+      if (!filter(id)) {
+        return void 0;
+      }
+      const { code, map } = await transform(sourcecode, {
+        ...transformOptions,
+        configFile: false,
+        filename: id,
+        swcrc: false
+      });
+      return {
+        code,
+        map
+      };
+    }
+  };
+};
+swcPlugin.NAME = "swc";
+
+export { swcPlugin as default };

package/dist/packem_shared/default-DavaZMwC.js

@@ -0,0 +1,32 @@
+import { transform } from '@swc/core';
+
+const isolatedDeclarationsSwcTransformer = async (id, code, sourceMap) => {
+  try {
+    const result = await transform(code, {
+      filename: id,
+      jsc: {
+        experimental: {
+          emitIsolatedDts: true
+        },
+        parser: {
+          syntax: "typescript",
+          tsx: false
+        }
+      },
+      sourceMaps: sourceMap
+    });
+    const output = JSON.parse(result.output);
+    return {
+      errors: [],
+      map: result.map ? JSON.parse(result.map).mappings : void 0,
+      sourceText: output.__swc_isolated_declarations__
+    };
+  } catch (error) {
+    return {
+      errors: [error.toString()],
+      sourceText: ""
+    };
+  }
+};
+
+export { isolatedDeclarationsSwcTransformer as default };

package/dist/packem_shared/default-DeYZ934H.js

@@ -0,0 +1,32 @@
+import { createFilter } from '@rollup/pluginutils';
+import { E as EXCLUDE_REGEXP } from './index-CTIRxV2x.js';
+import { transform } from 'oxc-transform';
+
+const oxcTransformPlugin = ({ exclude, include, ...transformOptions }) => {
+  const filter = createFilter(include, exclude ?? EXCLUDE_REGEXP);
+  return {
+    name: "packem:oxc-transform",
+    async transform(sourcecode, id) {
+      if (!filter(id)) {
+        return void 0;
+      }
+      const { code, errors, map } = transform(id, sourcecode, {
+        ...transformOptions,
+        sourcemap: true
+      });
+      if (errors.length > 0) {
+        return this.error({
+          message: ["\ntransform errors:", ...errors].join("\n\n"),
+          pluginCode: "ERR_TRANSFORM"
+        });
+      }
+      return {
+        code,
+        map
+      };
+    }
+  };
+};
+oxcTransformPlugin.NAME = "oxc";
+
+export { oxcTransformPlugin as default };

package/dist/packem_shared/default-tUOOZ8w7.js

@@ -0,0 +1,42 @@
+import { transpileDeclaration, formatDiagnostics, sys } from 'typescript';
+
+const stripMapUrl = (code) => {
+  const lines = code.split("\n");
+  const lastLine = lines.at(-1);
+  if (lastLine?.startsWith("//# sourceMappingURL=")) {
+    return lines.slice(0, -1).join("\n");
+  }
+  return code;
+};
+const isolatedDeclarationsTypescriptTransformer = async (id, code, sourceMap, transformOptions) => {
+  const compilerOptions = {
+    declarationMap: sourceMap,
+    ...transformOptions?.compilerOptions
+  };
+  let { diagnostics, outputText, sourceMapText } = transpileDeclaration(code, {
+    fileName: id,
+    reportDiagnostics: true,
+    ...transformOptions,
+    compilerOptions
+  });
+  if (compilerOptions.declarationMap) {
+    outputText = stripMapUrl(outputText);
+  }
+  const errors = diagnostics?.length ? [
+    formatDiagnostics(diagnostics, {
+      getCanonicalFileName: (fileName) => sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+      getCurrentDirectory: () => sys.getCurrentDirectory(),
+      getNewLine: () => sys.newLine
+    })
+  ] : [];
+  if (sourceMapText) {
+    sourceMapText = JSON.parse(sourceMapText).mappings;
+  }
+  return {
+    errors,
+    map: sourceMapText,
+    sourceText: outputText
+  };
+};
+
+export { isolatedDeclarationsTypescriptTransformer as default };

package/dist/packem_shared/default-wScAfTaq.js

@@ -0,0 +1,27 @@
+import { createFilter } from '@rollup/pluginutils';
+import { E as EXCLUDE_REGEXP } from './index-CTIRxV2x.js';
+import { transform } from 'sucrase';
+
+const sucraseTransformPlugin = ({ exclude, include, ...transformOptions }) => {
+  const filter = createFilter(include, exclude ?? EXCLUDE_REGEXP);
+  return {
+    name: "packem:sucrase",
+    async transform(sourcecode, id) {
+      if (!filter(id)) {
+        return void 0;
+      }
+      const { code, sourceMap: map } = transform(sourcecode, {
+        ...transformOptions,
+        filePath: id,
+        sourceMapOptions: {
+          compiledFilename: id
+        }
+      });
+      return { code, map };
+    }
+  };
+};
+sucraseTransformPlugin.NAME = "sucrase";
+const sucrasePlugin = sucraseTransformPlugin;
+
+export { sucrasePlugin };

package/dist/packem_shared/index-CTIRxV2x.js

@@ -0,0 +1,63 @@
+const VALID_EXPORT_EXTENSIONS = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  // JavaScript modules
+  ".ts",
+  ".mts",
+  ".cts",
+  // TypeScript modules
+  ".d.ts",
+  ".d.mts",
+  ".d.cts",
+  // TypeScript declarations
+  ".jsx",
+  ".tsx",
+  // JSX/TSX files
+  ".json",
+  // JSON modules
+  ".node"
+  // Native Node.js modules (compiled C++ addons)
+];
+const DEFAULT_EXTENSIONS = [
+  ...VALID_EXPORT_EXTENSIONS,
+  // Base extensions for all module types
+  ".ctsx",
+  ".mtsx"
+  // Additional JSX/TSX variants (not standard for exports but processable)
+];
+const DEFAULT_LOADERS = {
+  ".aac": "file",
+  ".cjs": "js",
+  ".cts": "ts",
+  ".ctsx": "tsx",
+  ".eot": "file",
+  ".flac": "file",
+  ".js": "js",
+  ".jsx": "jsx",
+  ".mjs": "js",
+  ".mp3": "file",
+  ".mp4": "file",
+  ".mts": "ts",
+  ".mtsx": "tsx",
+  ".ogg": "file",
+  ".otf": "file",
+  ".ts": "ts",
+  ".tsx": "tsx",
+  ".ttf": "file",
+  ".wav": "file",
+  ".webm": "file",
+  ".woff": "file",
+  ".woff2": "file"
+};
+const PRODUCTION_ENV = "production";
+const DEVELOPMENT_ENV = "development";
+const RUNTIME_EXPORT_CONVENTIONS = /* @__PURE__ */ new Set(["edge-light", "react-native", "react-server"]);
+const SPECIAL_EXPORT_CONVENTIONS = /* @__PURE__ */ new Set([DEVELOPMENT_ENV, PRODUCTION_ENV, ...RUNTIME_EXPORT_CONVENTIONS]);
+const EXCLUDE_REGEXP = /node_modules/;
+const ENDING_REGEX = /(?:\.d\.[mc]?tsx?|\.\w+)$/;
+const CHUNKS_PACKEM_FOLDER = "packem_chunks";
+const SHARED_PACKEM_FOLDER = "packem_shared";
+const ALLOWED_TRANSFORM_EXTENSIONS_REGEX = /\.(?:m|c)?(?:j|t)sx?$/;
+
+export { ALLOWED_TRANSFORM_EXTENSIONS_REGEX as A, CHUNKS_PACKEM_FOLDER as C, DEFAULT_EXTENSIONS as D, EXCLUDE_REGEXP as E, PRODUCTION_ENV as P, RUNTIME_EXPORT_CONVENTIONS as R, SHARED_PACKEM_FOLDER as S, VALID_EXPORT_EXTENSIONS as V, DEFAULT_LOADERS as a, DEVELOPMENT_ENV as b, SPECIAL_EXPORT_CONVENTIONS as c, ENDING_REGEX as d };