@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/runtime-DTMmliT1.js

@@ -0,0 +1,64 @@
+//#region src/core/config/runtime.ts
+/**
+* Pseudo-locales are a development aid: on in `vite dev` and non-production
+* builds (previews, staging), off in production and for the CLI unless
+* `vi18n compile --pseudo` asks for them.
+*/
+function pseudoActive(command, mode) {
+	if (command === "serve") return true;
+	if (command === "build") return mode !== "production";
+	return false;
+}
+function toRuntimeConfig(config, options) {
+	const pseudoLocales = options.pseudo ? [...config.pseudoLocales] : [];
+	const { routing, ssr } = config;
+	return {
+		sourceLocale: config.sourceLocale,
+		locales: [...config.locales, ...pseudoLocales],
+		pseudoLocales,
+		fallbacks: mapRecord(config.fallbacks, (chain) => [...chain]),
+		routing: {
+			strategy: [...routing.strategy],
+			routeStrategies: mapRecord(routing.routeStrategies, (chain) => [...chain]),
+			url: routing.url,
+			redirectRoot: routing.redirectRoot,
+			propagate: routing.propagate,
+			switch: routing.switch,
+			cookie: {
+				name: routing.cookie.name,
+				maxAge: routing.cookie.maxAge
+			},
+			base: normalizeBase(routing.base ?? options.base),
+			...Object.keys(routing.paths).length > 0 && { paths: mapRecord(routing.paths, (entry) => ({ ...entry })) },
+			...Object.keys(routing.domains).length > 0 && { domains: mapRecord(routing.domains, (locale) => locale) }
+		},
+		ssr: {
+			timeZone: ssr.timeZone,
+			timeZoneFrom: mapRecord(ssr.timeZoneFrom, (source) => source),
+			normalizeSpaces: ssr.normalizeSpaces,
+			...ssr.payload === "preload" && { payload: "preload" }
+		}
+	};
+}
+/** Whether the config localizes paths or routes by domain: the plugin's `__VI18N_ROUTES__`. */
+function hasRoutes(config) {
+	return Object.keys(config.routing.paths).length > 0 || Object.keys(config.routing.domains).length > 0;
+}
+/**
+* Vite's `base` as the URL codec needs it: a pathname starting and ending
+* with `/`. A relative base (`""`, `./`) serves the app from wherever it is
+* mounted, which for locale prefixes means the root; a full URL (CDN base)
+* contributes its pathname.
+*/
+function normalizeBase(base) {
+	let path = base;
+	if (/^[a-z][a-z\d+.-]*:\/\//i.test(path) || path.startsWith("//")) path = new URL(path, "http://localhost").pathname;
+	if (path === "" || path === "." || path === "./") return "/";
+	if (!path.startsWith("/")) path = "/" + path.replace(/^\.\//, "");
+	return path.endsWith("/") ? path : path + "/";
+}
+function mapRecord(record, map) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, map(value)]));
+}
+//#endregion
+export { toRuntimeConfig as i, normalizeBase as n, pseudoActive as r, hasRoutes as t };

package/dist/scan-worker.d.ts

