@smileid/usesmileid 12.0.2 → 12.1.1

package/src/l10n/__tests__/use_smile_id_localizations.test.ts

@@ -1,244 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { UseSmileIDLocalizations } from "../use_smile_id_localizations";
-import { CANONICAL_KEY_COUNT, enStrings } from "../strings_en";
-
-// Unicode FIRST STRONG ISOLATE / POP DIRECTIONAL ISOLATE.
-const FSI = "\u2068";
-const PDI = "\u2069";
-
-describe("strings_en — canonical key set", () => {
-  it("matches the documented canonical key count", () => {
-    // Concrete scenario: we silently drop a key during a refactor —
-    // RN renders the English fallback but partner overrides break
-    // for the missing key. Pin the count so any change requires
-    // bumping `CANONICAL_KEY_COUNT`.
-    expect(Object.keys(enStrings).length).toBe(CANONICAL_KEY_COUNT);
-  });
-
-  it("every key starts with the `si_` prefix", () => {
-    for (const key of Object.keys(enStrings)) {
-      expect(key).toMatch(/^si_/);
-    }
-  });
-
-  it("parameterized strings use named tokens, not positional `%1$s`", () => {
-    // The convention is named-token interpolation (`{partnerName}`).
-    // A regression that re-introduces positional tokens here would
-    // break translations that rely on the named-token contract.
-    for (const value of Object.values(enStrings)) {
-      expect(value).not.toMatch(/%\d+\$[s@]/);
-    }
-  });
-});
-
-describe("UseSmileIDLocalizations", () => {
-  it("returns English defaults when no overrides are passed", () => {
-    const loc = new UseSmileIDLocalizations();
-    expect(loc.siLabelContinue).toBe("Continue");
-    expect(loc.siInstructionsTitlePrefix).toBe("Get ready to capture your");
-    expect(loc.siInstructionsEmphasisSelfie).toBe("selfie");
-    expect(loc.siCaptureSmile).toBe("Please smile…");
-  });
-
-  it("uses overrides when present and falls back per-key when missing", () => {
-    // Concrete scenario: a partner ships only the consent strings
-    // translated, leaving capture-screen feedback at English. Their
-    // partial overrides map should NOT force the rest of the SDK
-    // into a "no fallback found" state; per-key fallback is the
-    // contract.
-    const loc = new UseSmileIDLocalizations({
-      si_consent_allow: "Autoriser",
-      si_consent_deny: "Refuser",
-    });
-    expect(loc.siConsentAllow).toBe("Autoriser");
-    expect(loc.siConsentDeny).toBe("Refuser");
-    expect(loc.siCaptureTooClose).toBe("Move your device away from your face");
-    expect(loc.siLabelContinue).toBe("Continue");
-  });
-
-  it("renders {name} placeholders via _t — siConsentTitle parameterized", () => {
-    const loc = new UseSmileIDLocalizations();
-    expect(loc.siConsentTitle("Acme")).toBe(
-      `${FSI}Acme${PDI} would like to verify your identity using Smile ID.`,
-    );
-  });
-
-  it("renders multiple placeholder occurrences (replaceAll semantics)", () => {
-    // Concrete scenario: a future translation duplicates the
-    // partner-name token (e.g. greeting + footer). The previous
-    // implementation used `String.replace` (single replacement) and
-    // would only swap the first. The current `split/join` does all
-    // occurrences — pin the contract.
-    const loc = new UseSmileIDLocalizations({
-      si_consent_title: "{partnerName} hi {partnerName}",
-    });
-    expect(loc.siConsentTitle("Acme")).toBe(
-      `${FSI}Acme${PDI} hi ${FSI}Acme${PDI}`,
-    );
-  });
-
-  it("uses partner override for parameterized partner-link key", () => {
-    // Partner-link key uses the `{partnerName}` named-token
-    // interpolation contract — confirm the override path renders
-    // correctly with a translated string.
-    const loc = new UseSmileIDLocalizations({
-      si_consent_learn_more_privacy_partner_link: "Politique {partnerName}",
-    });
-    expect(loc.siConsentLearnMorePrivacyPartnerLink("Acme")).toBe(
-      `Politique ${FSI}Acme${PDI}`,
-    );
-  });
-
-  it("renders the document flip title with the {id_type} token", () => {
-    const loc = new UseSmileIDLocalizations();
-    expect(loc.siDocumentFlipTitle("Green Book")).toBe(
-      `Flip your ${FSI}Green Book${PDI}`,
-    );
-    expect(loc.siDocumentCaptureBack).toBe("Capture Back of ID");
-    expect(loc.siDocumentSkipBack).toBe("Skip");
-    expect(loc.siDocumentGuidelineGood).toBe("Good");
-    expect(loc.siDocumentGuidelineNotReflective).toBe("Not reflective");
-  });
-
-  describe("fromOverrides static helper", () => {
-    it("strips ARB metadata keys (`@@locale`, `@key`)", () => {
-      // ARB files put `@@locale: "fr"` and per-key
-      // `@key: { description: ..., placeholders: ... }` metadata at
-      // the top level. Partners should be able to feed an ARB JSON
-      // straight into us without preprocessing.
-      const loc = UseSmileIDLocalizations.fromOverrides({
-        "@@locale": "fr",
-        "@si_consent_allow": { description: "Allow button label" },
-        si_consent_allow: "Autoriser",
-      });
-      expect(loc.siConsentAllow).toBe("Autoriser");
-    });
-
-    it("drops non-string values defensively", () => {
-      // Concrete scenario: a partner accidentally ships a JSON file
-      // with `si_processing_continue: 123` (number). Without this
-      // filter, our `_overrides` map would carry a `number` value
-      // and `_s(...)` would happily return it — TS wouldn't catch
-      // because we type as `Record<string, unknown>` at the
-      // boundary. Filter at parse time so the runtime contract
-      // (`_s` returns a string) holds.
-      const loc = UseSmileIDLocalizations.fromOverrides({
-        si_consent_allow: "Autoriser",
-        si_processing_continue: 123,
-        si_consent_deny: null,
-      });
-      expect(loc.siConsentAllow).toBe("Autoriser");
-      expect(loc.siProcessingContinue).toBe("Continue"); // English fallback
-      expect(loc.siConsentDeny).toBe("Deny"); // English fallback
-    });
-  });
-});
-
-describe("UseSmileIDLocalizations — bidi isolation of interpolated values", () => {
-  it("isolates a substituted value so it cannot reorder the sentence", () => {
-    const loc = new UseSmileIDLocalizations();
-    const rendered = loc.siConsentTitle("شركة");
-
-    expect(rendered).toContain(`${FSI}شركة${PDI}`);
-    expect(rendered.indexOf(FSI)).toBeLessThan(rendered.indexOf(PDI));
-  });
-
-  it("isolates every occurrence of a repeated placeholder", () => {
-    const loc = new UseSmileIDLocalizations({
-      si_consent_title: "{partnerName} — {partnerName}",
-    });
-    const rendered = loc.siConsentTitle("Acme");
-
-    expect(rendered.split(FSI)).toHaveLength(3);
-    expect(rendered.split(PDI)).toHaveLength(3);
-  });
-
-  it("leaves an empty value unwrapped rather than emitting a bare isolate pair", () => {
-    const loc = new UseSmileIDLocalizations({
-      si_consent_title: "[{partnerName}]",
-    });
-    expect(loc.siConsentTitle("")).toBe("[]");
-  });
-});
-
-describe("UseSmileIDLocalizations — active-locale identity", () => {
-  it("changes when the resolved locale changes", () => {
-    const original = UseSmileIDLocalizations.localeResolver;
-    try {
-      UseSmileIDLocalizations.localeResolver = () => "en";
-      const before = UseSmileIDLocalizations.activeLocaleKey;
-      UseSmileIDLocalizations.localeResolver = () => "fr";
-      expect(UseSmileIDLocalizations.activeLocaleKey).not.toBe(before);
-    } finally {
-      UseSmileIDLocalizations.localeResolver = original;
-    }
-  });
-
-  it("changes when a locale is registered after the first read", () => {
-    UseSmileIDLocalizations.clearRegistry();
-    const before = UseSmileIDLocalizations.activeLocaleKey;
-    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
-    expect(UseSmileIDLocalizations.activeLocaleKey).not.toBe(before);
-    UseSmileIDLocalizations.clearRegistry();
-  });
-});
-
-describe("UseSmileIDLocalizations — dev-build fallback warnings", () => {
-  const globalWithDev = globalThis as { __DEV__?: boolean };
-
-  function withDevBuild(body: (warn: ReturnType<typeof vi.fn>) => void): void {
-    const hadDev = "__DEV__" in globalWithDev;
-    const previousDev = globalWithDev.__DEV__;
-    const warn = vi.fn();
-    const originalWarn = console.warn;
-    globalWithDev.__DEV__ = true;
-    console.warn = warn;
-    try {
-      body(warn);
-    } finally {
-      console.warn = originalWarn;
-      if (hadDev) globalWithDev.__DEV__ = previousDev;
-      else delete globalWithDev.__DEV__;
-    }
-  }
-
-  it("warns when the device locale has no registered translations", () => {
-    withDevBuild((warn) => {
-      UseSmileIDLocalizations.clearRegistry();
-      const original = UseSmileIDLocalizations.localeResolver;
-      UseSmileIDLocalizations.localeResolver = () => "zu-ZA";
-      try {
-        UseSmileIDLocalizations.forActiveLocale();
-      } finally {
-        UseSmileIDLocalizations.localeResolver = original;
-      }
-
-      expect(warn).toHaveBeenCalledTimes(1);
-      expect(String(warn.mock.calls[0]?.[0])).toContain("zu-ZA");
-    });
-  });
-
-  it("warns once when a supplied translation is missing keys", () => {
-    withDevBuild((warn) => {
-      const loc = new UseSmileIDLocalizations({
-        si_consent_allow: "Autoriser",
-      });
-      expect(loc.siConsentAllow).toBe("Autoriser");
-      expect(warn).not.toHaveBeenCalled();
-
-      loc.siConsentDeny;
-      loc.siLabelContinue;
-
-      expect(warn).toHaveBeenCalledTimes(1);
-      expect(String(warn.mock.calls[0]?.[0])).toContain("si_consent_deny");
-    });
-  });
-
-  it("stays silent for the English-only default instance", () => {
-    withDevBuild((warn) => {
-      const loc = new UseSmileIDLocalizations();
-      expect(loc.siLabelContinue).toBe("Continue");
-      expect(warn).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/l10n/__tests__/use_smile_id_localizations_provider.test.tsx

@@ -1,112 +0,0 @@
-import { describe, it, expect } from "vitest";
-import * as React from "react";
-import { create as createRenderer, act } from "react-test-renderer";
-import {
-  UseSmileIDLocalizationsProvider,
-  useStableLocalizations,
-  useUseSmileIDLocalizations,
-} from "../use_smile_id_localizations_provider";
-import { UseSmileIDLocalizations } from "../use_smile_id_localizations";
-
-function renderReader(children: React.ReactNode) {
-  let renderer!: ReturnType<typeof createRenderer>;
-  act(() => {
-    renderer = createRenderer(<>{children}</>);
-  });
-  return renderer;
-}
-
-describe("useUseSmileIDLocalizations", () => {
-  it("returns the English default when no provider wraps the caller", () => {
-    const seen: string[] = [];
-    function Reader() {
-      seen.push(useUseSmileIDLocalizations().siConsentAllow);
-      return null;
-    }
-
-    renderReader(<Reader />);
-
-    expect(seen).toEqual(["Allow"]);
-  });
-
-  it("returns the provider's instance when one is mounted", () => {
-    const localizations = new UseSmileIDLocalizations({
-      si_consent_allow: "Autoriser",
-    });
-    const seen: UseSmileIDLocalizations[] = [];
-    function Reader() {
-      seen.push(useUseSmileIDLocalizations());
-      return null;
-    }
-
-    renderReader(
-      <UseSmileIDLocalizationsProvider value={localizations}>
-        <Reader />
-      </UseSmileIDLocalizationsProvider>,
-    );
-
-    expect(seen[0]).toBe(localizations);
-    expect(seen[0]?.siConsentAllow).toBe("Autoriser");
-  });
-});
-
-describe("useStableLocalizations", () => {
-  it("builds a localizations instance from the overrides map", () => {
-    const overrides = { si_consent_allow: "Autoriser" };
-    const seen: UseSmileIDLocalizations[] = [];
-    function Reader() {
-      seen.push(useStableLocalizations(overrides));
-      return null;
-    }
-
-    renderReader(<Reader />);
-
-    expect(seen[0]).toBeInstanceOf(UseSmileIDLocalizations);
-    expect(seen[0]?.siConsentAllow).toBe("Autoriser");
-  });
-
-  it("keeps one instance across re-renders for a stable overrides object", () => {
-    const overrides = { si_consent_allow: "Autoriser" };
-    const seen: UseSmileIDLocalizations[] = [];
-    function Reader(_props: { tick: number }) {
-      seen.push(useStableLocalizations(overrides));
-      return null;
-    }
-
-    let renderer!: ReturnType<typeof createRenderer>;
-    act(() => {
-      renderer = createRenderer(<Reader tick={0} />);
-    });
-    act(() => {
-      renderer.update(<Reader tick={1} />);
-    });
-
-    expect(seen).toHaveLength(2);
-    expect(seen[0]).toBe(seen[1]);
-  });
-
-  it("rebuilds when the partner passes a fresh overrides object", () => {
-    const seen: UseSmileIDLocalizations[] = [];
-    function Reader({
-      overrides,
-    }: {
-      overrides: Partial<Record<string, string>>;
-    }) {
-      seen.push(useStableLocalizations(overrides));
-      return null;
-    }
-
-    let renderer!: ReturnType<typeof createRenderer>;
-    act(() => {
-      renderer = createRenderer(
-        <Reader overrides={{ si_consent_allow: "Autoriser" }} />,
-      );
-    });
-    act(() => {
-      renderer.update(<Reader overrides={{ si_consent_allow: "Permitir" }} />);
-    });
-
-    expect(seen[0]).not.toBe(seen[1]);
-    expect(seen[1]?.siConsentAllow).toBe("Permitir");
-  });
-});

package/src/l10n/__tests__/use_smile_id_localizations_surface.test.ts

@@ -1,231 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { UseSmileIDLocalizations } from "../use_smile_id_localizations";
-import { enStrings } from "../strings_en";
-
-/**
- * Every localized accessor is a two-line `_s(key, enStrings[key])` /
- * `_t(key, enStrings[key], params)` wrapper. Hand-writing one test per
- * accessor would be ~130 near-identical tests, so this suite drives the
- * whole surface off the prototype: a Proxy overrides map reports which
- * `si_*` key each accessor asks for, which is then checked against the
- * English default it returns. A typo'd key (the realistic defect — a
- * copy-pasted getter reading its neighbour's key) fails here.
- */
-
-const PARAM_VALUE = "SENTINEL-PARAM";
-
-type Accessor = {
-  readonly name: string;
-  readonly arity: number;
-  readonly call: (instance: UseSmileIDLocalizations) => string;
-};
-
-const accessors: readonly Accessor[] = Object.entries(
-  Object.getOwnPropertyDescriptors(UseSmileIDLocalizations.prototype),
-)
-  .filter(([name]) => name.startsWith("si"))
-  .map(([name, descriptor]): Accessor => {
-    if (descriptor.get) {
-      return {
-        name,
-        arity: 0,
-        call: (instance) =>
-          (instance as unknown as Record<string, string>)[name] as string,
-      };
-    }
-    const method = descriptor.value as (...args: string[]) => string;
-    const arity = method.length;
-    return {
-      name,
-      arity,
-      call: (instance) =>
-        method.apply(
-          instance,
-          Array.from({ length: arity }, () => PARAM_VALUE),
-        ),
-    };
-  });
-
-/** Overrides map that reports which key an accessor looked up. */
-function keyProbe(): Partial<Record<string, string>> {
-  return new Proxy(
-    {},
-    {
-      get: (_target, property) =>
-        typeof property === "string" ? `<<${property}>>` : undefined,
-    },
-  ) as Partial<Record<string, string>>;
-}
-
-function lookedUpKey(accessor: Accessor): string {
-  const probed = accessor.call(new UseSmileIDLocalizations(keyProbe()));
-  const match = /^<<(.+)>>$/.exec(probed);
-  if (!match?.[1]) {
-    throw new Error(
-      `${accessor.name} did not resolve through the overrides map (got ${probed})`,
-    );
-  }
-  return match[1];
-}
-
-describe("UseSmileIDLocalizations — accessor surface", () => {
-  it("exposes an accessor for every localized string", () => {
-    expect(accessors.length).toBeGreaterThan(100);
-  });
-
-  it.each(accessors.map((accessor) => [accessor.name, accessor] as const))(
-    "%s reads its own si_ key and defaults to the English string",
-    (_name, accessor) => {
-      const key = lookedUpKey(accessor);
-
-      expect(key).toMatch(/^si_/);
-      expect(enStrings).toHaveProperty(key);
-
-      const english = (enStrings as Record<string, string>)[key] as string;
-      const actual = accessor.call(new UseSmileIDLocalizations());
-      const expected =
-        accessor.arity === 0
-          ? english
-          : english.replace(
-              /\{[A-Za-z_][A-Za-z0-9_]*\}/g,
-              `\u2068${PARAM_VALUE}\u2069`,
-            );
-
-      expect(actual).toBe(expected);
-    },
-  );
-
-  it("maps each accessor to a distinct key — no copy-paste collisions", () => {
-    const keys = accessors.map(lookedUpKey);
-
-    expect(new Set(keys).size).toBe(keys.length);
-  });
-
-  it("leaves no canonical string unreachable through the public surface", () => {
-    const reached = new Set(accessors.map(lookedUpKey));
-    const orphans = Object.keys(enStrings).filter((key) => !reached.has(key));
-
-    expect(orphans).toEqual([]);
-  });
-
-  it("substitutes named tokens only in the parameterized accessors", () => {
-    const parameterized = accessors.filter((accessor) => accessor.arity > 0);
-    expect(parameterized.length).toBeGreaterThan(0);
-
-    for (const accessor of parameterized) {
-      const rendered = accessor.call(new UseSmileIDLocalizations());
-      expect(rendered).toContain(PARAM_VALUE);
-      expect(rendered).not.toMatch(/\{[A-Za-z_][A-Za-z0-9_]*\}/);
-    }
-  });
-});
-
-describe("UseSmileIDLocalizations — locale registry", () => {
-  const originalResolver = UseSmileIDLocalizations.localeResolver;
-
-  beforeEach(() => {
-    UseSmileIDLocalizations.clearRegistry();
-  });
-
-  afterEach(() => {
-    UseSmileIDLocalizations.clearRegistry();
-    UseSmileIDLocalizations.localeResolver = originalResolver;
-  });
-
-  it("reports an empty registry until a locale is registered", () => {
-    expect(UseSmileIDLocalizations.hasRegisteredLocales()).toBe(false);
-
-    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
-
-    expect(UseSmileIDLocalizations.hasRegisteredLocales()).toBe(true);
-  });
-
-  it("clearRegistry empties it again", () => {
-    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
-    UseSmileIDLocalizations.clearRegistry();
-
-    expect(UseSmileIDLocalizations.hasRegisteredLocales()).toBe(false);
-  });
-
-  it("strips ARB metadata and non-string values on register", () => {
-    UseSmileIDLocalizations.register("fr", {
-      "@@locale": "fr",
-      "@si_consent_allow": { description: "Allow" },
-      si_consent_allow: "Autoriser",
-      si_consent_deny: 42,
-    });
-    UseSmileIDLocalizations.localeResolver = () => "fr";
-
-    const resolved = UseSmileIDLocalizations.forActiveLocale();
-
-    expect(resolved.siConsentAllow).toBe("Autoriser");
-    expect(resolved.siConsentDeny).toBe("Deny");
-  });
-
-  it("re-registering a locale replaces the prior translations", () => {
-    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Ancien" });
-    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
-    UseSmileIDLocalizations.localeResolver = () => "fr";
-
-    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
-      "Autoriser",
-    );
-  });
-
-  it("prefers an exact locale match over the language-only entry", () => {
-    UseSmileIDLocalizations.register("pt", { si_consent_allow: "Permitir" });
-    UseSmileIDLocalizations.register("pt-BR", {
-      si_consent_allow: "Permitir (BR)",
-    });
-    UseSmileIDLocalizations.localeResolver = () => "pt-BR";
-
-    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
-      "Permitir (BR)",
-    );
-  });
-
-  it("falls back to the language subtag when the region variant is unregistered", () => {
-    UseSmileIDLocalizations.register("pt", { si_consent_allow: "Permitir" });
-    UseSmileIDLocalizations.localeResolver = () => "pt-BR";
-
-    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
-      "Permitir",
-    );
-  });
-
-  it("falls back to English when neither the locale nor its language is registered", () => {
-    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
-    UseSmileIDLocalizations.localeResolver = () => "sw-KE";
-
-    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
-      "Allow",
-    );
-  });
-
-  it("falls back to English when the registry is empty", () => {
-    UseSmileIDLocalizations.localeResolver = () => "fr";
-
-    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
-      "Allow",
-    );
-  });
-
-  it("resolves the device language subtag by default", () => {
-    const language = UseSmileIDLocalizations.localeResolver();
-
-    expect(language).toMatch(/^[a-z]{2,3}$/);
-    expect(language).not.toContain("-");
-  });
-
-  it("falls back to English when Intl is unavailable", () => {
-    const originalIntl = globalThis.Intl;
-    // Concrete scenario: a JS engine (or a locked-down Hermes build)
-    // without full-ICU — the resolver must not throw at flow mount.
-    (globalThis as { Intl?: unknown }).Intl = undefined;
-    try {
-      expect(originalResolver()).toBe("en");
-    } finally {
-      globalThis.Intl = originalIntl;
-    }
-  });
-});