hanzio 3.0.0 → 3.1.0

package/dist/i18n/content-rules.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Content rules for translation VALUES, which key and placeholder parity cannot
+ * see: source code stored as copy ("row.name", "carTitle(car)") by an automated
+ * extraction pass, copy in the wrong language committed to the base catalog,
+ * banned product vocabulary, and copy shipped untranslated.
+ */
+export type ContentRulesConfig<Locale extends string = string> = {
+    /**
+     * Key prefixes the vocabulary and untranslated rules skip, such as internal
+     * admin tooling or a marketing site with its own copy owner.
+     */
+    exemptKeyPrefixes?: readonly string[];
+    /** Values that legitimately look like code, such as `'Solgt.com'`. */
+    allowCodeShapes?: readonly string[];
+    /**
+     * Flags base-catalog values written in another language: two distinct
+     * marker words, or one plus a letter from `letters`.
+     */
+    wrongLanguage?: {
+        /** Function words of the other language that are not English words. */
+        markers: readonly string[];
+        /** Letters only that language uses, e.g. `'æøåÆØÅ'`. */
+        letters?: string;
+        allowKeys?: readonly string[];
+    };
+    bannedWords?: {
+        /** Banned in every catalog, the base included. */
+        everywhere?: readonly string[];
+        /** Banned in translations only (loanwords readers do not use). */
+        translations?: readonly string[];
+        allowKeys?: readonly string[];
+    };
+    /** Translations allowed to equal the base value. */
+    identical?: {
+        /** Leading words (brands, acronyms) that make a value correct as-is. */
+        brands?: readonly string[];
+        /** Keys correct as-is, in the listed locales or `'all'`. */
+        allowKeys?: Readonly<Record<string, readonly Locale[] | 'all'>>;
+    };
+};
+/** Compiles the configured rules once; each detector returns why, or null. */
+export declare function createContentRules(config?: ContentRulesConfig): {
+    /** The shape name when a value looks like source code. */
+    codeShape(value: string): string | null;
+    /** The marker words found when a base value is in the wrong language. */
+    wrongLanguage(key: string, value: string): string | null;
+    /** The offending word when a value uses banned vocabulary. */
+    bannedWord(key: string, value: string, isBase: boolean): string | null;
+    /**
+     * A translation of two or more words identical to its source ("Document
+     * name", a whole English sentence). Single words stay out of scope:
+     * "Status" and "Email" are correct in many languages.
+     */
+    identicalLabel(key: string, locale: string, source: string, translated: string): boolean;
+};

package/dist/i18n/i18next.d.ts

@@ -0,0 +1,39 @@
+import type { i18n as I18next, InitOptions, ResourceLanguage } from 'i18next';
+import { type AsyncStorageLike } from '../storage';
+import type { LocaleRegistry } from '.';
+/**
+ * Starts `i18n` in the persisted locale, then the first supported device
+ * locale, then `locales.defaultLocale` (also the fallback). Interpolation uses
+ * `{name}` (not `{{name}}`) and does not escape, matching the catalog check
+ * and `hanzio/i18n`.
+ *
+ * ```ts
+ * export const appI18n = initI18next(i18n.use(initReactI18next), {
+ * 	locales: uiLocales,
+ * 	resources: { en: { translation: en }, da: { translation: da } },
+ * 	deviceLocales: () => getLocales().flatMap((l) => [l.languageTag, l.languageCode]),
+ * 	storageKey: 'app.ui-locale',
+ * 	storage: AsyncStorage
+ * })
+ * ```
+ */
+export declare function initI18next<L extends string>(i18n: I18next, options: Omit<InitOptions, 'lng' | 'resources'> & {
+    locales: LocaleRegistry<L>;
+    resources: Record<L, ResourceLanguage>;
+    /** Device languages in preference order, e.g. from `expo-localization`. */
+    deviceLocales?: () => readonly (string | null | undefined)[];
+    /** Remembers the chosen locale (a raw string). Needs `storage`. */
+    storageKey?: string;
+    storage?: AsyncStorageLike;
+}): {
+    /** Resolves once `i18n.init` finishes. Await it before the first render. */
+    ready: Promise<void>;
+    setLocale: (locale: L) => Promise<void>;
+    /** The active locale, or the default before `ready`. */
+    locale: () => L;
+    /**
+     * Follows a server-side preference (the signed-in user's locale). An
+     * unsupported or missing tag changes nothing.
+     */
+    syncLocale(tag: string | null | undefined): Promise<void>;
+};

