@intlayer/engine 9.0.0-canary.12

package/dist/types/init/frameworkSetup/nextAppRouter/restructure.d.ts

@@ -0,0 +1,56 @@
+//#region src/init/frameworkSetup/nextAppRouter/restructure.d.ts
+/**
+ * Detects whether a top-level App Router entry is already a locale segment, in
+ * any of the Next.js dynamic-segment forms:
+ * - `[locale]` — required segment (prefix every locale),
+ * - `[...locale]` / `[[...locale]]` — catch-all / optional catch-all segments.
+ *
+ * Used to skip the restructure when the project is already locale-aware, so an
+ * existing locale segment is never nested under a freshly created `[locale]`.
+ */
+declare const isLocaleSegment: (entryName: string) => boolean;
+/**
+ * Top-level App Router entries that must stay at the app root and never be
+ * moved under `[locale]`:
+ * - `api/` route handlers (not locale-prefixed),
+ * - global stylesheets,
+ * - metadata/asset file conventions (favicon, icon, sitemap, robots, manifest…),
+ * - `global-error` and `not-found` boundaries (kept as root fallbacks).
+ *
+ * Everything else (`page`, `loading`, `error`, `template`, `default`, the root
+ * `layout`, and nested route folders) is moved so it becomes locale-aware.
+ */
+declare const shouldKeepAppEntryAtRoot: (entryName: string) => boolean;
+type RewriteContext = {
+  appDirAbs: string;
+  localeDirAbs: string;
+  movedTopLevelNames: string[];
+};
+/**
+ * Rewrites relative import/export/`import()`/`require()` specifiers in a file
+ * that has moved from `oldAbs` to `newAbs`, so they keep resolving to the same
+ * modules after the move. Non-relative specifiers (bare packages, `@/` aliases)
+ * are left untouched. Returns the original code unchanged when nothing matched.
+ */
+declare const rewriteRelativeImports: (code: string, oldAbs: string, newAbs: string, context: RewriteContext) => string;
+/** Outcome of an attempted `[locale]` restructure. */
+type RestructureResult = {
+  status: 'already-structured';
+  localeSegment: string;
+} | {
+  status: 'nothing-to-move';
+} | {
+  status: 'moved';
+  movedEntries: string[];
+};
+/**
+ * Moves the routable App Router entries of `appDir` under a new `[locale]`
+ * segment and rewrites relative imports in the moved files. Idempotent: it is a
+ * no-op when the app is already locale-aware in any prefix mode (see
+ * {@link isLocaleSegment}), which is reported via `localeSegment`. Root-only
+ * files (see {@link shouldKeepAppEntryAtRoot}) are left in place.
+ */
+declare const restructureAppIntoLocale: (rootDir: string, appDir: string) => Promise<RestructureResult>;
+//#endregion
+export { RestructureResult, isLocaleSegment, restructureAppIntoLocale, rewriteRelativeImports, shouldKeepAppEntryAtRoot };
+//# sourceMappingURL=restructure.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/restructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restructure.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/restructure.ts"],"mappings":";;AAuBA;;;;;AAcA;;;cAda,eAAA,GAAmB,SAAA;;AA2C9B;;;;;;;;;AA0CF;cAvEa,wBAAA,GAA4B,SAAA;AAAA,KA+BpC,cAAA;EACH,SAAA;EACA,YAAA;EACA,kBAAA;AAAA;;;;;AAoGF;;cA/Da,sBAAA,GACX,IAAA,UACA,MAAA,UACA,MAAA,UACA,OAAA,EAAS,cAAA;;KA2DC,iBAAA;EACN,MAAA;EAA8B,aAAA;AAAA;EAC9B,MAAA;AAAA;EACA,MAAA;EAAiB,YAAA;AAAA;;;;;;;;cASV,wBAAA,GACX,OAAA,UACA,MAAA,aACC,OAAA,CAAQ,iBAAA"}

package/dist/types/init/frameworkSetup/nextAppRouter/templates.d.ts

