next-intlayer 9.2.0 → 9.3.0

package/dist/types/server/prepareSwcOptimization.d.ts

@@ -0,0 +1,67 @@
+import { SwcExtraCallerConfig } from "@intlayer/config/callers";
+import { GetConfigurationOptions } from "@intlayer/config/node";
+import { SerializedFieldRenameMap } from "@intlayer/babel";
+import { IntlayerConfig } from "@intlayer/types/config";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/server/prepareSwcOptimization.d.ts
+/**
+ * Field-rename tables keyed by dictionary key, forwarded to the
+ * `@intlayer/swc` plugin's `fieldRenameMap` option.
+ */
+type FieldRenameMapByDictionaryKey = Record<string, SerializedFieldRenameMap>;
+/** Verbosity forwarded to the `@intlayer/swc` plugin's `logLevel` option. */
+type SwcLogLevel = 'off' | 'info' | 'debug';
+/**
+ * Resolves the verbosity the `@intlayer/swc` plugin should report at.
+ *
+ * Off unless {@link SWC_LOG_LEVEL_ENV_VAR} asks for tracing: `log.mode` governs
+ * the purge and minify reporting, which the pipeline emits in Node so the
+ * Next.js build reads the same as the Vite one.
+ */
+declare const resolveSwcLogLevel: (intlayerConfig: IntlayerConfig) => SwcLogLevel;
+/**
+ * Whether the purge / minify pipeline can run at all, i.e. whether a usable
+ * `@intlayer/babel` is resolvable from the project.
+ *
+ * Used by `withIntlayer` to keep the build report honest: announcing
+ * `Dictionary minification enabled` while the pipeline cannot load would describe a
+ * pass that never happens.
+ */
+declare const getIsPurgePipelineAvailable: (intlayerConfig: IntlayerConfig) => boolean;
+type PrepareSwcOptimizationParams = {
+  /** Options forwarded to the intlayer configuration loader. */
+  configOptions?: GetConfigurationOptions;
+  /** Pre-loaded dictionaries, to avoid a second `getDictionaries` call. */
+  dictionaries?: Dictionary[];
+  /** Compat-adapter callers declared by the consuming plugin, if any. */
+  swcExtraCallers?: SwcExtraCallerConfig[];
+  /**
+   * Whether the `@intlayer/swc` plugin is installed *and* the resolved Next.js
+   * version can load it. False leaves the compiled dictionaries untouched.
+   */
+  isSwcPluginUsable: boolean;
+};
+/**
+ * Prepares the parts of the build optimisation the `@intlayer/swc` plugin
+ * cannot do itself, and returns the field-rename tables it needs.
+ *
+ * Removing unused content fields (`build.purge`) and assigning short field
+ * aliases (`build.minify`) require reading every component source file and
+ * rewriting the compiled dictionary JSON — file I/O and cross-file state that a
+ * per-file Wasm transform has no access to. That analysis therefore runs here,
+ * in Node, through `@intlayer/babel`; the plugin only receives the resulting
+ * tables and rewrites the matching source accesses
+ * (`content.title` → `content.a`).
+ *
+ * The work is coordinated by a sentinel file: Next.js loads `next.config.*` in
+ * several processes per build, and running the minify pass twice would derive
+ * the aliases from the already-renamed dictionaries. Processes that lose the
+ * race read the tables the winner cached.
+ *
+ * @returns The field-rename tables, keyed by dictionary key. Empty when the
+ *   pipeline is disabled, unavailable, or renamed nothing.
+ */
+declare const prepareSwcOptimization: (intlayerConfig: IntlayerConfig, params: PrepareSwcOptimizationParams) => Promise<FieldRenameMapByDictionaryKey>;
+//#endregion
+export { FieldRenameMapByDictionaryKey, SwcLogLevel, getIsPurgePipelineAvailable, prepareSwcOptimization, resolveSwcLogLevel };
+//# sourceMappingURL=prepareSwcOptimization.d.ts.map