@@ -0,0 +1,62 @@
+import { _ as MessageOccurrence, g as MessageCodec, h as Diagnostic, i as ResolvedConfig } from "./types-CgUCkFU1.js";
+//#region src/core/extract/worker.d.ts
+export interface FileTask {
+  /** Absolute path (a realpath from the file walk). */
+  file: string;
+  /** Posix path relative to the config root. */
+  refFile: string;
+  text: string;
+}
+/**
+ * What a file scan reads of the config. Plain data only: a worker gets it by
+ * structured clone, which the rest of a config (a custom AI provider holding
+ * an SDK client, rich-tag defaults) cannot survive.
+ */
+export type ScanConfig = Pick<ResolvedConfig, "root" | "sourceLocale" | "project" | "extraction" | "strict">;
+/** The scan's part of `config`, for a worker. */
+export declare function scanConfig(config: ResolvedConfig): ScanConfig;
+export interface FileResult {
+  occurrences: MessageOccurrence[];
+  diagnostics: Diagnostic[];
+  /** Parse errors and missing compilers abort the scan (§2.5.6). */
+  aborted: boolean;
+}
+/** Diagnostics that make `ProjectScan.aborted` true. */
+export declare const ABORT_CODES: ReadonlySet<Diagnostic["code"]>;
+export interface ScanSourceOptions {
+  /**
+   * Compile every framework file, as before parse-only extraction (§6
+   * D232): what the equivalence tests and the benchmark compare against.
+   */
+  compile?: boolean;
+}
+/**
+ * Scans one file: framework files are read parse-only or compiled first
+ * (each resulting module scanned on its own, positions recovered by
+ * search), scripts are parsed as they are. A file whose text names no
+ * import source, wrapper or global cannot bind a vi18n call and is not
+ * parsed at all.
+ */
+export declare function scanSource(task: FileTask, config: ScanConfig, codec: MessageCodec, options?: ScanSourceOptions): Promise<FileResult>;
+/** Marks this module's own workers, so importing it in any other thread starts nothing. */
+export declare const WORKER_MARKER = "vi18n:scan-worker";
+export interface WorkerInit {
+  marker: typeof WORKER_MARKER;
+  config: ScanConfig;
+  idLength: number;
+}
+export type WorkerRequest = {
+  batch: number;
+  tasks: FileTask[];
+};
+export type WorkerResponse = {
+  batch: number;
+  results: FileResult[];
+} | {
+  batch: number;
+  error: {
+    message: string;
+    stack?: string;
+  };
+};
+//#endregion

package/dist/scan-worker.js

@@ -0,0 +1 @@
+export { t as ABORT_CODES, n as WORKER_MARKER, r as scanConfig, i as scanSource } from "./worker-84U6uYB3.js";

package/dist/scoped-BMYpSthj.js

@@ -0,0 +1,44 @@
+import { C as fTime, S as fSegment, _ as fDuration, b as fPercent, d as fCompare, f as fCurrency, g as fDisplayName, h as fDateRange, l as fCollator, m as fDate, o as formatMessage, p as fCurrencyMinor, t as lookup, u as fCompact, v as fList, w as fUnit, x as fRelative, y as fNumber } from "./t-DC-c9zE5.js";
+import { r as richIn } from "./rich-DCUKl5HM.js";
+//#region src/runtime/scoped.ts
+/**
+* The API bound to one scope (INTERNALS §2.11.8): `createTranslator`,
+* `withLocale` helpers and e-mail jobs render with a fixed locale, zone and
+* `now`, and never subscribe a rendering computation.
+*/
+function createScopedApi(scope) {
+	const t = ((key, values) => {
+		const m = lookup(scope, key, false);
+		return typeof m === "string" ? m : formatMessage(m, values, scope);
+	});
+	const fmt = {
+		number: (v, o) => fNumber(scope, v, o),
+		currency: (v, c, o) => fCurrency(scope, v, c, o),
+		currencyMinor: (v, c, o) => fCurrencyMinor(scope, v, c, o),
+		unit: (v, u, o) => fUnit(scope, v, u, o),
+		compact: (v, o) => fCompact(scope, v, o),
+		percent: (v, o) => fPercent(scope, v, o),
+		date: (v, o) => fDate(scope, v, o),
+		time: (v, o) => fTime(scope, v, o),
+		dateRange: (a, b, o) => fDateRange(scope, a, b, o),
+		relative: (v, o) => fRelative(scope, v, o),
+		list: (items, o) => fList(scope, items, o),
+		displayName: (code, o) => fDisplayName(scope, code, o),
+		duration: (d, o) => fDuration(scope, d, o),
+		compare: (a, b, o) => fCompare(scope, a, b, o),
+		collator: (o) => fCollator(scope, o),
+		segment: (text, o) => fSegment(scope, text, o)
+	};
+	const html = (key, values) => richIn(key, values, 2, scope).join("");
+	const parts = (key, values) => richIn(key, values, 1, scope);
+	return {
+		locale: scope.locale,
+		t,
+		rich: (key, values) => richIn(key, values, 0, scope),
+		richHtml: html,
+		richParts: parts,
+		fmt
+	};
+}
+//#endregion
+export { createScopedApi as t };