@@ -0,0 +1,26 @@
+//#region src/init/frameworkSetup/nextAppRouter/templates.d.ts
+/**
+ * File templates for a fresh Next.js App Router integration. These are only
+ * written when the target file does not exist (or, for the locale layout/page,
+ * when the app is effectively empty) — they never overwrite user code.
+ */
+/** Next.js >= 16 locale-detection proxy (`src/proxy.ts`). */
+declare const PROXY_TEMPLATE = "export { intlayerProxy as proxy } from \"next-intlayer/proxy\";\n\nexport const config = {\n  matcher:\n    \"/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\\\..*|_next).*)\",\n};\n";
+/** Next.js < 16 locale-detection middleware (`src/middleware.ts`). */
+declare const MIDDLEWARE_TEMPLATE = "export { intlayerMiddleware as middleware } from \"next-intlayer/middleware\";\n\nexport const config = {\n  matcher:\n    \"/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\\\..*|_next).*)\",\n};\n";
+/** Minimal pass-through root layout (`app/layout.tsx`), lets `[locale]/layout` own `<html>`. */
+declare const ROOT_LAYOUT_TEMPLATE_TS = "import type { PropsWithChildren, FC } from \"react\";\n\nconst RootLayout: FC<PropsWithChildren> = ({ children }) => <>{children}</>;\n\nexport default RootLayout;\n";
+declare const ROOT_LAYOUT_TEMPLATE_JS = "const RootLayout = ({ children }) => <>{children}</>;\n\nexport default RootLayout;\n";
+/** Locale layout (`app/[locale]/layout.tsx`) providing `<html>` + client provider. */
+declare const LOCALE_LAYOUT_TEMPLATE_TS = "import { type NextLayoutIntlayer, IntlayerClientProvider } from \"next-intlayer\";\nimport { getHTMLTextDir } from \"intlayer\";\n\nexport { generateStaticParams } from \"next-intlayer\";\n\nconst LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {\n  const { locale } = await params;\n\n  return (\n    <html lang={locale} dir={getHTMLTextDir(locale)}>\n      <body>\n        <IntlayerClientProvider locale={locale}>\n          {children}\n        </IntlayerClientProvider>\n      </body>\n    </html>\n  );\n};\n\nexport default LocaleLayout;\n";
+declare const LOCALE_LAYOUT_TEMPLATE_JS = "import { IntlayerClientProvider } from \"next-intlayer\";\nimport { getHTMLTextDir } from \"intlayer\";\n\nexport { generateStaticParams } from \"next-intlayer\";\n\nconst LocaleLayout = async ({ children, params }) => {\n  const { locale } = await params;\n\n  return (\n    <html lang={locale} dir={getHTMLTextDir(locale)}>\n      <body>\n        <IntlayerClientProvider locale={locale}>\n          {children}\n        </IntlayerClientProvider>\n      </body>\n    </html>\n  );\n};\n\nexport default LocaleLayout;\n";
+/**
+ * Locale home page (`app/[locale]/page.tsx`). Self-contained starter that does
+ * not depend on an example content declaration — add Intlayer content (a
+ * `*.content.ts` file consumed via `useIntlayer`) as the next step.
+ */
+declare const LOCALE_PAGE_TEMPLATE_TS = "import { type NextPageIntlayer } from \"next-intlayer\";\n\nconst Page: NextPageIntlayer = async ({ params }) => {\n  const { locale } = await params;\n\n  return (\n    <main>\n      <h1>{locale}</h1>\n      <p>Get started by editing this page.</p>\n    </main>\n  );\n};\n\nexport default Page;\n";
+declare const LOCALE_PAGE_TEMPLATE_JS = "const Page = async ({ params }) => {\n  const { locale } = await params;\n\n  return (\n    <main>\n      <h1>{locale}</h1>\n      <p>Get started by editing this page.</p>\n    </main>\n  );\n};\n\nexport default Page;\n";
+//#endregion
+export { LOCALE_LAYOUT_TEMPLATE_JS, LOCALE_LAYOUT_TEMPLATE_TS, LOCALE_PAGE_TEMPLATE_JS, LOCALE_PAGE_TEMPLATE_TS, MIDDLEWARE_TEMPLATE, PROXY_TEMPLATE, ROOT_LAYOUT_TEMPLATE_JS, ROOT_LAYOUT_TEMPLATE_TS };
+//# sourceMappingURL=templates.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/templates.ts"],"mappings":";;AAOA;;;;;cAAa,cAAA;;cASA,mBAAA;;cASA,uBAAA;AAAA,cAOA,uBAAA;;cAMA,yBAAA;AAAA,cAsBA,yBAAA;;AA5Bb;;;;cAuDa,uBAAA;AAAA,cAgBA,uBAAA"}

package/dist/types/init/frameworkSetup/nextAppRouter/transforms.d.ts

@@ -0,0 +1,23 @@
+//#region src/init/frameworkSetup/nextAppRouter/transforms.d.ts
+/** Result of a source transform. `code` is unchanged for any non-`wrapped` status. */
+type TransformResult = {
+  code: string;
+  status: 'wrapped' | 'already' | 'skipped-client' | 'skipped';
+};
+/**
+ * Wraps the `{children}` of a Next.js App Router **layout** with
+ * `IntlayerClientProvider`, deriving the locale via `getLocale()`. Safe and
+ * idempotent: bails (returns the original code) for client components, when no
+ * `{children}` placeholder is found, or when there is no default export.
+ */
+declare const wrapLayoutWithProvider: (code: string) => TransformResult;
+/**
+ * Wraps the returned JSX of a Next.js App Router **page** with
+ * `IntlayerServerProvider`, deriving the locale via `getLocale()`. Safe and
+ * idempotent: bails for client components, when the page has no single
+ * top-level JSX return, or when there is no default export.
+ */
+declare const wrapPageWithProvider: (code: string) => TransformResult;
+//#endregion
+export { TransformResult, wrapLayoutWithProvider, wrapPageWithProvider };
+//# sourceMappingURL=transforms.d.ts.map

package/dist/types/init/frameworkSetup/nextAppRouter/transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/nextAppRouter/transforms.ts"],"mappings":";;KAUY,eAAA;EACV,IAAA;EACA,MAAA;AAAA;;AAiLF;;;;;cAAa,sBAAA,GAA0B,IAAA,aAAe,eAAA;;;;;;;cAsFzC,oBAAA,GAAwB,IAAA,aAAe,eAAA"}

package/dist/types/init/frameworkSetup/tanstackStart/detect.d.ts

