@intlayer/babel 6.1.6 → 7.0.0-canary.0

package/dist/cjs/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,25 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/cjs/babel-plugin-intlayer.cjs

@@ -1,282 +1,279 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var babel_plugin_intlayer_exports = {};
-__export(babel_plugin_intlayer_exports, {
-  intlayerBabelPlugin: () => intlayerBabelPlugin
-});
-module.exports = __toCommonJS(babel_plugin_intlayer_exports);
-var t = __toESM(require("@babel/types"));
-var import_chokidar = require("@intlayer/chokidar");
-var import_config = require("@intlayer/config");
-var import_node_path = require("node:path");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let __intlayer_chokidar = require("@intlayer/chokidar");
+__intlayer_chokidar = require_rolldown_runtime.__toESM(__intlayer_chokidar);
+let __intlayer_config = require("@intlayer/config");
+__intlayer_config = require_rolldown_runtime.__toESM(__intlayer_config);
+
+//#region src/babel-plugin-intlayer.ts
 const PACKAGE_LIST = [
-  "intlayer",
-  "@intlayer/core",
-  "react-intlayer",
-  "react-intlayer/client",
-  "react-intlayer/server",
-  "next-intlayer",
-  "next-intlayer/client",
-  "next-intlayer/server",
-  "svelte-intlayer",
-  "vue-intlayer",
-  "angular-intlayer",
-  "preact-intlayer",
-  "solid-intlayer"
+	"intlayer",
+	"@intlayer/core",
+	"react-intlayer",
+	"react-intlayer/client",
+	"react-intlayer/server",
+	"next-intlayer",
+	"next-intlayer/client",
+	"next-intlayer/server",
+	"svelte-intlayer",
+	"vue-intlayer",
+	"angular-intlayer",
+	"preact-intlayer",
+	"solid-intlayer"
 ];
 const CALLER_LIST = ["useIntlayer", "getIntlayer"];
+/**
+* Packages that support dynamic import
+*/
 const PACKAGE_LIST_DYNAMIC = [
-  "react-intlayer",
-  "react-intlayer/client",
-  "react-intlayer/server",
-  "next-intlayer",
-  "next-intlayer/client",
-  "next-intlayer/server",
-  "preact-intlayer",
-  "vue-intlayer",
-  "solid-intlayer",
-  "svelte-intlayer",
-  "angular-intlayer"
+	"react-intlayer",
+	"react-intlayer/client",
+	"react-intlayer/server",
+	"next-intlayer",
+	"next-intlayer/client",
+	"next-intlayer/server",
+	"preact-intlayer",
+	"vue-intlayer",
+	"solid-intlayer",
+	"svelte-intlayer",
+	"angular-intlayer"
 ];
 const STATIC_IMPORT_FUNCTION = {
-  getIntlayer: "getDictionary",
-  useIntlayer: "useDictionary"
-};
-const FETCH_IMPORT_FUNCTION = {
-  useIntlayer: "useDictionaryDynamic"
-};
-const DYNAMIC_IMPORT_FUNCTION = {
-  useIntlayer: "useDictionaryDynamic"
+	getIntlayer: "getDictionary",
+	useIntlayer: "useDictionary"
 };
