@magicvr/schema-ui-lib 0.1.2 → 0.1.3

package/i18n/money.d.ts

@@ -12,7 +12,7 @@
  *   (amount in minor units); unparsable input → null (callers show a
  *   localized input error and must NOT submit the raw string).
  */
-import { type Locale } from "./locale";
+import { type Locale } from "./locale.js";
 /** Site/machine default currency (ISO 4217). */
 export declare const DEFAULT_CURRENCY = "USD";
 /** Default minor-unit exponent per currency group (ISO 4217 minor units). */

package/i18n/money.js

@@ -0,0 +1,187 @@
+/**
+ * Money / number pure-logic unit (workspace-020 · R3 · C1/C2/C3/C5).
+ *
+ * Contract GOAL-002 D-001 §3 / §4.3 (user-confirmed I-002, 2026-08-26):
+ * - Display + input semantics live on the frontend; API stays a machine
+ *   contract (amounts = int64 JSON in the smallest currency unit).
+ * - No custom format templates: symbols / positions / fraction digits are
+ *   derived from `Intl.NumberFormat` (locale + currency).
+ * - Embedded default currency map (§4.3): zh-CN → CNY, en-US → USD,
+ *   unknown locale → USD. Missing configuration never throws.
+ * - Input parsing normalizes localized strings back to machine values
+ *   (amount in minor units); unparsable input → null (callers show a
+ *   localized input error and must NOT submit the raw string).
+ */
+import { SUPPORTED_LOCALES } from "./locale.js";
+/** Site/machine default currency (ISO 4217). */
+export const DEFAULT_CURRENCY = "USD";
+/** Default minor-unit exponent per currency group (ISO 4217 minor units). */
+export const DEFAULT_MINOR_UNITS = 2;
+/** Currency codes frozen in the contract's embedded default map (§4.3). */
+const DEFAULT_CURRENCY_MAP = {
+    "zh-CN": "CNY",
+    "en-US": "USD",
+};
+/** Uppercase three-letter ISO 4217 code; null for anything else. */
+export function normalizeCurrencyCode(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    const trimmed = raw.trim();
+    return /^[A-Za-z]{3}$/.test(trimmed) ? trimmed.toUpperCase() : null;
+}
+/**
+ * Embedded default currency for a locale (§4.3). Unknown locales fall back to
+ * USD; never throws.
+ */
+export function defaultCurrencyFor(locale) {
+    const key = SUPPORTED_LOCALES.includes(locale)
+        ? locale
+        : null;
+    return key === null ? DEFAULT_CURRENCY : DEFAULT_CURRENCY_MAP[key];
+}
+/**
+ * Effective default currency: the explicit site default (branding
+ * `defaultCurrency`, ISO 4217) wins when set; otherwise the embedded
+ * per-locale map (§4.3) applies. Never throws.
+ */
+export function resolveEffectiveCurrency(locale, siteDefault) {
+    const site = normalizeCurrencyCode(siteDefault);
+    return site !== null ? site : defaultCurrencyFor(locale);
+}
+export function localeSeparators(locale) {
+    let group = ",";
+    let decimal = ".";
+    try {
+        for (const part of new Intl.NumberFormat(locale).formatToParts(1234567.89)) {
+            if (part.type === "group") {
+                group = part.value;
+            }
+            else if (part.type === "decimal") {
+                decimal = part.value;
+            }
+        }
+    }
+    catch {
+        // Unsupported locale edge — keep the en-US-ish defaults.
+    }
+    return { group, decimal };
+}
+/** Priority: explicit option → site default → embedded per-locale map. */
+function resolveCurrency(locale, options) {
+    if (options.currency !== undefined) {
+        return normalizeCurrencyCode(options.currency);
+    }
+    return normalizeCurrencyCode(options.siteDefaultCurrency) ?? defaultCurrencyFor(locale);
+}
+/**
+ * Formats an amount given as machine value (minor units) into a
+ * locale+currency display string. Invalid input renders "" (fail-safe).
+ * R4 F-007: values beyond Number.MAX_SAFE_INTEGER render "" — the machine
+ * contract declares int64 minor units, which JS number cannot carry.
+ */
+export function formatMoney(minorValue, locale, options = {}) {
+    if (typeof minorValue !== "number" || !Number.isFinite(minorValue) || !Number.isSafeInteger(minorValue)) {
+        return "";
+    }
+    const currency = resolveCurrency(locale, options);
+    if (currency === null) {
+        return "";
+    }
+    const minorUnits = Number.isInteger(options.minorUnits) && options.minorUnits >= 0
+        ? options.minorUnits
+        : DEFAULT_MINOR_UNITS;
+    const major = minorValue / Math.pow(10, minorUnits);
+    try {
+        return new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency,
+            minimumFractionDigits: minorUnits,
+            maximumFractionDigits: minorUnits,
+        }).format(major);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Weakly parses a localized number (separators stripped) into a plain number.
+ * Returns null for anything without a parseable numeric core.
+ */
+function parseLocalizedNumberCore(raw, locale) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    const trimmed = raw.trim();
+    if (trimmed === "") {
+        return null;
+    }
+    const { group, decimal } = localeSeparators(locale);
+    let core = trimmed;
+    if (group !== "") {
+        // Strip the locale grouping separator wherever it appears. NOTE: group
+        // position correctness (e.g. "12,34.5") is intentionally NOT validated —
+        // out of the R3 verification scope (tolerance documented for R4 review).
+        core = core.split(group).join("");
+    }
+    if (decimal !== ".") {
+        core = core.split(decimal).join(".");
+    }
+    if ((core.match(/\./g) ?? []).length > 1) {
+        return null; // more than one decimal separator → not a number
+    }
+    if (!/^-?\d+(\.\d+)?$/.test(core)) {
+        return null;
+    }
+    const value = Number(core);
+    return Number.isFinite(value) ? value : null;
+}
+/** Strips a locale+currency symbol (e.g. "¥", "$", "CN¥") and the code itself. */
+function stripCurrencyAffixes(raw, locale, currency) {
+    let out = raw.trim();
+    try {
+        const parts = new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency,
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2,
+        }).formatToParts(1.23);
+        const symbol = parts.find((part) => part.type === "currency")?.value;
+        if (symbol !== undefined && symbol !== "") {
+            out = out.split(symbol).join("");
+        }
+    }
+    catch {
+        // Fall through with the raw string.
+    }
+    // Also tolerate the bare ISO code (e.g. "CNY 123.45").
+    return out.split(currency).join("").trim();
+}
+/**
+ * Parses a localized money string into the machine value (minor-unit
+ * integer per contract §3.3). Returns null when the input is not a
+ * parseable amount — callers must NOT submit the raw string.
+ */
+export function parseLocalizedMoney(raw, locale, options = {}) {
+    const currency = resolveCurrency(locale, options);
+    if (currency === null) {
+        return null;
+    }
+    const cleaned = stripCurrencyAffixes(raw, locale, currency);
+    const value = parseLocalizedNumberCore(cleaned, locale);
+    if (value === null) {
+        return null;
+    }
+    const minorUnits = Number.isInteger(options.minorUnits) && options.minorUnits >= 0
+        ? options.minorUnits
+        : DEFAULT_MINOR_UNITS;
+    const minor = Math.round(value * Math.pow(10, minorUnits));
+    // R4 F-007: the machine contract declares int64 minor units; JS number
+    // cannot represent values beyond MAX_SAFE_INTEGER — reject instead of
+    // silently losing precision.
+    return Number.isSafeInteger(minor) ? minor : null;
+}
+/** Parses a localized plain number into a machine number; null on failure. */
+export function parseLocalizedNumber(raw, locale) {
+    return parseLocalizedNumberCore(raw, locale);
+}