@@ -0,0 +1,19 @@
+//#region src/init/frameworkSetup/tanstackStart/detect.d.ts
+/** Location of the TanStack Router file-based routes directory. */
+type TanStackRoutesInfo = {
+  /** Routes directory relative to the root, e.g. `src/routes` or `routes`. */routesDir: string; /** `src` when the project uses a `src/` directory, otherwise `''`. */
+  srcDir: string;
+};
+/**
+ * Detects the TanStack Router routes directory, preferring `src/routes` over
+ * `routes`. Returns `null` when neither exists.
+ */
+declare const detectTanStackRoutesDir: (rootDir: string) => Promise<TanStackRoutesInfo | null>;
+/**
+ * Returns true when the project depends on TanStack Start (`@tanstack/react-start`)
+ * or, failing that, on `@tanstack/react-router` (file-based routing).
+ */
+declare const hasTanStackStartDeps: (allDeps: Record<string, string>) => boolean;
+//#endregion
+export { TanStackRoutesInfo, detectTanStackRoutesDir, hasTanStackStartDeps };
+//# sourceMappingURL=detect.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/detect.ts"],"mappings":";;KAIY,kBAAA;EAAkB,4EAE5B,SAAA;EAEA,MAAA;AAAA;;;;;cAOW,uBAAA,GACX,OAAA,aACC,OAAA,CAAQ,kBAAA;;;;AAcX;cAAa,oBAAA,GACX,OAAA,EAAS,MAAA"}

package/dist/types/init/frameworkSetup/tanstackStart/index.d.ts

