@intlayer/engine 9.5.9 → 9.5.11

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/types.ts"],"mappings":";;;;;;;YAOY;;EAEV;;EAEA,SAAS;;EAET,gBAAgB;;EAEhB;;;;;;;EAOA,aAAa;;;;;;;YAQH;;EAEV;;;;;EAKA,SAAS,SAAS,oCAAoC;;;;;;EAMtD,QAAQ,SAAS,0BAA0B"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/init/frameworkSetup/types.ts"],"mappings":";;;;;;;YAOY;;EAEV;;EAEA,SAAS;;EAET,gBAAgB;;EAEhB;;;;;;;EAOA,aAAa;;;;;;EAMb;;;;;;;YAQU;;EAEV;;;;;EAKA,SAAS,SAAS,oCAAoC;;;;;;EAMtD,QAAQ,SAAS,0BAA0B"}

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

@@ -1,4 +1,5 @@
 import { RoutingMode } from "./utils/configManipulation.js";
+import { DocumentationRouter, DocumentationRouterType, getDocumentationUrl } from "./documentationRouter.js";
 import "./utils/index.js";
 //#region src/init/index.d.ts
 /**
@@ -43,6 +44,8 @@ export type InitOptions = {
    * enabled.
    */
   noFrameworkSetup?: boolean;
+  /** Skip logging the final success message and documentation link. */
+  skipFinalMessage?: boolean;
   /**
    * Version to install the missing Intlayer packages at (typically the running
    * CLI version). Already declared Intlayer packages are upgraded to the latest
@@ -55,6 +58,13 @@ export type InitOptions = {
    * (`prefix-no-default`) is kept.
    */
   routingMode?: RoutingMode;
+  /**
+   * Whether the app routes by locale through the Intlayer proxy (middleware).
+   * Written to `routing.enableProxy` in the configuration file and drives the
+   * framework scaffolding: `false` skips the proxy file and any locale route
+   * segment. When omitted, the configured value is kept (unset means enabled).
+   */
+  enableProxy?: boolean;
   /**
    * Content organization strategy chosen by the interactive init prompt. Drives
    * the `compiler.output` template (`centralized`) or the injection of the
@@ -66,6 +76,10 @@ export type InitOptions = {
 /**
  * MAIN LOGIC
  */
-export declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<void>;
+export declare const initIntlayer: (rootDir: string, options?: InitOptions) => Promise<{
+  guideUrl: string;
+}>;
+export declare const logInitSuccessMessage: (guideUrl: string) => void;
 //#endregion
+export { DocumentationRouter, type DocumentationRouterType, getDocumentationUrl };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;qBA6Oa,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/init/index.ts"],"mappings":";;;;;;;;;;qBA6Ea,2BAAwB,cACrB;;;;;;;;;;YAsBJ;;;;YAQA;EACV;;EAEA;;;;;EAKA;;EAEA;;EAEA;;EAEA;;;;;;;EAOA;;EAEA;;;;;;EAMA;;;;;;EAMA,cAAc;;;;;;;EAOd;;;;;;;EAOA,kBAAkB;;;;;qBAMP,eAAY,iBAAyB,UAAY,gBAAW;;;qBA6kC5D,wBAAqB"}

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

@@ -11,6 +11,20 @@ export type RoutingMode = RoutingConfig['mode'];
  * TypeScript recast parser.
  */
 export declare const setIntlayerConfigRoutingMode: (content: string, extension: string, mode: RoutingMode) => string;