package/dist/i18n/index.d.ts

@@ -34,4 +34,19 @@ export declare function flattenMessages<const T extends Messages>(messages: T):
  * placeholders. Unknown keys at runtime return the key.
  */
 export declare function createTranslator<const T extends Messages>(messages: T): <K extends MessageKeys<T>>(key: K, ...args: PlaceholderArgs<Extract<MessageAt<T, K>, string>>) => string;
-export {};
+/** Generated key → placeholder-name map: `{ 'greeting': 'name', 'common.save': never }`. */
+export type TranslationParamsMap = Record<string, string>;
+/**
+ * Strict `t` over a generated key → placeholder-name map (see `hanzio-i18n
+ * generate`). Keys without placeholders take no params; keys with placeholders
+ * require every named value.
+ */
+export type TypedTranslate<Params extends TranslationParamsMap> = <Key extends keyof Params & string>(...args: [Params[Key]] extends [never] ? [key: Key] : [key: Key, params: Record<Params[Key], PlaceholderValue>]) => string;
+/** Explicit escape hatch for data-driven keys validated outside TypeScript. */
+export type DynamicTranslate = (key: string, params?: Record<string, PlaceholderValue>) => string;
+/**
+ * Narrows a framework's string-wide `t` (vue-i18n, i18next) to the generated
+ * map. Types only; returns `t` unchanged.
+ */
+export declare function typedTranslate<Params extends TranslationParamsMap>(t: (...args: never[]) => unknown): TypedTranslate<Params>;
+export * from './locales';

package/dist/i18n/locales.d.ts

@@ -0,0 +1,62 @@
+export type LocaleRegistry<L extends string> = {
+    /** Locale ids in declaration order. They name the catalog files. */
+    readonly locales: readonly L[];
+    readonly defaultLocale: L;
+    tag(locale: L): string;
+    name(locale: L): string;
+    /**
+     * A supported locale for a BCP-47-ish tag (`'da'`, `'da-DK'`, `'en_US'`), or
+     * `null`. Matches the id, then the tag, then the language subtag, then the
+     * aliases.
+     */
+    match(tag: string | null | undefined): L | null;
+    /** The first candidate that matches, else `defaultLocale`. */
+    resolve(...candidates: readonly (string | null | undefined)[]): L;
+};
+/** The locale union of a registry: `LocaleOf<typeof locales>`. */
+export type LocaleOf<R> = R extends LocaleRegistry<infer L> ? L : never;
+/**
+ * The app's shipped UI locales, shared by every runtime and the catalog check.
+ *
+ * ```ts
+ * export const uiLocales = defineLocales({
+ * 	locales: {
+ * 		en: { tag: 'en-US', name: 'English' },
+ * 		nb: { tag: 'nb-NO', name: 'Norsk bokmål' }
+ * 	},
+ * 	defaultLocale: 'en',
+ * 	aliases: { no: 'nb' }
+ * })
+ * uiLocales.match('no-NO') // 'nb'
+ * ```
+ */
+export declare function defineLocales<const T extends Record<string, {
+    /** BCP-47 tag for `Intl` and `<html lang>`, e.g. `'da-DK'`. */
+    tag: string;
+    /** The language naming itself, for locale pickers: `'Dansk'`. */
+    name: string;
+}>>(options: {
+    locales: T;
+    defaultLocale: keyof T & string;
+    /** Extra tags or language subtags that mean a locale: `{ no: 'nb' }`. */
+    aliases?: Record<string, keyof T & string>;
+}): LocaleRegistry<keyof T & string>;
+/**
+ * A locale picker that switches immediately and rolls back when `persist`
+ * (for example saving the user's language on the server) rejects.
+ *
+ * ```ts
+ * const selectLocale = createLocaleSelector({
+ * 	getLocale: () => locale.value,
+ * 	setLocale,
+ * 	persist: (locale) => api.user.updateLocale({ locale }),
+ * 	onError: () => toast.error(t('settings.language.error'))
+ * })
+ * ```
+ */
+export declare function createLocaleSelector<L extends string>(options: {
+    getLocale: () => L;
+    setLocale: (locale: L) => unknown;
+    persist?: (locale: L) => Promise<unknown>;
+    onError?: (error: unknown) => void;
+}): (next: L) => Promise<void>;