@@ -0,0 +1,13 @@
+import { FrameworkAdapter } from "../types.js";
+
+//#region src/init/frameworkSetup/tanstackStart/index.d.ts
+/**
+ * TanStack Start adapter. Restructures the file-based routes under a `{-$locale}`
+ * segment, scaffolds the locale segment route, and wraps the root document with
+ * the Intlayer provider — all idempotently and without overwriting user code it
+ * cannot confidently transform.
+ */
+declare const tanStackStartAdapter: FrameworkAdapter;
+//#endregion
+export { tanStackStartAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/index.ts"],"mappings":";;;;;AA4EA;;;;cAAa,oBAAA,EAAsB,gBAAA"}

package/dist/types/init/frameworkSetup/tanstackStart/restructure.d.ts

@@ -0,0 +1,68 @@
+import { RoutingMode } from "../../utils/configManipulation.js";
+
+//#region src/init/frameworkSetup/tanstackStart/restructure.d.ts
+/**
+ * The optional TanStack Router locale segment directory (`{-$locale}` param),
+ * used by every routing mode except `prefix-all` so the default locale stays
+ * prefix-free.
+ */
+declare const LOCALE_SEGMENT = "{-$locale}";
+/**
+ * The required TanStack Router locale segment directory (`$locale` param), used
+ * by `prefix-all` routing where every URL — including the default locale — is
+ * prefixed.
+ */
+declare const PREFIX_ALL_LOCALE_SEGMENT = "$locale";
+/**
+ * Picks the locale segment directory for the project's routing mode. `prefix-all`
+ * requires the mandatory `$locale` param so the default locale is also prefixed;
+ * all other modes use the optional `{-$locale}` param so the default locale stays
+ * prefix-free.
+ */
+declare const getLocaleSegment: (routingMode: RoutingMode) => string;
+/**
+ * Detects whether a top-level route entry is already a locale segment, in any of
+ * the TanStack Router param forms:
+ * - `{-$locale}` — optional param (prefix every locale except the default),
+ * - `$locale` / `{$locale}` — required param (prefix **all** locales).
+ *
+ * Used to skip the restructure when the project is already locale-aware, so an
+ * existing prefix-all `$locale` directory is never nested under a freshly created
+ * `{-$locale}` (which would produce `{-$locale}/$locale`).
+ */
+declare const isLocaleSegment: (entryName: string) => boolean;
+/**
+ * Routes-directory entries that must stay at the root and never be moved under
+ * `{-$locale}`:
+ * - `__root` (the root route document),
+ * - `routeTree.gen` (generated route tree),
+ * - `api` (server / API routes — these are not locale-prefixed),
+ * - TanStack-ignored entries prefixed with `-` (e.g. `-components`, `-utils`),
+ * - stylesheets.
+ *
+ * Everything else (route files and nested route folders) is moved so it becomes
+ * locale-aware.
+ */
+declare const shouldKeepRouteAtRoot: (entryName: string) => boolean;
+/** Outcome of an attempted `{-$locale}` restructure. */
+type RestructureResult = {
+  status: 'already-structured';
+  localeSegment: string;
+} | {
+  status: 'nothing-to-move';
+} | {
+  status: 'moved';
+  movedEntries: string[];
+};
+/**
+ * Moves the routable entries of `routesDir` under a new `localeSegment` directory
+ * (the optional `{-$locale}` by default, or the required `$locale` for
+ * `prefix-all`) and rewrites relative imports in the moved files. Idempotent: a
+ * no-op when the routes are already locale-aware in any prefix mode (see
+ * {@link isLocaleSegment}), which is reported via `localeSegment`. Root-only
+ * files (see {@link shouldKeepRouteAtRoot}) are left in place.
+ */
+declare const restructureRoutesIntoLocale: (rootDir: string, routesDir: string, localeSegment?: string) => Promise<RestructureResult>;
+//#endregion
+export { LOCALE_SEGMENT, PREFIX_ALL_LOCALE_SEGMENT, RestructureResult, getLocaleSegment, isLocaleSegment, restructureRoutesIntoLocale, shouldKeepRouteAtRoot };
+//# sourceMappingURL=restructure.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/restructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restructure.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/restructure.ts"],"mappings":";;;;;AAcA;;;cAAa,cAAA;;AAOb;;;;cAAa,yBAAA;AAQb;;;;;AAaA;AAbA,cAAa,gBAAA,GAAoB,WAAA,EAAa,WAAA;;;;AAgC9C;;;;;AAUA;;cA7Ba,eAAA,GAAmB,SAAA;;;;;;;;;AA0ChC;;;;cAvBa,qBAAA,GAAyB,SAAA;;KAU1B,iBAAA;EACN,MAAA;EAA8B,aAAA;AAAA;EAC9B,MAAA;AAAA;EACA,MAAA;EAAiB,YAAA;AAAA;;;;;;;;;cAUV,2BAAA,GACX,OAAA,UACA,SAAA,UACA,aAAA,cACC,OAAA,CAAQ,iBAAA"}

package/dist/types/init/frameworkSetup/tanstackStart/templates.d.ts

@@ -0,0 +1,22 @@
+//#region src/init/frameworkSetup/tanstackStart/templates.d.ts
+/**
+ * File templates for a fresh TanStack Start integration. These are only written
+ * when the target file does not exist — they never overwrite user code.
+ */
+/**
+ * Builds the locale segment route (`routes/<localeSegment>/route.tsx`) for the
+ * given segment. The optional `{-$locale}` param makes the default locale
+ * prefix-free, while the required `$locale` param (`prefix-all`) prefixes every
+ * locale; in both cases `validatePrefix` redirects unknown prefixes to a valid
+ * one. Identical for TypeScript and JavaScript projects.
+ */
+declare const buildLocaleRouteTemplate: (localeSegment: string) => string;
+/**
+ * Root route document (`routes/__root.tsx`) providing `<html>` + the Intlayer
+ * provider, with the locale read from the `{-$locale}` route param.
+ */
+declare const ROOT_TEMPLATE_TS = "import {\n  createRootRoute,\n  HeadContent,\n  Scripts,\n  useParams,\n} from \"@tanstack/react-router\";\nimport { defaultLocale, getHTMLTextDir } from \"intlayer\";\nimport type { ReactNode } from \"react\";\nimport { IntlayerProvider } from \"react-intlayer\";\n\nexport const Route = createRootRoute({\n  shellComponent: RootDocument,\n});\n\nfunction RootDocument({ children }: { children: ReactNode }) {\n  const params = useParams({ strict: false });\n  const locale = params.locale ?? defaultLocale;\n\n  return (\n    <html dir={getHTMLTextDir(locale)} lang={locale}>\n      <head>\n        <HeadContent />\n      </head>\n      <body>\n        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>\n        <Scripts />\n      </body>\n    </html>\n  );\n}\n";
+declare const ROOT_TEMPLATE_JS = "import {\n  createRootRoute,\n  HeadContent,\n  Scripts,\n  useParams,\n} from \"@tanstack/react-router\";\nimport { defaultLocale, getHTMLTextDir } from \"intlayer\";\nimport { IntlayerProvider } from \"react-intlayer\";\n\nexport const Route = createRootRoute({\n  shellComponent: RootDocument,\n});\n\nfunction RootDocument({ children }) {\n  const params = useParams({ strict: false });\n  const locale = params.locale ?? defaultLocale;\n\n  return (\n    <html dir={getHTMLTextDir(locale)} lang={locale}>\n      <head>\n        <HeadContent />\n      </head>\n      <body>\n        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>\n        <Scripts />\n      </body>\n    </html>\n  );\n}\n";
+//#endregion
+export { ROOT_TEMPLATE_JS, ROOT_TEMPLATE_TS, buildLocaleRouteTemplate };
+//# sourceMappingURL=templates.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/templates.ts"],"mappings":";;AAYA;;;;;AA4BA;;;;;cA5Ba,wBAAA,GACX,aAAA;;;;;cA2BW,gBAAA;AAAA,cAgCA,gBAAA"}

package/dist/types/init/frameworkSetup/tanstackStart/transforms.d.ts

@@ -0,0 +1,17 @@
+//#region src/init/frameworkSetup/tanstackStart/transforms.d.ts
+/** Result of a source transform. `code` is unchanged for any non-`wrapped` status. */
+type TransformResult = {
+  code: string;
+  status: 'wrapped' | 'already' | 'skipped';
+};
+/**
+ * Wraps the `{children}` of a TanStack Start root document with
+ * `IntlayerProvider`, deriving the locale from the `{-$locale}` route param.
+ * Safe and idempotent: bails (returns the original code) when the provider is
+ * already present, when no `<html>` document function is found, or when there is
+ * no `{children}` placeholder to wrap.
+ */
+declare const wrapRootWithProvider: (code: string) => TransformResult;
+//#endregion
+export { TransformResult, wrapRootWithProvider };
+//# sourceMappingURL=transforms.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/transforms.ts"],"mappings":";;KAUY,eAAA;EACV,IAAA;EACA,MAAA;AAAA;;AAqJF;;;;;;cAAa,oBAAA,GAAwB,IAAA,aAAe,eAAA"}

package/dist/types/init/frameworkSetup/types.d.ts

@@ -0,0 +1,43 @@
+import { PackageManager } from "../utils/packageManager.js";
+import { RoutingMode } from "../utils/configManipulation.js";
+
+//#region src/init/frameworkSetup/types.d.ts
+/**
+ * Shared context passed to every framework adapter. Mirrors the data already
+ * computed by `initIntlayer` so adapters don't re-detect it.
+ */
+type FrameworkSetupContext = {
+  /** Absolute project root directory. */rootDir: string; /** Merged prod + dev dependencies of the project's package.json. */
+  allDeps: Record<string, string>; /** Detected package manager (unused today, kept for adapter parity). */
+  packageManager: PackageManager; /** Whether the project is a TypeScript project (drives file extensions). */
+  useTypeScript: boolean;
+  /**
+   * Effective locale routing mode for the project (the user's interactive
+   * choice, else the configured/`routing.mode` default). Drives whether the
+   * locale path segment is required (`prefix-all` → `$locale`) or optional
+   * (`prefix-no-default` → `{-$locale}`).
+   */
+  routingMode: RoutingMode;
+};
+/**
+ * A framework integration adapter. Each adapter knows how to recognize a
+ * project shape and scaffold the matching Intlayer integration (middleware,
+ * providers, example content) in a way that is safe to re-run.
+ */
+type FrameworkAdapter = {
+  /** Human-readable adapter name, used in logs. */name: string;
+  /**
+   * Returns true when this adapter applies to the project. Adapters are tried
+   * in registration order and the first match wins.
+   */
+  detect: (context: FrameworkSetupContext) => boolean | Promise<boolean>;
+  /**
+   * Performs the (idempotent, non-destructive) scaffolding. Implementations
+   * must never overwrite user code they cannot confidently transform — they
+   * should skip and log guidance instead.
+   */
+  setup: (context: FrameworkSetupContext) => Promise<void>;
+};
+//#endregion
+export { FrameworkAdapter, FrameworkSetupContext };
+//# sourceMappingURL=types.d.ts.map

package/dist/types/init/frameworkSetup/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/types.ts"],"mappings":";;;;;;AAOA;;KAAY,qBAAA;EAID,uCAFT,OAAA,UAaa;EAXb,OAAA,EAAS,MAAA,kBAWe;EATxB,cAAA,EAAgB,cAAA,EAFhB;EAIA,aAAA;EAFA;;;;;;EASA,WAAA,EAAa,WAAA;AAAA;;;;;;KAQH,gBAAA;EAawC,iDAXlD,IAAA;EAAA;;;;EAKA,MAAA,GAAS,OAAA,EAAS,qBAAA,eAAoC,OAAA;EAMtD;;;;;EAAA,KAAA,GAAQ,OAAA,EAAS,qBAAA,KAA0B,OAAA;AAAA"}

package/dist/types/init/index.d.ts

@@ -0,0 +1,46 @@
+import { RoutingMode } from "./utils/configManipulation.js";
+//#region src/init/index.d.ts
+/**
+ * OPTIONS
+ */
+type InitOptions = {
+  noGitignore?: boolean; /** Skip scaffolding the `fill` and `test` GitHub Actions workflows. */
+  noGithubActions?: boolean;
+  /**
+   * Skip installing missing Intlayer dependencies and upgrading outdated ones.
+   */
+  noInstallPackages?: boolean; /** Skip adding the Intlayer extension to `.vscode/extensions.json`. */
+  noVscodeExtension?: boolean; /** Skip writing the Intlayer LSP configuration to `.vscode/settings.json`. */
+  noLsp?: boolean;
+  /**
+   * Skip framework-specific scaffolding (middleware/proxy, providers in
+   * layout/page, example content). Defaults to enabled.
+   */
+  noFrameworkSetup?: boolean;
+  /**
+   * Version that outdated Intlayer packages should be upgraded to (typically the
+   * running CLI version). When omitted, installed packages are left untouched and
+   * only missing ones are installed.
+   */
+  upgradeToVersion?: string;
+  /**
+   * Locale routing strategy to write to `routing.mode` in the generated/existing
+   * Intlayer configuration file. When omitted, the configuration default
+   * (`prefix-no-default`) is kept.
+   */
+  routingMode?: RoutingMode;
+  /**
+   * Extra packages hinted by the interactive init prompt (compat i18n library
+   * selections made before those libraries are actually installed). These are
+   * merged into the dependency map used by {@link detectMissingIntlayerPackages}
+   * so the correct sync plugin and compat adapter are always scheduled.
+   */
+  hintDependencies?: Record<string, string>;
+};
+/**
+ * MAIN LOGIC
+ */
+declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<void>;
+//#endregion
+export { InitOptions, initIntlayer };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/init/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;KAuLY,WAAA;EACV,WAAA;EAEA,eAAA;EAFA;;;EAMA,iBAAA,YAIA;EAFA,iBAAA,YAaA;EAXA,KAAA;EAiBc;;;;EAZd,gBAAA;EAyBW;;;;;EAnBX,gBAAA;EAmBkD;;;;;EAblD,WAAA,GAAc,WAAA;;;;;;;EAOd,gBAAA,GAAmB,MAAA;AAAA;;;;cAMR,YAAA,GAAsB,OAAA,UAAiB,OAAA,GAAU,WAAA,KAAW,OAAA"}

package/dist/types/init/utils/astImports.d.ts

@@ -0,0 +1,29 @@
+//#region src/init/utils/astImports.d.ts
+/**
+ * Index just past the leading directives (e.g. `'use client'`) and import
+ * declarations — the safe insertion point for a new import.
+ */
+declare const firstInsertIndex: (ast: any) => number;
+/**
+ * Whether `name` is already bound at module scope — by any import (under that
+ * local name, regardless of source) or by a top-level
+ * `const`/`let`/`var`/`function`/`class` declaration.
+ *
+ * Used to avoid redeclaring an identifier the file already provides (e.g. a
+ * `defaultLocale` re-exported from a local `i18n` module), which would otherwise
+ * produce an `Identifier '…' has already been declared` parse error.
+ */
+declare const isModuleScopeBinding: (ast: any, name: string) => boolean;
+/**
+ * Ensures `import { importName } from source`, merging into an existing import
+ * from the same source. No-ops when `importName` is already bound at module
+ * scope (imported from another source or declared locally), reusing that binding
+ * instead of redeclaring it.
+ *
+ * Shared across every framework adapter so injected identifiers never collide
+ * with bindings the user's file already provides.
+ */
+declare const ensureNamedImport: (ast: any, importName: string, source: string) => void;
+//#endregion
+export { ensureNamedImport, firstInsertIndex, isModuleScopeBinding };
+//# sourceMappingURL=astImports.d.ts.map

package/dist/types/init/utils/astImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astImports.d.ts","names":[],"sources":["../../../../src/init/utils/astImports.ts"],"mappings":";;AAQA;;;cAAa,gBAAA,GAAoB,GAAA;;AAuBjC;;;;;AAoCA;;;cApCa,oBAAA,GAAwB,GAAA,OAAU,IAAA;;;;;;;;;;cAoClC,iBAAA,GACX,GAAA,OACA,UAAA,UACA,MAAA"}

package/dist/types/init/utils/configManipulation.d.ts

@@ -0,0 +1,99 @@
+import { CompatSyncConfig, CompatVitePluginConfig } from "./packageManager.js";
+import { RoutingConfig } from "@intlayer/types/config";
+
+//#region src/init/utils/configManipulation.d.ts
+/** The locale routing strategies supported by the Intlayer configuration. */
+type RoutingMode = RoutingConfig['mode'];
+/**
+ * Sets `routing.mode` in an Intlayer configuration file to the requested
+ * strategy. Idempotent: re-running with the same mode produces identical
+ * output. Supports `.ts`, `.mjs`, `.js` and `.cjs` configs; JSON configs are
+ * handled with a scoped string replacement since they cannot be parsed by the
+ * TypeScript recast parser.
+ */
+declare const setIntlayerConfigRoutingMode: (content: string, extension: string, mode: RoutingMode) => string;
+/**
+ * Enables the Intlayer visual editor in a configuration file: sets
+ * `editor.enabled` to `true` and wires `clientId` / `clientSecret` to the
+ * `INTLAYER_CLIENT_ID` / `INTLAYER_CLIENT_SECRET` environment variables.
+ * Idempotent and non-destructive — existing `clientId` / `clientSecret` values
+ * are preserved. Only `.ts`, `.mjs`, `.js` and `.cjs` configs are supported
+ * (JSON cannot reference `process.env`).
+ */
+declare const enableIntlayerEditorConfig: (content: string) => string;
+declare const updateViteConfig: (content: string, extension: string) => string;
+declare const updateAstroConfig: (content: string, extension: string) => string;
+declare const updateNextConfig: (content: string, extension: string) => string;
+/**
+ * Wraps a React Native Metro config's exported value with
+ * `configMetroIntlayerSync` from `react-native-intlayer/metro`, injecting the
+ * import. The synchronous helper is used because it wraps a plain config object
+ * and needs no IIFE, making it safe to inject into existing configs without
+ * restructuring them.
+ *
+ * Non-destructive: returns the content unchanged when the export is already
+ * wrapped, when the Intlayer Metro plugin is already present, or when the export
+ * is a custom async IIFE that cannot be wrapped synchronously. Callers should
+ * compare the result with the input to detect the skipped case.
+ */
+declare const updateMetroConfig: (content: string, extension: string) => string;
+/**
+ * Builds the contents of a fresh `metro.config.js` wired with the Intlayer
+ * Metro plugin. Uses the async `configMetroIntlayer` helper (which can build
+ * dictionaries on server start) and picks the default-config source based on
+ * whether the project is an Expo app.
+ */
+declare const getMetroConfigTemplate: (isExpo: boolean) => string;
+declare const updateNuxtConfig: (content: string) => string;
+/**
+ * Updates a Vite config for vue-i18n compat: injects `vueI18nVitePlugin` from
+ * `@intlayer/vue-i18n/plugin` into the plugins array.
+ */
+declare const updateViteConfigForVueI18n: (content: string, extension: string) => string;
+/**
+ * Generic vite config updater for any compat plugin that uses alias injection.
+ * Injects the named import from `pluginPackageSource` and appends the plugin
+ * call to the `plugins` array.
+ */
+declare const updateViteConfigForCompatPlugin: (content: string, extension: string, pluginConfig: CompatVitePluginConfig) => string;
+/**
+ * Rewrites the module source of an existing named import in a vite config,
+ * keeping the imported binding and its call site untouched. Used when a compat
+ * plugin is a drop-in replacement for an i18n library's own vite plugin — e.g.
+ * lingui: `import { lingui } from "@lingui/vite-plugin"` becomes
+ * `import { lingui } from "@intlayer/lingui/plugin"`, leaving `lingui()` in the
+ * `plugins` array as-is. Returns the content unchanged when no matching import
+ * is found.
+ */
+declare const replaceViteConfigPluginImportSource: (content: string, importName: string, fromPackageSource: string, toPackageSource: string) => string;
+/**
+ * Updates a Next.js config for next-translate compat: wraps the default export
+ * with `withNextTranslate` from `@intlayer/next-translate/plugin`.
+ */
+declare const updateNextConfigForNextTranslate: (content: string, extension: string) => string;
+/**
+ * Updates a Nuxt config for nuxtjs-i18n compat: adds `@intlayer/nuxtjs-i18n`
+ * to the `modules` array.
+ */
+declare const updateNuxtConfigForNuxtjsI18n: (content: string) => string;
+/**
+ * Updates a Next.js config for next-i18next compat: wraps the default export
+ * with `withI18next` from `@intlayer/next-i18next/plugin`.
+ */
+declare const updateNextConfigForNextI18next: (content: string, extension: string) => string;
+/**
+ * Updates a Next.js config for next-intl compat: replaces any existing
+ * `next-intl/plugin` import source with `@intlayer/next-intl/plugin`, or
+ * injects `createNextIntlPlugin` with a factory-call wrapper when no such
+ * import is present.
+ */
+declare const updateNextConfigForNextIntl: (content: string, extension: string) => string;
+/**
+ * Injects the sync plugin import (`syncJSON` / `syncPO`) and a configured
+ * `syncJSON(...)` / `syncPO(...)` call into the plugins array of an intlayer
+ * config file. Idempotent: skips when the plugin call is already present.
+ */
+declare const updateIntlayerConfigWithSyncPlugin: (content: string, extension: string, syncConfig: CompatSyncConfig) => string;
+//#endregion
+export { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, replaceViteConfigPluginImportSource, setIntlayerConfigRoutingMode, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n };
+//# sourceMappingURL=configManipulation.d.ts.map

package/dist/types/init/utils/configManipulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";;;;;KAWY,WAAA,GAAc,aAAA;AAA1B;;;;;AA0FA;;AA1FA,cA0Fa,4BAAA,GACX,OAAA,UACA,SAAA,UACA,IAAA,EAAM,WAAA;;;;;;;;AA0CR;cAAa,0BAAA,GAA8B,OAAA;AAAA,cA4M9B,gBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAmBW,iBAAA,GACX,OAAA,UACA,SAAA;AAAA,cAmBW,gBAAA,GACX,OAAA,UACA,SAAA;AA5CF;;;;;AAqBA;;;;;AAqBA;;AA1CA,cAsHa,iBAAA,GACX,OAAA,UACA,SAAA;;;AAFF;;;;cA4Ea,sBAAA,GAA0B,MAAA;AAAA,cAgB1B,gBAAA,GAAoB,OAAA;;;;;cA6DpB,0BAAA,GACX,OAAA,UACA,SAAA;;;;;AAFF;cA+Ba,+BAAA,GACX,OAAA,UACA,SAAA,UACA,YAAA,EAAc,sBAAA;;;;AAHhB;;;;;;cAoCa,mCAAA,GACX,OAAA,UACA,UAAA,UACA,iBAAA,UACA,eAAA;;;;AAJF;cAwGa,gCAAA,GACX,OAAA,UACA,SAAA;;;;;cAaW,6BAAA,GAAiC,OAAA;;;;AAf9C;cA8Ea,8BAAA,GACX,OAAA,UACA,SAAA;;;;AAjEF;;;cAgFa,2BAAA,GACX,OAAA,UACA,SAAA;;AAnBF;;;;cAgPa,kCAAA,GACX,OAAA,UACA,SAAA,UACA,UAAA,EAAY,gBAAA"}