+/**
+ * Sets `routing.enableProxy` in an Intlayer configuration file. Idempotent and
+ * comment-preserving: an existing property only has its value swapped. Supports
+ * `.ts`, `.mjs`, `.js`, `.cjs` and `.json` configs.
+ */
+export declare const setIntlayerConfigEnableProxy: (content: string, extension: string, enableProxy: boolean) => string;
+/**
+ * Reduces `routing` in an Intlayer configuration file to its `storage` entry,
+ * for projects without URL routing (backend-only, React Native…) where the
+ * routing mode and the locale proxy have no effect. An existing `storage`
+ * value is kept; otherwise `['cookie', 'header']` is written. JSON configs are
+ * returned unchanged.
+ */
+export declare const setIntlayerConfigRoutingStorageOnly: (content: string, extension: string) => string;
 /**
  * Sets `compiler.output` in an Intlayer configuration file to the given path
  * template (the `{{variable}}` string form, e.g.

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

@@ -1 +1 @@
-{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";;;;YAYY,cAAc;;;;;;;;qBA0Fb,+BAA4B,iBACxB,mBACE,MACX;;;;;;;;;qBA0CK,kCAA+B,iBAC3B,mBACE;;;;;;;;;qBA0CN,6BAA0B;;;;;;;;qBA+Q1B,wBAAqB;qBAIrB,mBAAgB,iBACZ;qBAoBJ,oBAAiB,iBACb;qBAoBJ,mBAAgB,iBACZ;;;;;;;;;;;;;qBA2EJ,oBAAiB,iBACb;;;;;;;qBA2EJ,yBAAsB;qBAgBtB,mBAAgB;;;;;qBA6DhB,6BAA0B,iBACtB;;;;;;qBA8BJ,kCAA+B,iBAC3B,mBACE,cACH;;;;;;;;;;qBAiCH,sCAAmC,iBAC/B,oBACG,2BACO;;;;;qBAqGd,mCAAgC,iBAC5B;;;;;qBAcJ,gCAA6B;;;;;qBA+D7B,iCAA8B,iBAC1B;;;;;;;qBAgBJ,8BAA2B,iBACvB;;;;;;qBAgQJ,qCAAkC,iBAC9B,mBACE,YACL"}
+{"version":3,"file":"configManipulation.d.ts","names":[],"sources":["../../../../src/init/utils/configManipulation.ts"],"mappings":";;;;YAYY,cAAc;;;;;;;;qBA0Fb,+BAA4B,iBACxB,mBACE,MACX;;;;;;qBAuCK,+BAA4B,iBACxB,mBACE;;;;;;;;qBA+CN,sCAAmC,iBAC/B;;;;;;;;;qBAgDJ,kCAA+B,iBAC3B,mBACE;;;;;;;;;qBA0CN,6BAA0B;;;;;;;;qBA+Q1B,wBAAqB;qBAIrB,mBAAgB,iBACZ;qBAoBJ,oBAAiB,iBACb;qBAoBJ,mBAAgB,iBACZ;;;;;;;;;;;;;qBA2EJ,oBAAiB,iBACb;;;;;;;qBA2EJ,yBAAsB;qBAgBtB,mBAAgB;;;;;qBA6DhB,6BAA0B,iBACtB;;;;;;qBA8BJ,kCAA+B,iBAC3B,mBACE,cACH;;;;;;;;;;qBAiCH,sCAAmC,iBAC/B,oBACG,2BACO;;;;;qBAqGd,mCAAgC,iBAC5B;;;;;qBAcJ,gCAA6B;;;;;qBA+D7B,iCAA8B,iBAC1B;;;;;;;qBAgBJ,8BAA2B,iBACvB;;;;;;qBAgQJ,qCAAkC,iBAC9B,mBACE,YACL"}

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

@@ -1,12 +1,14 @@
-import { COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, PackageManager, detectCompatI18nLibraries, detectMissingIntlayerPackages, detectPackageManager, findLockFileDir, hasLintTooling, installPackages, isIntlayerPackageName, moveCompatPackagesToDevDependencies, normalizeVersion, runPackageInstall } from "./packageManager.js";
-import { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, hasIntlayerVitePlugin, replaceViteConfigPluginImportSource, setIntlayerConfigCompilerOutput, setIntlayerConfigRoutingMode, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
+import { COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, IntlayerPackageAnalysis, MINIMUM_ESLINT_MAJOR, PENDING_COMPAT_ADAPTERS, PackageManager, detectCompatI18nLibraries, detectMissingIntlayerPackages, detectPackageManager, findLockFileDir, hasLegacyEslint, hasLintTooling, installPackages, isIntlayerPackageName, moveCompatPackagesToDevDependencies, normalizeVersion, runPackageInstall } from "./packageManager.js";
+import { RoutingMode, enableIntlayerEditorConfig, getMetroConfigTemplate, hasIntlayerVitePlugin, replaceViteConfigPluginImportSource, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n } from "./configManipulation.js";
 import { ensureNamedImport, firstInsertIndex, isModuleScopeBinding } from "./astImports.js";
 import { BACKEND_INTLAYER_PACKAGES, ResolveDevScriptParams, resolveDevScript } from "./devScript.js";
 import { JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NextIntlMessagesPattern, detectJsonLocalePattern, detectLinguiCatalogPattern, detectNextIntlMessagesPattern, ensureDirectory, exists, readFileFromRoot, writeFileToRoot } from "./fileSystem.js";
 import { GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, getGithubWorkflows, resolveGithubWorkflowsContext } from "./githubActions.js";
 import { IntlayerDependency, IntlayerDependencyUpgrade, PackageJsonIntlayerDependencies, fetchLatestPackageVersion, findPackageJsonFiles, getIntlayerDependencies, getIntlayerDependencyUpgrades, listIntlayerDependencies, toRange, writeIntlayerDependencyUpgrades } from "./intlayerDependencies.js";
 import { parseJSONWithComments } from "./jsonParser.js";
+import { LINT_PLUGIN_PACKAGE_NAME, OxlintConfig, addIntlayerRulesToOxlintConfig } from "./lintConfig.js";
 import { NEXT_INTLAYER_BABEL_CONFIG_CONTENT, setupNextCompilerBabelConfig } from "./nextCompilerBabel.js";
 import { findTsConfigFiles } from "./tsConfig.js";
+import { hasUrlRoutingFramework } from "./urlRoutingFramework.js";
 import { isVersionAtLeast } from "./version.js";
-export { BACKEND_INTLAYER_PACKAGES, COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, IntlayerDependency, IntlayerDependencyUpgrade, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LinguiCatalogPattern, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, PackageJsonIntlayerDependencies, PackageManager, ResolveDevScriptParams, RoutingMode, detectCompatI18nLibraries, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, fetchLatestPackageVersion, findLockFileDir, findPackageJsonFiles, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getIntlayerDependencies, getIntlayerDependencyUpgrades, getMetroConfigTemplate, hasIntlayerVitePlugin, hasLintTooling, installPackages, isIntlayerPackageName, isModuleScopeBinding, isVersionAtLeast, listIntlayerDependencies, moveCompatPackagesToDevDependencies, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, resolveDevScript, resolveGithubWorkflowsContext, runPackageInstall, setIntlayerConfigCompilerOutput, setIntlayerConfigRoutingMode, setupNextCompilerBabelConfig, toRange, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot, writeIntlayerDependencyUpgrades };
+export { BACKEND_INTLAYER_PACKAGES, COMPAT_I18N_LIBRARIES, COMPAT_PACKAGE_REPLACEMENTS, CompatI18nLibrary, CompatSyncConfig, CompatVitePluginConfig, DetectMissingPackagesOptions, GITHUB_FILL_WORKFLOW_PATH, GITHUB_TEST_WORKFLOW_PATH, GithubWorkflowFile, GithubWorkflowsContext, GithubWorkflowsOptions, IntlayerDependency, IntlayerDependencyUpgrade, IntlayerPackageAnalysis, JsonLocalePattern, JsonLocalePatternType, LINT_PLUGIN_PACKAGE_NAME, LinguiCatalogPattern, MINIMUM_ESLINT_MAJOR, NEXT_INTLAYER_BABEL_CONFIG_CONTENT, NextIntlMessagesPattern, OxlintConfig, PENDING_COMPAT_ADAPTERS, PackageJsonIntlayerDependencies, PackageManager, ResolveDevScriptParams, RoutingMode, addIntlayerRulesToOxlintConfig, detectCompatI18nLibraries, detectJsonLocalePattern, detectLinguiCatalogPattern, detectMissingIntlayerPackages, detectNextIntlMessagesPattern, detectPackageManager, enableIntlayerEditorConfig, ensureDirectory, ensureNamedImport, exists, fetchLatestPackageVersion, findLockFileDir, findPackageJsonFiles, findTsConfigFiles, firstInsertIndex, getGithubWorkflows, getIntlayerDependencies, getIntlayerDependencyUpgrades, getMetroConfigTemplate, hasIntlayerVitePlugin, hasLegacyEslint, hasLintTooling, hasUrlRoutingFramework, installPackages, isIntlayerPackageName, isModuleScopeBinding, isVersionAtLeast, listIntlayerDependencies, moveCompatPackagesToDevDependencies, normalizeVersion, parseJSONWithComments, readFileFromRoot, replaceViteConfigPluginImportSource, resolveDevScript, resolveGithubWorkflowsContext, runPackageInstall, setIntlayerConfigCompilerOutput, setIntlayerConfigEnableProxy, setIntlayerConfigRoutingMode, setIntlayerConfigRoutingStorageOnly, setupNextCompilerBabelConfig, toRange, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n, writeFileToRoot, writeIntlayerDependencyUpgrades };

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

@@ -0,0 +1,28 @@
+//#region src/init/utils/lintConfig.d.ts
+/**
+ * The Intlayer lint setup, as `intlayer init` writes it into `.oxlintrc.json`.
+ *
+ * Declared locally on purpose: `@intlayer/engine` is installed by every Intlayer
+ * user, so it must not depend on a lint plugin to write a handful of strings
+ * into a JSON file. oxlint resolves a plugin's *rules* but not its shipped
+ * *configs*, so the preset cannot be referenced by name there either.
+ *
+ * Mirrors the `recommended` preset of `eslint-plugin-intlayer`; keep in sync
+ * when a rule is enabled by default there.
+ */
+export declare const LINT_PLUGIN_PACKAGE_NAME = "eslint-plugin-intlayer";
+/** The `.oxlintrc.json` fields init reads and writes. */
+export type OxlintConfig = {
+  jsPlugins?: string[];
+  rules?: Record<string, unknown>;
+  ignorePatterns?: string[];
+};
+/**
+ * Adds the Intlayer plugin, the `recommended` rules and the generated-output
+ * ignore to an oxlint config, in place. Rules the user already set are kept.
+ *
+ * @returns Whether anything was added.
+ */
+export declare const addIntlayerRulesToOxlintConfig: (oxlintConfig: OxlintConfig) => boolean;
+//#endregion
+//# sourceMappingURL=lintConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lintConfig.d.ts","names":[],"sources":["../../../../src/init/utils/lintConfig.ts"],"mappings":";;;;;;;;;;;;qBAWa;;YAaD;EACV;EACA,QAAQ;EACR;;;;;;;;qBASW,iCAA8B,cAC3B"}

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