package/dist/i18n/vite.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from 'vite';
+/**
+ * Dev-server plugin: reload the page with fresh catalogs when a
+ * `locales/*.json` file changes.
+ *
+ * `@intlify/unplugin-vue-i18n` serves each catalog as a `virtual:intlify-i18n-N`
+ * module that the module graph cannot tie back to its JSON file, and its own
+ * hot update only invalidates its bundle module, so an edited key kept serving
+ * the old catalog until the dev server restarted. This invalidates every
+ * catalog module and reloads: `createI18n` reads messages once at startup, so a
+ * hot swap would not reach the running instance anyway.
+ */
+export declare function localeCatalogReloadPlugin(options?: {
+    /** Which changed files are catalogs. Default: `.json` in a `locales` folder. */
+    match?: RegExp;
+}): Plugin;

package/dist/i18n/vue.d.ts

@@ -0,0 +1,93 @@
+import type { WritableComputedRef } from 'vue';
+import { type I18nOptions } from 'vue-i18n';
+import { type SyncStorageLike } from '../storage';
+import { type LocaleRegistry, type Messages, type TranslationParamsMap } from '.';
+/**
+ * `createI18n` in composition mode, starting in the persisted locale, then the
+ * browser language, then `locales.defaultLocale` (also the fallback locale).
+ * `setLocale` is the one write path: it switches vue-i18n, persists the choice
+ * and keeps `<html lang>` accurate. `useI18n<Params>()` is vue-i18n's composer
+ * with the locale and `t` narrowed to the registry and a generated key map;
+ * make it the one place the app calls vue-i18n's `useI18n`.
+ */
+export declare function createVueI18n<L extends string>(options: Omit<I18nOptions, 'legacy' | 'locale' | 'messages'> & {
+    locales: LocaleRegistry<L>;
+    /** One catalog per locale; a missing locale is a type error. */
+    messages: Record<L, Messages>;
+    /**
+     * Remembers the chosen locale (a raw string) so screens before sign-in
+     * come up in the right language. Omit to persist nothing.
+     */
+    storageKey?: string;
+    /** Defaults to `localStorage`, falling back to memory. */
+    storage?: SyncStorageLike;
+}): {
+    i18n: import("vue-i18n").I18n<Record<L, Messages> extends Record<string, unknown> ? Record<L, Messages> : {}, {}, {}, L extends string ? L : string, false>;
+    setLocale(locale: L): void;
+    useI18n<Params extends TranslationParamsMap>(): {
+        id: number;
+        fallbackLocale: WritableComputedRef<import("@intlify/core-base").FallbackLocales<string>, import("@intlify/core-base").FallbackLocales<string>>;
+        inheritLocale: boolean;
+        availableLocales: string[];
+        messages: import("vue").ComputedRef<{
+            [x: string]: import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType>;
+        }>;
+        datetimeFormats: import("vue").ComputedRef<{
+            [x: string]: import("vue-i18n").IntlDateTimeFormat;
+        }>;
+        numberFormats: import("vue").ComputedRef<{
+            [x: string]: import("vue-i18n").IntlNumberFormat;
+        }>;
+        modifiers: import("vue-i18n").LinkedModifiers<import("vue-i18n").VueMessageType>;
+        pluralRules: import("@intlify/core-base").PluralizationRules;
+        isGlobal: boolean;
+        missingWarn: boolean | RegExp;
+        fallbackWarn: boolean | RegExp;
+        fallbackRoot: boolean;
+        fallbackFormat: boolean;
+        warnHtmlMessage: boolean;
+        escapeParameter: boolean;
+        rt: import("vue-i18n").ComposerResolveLocaleMessageTranslation<string>;
+        d: import("vue-i18n").ComposerDateTimeFormatting<{
+            [x: string]: import("vue-i18n").IntlDateTimeFormat;
+        }, string, import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("@intlify/core-base").DateTimeFormatOptions;
+        }>, never, never, never>;
+        n: import("vue-i18n").ComposerNumberFormatting<{
+            [x: string]: import("vue-i18n").IntlNumberFormat;
+        }, string, import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("@intlify/core-base").NumberFormatOptions;
+        }>, never, never, never>;
+        te<Str extends string, Key extends string = string>(key: Key | Str, locale?: string | undefined): boolean;
+        tm<Key extends string, ResourceKeys extends string = string, Locale extends string = string, Target = import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("vue-i18n").LocaleMessageValue<import("vue-i18n").VueMessageType>;
+        }>, Return = ResourceKeys extends import("@intlify/core-base").ResourcePath<Target> ? import("@intlify/core-base").ResourceValue<Target, ResourceKeys> : Record<string, any>>(key: Key | ResourceKeys): Return;
+        getLocaleMessage<MessageSchema extends import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType> = never, LocaleSchema extends string = string, Locale extends string = string, Return = import("vue-i18n").IsNever<MessageSchema> extends true ? import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("vue-i18n").LocaleMessageValue<import("vue-i18n").VueMessageType>;
+        }> : MessageSchema>(locale: Locale | LocaleSchema): Return;
+        setLocaleMessage<MessageSchema extends import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType> = never, LocaleSchema extends string = string, Locale extends string = string, MessageType = import("vue-i18n").IsNever<MessageSchema> extends true ? import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("vue-i18n").LocaleMessageValue<import("vue-i18n").VueMessageType>;
+        }> : MessageSchema, Message extends MessageType = MessageType>(locale: Locale | LocaleSchema, message: Message): void;
+        mergeLocaleMessage<MessageSchema extends import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType> = never, LocaleSchema extends string = string, Locale extends string = string, Message = import("vue-i18n").IsNever<MessageSchema> extends true ? Record<string, any> : MessageSchema>(locale: Locale | LocaleSchema, message: Message): void;
+        getDateTimeFormat<DateTimeSchema extends Record<string, any> = never, LocaleSchema extends string = string, Locale extends string = string, Return = import("vue-i18n").IsNever<DateTimeSchema> extends true ? import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("@intlify/core-base").DateTimeFormatOptions;
+        }> : DateTimeSchema>(locale: Locale | LocaleSchema): Return;
+        setDateTimeFormat<DateTimeSchema extends Record<string, any> = never, LocaleSchema extends string = string, Locale extends string = string, FormatsType = import("vue-i18n").IsNever<DateTimeSchema> extends true ? import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("@intlify/core-base").DateTimeFormatOptions;
+        }> : DateTimeSchema, Formats extends FormatsType = FormatsType>(locale: Locale | LocaleSchema, format: Formats): void;
+        mergeDateTimeFormat<DateTimeSchema extends Record<string, any> = never, LocaleSchema extends string = string, Locale extends string = string, Formats = import("vue-i18n").IsNever<DateTimeSchema> extends true ? Record<string, any> : DateTimeSchema>(locale: Locale | LocaleSchema, format: Formats): void;
+        getNumberFormat<NumberSchema extends Record<string, any> = never, LocaleSchema extends string = string, Locale extends string = string, Return = import("vue-i18n").IsNever<NumberSchema> extends true ? import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("@intlify/core-base").NumberFormatOptions;
+        }> : NumberSchema>(locale: Locale | LocaleSchema): Return;
+        setNumberFormat<NumberSchema extends Record<string, any> = never, LocaleSchema extends string = string, Locale extends string = string, FormatsType = import("vue-i18n").IsNever<NumberSchema> extends true ? import("@intlify/core-base").RemoveIndexSignature<{
+            [x: string]: import("@intlify/core-base").NumberFormatOptions;
+        }> : NumberSchema, Formats extends FormatsType = FormatsType>(locale: Locale | LocaleSchema, format: Formats): void;
+        mergeNumberFormat<NumberSchema extends Record<string, any> = never, LocaleSchema extends string = string, Locale extends string = string, Formats = import("vue-i18n").IsNever<NumberSchema> extends true ? Record<string, any> : NumberSchema>(locale: Locale | LocaleSchema, format: Formats): void;
+        getPostTranslationHandler(): import("vue-i18n").PostTranslationHandler<import("vue-i18n").VueMessageType> | null;
+        setPostTranslationHandler(handler: import("vue-i18n").PostTranslationHandler<import("vue-i18n").VueMessageType> | null): void;
+        getMissingHandler(): import("vue-i18n").MissingHandler | null;
+        setMissingHandler(handler: import("vue-i18n").MissingHandler | null): void;
+        locale: WritableComputedRef<L, L>;
+        t: import(".").TypedTranslate<Params>;
+    };
+};

