npm - @magicvr/schema-ui-ui - Versions diffs - 0.1.1 → 0.1.3 - Mend

@magicvr/schema-ui-ui 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/components/data-table.js +156 -0
package/components/ui/async-state.js +29 -0
package/components/ui/badge.js +21 -0
package/components/ui/breadcrumbs.js +126 -0
package/components/ui/button.js +30 -0
package/components/ui/card.js +16 -0
package/components/ui/index.d.ts +10 -10
package/components/ui/index.js +13 -0
package/components/ui/input.js +8 -0
package/components/ui/label.js +6 -0
package/components/ui/skeleton.js +6 -0
package/components/ui/textarea.js +8 -0
package/i18n/catalog.d.ts +1 -1
package/i18n/catalog.js +96 -0
package/i18n/format.d.ts +1 -1
package/i18n/format.js +35 -0
package/i18n/locale.js +79 -0
package/i18n/messages/en-US.json +954 -0
package/i18n/messages/zh-CN.json +954 -0
package/i18n/runtime.d.ts +3 -3
package/i18n/runtime.js +184 -0
package/i18n/timezone.js +117 -0
package/lib/datetime.js +36 -0
package/lib/utils.js +5 -0
package/package.json +5 -5
package/index.js +0 -6223

package/i18n/runtime.d.ts CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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/utils.js ADDED Viewed

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

package/package.json CHANGED Viewed

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