@@ -83,7 +83,20 @@ export type IntlayerPackageAnalysis = {
    * library requires alias injection.
    */
   compatVitePluginConfig: CompatVitePluginConfig | undefined;
+  /**
+   * Compat adapters the project would need but that are not published yet
+   * (see {@link PENDING_COMPAT_ADAPTERS}). The original library is kept as is;
+   * only its catalogs are synced.
+   */
+  pendingCompatAdapters: string[];
 };
+/**
+ * Compat adapters that live in `compat-comming/` and are not published to npm
+ * yet. Installing one fails the whole install command, so init keeps the
+ * original library, skips the adapter and its bundler / framework wiring, and
+ * only syncs the catalogs. Remove an entry once its package is released.
+ */
+export declare const PENDING_COMPAT_ADAPTERS: ReadonlySet<string>;
 /**
  * Detects the package manager in use by checking for lock files in the
  * project root, then the `packageManager` field of its `package.json`. Falls
@@ -166,14 +179,24 @@ export declare const moveCompatPackagesToDevDependencies: (packageJson: Record<s
  * @param dependencies - Merged dependencies of the target project.
  */
 export declare const detectCompatI18nLibraries: (dependencies: Record<string, string>) => string[];
+/** Lowest ESLint major `eslint-plugin-intlayer` supports (flat config). */
+export declare const MINIMUM_ESLINT_MAJOR = 9;
+/**
+ * True when the project pins ESLint below {@link MINIMUM_ESLINT_MAJOR}.
+ * Installing the plugin there fails on its `eslint` peer range (and takes the
+ * whole install command down with it). Ranges without a version number
+ * (`latest`, `*`, `catalog:`) are assumed current.
+ *
+ * @param dependencies - Merged dependencies of the target project.
+ */
+export declare const hasLegacyEslint: (dependencies: Record<string, string>) => boolean;
 /**
- * True when the project already lints, and so has something to plug the
- * Intlayer lint rules into.
+ * True when the project already lints with a linter the Intlayer rules can
+ * plug into: oxlint, or ESLint 9+.
  *
- * `eslint-plugin-intlayer` loads in both ESLint and oxlint, so either linter is
- * enough. Shared with the init flow so that installing the plugin and wiring up
- * its configuration are gated on exactly the same condition — a project that
- * does not lint is left alone entirely.
+ * Shared with the init flow so that installing the plugin and wiring up its
+ * configuration are gated on exactly the same condition — a project that does
+ * not lint, or lints with ESLint 8, is left alone.
  *
  * @param dependencies - Merged dependencies of the target project.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"packageManager.d.ts","names":[],"sources":["../../../../src/init/utils/packageManager.ts"],"mappings":";;YAKY;;;;;YAMA;;;;;;;EAOV;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;EAeA;;;;;;;YAQU;;EAEV;;EAEA;;;;;;;;EAQA;;IAEE;;IAEA;;;;YAKQ;;EAEV;;EAEA;;EAEA;;;;;;EAMA,kBAAkB;;;;;;EAMlB,wBAAwB;;;;;;;qBA8Cb,uBAAoB,oBAAsB;;;;;;qBAY1C,kBAAe;;;;;;;YA2ChB;;;;;;EAMV;;;;;;EAMA,eAAe;;;;EAIf,kBAAkB;;;YAIR;;EAEV;;;;;;EAMA;;;;;EAKA,cAAc;;;;;;;;qBASH,gCAAgC;;;;;qBA+GhC,6BAA6B;;;;;;;;qBAc7B,sCAAmC,aACjC;;;;;;;;;;qBA8BF,4BAAyB,cACtB;;;;;;;;;;;;qBAiBH,iBAAc,cAAkB;qBAGhC,gCAA6B,iBACvB,wBAAsB,UAC9B,iCACR;;;;;qBA4VU,kBAAe,iBACX,oBACG,gBACF,gBAAc;;;;;;;;;;qBAgBnB,wBAAqB;;;;;;;;qBAarB,mBAAgB;;;;;;qBAahB,oBAAiB,iBACb,gBACC"}
+{"version":3,"file":"packageManager.d.ts","names":[],"sources":["../../../../src/init/utils/packageManager.ts"],"mappings":";;YAMY;;;;;YAMA;;;;;;;EAOV;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;EAeA;;;;;;;YAQU;;EAEV;;EAEA;;;;;;;;EAQA;;IAEE;;IAEA;;;;YAKQ;;EAEV;;EAEA;;EAEA;;;;;;EAMA,kBAAkB;;;;;;EAMlB,wBAAwB;;;;;;EAMxB;;;;;;;;qBASW,yBAAyB;;;;;;qBAiDzB,uBAAoB,oBAAsB;;;;;;qBAY1C,kBAAe;;;;;;;YA2ChB;;;;;;EAMV;;;;;;EAMA,eAAe;;;;EAIf,kBAAkB;;;YAIR;;EAEV;;;;;;EAMA;;;;;EAKA,cAAc;;;;;;;;qBASH,gCAAgC;;;;;qBA+GhC,6BAA6B;;;;;;;;qBAc7B,sCAAmC,aACjC;;;;;;;;;;qBA8BF,4BAAyB,cACtB;;qBAOH;;;;;;;;;qBAUA,kBAAe,cACZ;;;;;;;;;;;qBAiBH,iBAAc,cAAkB;qBAIhC,gCAA6B,iBACvB,wBAAsB,UAC9B,iCACR;;;;;qBAyZU,kBAAe,iBACX,oBACG,gBACF,gBAAc;;;;;;;;;;qBAgBnB,wBAAqB;;;;;;;;qBAarB,mBAAgB;;;;;;qBAahB,oBAAiB,iBACb,gBACC"}

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

@@ -0,0 +1,9 @@
+//#region src/init/utils/urlRoutingFramework.d.ts
+/**
+ * Returns true when the project is a web frontend for which locale routing is
+ * meaningful. React Native / Expo apps are excluded (no URL routing), as are
+ * backend-only and plain Node projects.
+ */
+export declare const hasUrlRoutingFramework: (dependencies: Record<string, string>) => boolean;
+//#endregion
+//# sourceMappingURL=urlRoutingFramework.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"urlRoutingFramework.d.ts","names":[],"sources":["../../../../src/init/utils/urlRoutingFramework.ts"],"mappings":";;;;;;qBAgCa,yBAAsB,cACnB"}

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