package/dist/{index-kj1phgrx.js → index-29mmh343.js}

@@ -165,5 +165,28 @@ function safeDecodeURIComponent(value) {
     return value;
   }
 }
+function escapeHtml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var EMOJI_PATTERN = /[\p{Extended_Pictographic}\u{1F1E6}-\u{1F1FF}\u{1F3FB}-\u{1F3FF}\u{20E3}\u{FE0F}\u{200D}]/gu;
+function stripEmoji2(text) {
+  const stripped = text.replace(EMOJI_PATTERN, "");
+  if (stripped === text)
+    return text;
+  return stripped.replace(/ {2,}/g, " ").replace(/ +([,.!?;:])/g, "$1").trim();
+}
+function fileExtension2(filename) {
+  const name = filename.slice(Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\")) + 1);
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0 || dot === name.length - 1)
+    return;
+  return name.slice(dot + 1).toLowerCase();
+}
+function toJsonValue2(value) {
+  if (value === undefined)
+    return null;
+  const text = JSON.stringify(value);
+  return text === undefined ? null : JSON.parse(text);
+}
 
-export { extractNumber2, generateId2, sha256Id2, slugify2, stableStringify2, truncate2, normalizeWhitespace2, escapeRegExp2, foldForSearch2, matchesSearch2, initials2, safeJsonParse2 };
+export { extractNumber2, generateId2, sha256Id2, slugify2, stableStringify2, truncate2, normalizeWhitespace2, escapeRegExp2, foldForSearch2, matchesSearch2, initials2, safeJsonParse2, escapeHtml2, stripEmoji2, fileExtension2, toJsonValue2 };

package/dist/{index-zbj9s3s3.js → index-2kz392vw.js}

@@ -7,7 +7,7 @@ import {
   promiseTimeout2,
   exponentialBackoff2,
   anySignal2
-} from "./index-0zvtcbzy.js";
+} from "./index-6f2w90pp.js";
 import {
   buildQueryString2,
   parseRetryAfter2