package/dist/types/server/prepareSwcOptimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareSwcOptimization.d.ts","names":[],"sources":["../../../src/server/prepareSwcOptimization.ts"],"mappings":";;;;;;;;;;KAsBY,gCAAgC,eAE1C;;KAIU;;;;;;;;cAoDC,qBAAkB,gBACb,mBACf;;;;;;;;;cAmGU,8BAA2B,gBACtB;KAkGb;;EAEH,gBAAgB;;EAEhB,eAAe;;EAEf,kBAAkB;;;;;EAKlB;;;;;;;;;;;;;;;;;;;;;;cAuBW,yBAAsB,gBACjB,gBAAc,QACtB,iCACP,QAAQ"}

package/dist/types/server/swcPluginCompatibility.d.ts

@@ -0,0 +1,52 @@
+//#region src/server/swcPluginCompatibility.d.ts
+/**
+ * Oldest Next.js release whose bundled SWC can load the `@intlayer/swc` Wasm
+ * plugin.
+ *
+ * A Wasm plugin only loads in a host that speaks its `swc_ecma_ast` schema.
+ * Next.js 16.1.0 is the first release built on SWC's forward-compatible plugin
+ * ABI — the AST travels as self-describing CBOR instead of rkyv, so a plugin
+ * compiled against an older `swc_core` keeps loading in newer hosts. Every
+ * earlier release uses the rkyv ABI, which requires an exact schema match and
+ * rejects the plugin outright, failing the build with `failed to invoke
+ * plugin`.
+ *
+ * Verified by driving `transformSync` on the shipped `@next/swc` binaries with
+ * the plugin attached:
+ *
+ * | Next.js | swc_ecma_ast | plugin loads |
+ * | ------- | ------------ | ------------ |
+ * | 14.2.x  | 0.112.7      | no           |
+ * | 15.5.x  | 14.0.0       | no           |
+ * | 16.0.x  | 16.0.0       | no           |
+ * | 16.1.x  | 19.0.0       | yes          |
+ * | 16.2.x  | 20.0.1       | yes          |
+ * | 16.3.x  | 25.0.0       | yes          |
+ *
+ * Keep in sync with the `swc_core` pin in
+ * `packages/@intlayer/swc/Cargo.toml`: the plugin must stay on the
+ * `swc_ecma_ast` version this Next.js release ships, never a newer one, or the
+ * floor moves up with it.
+ */
+declare const MINIMUM_SWC_PLUGIN_NEXT_VERSION = "16.1.0";
+/**
+ * Whether `nextVersion` bundles an SWC able to load the `@intlayer/swc` Wasm
+ * plugin.
+ *
+ * Pre-releases of a supported version (`16.1.0-canary.4`, `16.3.0-preview.5`)
+ * count as supported: they track the release they lead to, and opting into a
+ * canary already means opting into its churn.
+ *
+ * @param nextVersion - Version string read from the project's `next/package.json`.
+ * @returns `true` when the plugin can be registered in `experimental.swcPlugins`.
+ *
+ * @example
+ * ```ts
+ * getIsSwcPluginSupported('16.3.0'); // true
+ * getIsSwcPluginSupported('15.5.18'); // false
+ * ```
+ */
+declare const getIsSwcPluginSupported: (nextVersion: string) => boolean;
+//#endregion
+export { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported };
+//# sourceMappingURL=swcPluginCompatibility.d.ts.map

package/dist/types/server/swcPluginCompatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swcPluginCompatibility.d.ts","names":[],"sources":["../../../src/server/swcPluginCompatibility.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba;;;;;;;;;;;;;;;;;;cAmBA,0BAAuB"}

package/dist/types/server/withIntlayer.d.ts

@@ -1,3 +1,5 @@
+import { FieldRenameMapByDictionaryKey } from "./prepareSwcOptimization.js";
+import { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported } from "./swcPluginCompatibility.js";
 import { NextConfig } from "next";
 import { SwcExtraCallerConfig } from "@intlayer/config/callers";
 import { GetConfigurationOptions } from "@intlayer/config/node";