package/dist/types/init/utils/fileSystem.d.ts

@@ -0,0 +1,111 @@
+//#region src/init/utils/fileSystem.d.ts
+/**
+ * Helper to check if a file exists
+ */
+declare const exists: (rootDir: string, filePath: string) => Promise<boolean>;
+/**
+ * Helper to read a file
+ */
+declare const readFileFromRoot: (rootDir: string, filePath: string) => Promise<string>;
+/**
+ * Helper to write a file
+ */
+declare const writeFileToRoot: (rootDir: string, filePath: string, content: string) => Promise<void>;
+/**
+ * Helper to ensure a directory exists
+ */
+declare const ensureDirectory: (rootDir: string, dirPath: string) => Promise<void>;
+/**
+ * Pattern type for locale JSON file organisation.
+ * - 'nested': files are at `{base}/{locale}/{key}.json`
+ * - 'flat':   files are at `{base}/{locale}.json`
+ */
+type JsonLocalePatternType = 'nested' | 'flat';
+/**
+ * Detected locale JSON file pattern and the corresponding source template.
+ * `template` uses `${locale}` and `${key}` as literal placeholders (not JS
+ * expressions) so it can be embedded directly in a template-literal string.
+ */
+type JsonLocalePattern = {
+  type: JsonLocalePatternType;
+  /**
+   * Source path template for syncJSON `source` option.
+   * Example nested: `./locales/${locale}/${key}.json`
+   * Example flat:   `./locales/${locale}.json`
+   */
+  template: string;
+  /**
+   * Detected locales in the directory.
+   */
+  locales: string[];
+};
+/**
+ * Scans the project for JSON files and determines whether locale files are
+ * organised as `{base}/{locale}/{key}.json` (nested) or `{base}/{locale}.json`
+ * (flat).  Returns the most likely source template, or `null` when no locale
+ * JSON files are found.
+ *
+ * The returned `template` contains `${locale}` and `${key}` as **literal**
+ * placeholder strings so it can be embedded inside a JS template literal.
+ */
+declare const detectJsonLocalePattern: (rootDir: string) => Promise<JsonLocalePattern | null>;
+/**
+ * Detected lingui catalog pattern. lingui stores one catalog file per locale
+ * (default name `messages`), as `.po` (its default) or `.json`.
+ */
+type LinguiCatalogPattern = {
+  /** Which sync plugin should ingest the catalogs. */format: 'po' | 'json';
+  /**
+   * Source path template, with `${locale}` and `${key}` as literal
+   * placeholders. The catalog filename (`messages`) is captured by `${key}` so
+   * the produced intlayer dictionary key is `messages` — matching the fixed
+   * `messages` namespace the lingui compat runtime reads from.
+   * Example: `./src/locales/${locale}/${key}.po`.
+   */
+  template: string; /** Detected locales. */
+  locales: string[];
+};
+/**
+ * Scans the project for lingui catalog files (`{base}/{locale}/messages.po` or
+ * `…/messages.json`, lingui's default layout) and derives the `syncPO` /
+ * `syncJSON` `source` template.
+ *
+ * `.po` is preferred when present (lingui's default format). Returns `null`
+ * when no lingui catalog is found, in which case the caller falls back to the
+ * generic JSON detection.
+ *
+ * @param rootDir - Project root directory.
+ */
+declare const detectLinguiCatalogPattern: (rootDir: string) => Promise<LinguiCatalogPattern | null>;
+/**
+ * The messages source template derived from a `next-intl` `i18n/request.ts`
+ * file, ready to be used as a `syncJSON` `source` builder.
+ */
+type NextIntlMessagesPattern = {
+  /** `'flat'` (one file per locale) or `'nested'` (per-namespace files). */type: JsonLocalePatternType;
+  /**
+   * Source path template relative to the project root, with `${locale}` (and
+   * `${key}` when nested) as literal placeholders, e.g. `./messages/${locale}.json`.
+   */
+  template: string;
+};
+/**
+ * Derives the messages source template from a `next-intl` `i18n/request.ts`
+ * file, which is the authoritative location of the messages path in a next-intl
+ * project (e.g. `messages: (await import(\`../messages/${locale}.json\`)).default`).
+ *
+ * Reading it removes the ambiguity of globbing the file system and yields the
+ * exact `source` template for `syncJSON`. When the resulting template has no
+ * `${key}` segment (the common single-file-per-locale layout, where top-level
+ * keys are namespaces), `syncJSON` `splitKeys` auto-detection turns each
+ * top-level key into its own dictionary.
+ *
+ * Returns `null` when no request file is found, the messages import cannot be
+ * parsed, or the path is not project-root-relative (e.g. uses a TS path alias).
+ *
+ * @param rootDir - Project root directory.
+ */
+declare const detectNextIntlMessagesPattern: (rootDir: string) => Promise<NextIntlMessagesPattern | null>;
+//#endregion
+export { JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NextIntlMessagesPattern, detectJsonLocalePattern, detectLinguiCatalogPattern, detectNextIntlMessagesPattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot };
+//# sourceMappingURL=fileSystem.d.ts.map