-const makeIdent = (key) => {
-  const hash = (0, import_chokidar.getFileHash)(key);
-  return t.identifier(`_${hash}`);
+const DYNAMIC_IMPORT_FUNCTION = { useIntlayer: "useDictionaryDynamic" };
+/**
+* Replicates the xxHash64 → Base-62 algorithm used by the SWC version
+* and prefixes an underscore so the generated identifiers never collide
+* with user-defined ones.
+*/
+const makeIdent = (key, t) => {
+	const hash = (0, __intlayer_chokidar.getFileHash)(key);
+	return t.identifier(`_${hash}`);
 };
 const computeImport = (fromFile, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, importMode) => {
-  let relativePath = (0, import_node_path.join)(dictionariesDir, `${key}.json`);
-  if (importMode === "live") {
-    relativePath = (0, import_node_path.join)(fetchDictionariesDir, `${key}.mjs`);
-  }
-  if (importMode === "dynamic") {
-    relativePath = (0, import_node_path.join)(dynamicDictionariesDir, `${key}.mjs`);
-  }
-  let rel = (0, import_node_path.relative)((0, import_node_path.dirname)(fromFile), relativePath);
-  rel = (0, import_config.normalizePath)(rel);
-  if (!rel.startsWith("./") && !rel.startsWith("../")) {
-    rel = `./${rel}`;
-  }
-  return rel;
+	let relativePath = (0, node_path.join)(dictionariesDir, `${key}.json`);
+	if (importMode === "live") relativePath = (0, node_path.join)(fetchDictionariesDir, `${key}.mjs`);
+	if (importMode === "dynamic") relativePath = (0, node_path.join)(dynamicDictionariesDir, `${key}.mjs`);
+	let rel = (0, node_path.relative)((0, node_path.dirname)(fromFile), relativePath);
+	rel = (0, __intlayer_config.normalizePath)(rel);
+	if (!rel.startsWith("./") && !rel.startsWith("../")) rel = `./${rel}`;
+	return rel;
 };
-const intlayerBabelPlugin = () => {
-  return {
-    name: "babel-plugin-intlayer-transform",
-    pre() {
-      this._newStaticImports = /* @__PURE__ */ new Map();
-      this._newDynamicImports = /* @__PURE__ */ new Map();
-      this._isIncluded = true;
-      this._hasValidImport = false;
-      this._isDictEntry = false;
-      this._useDynamicHelpers = false;
-      const filename = this.file.opts.filename;
-      if (this.opts.filesList && filename) {
-        const isIncluded = this.opts.filesList.includes(filename);
-        if (!isIncluded) {
-          this._isIncluded = false;
-          return;
-        }
-      }
-    },
-    visitor: {
-      /* 0. If this file *is* the dictionaries entry, short-circuit: export {} */
-      Program: {
-        enter(programPath, state) {
-          const filename = state.file.opts.filename;
-          if (state.opts.replaceDictionaryEntry && filename === state.opts.dictionariesEntryPath) {
-            state._isDictEntry = true;
-            programPath.node.body = [
-              t.exportDefaultDeclaration(t.objectExpression([]))
-            ];
-            programPath.stop();
-          }
-        },
-        /* 3. After full traversal, inject the JSON dictionary imports. */
-        exit(programPath, state) {
-          if (state._isDictEntry) return;
-          if (!state._hasValidImport) return;
-          if (!state._isIncluded) return;
-          const file = state.file.opts.filename;
-          const dictionariesDir = state.opts.dictionariesDir;
-          const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;
-          const fetchDictionariesDir = state.opts.fetchDictionariesDir;
-          const imports = [];
-          for (const [key, ident] of state._newStaticImports) {
-            const rel = computeImport(
-              file,
-              dictionariesDir,
-              dynamicDictionariesDir,
-              fetchDictionariesDir,
-              key,
-              "static"
-            );
-            const importDeclarationNode = t.importDeclaration(
-              [t.importDefaultSpecifier(t.identifier(ident.name))],
-              t.stringLiteral(rel)
-            );
-            importDeclarationNode.attributes = [
-              t.importAttribute(t.identifier("type"), t.stringLiteral("json"))
-            ];
-            imports.push(importDeclarationNode);
-          }
-          for (const [key, ident] of state._newDynamicImports) {
-            const modeForThisIdent = ident.name.endsWith(
-              "_fetch"
-            ) ? "live" : "dynamic";
-            const rel = computeImport(
-              file,
-              dictionariesDir,
-              dynamicDictionariesDir,
-              fetchDictionariesDir,
-              key,
-              modeForThisIdent
-            );
-            imports.push(
-              t.importDeclaration(
-                [t.importDefaultSpecifier(t.identifier(ident.name))],
-                t.stringLiteral(rel)
-              )
-            );
-          }
-          if (!imports.length) return;
-          const bodyPaths = programPath.get("body");
-          let insertPos = 0;
-          for (const stmtPath of bodyPaths) {
-            const stmt = stmtPath.node;
-            if (t.isExpressionStatement(stmt) && t.isStringLiteral(stmt.expression) && !stmt.expression.value.startsWith("import") && !stmt.expression.value.startsWith("require")) {
-              insertPos += 1;
-            } else {
-              break;
-            }
-          }
-          programPath.node.body.splice(insertPos, 0, ...imports);
-        }
-      },
-      /* 1. Inspect *every* intlayer import. */
-      ImportDeclaration(path, state) {
-        if (state._isDictEntry) return;
-        const src = path.node.source.value;
-        if (!PACKAGE_LIST.includes(src)) return;
-        state._hasValidImport = true;
-        for (const spec of path.node.specifiers) {
-          if (!t.isImportSpecifier(spec)) continue;
-          const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-          const importMode = state.opts.importMode;
-          const shouldUseDynamicHelpers = (importMode === "dynamic" || importMode === "live") && PACKAGE_LIST_DYNAMIC.includes(src);
-          if (shouldUseDynamicHelpers) {
-            state._useDynamicHelpers = true;
-          }
-          let helperMap;
-          if (shouldUseDynamicHelpers) {
-            helperMap = {
-              ...STATIC_IMPORT_FUNCTION,
-              ...DYNAMIC_IMPORT_FUNCTION
-            };
-          } else {
-            helperMap = STATIC_IMPORT_FUNCTION;
-          }
-          const newIdentifier = helperMap[importedName];
-          if (newIdentifier) {
-            spec.imported = t.identifier(newIdentifier);
-          }
-        }
-      },
-      /* 2. Replace calls: useIntlayer("foo") → useDictionary(_hash) or useDictionaryDynamic(_hash, "foo") */
-      CallExpression(path, state) {
-        if (state._isDictEntry) return;
-        const callee = path.node.callee;
-        if (!t.isIdentifier(callee)) return;
-        if (!CALLER_LIST.includes(callee.name)) return;
-        state._hasValidImport = true;
-        const arg = path.node.arguments[0];
-        if (!arg || !t.isStringLiteral(arg)) return;
-        const key = arg.value;
-        const importMode = state.opts.importMode;
-        const isUseIntlayer = callee.name === "useIntlayer";
-        const useDynamicHelpers = Boolean(state._useDynamicHelpers);
-        let perCallMode = "static";
-        if (isUseIntlayer && useDynamicHelpers) {
-          if (importMode === "dynamic") {
-            perCallMode = "dynamic";
-          } else if (importMode === "live") {
-            const liveKeys = state.opts.liveSyncKeys ?? [];
-            perCallMode = liveKeys.includes(key) ? "live" : "dynamic";
-          }
-        }
-        let ident;
-        if (perCallMode === "live") {
-          let dynamicIdent = state._newDynamicImports.get(key);
-          if (!dynamicIdent) {
-            const hash = (0, import_chokidar.getFileHash)(key);
-            dynamicIdent = t.identifier(`_${hash}_fetch`);
-            state._newDynamicImports.set(key, dynamicIdent);
-          }
-          ident = dynamicIdent;
-          path.node.arguments = [
-            t.identifier(ident.name),
-            ...path.node.arguments
-          ];
-        } else if (perCallMode === "dynamic") {
-          let dynamicIdent = state._newDynamicImports.get(key);
-          if (!dynamicIdent) {
-            const hash = (0, import_chokidar.getFileHash)(key);
-            dynamicIdent = t.identifier(`_${hash}_dyn`);
-            state._newDynamicImports.set(key, dynamicIdent);
-          }
-          ident = dynamicIdent;
-          path.node.arguments = [
-            t.identifier(ident.name),
-            ...path.node.arguments
-          ];
-        } else {
-          let staticIdent = state._newStaticImports.get(key);
-          if (!staticIdent) {
-            staticIdent = makeIdent(key);
-            state._newStaticImports.set(key, staticIdent);
-          }
-          ident = staticIdent;
-          path.node.arguments[0] = t.identifier(ident.name);
-        }
-      }
-    }
-  };
+/**
+* Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.
+*
+* This plugin transforms calls to `useIntlayer()` and `getIntlayer()` from various Intlayer
+* packages into optimized dictionary access patterns, automatically importing the required
+* dictionary files based on the configured import mode.
+*
+* ## Supported Input Patterns
+*
+* The plugin recognizes these function calls:
+*
+* ```ts
+* // useIntlayer
+* import { useIntlayer } from 'react-intlayer';
+* import { useIntlayer } from 'next-intlayer';
+*
+* // getIntlayer
+* import { getIntlayer } from 'intlayer';
+*
+* // Usage
+* const content = useIntlayer('app');
+* const content = getIntlayer('app');
+* ```
+*
+* ## Transformation Modes
+*
+* ### Static Mode (default: `importMode = "static"`)
+*
+* Imports JSON dictionaries directly and replaces function calls with dictionary access:
+*
+* **Output:**
+* ```ts
+* import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
+* import { useDictionary as useIntlayer } from 'react-intlayer';
+* import { getDictionary as getIntlayer } from 'intlayer';
+*
+* const content1 = useIntlayer(_dicHash);
+* const content2 = getIntlayer(_dicHash);
+* ```
+*
+* ### Dynamic Mode (`importMode = "dynamic"`)
+*
+* Uses dynamic dictionary loading with Suspense support:
+*
+* **Output:**
+* ```ts
+* import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
+* import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';
+* import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';
+* import { getDictionary as getIntlayer } from 'intlayer';
+*
+* const content1 = useIntlayer(_dicHash_dyn, 'app');
+* const content2 = getIntlayer(_dicHash);
+* ```
+*
+* ### Live Mode (`importMode = "live"`)
+*
+* Uses live-based dictionary loading for remote dictionaries:
+*
+* **Output if `liveSyncKeys` includes the key:**
+* ```ts
+* import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
+* import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';
+* import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';
+* import { getDictionary as getIntlayer } from 'intlayer';
+*
+* const content1 = useIntlayer(_dicHash_fetch, "app");
+* const content2 = getIntlayer(_dicHash);
+* ```
+*
+* > If `liveSyncKeys` does not include the key, the plugin will fallback to the dynamic impor
+*
+* ```ts
+* import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };
+* import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';
+* import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';
+* import { getDictionary as getIntlayer } from 'intlayer';
+*
+* const content1 = useIntlayer(_dicHash_dyn, 'app');
+* const content2 = getIntlayer(_dicHash);
+* ```
+*/
+const intlayerBabelPlugin = (babel) => {
+	const { types: t } = babel;
+	return {
+		name: "babel-plugin-intlayer-transform",
+		pre() {
+			this._newStaticImports = /* @__PURE__ */ new Map();
+			this._newDynamicImports = /* @__PURE__ */ new Map();
+			this._isIncluded = true;
+			this._hasValidImport = false;
+			this._isDictEntry = false;
+			this._useDynamicHelpers = false;
+			const filename = this.file.opts.filename;
+			if (this.opts.filesList && filename) {
+				if (!this.opts.filesList.includes(filename)) {
+					this._isIncluded = false;
+					return;
+				}
+			}
+		},
+		visitor: {
+			Program: {
+				enter(programPath, state) {
+					const filename = state.file.opts.filename;
+					if (state.opts.replaceDictionaryEntry && filename === state.opts.dictionariesEntryPath) {
+						state._isDictEntry = true;
+						programPath.node.body = [t.exportDefaultDeclaration(t.objectExpression([]))];
+						programPath.stop();
+					}
+				},
+				exit(programPath, state) {
+					if (state._isDictEntry) return;
+					if (!state._hasValidImport) return;
+					if (!state._isIncluded) return;
+					const file = state.file.opts.filename;
+					const dictionariesDir = state.opts.dictionariesDir;
+					const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;
+					const fetchDictionariesDir = state.opts.fetchDictionariesDir;
+					const imports = [];
+					for (const [key, ident] of state._newStaticImports) {
+						const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, "static");
+						const importDeclarationNode = t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel));
+						importDeclarationNode.attributes = [t.importAttribute(t.identifier("type"), t.stringLiteral("json"))];
+						imports.push(importDeclarationNode);
+					}
+					for (const [key, ident] of state._newDynamicImports) {
+						const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, ident.name.endsWith("_fetch") ? "live" : "dynamic");
+						imports.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel)));
+					}
+					if (!imports.length) return;
+					const bodyPaths = programPath.get("body");
+					let insertPos = 0;
+					for (const stmtPath of bodyPaths) {
+						const stmt = stmtPath.node;
+						if (t.isExpressionStatement(stmt) && t.isStringLiteral(stmt.expression) && !stmt.expression.value.startsWith("import") && !stmt.expression.value.startsWith("require")) insertPos += 1;
+						else break;
+					}
+					programPath.node.body.splice(insertPos, 0, ...imports);
+				}
+			},
+			ImportDeclaration(path, state) {
+				if (state._isDictEntry) return;
+				const src = path.node.source.value;
+				if (!PACKAGE_LIST.includes(src)) return;
+				state._hasValidImport = true;
+				for (const spec of path.node.specifiers) {
+					if (!t.isImportSpecifier(spec)) continue;
+					const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+					const importMode = state.opts.importMode;
+					const shouldUseDynamicHelpers = (importMode === "dynamic" || importMode === "live") && PACKAGE_LIST_DYNAMIC.includes(src);
+					if (shouldUseDynamicHelpers) state._useDynamicHelpers = true;
+					let helperMap;
+					if (shouldUseDynamicHelpers) helperMap = {
+						...STATIC_IMPORT_FUNCTION,
+						...DYNAMIC_IMPORT_FUNCTION
+					};
+					else helperMap = STATIC_IMPORT_FUNCTION;
+					const newIdentifier = helperMap[importedName];
+					if (newIdentifier) spec.imported = t.identifier(newIdentifier);
+				}
+			},
+			CallExpression(path, state) {
+				if (state._isDictEntry) return;
+				const callee = path.node.callee;
+				if (!t.isIdentifier(callee)) return;
+				if (!CALLER_LIST.includes(callee.name)) return;
+				state._hasValidImport = true;
+				const arg = path.node.arguments[0];
+				if (!arg || !t.isStringLiteral(arg)) return;
+				const key = arg.value;
+				const importMode = state.opts.importMode;
+				const isUseIntlayer = callee.name === "useIntlayer";
+				const useDynamicHelpers = Boolean(state._useDynamicHelpers);
+				let perCallMode = "static";
+				if (isUseIntlayer && useDynamicHelpers) {
+					if (importMode === "dynamic") perCallMode = "dynamic";
+					else if (importMode === "live") perCallMode = (state.opts.liveSyncKeys ?? []).includes(key) ? "live" : "dynamic";
+				}
+				let ident;
+				if (perCallMode === "live") {
+					let dynamicIdent = state._newDynamicImports?.get(key);
+					if (!dynamicIdent) {
+						const hash = (0, __intlayer_chokidar.getFileHash)(key);
+						dynamicIdent = t.identifier(`_${hash}_fetch`);
+						state._newDynamicImports?.set(key, dynamicIdent);
+					}
+					ident = dynamicIdent;
+					path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
+				} else if (perCallMode === "dynamic") {
+					let dynamicIdent = state._newDynamicImports?.get(key);
+					if (!dynamicIdent) {
+						const hash = (0, __intlayer_chokidar.getFileHash)(key);
+						dynamicIdent = t.identifier(`_${hash}_dyn`);
+						state._newDynamicImports?.set(key, dynamicIdent);
+					}
+					ident = dynamicIdent;
+					path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
+				} else {
+					let staticIdent = state._newStaticImports?.get(key);
+					if (!staticIdent) {
+						staticIdent = makeIdent(key, t);
+						state._newStaticImports?.set(key, staticIdent);
+					}
+					ident = staticIdent;
+					path.node.arguments[0] = t.identifier(ident.name);
+				}
+			}
+		}
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  intlayerBabelPlugin
-});
+
+//#endregion
+exports.intlayerBabelPlugin = intlayerBabelPlugin;
 //# sourceMappingURL=babel-plugin-intlayer.cjs.map