package/i18n/runtime.d.ts

@@ -9,9 +9,9 @@
  * - Exposes `t` / `formatDate` / `formatNumber` to components.
  */
 import { type ReactNode } from "react";
-import { type MessageParams } from "./catalog";
-import { type Locale, type LocalePreference } from "./locale";
-import { type TimezonePreference } from "./timezone";
+import { type MessageParams } from "./catalog.js";
+import { type Locale, type LocalePreference } from "./locale.js";
+import { type TimezonePreference } from "./timezone.js";
 export declare const LOCALE_STORAGE_KEY = "schema-ui:locale";
 export declare function readStoredLocale(): string | null;
 export declare function writeStoredLocale(preference: LocalePreference): void;

package/i18n/runtime.js

@@ -0,0 +1,184 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * I18n React runtime (S1 · C4/C5).
+ *
+ * - Resolves the effective locale via `resolveLocale` (frozen priority).
+ * - Persists the user's explicit choice in localStorage["schema-ui:locale"]
+ *   (single channel, same pattern as the theme mechanism; login/logout never
+ *   clears it — D-002 §I-L10N-002).
+ * - Applies `document.documentElement.lang` on locale change.
+ * - Exposes `t` / `formatDate` / `formatNumber` to components.
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from "react";
+import { createTranslator } from "./catalog.js";
+import { formatDate as formatDateImpl, formatNumber as formatNumberImpl } from "./format.js";
+import { defaultBrowserLanguages, DEFAULT_LOCALE, normalizePreference, resolveLocale, } from "./locale.js";
+import { AUTO_TIMEZONE, detectBrowserTimezone, normalizeTimezonePreference, readStoredTimezone, resolveEffectiveTimezone, writeStoredTimezone, } from "./timezone.js";
+export const LOCALE_STORAGE_KEY = "schema-ui:locale";
+export function readStoredLocale() {
+    try {
+        if (typeof localStorage === "undefined") {
+            return null;
+        }
+        return localStorage.getItem(LOCALE_STORAGE_KEY);
+    }
+    catch {
+        // Privacy mode / disabled storage throws SecurityError — same posture as
+        // tokens.ts / theme.ts. Never let locale boot white-screen the tree.
+        return null;
+    }
+}
+export function writeStoredLocale(preference) {
+    try {
+        if (typeof localStorage === "undefined") {
+            return;
+        }
+        if (preference === "auto") {
+            localStorage.removeItem(LOCALE_STORAGE_KEY);
+        }
+        else {
+            localStorage.setItem(LOCALE_STORAGE_KEY, preference);
+        }
+    }
+    catch {
+        // Best-effort persist; the in-memory preference still applies this page.
+    }
+}
+/** Applies the effective locale to <html lang>. No-op outside a browser. */
+export function applyLocaleToDocument(locale) {
+    if (typeof document !== "undefined") {
+        document.documentElement.lang = locale;
+    }
+}
+// ── active-locale registry ────────────────────────────────────────────────────
+// Module-level current locale for non-React consumers (API fetchers attach it
+// as Accept-Language so the server negotiates the same language — VP-007 S4).
+let activeLocale = "en-US";
+/** Returns the provider's currently effective locale (defaults en-US). */
+export function getActiveLocale() {
+    return activeLocale;
+}
+/** Internal: keeps the registry in sync with the provider's effective locale. */
+export function setActiveLocale(locale) {
+    activeLocale = locale;
+}
+const I18nContext = createContext(null);
+export function I18nProvider({ children, systemDefault = null, stored, browserLanguages, siteTimezone = null, storedTimezone, detectTimezone, siteDefaultCurrency = null, systemDefaultUrl, }) {
+    const [preference, setPreferenceState] = useState(() => {
+        const raw = stored !== undefined ? stored : readStoredLocale();
+        return normalizePreference(raw);
+    });
+    const [fetchedSystemDefault, setFetchedSystemDefault] = useState(null);
+    const [fetchedSiteTimezone, setFetchedSiteTimezone] = useState(null);
+    const [fetchedSiteDefaultCurrency, setFetchedSiteDefaultCurrency] = useState(null);
+    const [timezonePreference, setTimezonePreferenceState] = useState(() => {
+        const raw = storedTimezone !== undefined ? storedTimezone : readStoredTimezone();
+        return normalizeTimezonePreference(raw);
+    });
+    const browserList = browserLanguages !== undefined ? browserLanguages : defaultBrowserLanguages();
+    useEffect(() => {
+        if (systemDefaultUrl === undefined) {
+            return;
+        }
+        let cancelled = false;
+        fetch(systemDefaultUrl)
+            .then((response) => (response.ok ? response.json() : null))
+            .then((body) => {
+            if (cancelled) {
+                return;
+            }
+            const record = body;
+            const locale = typeof record?.defaultLocale === "string" ? record.defaultLocale : null;
+            setFetchedSystemDefault(locale === "auto" ? null : locale);
+            const zone = typeof record?.siteTimezone === "string" ? record.siteTimezone : null;
+            setFetchedSiteTimezone(zone === "auto" ? null : zone);
+            const currency = typeof record?.defaultCurrency === "string" ? record.defaultCurrency.trim().toUpperCase() : null;
+            setFetchedSiteDefaultCurrency(currency === "" || currency === null ? null : currency);
+        })
+            .catch(() => {
+            if (!cancelled) {
+                setFetchedSystemDefault(null);
+                setFetchedSiteTimezone(null);
+                setFetchedSiteDefaultCurrency(null);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [systemDefaultUrl]);
+    const effectiveSystemDefault = systemDefault ?? fetchedSystemDefault;
+    const effectiveSiteTimezone = siteTimezone ?? fetchedSiteTimezone;
+    const effectiveSiteDefaultCurrency = siteDefaultCurrency ?? fetchedSiteDefaultCurrency;
+    const locale = useMemo(() => resolveLocale({
+        stored: preference === "auto" ? null : preference,
+        systemDefault: effectiveSystemDefault,
+        browserLanguages: browserList,
+    }), [preference, effectiveSystemDefault, browserList]);
+    const timezone = useMemo(() => resolveEffectiveTimezone({
+        stored: timezonePreference === AUTO_TIMEZONE ? null : timezonePreference,
+        siteDefault: effectiveSiteTimezone,
+        detect: detectTimezone ?? detectBrowserTimezone,
+    }), [timezonePreference, effectiveSiteTimezone, detectTimezone]);
+    useEffect(() => {
+        applyLocaleToDocument(locale);
+        setActiveLocale(locale);
+    }, [locale]);
+    const setPreference = useCallback((next) => {
+        writeStoredLocale(next);
+        setPreferenceState(next);
+    }, []);
+    const setTimezonePreference = useCallback((next) => {
+        writeStoredTimezone(next);
+        setTimezonePreferenceState(next);
+    }, []);
+    const t = useMemo(() => createTranslator(locale), [locale]);
+    const formatDate = useCallback((value, options = {}) => {
+        const requested = options.timeZone !== undefined && options.timeZone !== "" ? options.timeZone : null;
+        const zone = requested ?? (timezone === AUTO_TIMEZONE ? null : timezone);
+        return formatDateImpl(value, locale, zone === null ? {} : { timeZone: zone });
+    }, [locale, timezone]);
+    const formatNumber = useCallback((value, options) => formatNumberImpl(value, locale, options), [locale]);
+    const value = useMemo(() => ({
+        locale,
+        preference,
+        setPreference,
+        timezone,
+        timezonePreference,
+        setTimezonePreference,
+        defaultCurrency: effectiveSiteDefaultCurrency ?? "",
+        t,
+        formatDate,
+        formatNumber,
+    }), [
+        locale,
+        preference,
+        setPreference,
+        timezone,
+        timezonePreference,
+        setTimezonePreference,
+        effectiveSiteDefaultCurrency,
+        t,
+        formatDate,
+        formatNumber,
+    ]);
+    return _jsx(I18nContext.Provider, { value: value, children: children });
+}
+export function useI18n() {
+    const value = useContext(I18nContext);
+    if (value === null) {
+        throw new Error("useI18n must be used within an I18nProvider");
+    }
+    return value;
+}
+/**
+ * Tolerant translator hook for deep renderer internals.
+ *
+ * Returns the provider's translator, or a safe default (en-US resolution +
+ * missing-key observable fallback) when no provider is mounted. Production
+ * always mounts I18nProvider; bare component tests and pre-provider surfaces
+ * degrade to the documented safe fallback instead of throwing.
+ */
+export function useTranslate() {
+    const value = useContext(I18nContext);
+    return useMemo(() => value?.t ?? createTranslator(DEFAULT_LOCALE), [value]);
+}

package/i18n/timezone.js

@@ -0,0 +1,117 @@
+/**
+ * Timezone pure-logic unit (workspace-020 · R2 · C1).
+ *
+ * `resolveEffectiveTimezone` computes the effective timezone from the user's
+ * explicit override, the session probe, and the site default, per contract
+ * GOAL-002 D-001 §2 (user-confirmed I-001, 2026-08-26):
+ *
+ *   L1 user override (localStorage "schema-ui:timezone") → L2 session probe
+ *   (Intl) → L3 site default (siteTimezone) → L4 "auto" fallback
+ *
+ * Keeping the decision logic in plain functions lets vitest exercise every
+ * branch; the probe is injectable so tests do not depend on the host zone.
+ */
+export const TIMEZONE_STORAGE_KEY = "schema-ui:timezone";
+export const AUTO_TIMEZONE = "auto";
+/**
+ * Validates an IANA timezone name via Intl (RangeError on invalid names).
+ * Side-effect-free apart from the noexcept Intl probe; returns false for
+ * empty / non-string / unknown zones instead of throwing.
+ */
+export function isValidIanaTimeZone(raw) {
+    if (typeof raw !== "string") {
+        return false;
+    }
+    const trimmed = raw.trim();
+    if (trimmed === "") {
+        return false;
+    }
+    try {
+        // The format call itself never renders; constructing with the option is
+        // the validation probe (RangeError for unknown "Foo/Bar" style names).
+        new Intl.DateTimeFormat("en-US", { timeZone: trimmed });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Normalizes a raw stored/site value into a TimezonePreference.
+ * Any value that is not a valid IANA name resolves to "auto".
+ */
+export function normalizeTimezonePreference(raw) {
+    if (typeof raw !== "string") {
+        return AUTO_TIMEZONE;
+    }
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed.toLowerCase() === AUTO_TIMEZONE) {
+        return AUTO_TIMEZONE;
+    }
+    return isValidIanaTimeZone(trimmed) ? trimmed : AUTO_TIMEZONE;
+}
+/** Reads the stored user override; best-effort (privacy mode → null). */
+export function readStoredTimezone() {
+    try {
+        if (typeof localStorage === "undefined") {
+            return null;
+        }
+        return localStorage.getItem(TIMEZONE_STORAGE_KEY);
+    }
+    catch {
+        return null;
+    }
+}
+/** Persists the user override; "auto" removes the key (single channel). */
+export function writeStoredTimezone(preference) {
+    try {
+        if (typeof localStorage === "undefined") {
+            return;
+        }
+        if (preference === AUTO_TIMEZONE) {
+            localStorage.removeItem(TIMEZONE_STORAGE_KEY);
+        }
+        else {
+            localStorage.setItem(TIMEZONE_STORAGE_KEY, preference);
+        }
+    }
+    catch {
+        // Best-effort persist; the in-memory preference still applies this page.
+    }
+}
+/** Real session probe: the host zone from Intl.resolvedOptions(). */
+export function detectBrowserTimezone() {
+    try {
+        const zone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+        return typeof zone === "string" ? zone : "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Resolves the effective timezone per contract §2 (L1 → L2 → L3 → L4).
+ * Returns an IANA name, or "auto" when nothing is configured/detectable —
+ * consumers then fall back to the locale's default zone.
+ */
+export function resolveEffectiveTimezone(input) {
+    const stored = normalizeTimezonePreference(input.stored);
+    if (stored !== AUTO_TIMEZONE) {
+        return stored; // L1 · user override wins
+    }
+    let detected = "";
+    try {
+        detected = String(input.detect() ?? "");
+    }
+    catch {
+        detected = "";
+    }
+    if (isValidIanaTimeZone(detected)) {
+        return detected; // L2 · session probe
+    }
+    const site = normalizeTimezonePreference(input.siteDefault);
+    if (site !== AUTO_TIMEZONE) {
+        return site; // L3 · site default
+    }
+    return AUTO_TIMEZONE; // L4 · embedded default
+}

package/lib/datetime.js

@@ -0,0 +1,36 @@
+/**
+ * Display-time formatting (GOAL-011 table style): ISO-8601 timestamps are
+ * rendered in a human-readable local-time form ("2026-08-01 18:02") instead
+ * of the raw wire value ("2026-08-01T18:02:44.000Z").
+ *
+ * Returns null when the value is not a renderable timestamp so callers fall
+ * back to the raw text (numbers, booleans, plain strings, arbitrary dates
+ * with other shapes stay untouched).
+ */
+/** Matches the ISO-8601 timestamps shipped by the API (UTC Z or ±hh:mm). */
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}
+/**
+ * Formats an ISO-8601 timestamp string to local "YYYY-MM-DD HH:mm". Returns
+ * null for non-timestamp values, malformed dates, or non-string input.
+ */
+export function formatDisplayTime(value) {
+    if (typeof value !== "string" || !ISO_TIMESTAMP_PATTERN.test(value)) {
+        return null;
+    }
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return null;
+    }
+    return (date.getFullYear() +
+        "-" +
+        pad2(date.getMonth() + 1) +
+        "-" +
+        pad2(date.getDate()) +
+        " " +
+        pad2(date.getHours()) +
+        ":" +
+        pad2(date.getMinutes()));
+}

package/lib/fetch-timeout.js

@@ -0,0 +1,43 @@
+/**
+ * W10 F-002: fetch timeout wrapper.
+ *
+ * Wraps a fetch implementation so a hung request (slow network, stalled
+ * server) aborts after a bounded window instead of pending forever. The
+ * returned function is drop-in compatible with `typeof fetch`; a caller-
+ * provided AbortSignal in `init` is composed with the timeout signal (either
+ * firing aborts the request). Timers are cleared once the request settles, so
+ * no handles leak on the happy path.
+ */
+/** Default ceiling for a single request (30s). */
+export const DEFAULT_FETCH_TIMEOUT_MS = 30_000;
+export function withTimeout(fetchImpl, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    return async function fetchWithTimeout(input, init) {
+        // Resolved per call (not at wrap time) so a later global fetch stub —
+        // test doubles, service workers — is always honored.
+        const doFetch = fetchImpl ?? globalThis.fetch;
+        // RequestInit.signal is `AbortSignal | null | undefined`; normalize to
+        // undefined so the guards below stay simple.
+        const outer = init?.signal ?? undefined;
+        // An already-aborted caller signal must fail fast without touching the
+        // network (no fetch call, no timer).
+        if (outer?.aborted === true) {
+            throw new DOMException("The operation was aborted.", "AbortError");
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        // Relay the caller signal onto our controller; the relay listener is
+        // removed once the request settles so a long-lived shared signal does not
+        // accumulate listeners across calls (A-003 recommended F-002).
+        const relayAbort = () => controller.abort();
+        if (outer !== undefined) {
+            outer.addEventListener("abort", relayAbort, { once: true });
+        }
+        try {
+            return await doFetch(input, { ...init, signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timer);
+            outer?.removeEventListener("abort", relayAbort);
+        }
+    };
+}

package/lib/index.d.ts

@@ -1,12 +1,12 @@
 /**
  * @schema-ui/lib 聚合导出（R3 六包化）：通用工具 + i18n 运行时面。
  */
-export * from "./datetime";
-export * from "./fetch-timeout";
-export * from "./utils";
-export * from "../i18n/runtime";
-export * from "../i18n/catalog";
-export type * from "../i18n/locale";
-export * from "../i18n/format";
-export * from "../i18n/money";
-export * from "../i18n/timezone";
+export * from "./datetime.js";
+export * from "./fetch-timeout.js";
+export * from "./utils.js";
+export * from "../i18n/runtime.js";
+export * from "../i18n/catalog.js";
+export type * from "../i18n/locale.js";
+export * from "../i18n/format.js";
+export * from "../i18n/money.js";
+export * from "../i18n/timezone.js";

package/lib/index.js

@@ -0,0 +1,11 @@
+/**
+ * @magicvr/schema-ui-lib 聚合导出（R3 六包化）：通用工具 + i18n 运行时面。
+ */
+export * from "./datetime.js";
+export * from "./fetch-timeout.js";
+export * from "./utils.js";
+export * from "../i18n/runtime.js";
+export * from "../i18n/catalog.js";
+export * from "../i18n/format.js";
+export * from "../i18n/money.js";
+export * from "../i18n/timezone.js";

package/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@magicvr/schema-ui-lib",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
-  "description": "schema-ui-core 包面（VP-023 R3 六包化）",
-  "main": "index.js",
-  "types": "./lib/index.d.ts",
+  "description": "schema-ui-core 包面（lib）",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib/index.d.ts",
+      "types": "lib/index.d.ts",
       "import": "./index.js"
     },
     "./*": "./*"