@@ -13,7 +13,9 @@ export type InitConfigOptions = {
 /**
  * Initialize the Intlayer configuration file. No-ops when a configuration file
  * already exists at `baseDir`.
+ *
+ * @returns `true` when the file was created, `false` when one already existed.
  */
-export declare const initConfig: (format: (typeof configurationFilesCandidates)[number], baseDir: string, options?: InitConfigOptions) => Promise<void>;
+export declare const initConfig: (format: (typeof configurationFilesCandidates)[number], baseDir: string, options?: InitConfigOptions) => Promise<boolean>;
 //#endregion
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/initConfig/index.ts"],"mappings":";;;YA6BY;;EAEV;;;;;EAKA;;;;;;qBAOW,aAAU,gBACL,uCAAqC,iBACtC,UACL,sBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/initConfig/index.ts"],"mappings":";;;YA6BY;;EAEV;;;;;EAKA;;;;;;;;qBASW,aAAU,gBACL,uCAAqC,iBACtC,UACL,sBACT"}

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts

@@ -1,5 +1,9 @@
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/loadDictionaries/logTypeScriptErrors.d.ts
+/**
+ * Type-checks content declaration files and logs errors as warnings.
+ * Supports both the classic (`typescript` <= 6) and native (>= 7) compilers.
+ */
 export declare const logTypeScriptErrors: (filePaths: string[], configuration: IntlayerConfig) => Promise<void>;
 //#endregion
 //# sourceMappingURL=logTypeScriptErrors.d.ts.map

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;qBAIa,sBAAmB,qBACX,eACJ,mBAAc"}
+{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;;;;;qBAsRa,sBAAmB,qBACX,eACJ,mBACd"}

package/dist/types/scan/analyzeBundleContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;;;;;;;qBA6Ka,uBAAoB,QACvB,oBAAkB,qBACP,uBACE,0BAEpB"}
+{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;;;;;;;qBAkNa,uBAAoB,QACvB,oBAAkB,qBACP,uBACE,0BAEpB"}

package/dist/types/scan/calculateScore.d.ts

@@ -37,10 +37,13 @@ export declare const scoreRecord: {
   readonly url_htmlDir: 3;
   readonly url_hasCanonical: 10;
   readonly url_hreflang: 9;
+  readonly url_hreflangReciprocal: 8;
   readonly url_hasLocalizedLinks: 8;
   readonly url_hasXDefault: 7;
   readonly url_allAnchorsLocalized: 6;
-  readonly url_currentLocale: 3;
+  readonly url_hasLangSelector: 6;
+  readonly url_currentLocale: 5;
+  readonly url_ogLocale: 3;
   readonly url_unusedBundleContent: 8;
 };
 /** Identifier of a scorable check (without the URL suffix). */

package/dist/types/scan/calculateScore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;;;;;;;;;YAUY;;EAEV;;EAEA;;;;;;;;;YAUU;EACV;EACA;;;qBAgBW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;YAIU,8BAA8B;;;;;;;;;;qBAW7B,cAAW,OAAW,OAAK,OAAS,kBAAgB;;;;;;;qBAyBpD,iBAAc,OAAW"}
+{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;;;;;;;;;YAUY;;EAEV;;EAEA;;;;;;;;;YAUU;EACV;EACA;;;qBAgBW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;YAIU,8BAA8B;;;;;;;;;;qBAW7B,cAAW,OAAW,OAAK,OAAS,kBAAgB;;;;;;;qBAyBpD,iBAAc,OAAW"}

package/dist/types/scan/checks.d.ts

@@ -1,36 +1,129 @@
+import { RoutingDetection } from "./detection/detectRoutingStrategy.js";
 import { BundleChunkInput, BundleContentAnalysis, ScanEvent } from "./types.js";
-import { Anchor } from "./parseHtml.js";
+import { ScanFetchOptions } from "./fetchText.js";
+import { Anchor, HreflangLink } from "./parseHtml.js";
 //#region src/scan/checks.d.ts
+/** Receives every check result as soon as it is produced. */
+export type EmitScanEvent = (event: ScanEvent) => void;
+/** Signals of the scanned page shared by the page-level checks. */
+export type PageSignals = {
+  targetUrl: string;
+  langTag?: string;
+  dirTag?: string;
+  ogLocale?: string;
+  /** `og:locale:alternate` values. */
+  ogLocaleAlternates?: string[];
+  /** Raw `href` of the canonical link (`''` when present but empty). */
+  canonicalHref?: string;
+  hreflangs: HreflangLink[];
+  anchors: Anchor[];
+  routing: RoutingDetection;
+  /** Locale of the page: from its URL when possible, else `<html lang>`. */
+  pageLocale?: string;
+};
 /** Format a byte count as a human-readable size. */
 export declare const formatSize: (bytes: number) => string;
+/** `url_htmlLang`: `<html lang>` is present and a valid BCP 47 tag. */
+export declare const checkHtmlLang: ({ targetUrl, langTag }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_htmlDir`: the text direction matches the language. `dir` is only
+ * required for right-to-left languages, `ltr` being the browser default.
+ */
+export declare const checkHtmlDir: ({ targetUrl, langTag, dirTag }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_currentLocale`: the locale announced by `<html lang>`, the URL and the
+ * self hreflang entry agree.
+ */
+export declare const checkLocaleConsistency: ({ targetUrl, langTag, hreflangs, routing }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_ogLocale`: `og:locale` is set, uses the Open Graph `language_TERRITORY`
+ * format (`en_GB`, not `en` nor `en-GB`) and matches `<html lang>`.
+ * `og:locale:alternate` values must use the same format.
+ */
+export declare const checkOgLocale: ({ targetUrl, ogLocale, ogLocaleAlternates, langTag }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_hasCanonical`: a canonical link exists and does not point to another
+ * locale version (which would de-index the current one).
+ */
+export declare const checkCanonical: ({ targetUrl, canonicalHref, hreflangs, routing, pageLocale }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_hreflang`: hreflang tags exist, use valid codes and absolute URLs, have
+ * no duplicates, and include a self reference.
+ */
+export declare const checkHreflang: ({ targetUrl, hreflangs, canonicalHref }: PageSignals, emit: EmitScanEvent) => void;
+/** `url_hasXDefault`: an `x-default` hreflang is declared. */
+export declare const checkXDefault: ({ targetUrl, hreflangs }: PageSignals, emit: EmitScanEvent) => void;
+/**
+ * `url_hreflangReciprocal`: every alternate answers with a 200, is not
+ * redirected, links back to this page and declares the expected language.
+ * Search engines ignore hreflang pairs without a return link.
+ */
+export declare const checkHreflangReciprocity: ({ targetUrl, hreflangs, canonicalHref }: PageSignals, fetchOptions: ScanFetchOptions, emit: EmitScanEvent) => Promise<void>;
 /**
- * Check the `<html>` element attributes (`lang`, `dir`) and the resulting
- * current-locale signal. Returns the detected language tag.
+ * Link checks, interpreted through the detected routing strategy (so an
+ * unprefixed link is correct on the default locale of a `prefix-no-default`
+ * site, and `?lang=` links are understood on `search-params` sites):
+ *
+ * - `url_hasLocalizedLinks`: internal links keep the page locale
+ * - `url_allAnchorsLocalized`: no internal link loses or switches the locale
+ * - `url_hasLangSelector`: crawlable links to the other locale versions exist
  */
-export declare const checkHtmlAttributes: (html: string, targetUrl: string, events: ScanEvent[]) => {
-  langTag: string | undefined;
+export declare const checkInternalLinks: (signals: PageSignals, emit: EmitScanEvent) => void;
+/** Human-readable version of a {@link BundleContentAnalysis}, for display. */
+export declare const formatBundleAnalysis: (analysis: BundleContentAnalysis) => {
+  currentLocale: string;
+  totalPageSize: string;
+  renderedContentSize: string;
+  contentSize: string;
+  totalLocaleSize: string;
+  totalUnusedLocaleSize: string;
+  unusedPercentOfLocale: string;
+  mainBundleChunks: {
+    filename: string;
+    url: string;
+    fileSize: string;
+    totalLocaleSize: string;
+    usedLocaleSize: string;
+    unusedLocaleSize: string;
+    dictionariesFound: number;
+    unusedPercent: string;
+  }[];
+  lazyBundleChunks: {
+    filename: string;
+    url: string;
+    fileSize: string;
+    totalLocaleSize: string;
+    usedLocaleSize: string;
+    unusedLocaleSize: string;
+    dictionariesFound: number;
+    unusedPercent: string;
+  }[];
 };
-/** Check the presence of a canonical link. */
-export declare const checkCanonical: (html: string, targetUrl: string, events: ScanEvent[]) => void;
 /**
- * Check the page's hreflang structure and collect discovered locales into
- * `localesSet`.
+ * `url_unusedBundleContent`: share of other-locale translations shipped in the
+ * eagerly loaded bundles. Returns the raw analysis for reporting.
  */
-export declare const checkLinguisticStructure: (html: string, targetUrl: string, localesSet: Set<string>, events: ScanEvent[]) => void;
+export declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, emit: EmitScanEvent) => BundleContentAnalysis | undefined;
 /**
- * Check whether internal links carry a locale segment, mirroring the hosted
- * audit's URL-structure analysis but operating on parsed anchors instead of a
- * live DOM.
+ * Fetch `robots.txt` and check that neither the site nor its localized URLs
+ * are blocked for Googlebot.
+ *
+ * - `robots_robotsPresent`
+ * - `robots_noLocalizedUrlsForgotten`
+ *
+ * @param localizedUrls - URLs of every locale version (hreflang alternates).
+ * @returns The sitemaps declared in `robots.txt`.
  */
-export declare const checkUrlStructure: (anchors: Anchor[], origin: string, targetUrl: string, events: ScanEvent[]) => void;
+export declare const checkRobots: (origin: string, localizedUrls: string[], fetchOptions: ScanFetchOptions, emit: EmitScanEvent) => Promise<string[]>;
 /**
- * Analyze the JavaScript bundles for unused locale content and emit the
- * corresponding event. Returns the analysis so callers can report on it.
+ * Read the sitemaps (declared in `robots.txt`, else the default locations,
+ * following sitemap indexes) and check their locale coverage.
+ *
+ * - `sitemap_sitemapPresent`
+ * - `sitemap_noLocalizedUrlsForgotten`: every locale is listed, and entries
+ *   declaring alternates declare all of them
+ * - `sitemap_hasAlternates` / `sitemap_hasXDefault`
  */
-export declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, events: ScanEvent[]) => BundleContentAnalysis | undefined;
-/** Fetch and check `robots.txt`, emitting robots-related events. */
-export declare const checkRobots: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
-/** Fetch and check `sitemap.xml`, emitting sitemap-related events. */
-export declare const checkSitemap: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+export declare const checkSitemap: (origin: string, declaredSitemapUrls: string[], routing: RoutingDetection, fetchOptions: ScanFetchOptions, emit: EmitScanEvent) => Promise<void>;
 //#endregion
 //# sourceMappingURL=checks.d.ts.map

package/dist/types/scan/checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;qBAgBa,aAAU;;;;;qBAUV,sBAAmB,cAClB,mBACK,QACT;EACL;;;qBAmCQ,iBAAc,cACb,mBACK,QACT;;;;;qBAcG,2BAAwB,cACvB,mBACK,YACL,aAAW,QACf;;;;;;qBAwCG,oBAAiB,SACnB,UAAQ,gBACH,mBACG,QACT;;;;;qBAwEG,qBAAkB,QACrB,oBAAkB,cACd,mCACqB,mBAChB,uBACI,QACb,gBACP;;qBA0CU,cAAW,gBACR,mBACK,aAAW,mBACb,QACT,gBACP;;qBA0DU,eAAY,gBACT,mBACK,aAAW,mBACb,QACT,gBACP"}
+{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;;;YAkCY,iBAAiB,OAAO;;YAGxB;EACV;EACA;EACA;EACA;;EAEA;;EAEA;EACA,WAAW;EACX,SAAS;EACT,SAAS;;EAET;;;qBAWW,aAAU;;qBAgCV,kBAAa,WAAA,WACA,aAAW,MAC7B;;;;;qBAqBK,iBAAY,WAAA,SAAA,UACS,aAAW,MACrC;;;;;qBAuCK,2BAAsB,WAAA,SAAA,WAAA,WACW,aAAW,MACjD;;;;;;qBA4DK,kBAAa,WAAA,UAAA,oBAAA,WACmC,aAAW,MAChE;;;;;qBAmEK,mBAAc,WAAA,eAAA,WAAA,SAAA,cACqC,aAAW,MACnE;;;;;qBAgDK,kBAAa,WAAA,WAAA,iBACiB,aAAW,MAC9C;;qBAgFK,kBAAa,WAAA,aACE,aAAW,MAC/B;;;;;;qBA4EK,6BAAwB,WAAA,WAAA,iBACM,aAAW,cACtC,kBAAgB,MACxB,kBACL;;;;;;;;;;qBAkFU,qBAAkB,SACpB,aAAW,MACd;;qBAwFK,uBAAoB,UAAc;EAC7C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;EACA;;;;;;;;;;;;;;;qBAOW,qBAAkB,QACrB,oBAAkB,cACd,mCACqB,mBAChB,uBACI,MACf,kBACL;;;;;;;;;;;qBAoDU,cAAW,gBACR,yBACS,cACT,kBAAgB,MACxB,kBACL;;;;;;;;;;qBAwDU,eAAY,gBACT,+BACe,SACpB,kBAAgB,cACX,kBAAgB,MACxB,kBACL"}

package/dist/types/scan/detection/checkDetails.d.ts

@@ -0,0 +1,29 @@
+//#region src/scan/detection/checkDetails.d.ts
+/** Details of a scan check, split for display. */
+export type CheckDetailParts = {
+  /** Explanation of the check result. */
+  message?: string;
+  /** Offending `<a>` elements, as HTML source. */
+  links: string[];
+  /** Other listed items: issues, hreflang alternates, URLs… */
+  items: string[];
+};
+/**
+ * Split the details attached to a scan check into its message, the listed
+ * links (HTML source) and the other listed items. Shapes without any of them
+ * (bundle summaries, hreflang lists…) return empty lists.
+ *
+ * @param details - The `success` / `warning` / `error` payload of a check.
+ */
+export declare const splitCheckDetails: (details: unknown) => CheckDetailParts;
+/**
+ * Turn the details attached to a scan check into short printable lines: its
+ * message, then the listed issues / links / URLs. Shared by the CLI report and
+ * the Chrome extension popup.
+ *
+ * @param details - The `success` / `warning` / `error` payload of a check.
+ * @returns The message first, then one line per listed item.
+ */
+export declare const getCheckDetailLines: (details: unknown) => string[];
+//#endregion
+//# sourceMappingURL=checkDetails.d.ts.map

package/dist/types/scan/detection/checkDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkDetails.d.ts","names":[],"sources":["../../../../src/scan/detection/checkDetails.ts"],"mappings":";;YACY;;EAEV;;EAEA;;EAEA;;;;;;;;;qBAUW,oBAAiB,qBAAuB;;;;;;;;;qBAkCxC,sBAAmB"}

package/dist/types/scan/detection/classifyInternalLinks.d.ts

@@ -0,0 +1,44 @@
+import { RoutingDetection } from "./detectRoutingStrategy.js";
+//#region src/scan/detection/classifyInternalLinks.d.ts
+/** A page anchor, as parsed from HTML or read from a live DOM. */
+export type LinkAnchor = {
+  href: string;
+  text: string;
+  /** `hreflang` attribute, set on language-switcher links. */
+  hreflang?: string;
+};
+/** Input of {@link classifyInternalLinks}. */
+export type LinkClassificationInput<Anchor extends LinkAnchor> = {
+  /** Absolute URL of the page holding the anchors. */
+  targetUrl: string;
+  anchors: Anchor[];
+  hreflangs: {
+    hreflang: string;
+    href: string;
+  }[];
+  routing: RoutingDetection;
+  /** Locale of the page. */
+  pageLocale?: string;
+};
+/** Internal anchors of a page, grouped by the locale they lead to. */
+export type LinkClassification<Anchor extends LinkAnchor> = {
+  /** Internal page links, language-switcher links excluded. */
+  internalLinks: Anchor[];
+  /** Internal links keeping the page locale. */
+  sameLocaleLinks: Anchor[];
+  /** Internal links leading to another locale. */
+  otherLocaleLinks: Anchor[];
+  /** Internal links whose URL carries no locale. */
+  unlocalizedLinks: Anchor[];
+  /** Links to the other locale versions (hreflang alternates). */
+  switcherLinks: Anchor[];
+};
+/**
+ * Group the internal anchors of a page by the locale they lead to, reading
+ * each URL through the detected routing strategy (so unprefixed links count as
+ * the default locale on a `prefix-no-default` site, and `?lang=` is understood
+ * on a `search-params` site).
+ */
+export declare const classifyInternalLinks: <Anchor extends LinkAnchor>({ targetUrl, anchors, hreflangs, routing, pageLocale }: LinkClassificationInput<Anchor>) => LinkClassification<Anchor>;
+//#endregion
+//# sourceMappingURL=classifyInternalLinks.d.ts.map

package/dist/types/scan/detection/classifyInternalLinks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifyInternalLinks.d.ts","names":[],"sources":["../../../../src/scan/detection/classifyInternalLinks.ts"],"mappings":";;;YAKY;EACV;EACA;;EAEA;;;YAIU,wBAAwB,eAAe;;EAEjD;EACA,SAAS;EACT;IAAa;IAAkB;;EAC/B,SAAS;;EAET;;;YAIU,mBAAmB,eAAe;;EAE5C,eAAe;;EAEf,iBAAiB;;EAEjB,kBAAkB;;EAElB,kBAAkB;;EAElB,eAAe;;;;;;;;qBAYJ,wBAAyB,eAAe,cAAU,WAAA,SAAA,WAAA,SAAA,cAM5D,wBAAwB,YAAU,mBAAmB"}

package/dist/types/scan/detection/detectRoutingStrategy.d.ts

@@ -0,0 +1,60 @@
+//#region src/scan/detection/detectRoutingStrategy.d.ts
+/**
+ * How a website exposes its locales in URLs. Mirrors Intlayer's
+ * `routing.mode` values, plus the domain-based strategies.
+ *
+ * - `prefix-all`: every locale is prefixed (`/en/about`, `/fr/about`)
+ * - `prefix-no-default`: the default locale is not prefixed (`/about`, `/fr/about`)
+ * - `search-params`: the locale is a query parameter (`/about?lang=fr`)
+ * - `subdomain`: the locale is a subdomain (`fr.example.com`)
+ * - `domain`: one domain per locale (`example.fr`, `example.de`)
+ * - `no-prefix`: a single URL serves every locale (cookie / header based)
+ * - `unknown`: not enough signals to decide
+ */
+export type RoutingStrategy = 'prefix-all' | 'prefix-no-default' | 'search-params' | 'subdomain' | 'domain' | 'no-prefix' | 'unknown';
+/** Result of {@link detectRoutingStrategy}. */
+export type RoutingDetection = {
+  strategy: RoutingStrategy;
+  /**
+   * `high` when inferred from the hreflang alternates, `low` when guessed from
+   * the scanned URL alone.
+   */
+  confidence: 'high' | 'low';
+  /** Locales known to the site (hreflang values, else the page `lang`). */
+  locales: string[];
+  /** Locale served without any marker (`prefix-no-default`, `search-params`…). */
+  defaultLocale?: string;
+  /** Query parameter carrying the locale, for `search-params`. */
+  searchParamName?: string;
+  /** Hostname → locale map, for `subdomain` / `domain`. */
+  hostLocales?: Record<string, string>;
+  /** Locale of the scanned page according to its URL alone. */
+  urlLocale?: string;
+  /** Human-readable explanation of the decision. */
+  evidence: string;
+};
+/** Input of {@link detectRoutingStrategy}. */
+export type RoutingDetectionInput = {
+  /** Absolute URL of the scanned page. */
+  pageUrl: string;
+  /** Value of `<html lang>`, when present. */
+  htmlLang?: string;
+  /** `<link rel="alternate" hreflang>` entries of the page. */
+  hreflangs: {
+    hreflang: string;
+    href: string;
+  }[];
+};
+/** Locale of a URL according to an already-detected routing strategy. */
+export declare const getUrlLocale: (url: string, routing: RoutingDetection) => string | undefined;
+/**
+ * Detect how the site encodes the locale in its URLs (path prefix, query
+ * parameter, subdomain, domain or nothing).
+ *
+ * The hreflang alternates are the most reliable signal: each one pairs a
+ * locale with its URL, so the shared pattern reveals the strategy. Without
+ * alternates the scanned URL alone is used, with `confidence: 'low'`.
+ */
+export declare const detectRoutingStrategy: ({ pageUrl, htmlLang, hreflangs }: RoutingDetectionInput) => RoutingDetection;
+//#endregion
+//# sourceMappingURL=detectRoutingStrategy.d.ts.map

package/dist/types/scan/detection/detectRoutingStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectRoutingStrategy.d.ts","names":[],"sources":["../../../../src/scan/detection/detectRoutingStrategy.ts"],"mappings":";;;;;;;;;;;;;YAoBY;;YAUA;EACV,UAAU;;;;;EAKV;;EAEA;;EAEA;;EAEA;;EAEA,cAAc;;EAEd;;EAEA;;;YAIU;;EAEV;;EAEA;;EAEA;IAAa;IAAkB;;;;qBAMpB,eAAY,aACZ,SACF;;;;;;;;;qBA+ME,0BAAqB,SAAA,UAAA,aAI/B,0BAAwB"}