package/dist/types/init/utils/fileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystem.d.ts","names":[],"sources":["../../../../src/init/utils/fileSystem.ts"],"mappings":";;AASA;;cAAa,MAAA,GAAgB,OAAA,UAAiB,QAAA,aAAgB,OAAA;;;;cAYjD,gBAAA,GAA0B,OAAA,UAAiB,QAAA,aAAgB,OAAA;;;AAAxE;cAMa,eAAA,GACX,OAAA,UACA,QAAA,UACA,OAAA,aAAe,OAAA;;;;cAMJ,eAAA,GAAyB,OAAA,UAAiB,OAAA,aAAe,OAAA;;;;AATtE;;KAsBY,qBAAA;;;;;;KAOA,iBAAA;EACV,IAAA,EAAM,qBAAA;EArBK;;;;;EA2BX,QAAA;EA3BoE;;;EA+BpE,OAAA;AAAA;;;;AAXF;;;;;;cAuDa,uBAAA,GACX,OAAA,aACC,OAAA,CAAQ,iBAAA;;;;AAFX;KAgFY,oBAAA;sDAEV,MAAA;EAjFA;;;;;AA+EF;;EAUE,QAAA,UAV8B;EAY9B,OAAA;AAAA;;;;AAcF;;;;;;;;cAAa,0BAAA,GACX,OAAA,aACC,OAAA,CAAQ,oBAAA;AA4DX;;;;AAAA,KAAY,uBAAA;EAEJ,0EAAN,IAAA,EAAM,qBAAA;EAKE;;AAiCV;;EAjCE,QAAA;AAAA;;;;;;;;;;;;;;;;;cAiCW,6BAAA,GACX,OAAA,aACC,OAAA,CAAQ,uBAAA"}