@@ -5,6 +7,15 @@ import { GetConfigurationOptions } from "@intlayer/config/node";
 type WithIntlayerOptions = GetConfigurationOptions & {
   enableTurbopack?: boolean;
   swcExtraCallers?: SwcExtraCallerConfig[];
+  /**
+   * Field-rename tables produced by the purge / minify pipeline, forwarded to
+   * the `@intlayer/swc` plugin so it rewrites source accesses to match the
+   * renamed dictionaries.
+   *
+   * @internal Set by {@link withIntlayer}; `withIntlayerSync` on its own runs
+   * no dictionary rewrite, so it leaves this unset and no rename is applied.
+   */
+  fieldRenameMap?: FieldRenameMapByDictionaryKey;
 };
 /**
  * A Next.js plugin that adds the intlayer configuration to the webpack configuration
@@ -35,5 +46,5 @@ declare const withIntlayerSync: <T extends Partial<NextConfig>>(nextConfig?: T,
  */
 declare const withIntlayer: <T extends NextConfig | Partial<NextConfig>>(nextConfig?: T | Promise<T>, configOptions?: WithIntlayerOptions) => Promise<NextConfig & T>;
 //#endregion
-export { withIntlayer, withIntlayerSync };
+export { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported, withIntlayer, withIntlayerSync };
 //# sourceMappingURL=withIntlayer.d.ts.map

package/dist/types/server/withIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withIntlayer.d.ts","names":[],"sources":["../../../src/server/withIntlayer.ts"],"mappings":";;;;KA4RK,sBAAsB;EACzB;EACA,kBAAkB;;;;;;;;;;;;;cAuDP,mBAAoB,UAAU,QAAQ,aAAW,aAChD,GAAC,gBACG,wBACf,aAAa;;;;;;;;;;;;;;;;cA8PH,eAAsB,UAAU,aAAa,QAAQ,aAAW,aAC/D,IAAI,QAAQ,IAAE,gBACV,wBACf,QAAQ,aAAa"}
+{"version":3,"file":"withIntlayer.d.ts","names":[],"sources":["../../../src/server/withIntlayer.ts"],"mappings":";;;;;;KA4XK,sBAAsB;EACzB;EACA,kBAAkB;;;;;;;;;EAUlB,iBAAiB;;;;;;;;;;;;;cAuDN,mBAAoB,UAAU,QAAQ,aAAW,aAChD,GAAC,gBACG,wBACf,aAAa;;;;;;;;;;;;;;;;cA4QH,eAAsB,UAAU,aAAa,QAAQ,aAAW,aAC/D,IAAI,QAAQ,IAAE,gBACV,wBACf,QAAQ,aAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-intlayer",
-  "version": "9.2.0",
+  "version": "9.3.0",
   "private": false,
   "description": "Simplify internationalization i18n in Next.js with context providers, hooks, locale detection, and multilingual content integration.",
   "keywords": [
@@ -133,18 +133,19 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.2.0",
-    "@intlayer/core": "9.2.0",
-    "@intlayer/dictionaries-entry": "9.2.0",
-    "@intlayer/engine": "9.2.0",
-    "@intlayer/types": "9.2.0",
-    "@intlayer/webpack": "9.2.0",
+    "@intlayer/config": "9.3.0",
+    "@intlayer/core": "9.3.0",
+    "@intlayer/dictionaries-entry": "9.3.0",
+    "@intlayer/engine": "9.3.0",
+    "@intlayer/types": "9.3.0",
+    "@intlayer/webpack": "9.3.0",
     "defu": "6.1.7",
     "node-loader": "2.1.0",
-    "react-intlayer": "9.2.0"
+    "react-intlayer": "9.3.0"
   },
   "devDependencies": {
-    "@types/node": "26.1.2",
+    "@intlayer/babel": "9.3.0",
+    "@types/node": "26.2.0",
     "@types/react": ">=16.0.0",
     "@types/react-dom": ">=16.0.0",
     "@utils/ts-config": "1.0.4",