@azmr/ui 0.1.0 → 0.2.0

package/dist/presets.js

@@ -0,0 +1,94 @@
+import {
+  motionPresets
+} from "./chunk-GLB75NT3.js";
+import {
+  cn
+} from "./chunk-7EOSDFS3.js";
+
+// src/motion/presets/animated-check.tsx
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var AnimatedCheck = forwardRef(function AnimatedCheck2({ size = 24, label, className, ...props }, ref) {
+  return (
+    // biome-ignore lint/a11y/noSvgWithoutTitle: decorative (aria-hidden) by default, or role="img" with an aria-label when `label` is set
+    /* @__PURE__ */ jsx(
+      "svg",
+      {
+        ref,
+        viewBox: "0 0 24 24",
+        width: size,
+        height: size,
+        fill: "none",
+        className: cn(motionPresets.checkDraw, className),
+        ...label ? { role: "img", "aria-label": label } : { "aria-hidden": true },
+        ...props,
+        children: /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: "M5 13l4 4L19 7",
+            pathLength: 24,
+            stroke: "currentColor",
+            strokeWidth: 2,
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          }
+        )
+      }
+    )
+  );
+});
+
+// src/motion/presets/collapse.tsx
+import { forwardRef as forwardRef2, version } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function inertProps(reactVersion = version) {
+  const major = Number.parseInt(reactVersion, 10);
+  return major < 19 ? { inert: "" } : { inert: true };
+}
+var Collapse = forwardRef2(function Collapse2({ open, className, children, ...props }, ref) {
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      ref,
+      "data-state": open ? "open" : "closed",
+      ...open ? {} : { ...inertProps(), "aria-hidden": true },
+      className: cn(motionPresets.collapse.root, className),
+      ...props,
+      children: /* @__PURE__ */ jsx2("div", { className: motionPresets.collapse.inner, children })
+    }
+  );
+});
+
+// src/motion/presets/stagger.tsx
+import {
+  Children,
+  cloneElement,
+  createElement,
+  isValidElement
+} from "react";
+function Stagger({ as = "div", max = 12, className, children, ...props }) {
+  let index = 0;
+  const items = Children.toArray(children).map((child) => {
+    if (!isValidElement(child)) return child;
+    const element = child;
+    const style = {
+      ...element.props.style,
+      "--stagger-index": Math.min(index++, max)
+    };
+    return cloneElement(element, {
+      className: cn(element.props.className, motionPresets.stagger.item),
+      style
+    });
+  });
+  return createElement(
+    as,
+    { className: cn(motionPresets.stagger.container, className), ...props },
+    items
+  );
+}
+export {
+  AnimatedCheck,
+  Collapse,
+  Stagger,
+  motionPresets
+};

package/dist/progress.d.ts

@@ -0,0 +1,70 @@
+import { ForwardRefExoticComponent, ComponentPropsWithoutRef, RefAttributes } from 'react';
+import { Progress as Progress$1 } from '@base-ui/react/progress';
+
+/**
+ * The indicator colour per tone. `token` names the design token the colour comes from; a test
+ * checks it has 3:1 contrast against both the track and the page in light and dark. Warning uses
+ * `warning-text`, not the yellow `warning` surface colour, which is far too faint on a light track.
+ */
+declare const progressTones: {
+    readonly default: {
+        readonly token: "primary";
+        readonly indicator: "bg-primary";
+        readonly ring: "text-primary";
+    };
+    readonly success: {
+        readonly token: "success";
+        readonly indicator: "bg-success";
+        readonly ring: "text-success";
+    };
+    readonly warning: {
+        readonly token: "warning-text";
+        readonly indicator: "bg-warning-text";
+        readonly ring: "text-warning-text";
+    };
+    readonly destructive: {
+        readonly token: "destructive";
+        readonly indicator: "bg-destructive";
+        readonly ring: "text-destructive";
+    };
+    readonly info: {
+        readonly token: "info";
+        readonly indicator: "bg-info";
+        readonly ring: "text-info";
+    };
+};
+type ProgressTone = keyof typeof progressTones;
+declare const LINEAR_HEIGHT: {
+    readonly sm: "h-1.5";
+    readonly md: "h-2";
+    readonly lg: "h-3";
+};
+interface ProgressOwnProps {
+    /** The current value, or `null` when the amount is not known (indeterminate). Default range is 0 to 100. */
+    value: number | null;
+    min?: number;
+    max?: number;
+    /** `linear` (default) is a bar; `circular` is a ring. */
+    variant?: "linear" | "circular";
+    size?: keyof typeof LINEAR_HEIGHT;
+    tone?: ProgressTone;
+    /** Show the percentage as text next to (linear) or inside (circular) the indicator. */
+    showValue?: boolean;
+    /** The text a screen reader announces, instead of the default percentage. */
+    valueText?: (value: number | null) => string;
+    className?: string;
+}
+/** A progress bar needs a name: a label, or the id of the heading that describes it. */
+type Named = {
+    "aria-label": string;
+} | {
+    "aria-labelledby": string;
+};
+type ProgressProps = ProgressOwnProps & Named & Omit<ComponentPropsWithoutRef<typeof Progress$1.Root>, keyof ProgressOwnProps | "aria-label" | "aria-labelledby" | "getAriaValueText" | "children">;
+/**
+ * A linear or circular progress indicator with a required accessible name. `value={null}` is
+ * indeterminate. Built on Base UI, so the progressbar semantics and `aria-valuenow` are native.
+ */
+declare const Progress: ForwardRefExoticComponent<ProgressProps & RefAttributes<HTMLDivElement>>;
+
+export { Progress, type ProgressOwnProps, type ProgressProps, type ProgressTone, progressTones };

package/dist/progress.js

@@ -0,0 +1,138 @@
+"use client";
+import {
+  cn
+} from "./chunk-2TQSHVXA.js";
+
+// src/components/progress/progress.tsx
+import {
+  forwardRef
+} from "react";
+
+// src/primitives/progress.ts
+import { Progress } from "@base-ui/react/progress";
+
+// src/components/progress/progress.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var progressTones = {
+  default: { token: "primary", indicator: "bg-primary", ring: "text-primary" },
+  success: { token: "success", indicator: "bg-success", ring: "text-success" },
+  warning: { token: "warning-text", indicator: "bg-warning-text", ring: "text-warning-text" },
+  destructive: { token: "destructive", indicator: "bg-destructive", ring: "text-destructive" },
+  info: { token: "info", indicator: "bg-info", ring: "text-info" }
+};
+var LINEAR_HEIGHT = { sm: "h-1.5", md: "h-2", lg: "h-3" };
+var CIRCULAR_SIZE = { sm: "size-6", md: "size-10", lg: "size-16" };
+var RADIUS = 16;
+var CIRCUMFERENCE = Number((2 * Math.PI * RADIUS).toFixed(2));
+var ProgressImpl = forwardRef(function Progress2({
+  value,
+  min = 0,
+  max = 100,
+  variant = "linear",
+  size = "md",
+  tone = "default",
+  showValue = false,
+  valueText,
+  className,
+  ...props
+}, ref) {
+  const current = value === null || !Number.isFinite(value) ? null : Math.min(max, Math.max(min, value));
+  const indeterminate = current === null;
+  const percent = indeterminate ? 0 : (current - min) / (max - min || 1) * 100;
+  const palette = progressTones[tone];
+  const text = indeterminate ? "" : `${Math.round(percent)}%`;
+  const root = {
+    ref,
+    value: current,
+    min,
+    max,
+    getAriaValueText: valueText ? (_formatted, v) => valueText(v) : void 0,
+    ...props
+  };
+  if (variant === "circular") {
+    const filled = Number((CIRCUMFERENCE * (indeterminate ? 25 : percent) / 100).toFixed(2));
+    return /* @__PURE__ */ jsxs(
+      Progress.Root,
+      {
+        ...root,
+        className: cn(
+          "relative inline-flex shrink-0 items-center justify-center",
+          CIRCULAR_SIZE[size],
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsxs(
+            "svg",
+            {
+              viewBox: "0 0 36 36",
+              fill: "none",
+              "aria-hidden": "true",
+              "data-motion": indeterminate ? "essential" : void 0,
+              className: cn("size-full -rotate-90", palette.ring, indeterminate && "animate-spin"),
+              children: [
+                /* @__PURE__ */ jsx("circle", { cx: "18", cy: "18", r: RADIUS, strokeWidth: "4", className: "stroke-muted" }),
+                /* @__PURE__ */ jsx(
+                  "circle",
+                  {
+                    "data-arc": "",
+                    cx: "18",
+                    cy: "18",
+                    r: RADIUS,
+                    stroke: "currentColor",
+                    strokeWidth: "4",
+                    strokeLinecap: "round",
+                    strokeDasharray: `${filled} ${CIRCUMFERENCE}`
+                  }
+                )
+              ]
+            }
+          ),
+          showValue && !indeterminate && /* @__PURE__ */ jsx(
+            "span",
+            {
+              "data-progress-value": "",
+              "aria-hidden": "true",
+              className: "absolute text-xs font-medium tabular-nums",
+              children: text
+            }
+          )
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Progress.Root, { ...root, className: cn("flex w-full items-center gap-3", className), children: [
+    /* @__PURE__ */ jsx(
+      Progress.Track,
+      {
+        className: cn("relative w-full overflow-hidden rounded-full bg-muted", LINEAR_HEIGHT[size]),
+        children: /* @__PURE__ */ jsx(
+          Progress.Indicator,
+          {
+            "data-motion": indeterminate ? "essential" : void 0,
+            className: cn(
+              "h-full rounded-full transition-[width] duration-(--motion-duration-base) ease-standard",
+              palette.indicator,
+              // Unknown amount: a partial bar that pulses. Under reduced motion it keeps pulsing
+              // (opacity, not movement) because a still full-width bar would read as complete.
+              indeterminate && "w-2/5 animate-pulse"
+            )
+          }
+        )
+      }
+    ),
+    showValue && !indeterminate && /* @__PURE__ */ jsx(
+      "span",
+      {
+        "data-progress-value": "",
+        "aria-hidden": "true",
+        className: "min-w-10 text-right text-sm tabular-nums text-muted-foreground",
+        children: text
+      }
+    )
+  ] });
+});
+var Progress3 = ProgressImpl;
+export {
+  Progress3 as Progress,
+  progressTones
+};

package/dist/react.d.ts

@@ -0,0 +1,81 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+interface LocaleMessages {
+    close: string;
+    cancel: string;
+    confirm: string;
+    loading: string;
+    noResults: string;
+    clear: string;
+    search: string;
+    previousPage: string;
+    nextPage: string;
+}
+type WeekStart = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+interface LocaleOptions {
+    /** BCP 47 tag. Default `en-NZ`. */
+    locale?: string;
+    /** ISO 4217 code. Default `NZD`. */
+    currency?: string;
+    /** 0 = Sunday ... 6 = Saturday. Default 1 (Monday). */
+    weekStartsOn?: WeekStart;
+    /** IANA zone used to display instants. Default: the runtime's zone. */
+    timeZone?: string;
+    messages?: Partial<LocaleMessages>;
+}
+type DateInput = Date | number | string | null | undefined;
+interface Locale {
+    readonly locale: string;
+    readonly currency: string;
+    readonly weekStartsOn: WeekStart;
+    readonly timeZone: string | undefined;
+    readonly messages: LocaleMessages;
+    formatNumber(value: number | null | undefined, options?: Intl.NumberFormatOptions): string;
+    formatCurrency(value: number | null | undefined, options?: Intl.NumberFormatOptions): string;
+    /** Date-only strings (`2026-10-15`) print that calendar day in every time zone. */
+    formatDate(value: DateInput, options?: Intl.DateTimeFormatOptions): string;
+    formatDateTime(value: DateInput, options?: Intl.DateTimeFormatOptions): string;
+}
+
+type LocaleProviderProps = LocaleOptions & {
+    children: ReactNode;
+};
+/** Provide locale, currency, week start, time zone and component strings to everything below. */
+declare function LocaleProvider({ children, locale, currency, weekStartsOn, timeZone, messages, }: LocaleProviderProps): react.JSX.Element;
+declare function useLocale(): Locale;
+
+declare const THEME_PREFERENCES: readonly ["light", "dark", "system"];
+type ThemePreference = (typeof THEME_PREFERENCES)[number];
+declare const DENSITIES: readonly ["compact", "comfortable", "spacious"];
+type Density = (typeof DENSITIES)[number];
+
+interface ThemeContextValue {
+    /** The stored preference: `light`, `dark` or `system`. */
+    theme: ThemePreference;
+    /** What is actually showing: `system` resolved against the operating system. */
+    resolvedTheme: "light" | "dark";
+    setTheme: (theme: ThemePreference) => void;
+    density: Density;
+    setDensity: (density: Density) => void;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+    /** Initial preference, normally read from the cookie on the server. Default `system`. */
+    defaultTheme?: ThemePreference;
+    /** Initial density, normally read from the cookie on the server. Default `comfortable`. */
+    defaultDensity?: Density;
+    /** Remember changes in a cookie so the server can render them next time. Default true. */
+    persist?: boolean;
+    /** Element that receives `data-theme` / `data-density`. Default `<html>`. */
+    target?: HTMLElement;
+}
+/**
+ * Applies `data-theme` and `data-density` to `<html>`, tracks the operating system while the
+ * preference is `system`, and remembers changes in a cookie. The server should render the same
+ * attributes with `htmlAttributes.fromCookies(...)` so there is no flash on first paint.
+ */
+declare function ThemeProvider({ children, defaultTheme, defaultDensity, persist, target, }: ThemeProviderProps): react.JSX.Element;
+declare function useTheme(): ThemeContextValue;
+
+export { LocaleProvider, type LocaleProviderProps, type ThemeContextValue, ThemeProvider, type ThemeProviderProps, useLocale, useTheme };

package/dist/react.js

@@ -0,0 +1,281 @@
+"use client";
+
+// src/react/LocaleProvider.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// src/theme/locale.ts
+var DEFAULT_MESSAGES = Object.freeze({
+  close: "Close",
+  cancel: "Cancel",
+  confirm: "Confirm",
+  loading: "Loading",
+  noResults: "No results found",
+  clear: "Clear",
+  search: "Search",
+  previousPage: "Previous page",
+  nextPage: "Next page"
+});
+var DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+var FIELD_OPTIONS = [
+  "weekday",
+  "era",
+  "year",
+  "month",
+  "day",
+  "dayPeriod",
+  "hour",
+  "minute",
+  "second",
+  "fractionalSecondDigits",
+  "timeZoneName"
+];
+function toInstant(value) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  if (typeof value === "string") {
+    const match = DATE_ONLY.exec(value);
+    if (match) {
+      const date2 = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3])));
+      return Number.isNaN(date2.getTime()) ? void 0 : { date: date2, calendarDay: true };
+    }
+  }
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : { date, calendarDay: false };
+}
+function createLocale(options = {}) {
+  const locale = options.locale ?? "en-NZ";
+  const currency = options.currency ?? "NZD";
+  const weekStartsOn = options.weekStartsOn ?? 1;
+  const timeZone = options.timeZone;
+  try {
+    Intl.getCanonicalLocales(locale);
+  } catch {
+    throw new Error(`createLocale: invalid locale ${JSON.stringify(locale)}`);
+  }
+  if (!/^[A-Z]{3}$/.test(currency)) {
+    throw new Error(
+      `createLocale: currency must be an ISO 4217 code like "NZD", got ${JSON.stringify(currency)}`
+    );
+  }
+  if (timeZone !== void 0) {
+    try {
+      new Intl.DateTimeFormat(locale, { timeZone });
+    } catch {
+      throw new Error(`createLocale: unknown time zone ${JSON.stringify(timeZone)}`);
+    }
+  }
+  if (!Number.isInteger(weekStartsOn) || weekStartsOn < 0 || weekStartsOn > 6) {
+    throw new Error(
+      `createLocale: weekStartsOn must be an integer from 0 to 6, got ${weekStartsOn}`
+    );
+  }
+  const numberFormats = /* @__PURE__ */ new Map();
+  const dateFormats = /* @__PURE__ */ new Map();
+  const numberFormat = (opts) => {
+    const key = JSON.stringify(opts);
+    let format = numberFormats.get(key);
+    if (!format) {
+      format = new Intl.NumberFormat(locale, opts);
+      numberFormats.set(key, format);
+    }
+    return format;
+  };
+  const dateFormat = (opts) => {
+    const key = JSON.stringify(opts);
+    let format = dateFormats.get(key);
+    if (!format) {
+      format = new Intl.DateTimeFormat(locale, opts);
+      dateFormats.set(key, format);
+    }
+    return format;
+  };
+  const formatDateWith = (defaults) => (value, opts = {}) => {
+    const instant = toInstant(value);
+    if (!instant) return "";
+    const zone = instant.calendarDay ? "UTC" : opts.timeZone ?? timeZone;
+    const customised = FIELD_OPTIONS.some((key) => key in opts) || "dateStyle" in opts || "timeStyle" in opts;
+    return dateFormat({
+      ...customised ? {} : defaults,
+      ...opts,
+      ...zone ? { timeZone: zone } : {}
+    }).format(instant.date);
+  };
+  const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+  return {
+    locale,
+    currency,
+    weekStartsOn,
+    timeZone,
+    messages: { ...DEFAULT_MESSAGES, ...options.messages },
+    formatNumber: (value, opts = {}) => isNumber(value) ? numberFormat(opts).format(value) : "",
+    formatCurrency: (value, opts = {}) => isNumber(value) ? numberFormat({ style: "currency", currency, ...opts }).format(value) : "",
+    formatDate: formatDateWith({ dateStyle: "medium" }),
+    formatDateTime: formatDateWith({ dateStyle: "medium", timeStyle: "short" })
+  };
+}
+
+// src/react/LocaleProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var LocaleContext = createContext(createLocale());
+function LocaleProvider({
+  children,
+  locale,
+  currency,
+  weekStartsOn,
+  timeZone,
+  messages
+}) {
+  const messagesKey = JSON.stringify(messages ?? {});
+  const value = useMemo(
+    () => createLocale({
+      locale,
+      currency,
+      weekStartsOn,
+      timeZone,
+      messages: JSON.parse(messagesKey)
+    }),
+    [locale, currency, weekStartsOn, timeZone, messagesKey]
+  );
+  return /* @__PURE__ */ jsx(LocaleContext.Provider, { value, children });
+}
+function useLocale() {
+  return useContext(LocaleContext);
+}
+
+// src/react/ThemeProvider.tsx
+import {
+  createContext as createContext2,
+  useCallback,
+  useContext as useContext2,
+  useEffect,
+  useMemo as useMemo2,
+  useState,
+  useSyncExternalStore
+} from "react";
+
+// src/theme/preferences.ts
+var THEME_PREFERENCES = ["light", "dark", "system"];
+var DENSITIES = ["compact", "comfortable", "spacious"];
+var THEME_COOKIE = "azmr-theme";
+var DENSITY_COOKIE = "azmr-density";
+var ONE_YEAR_SECONDS = 60 * 60 * 24 * 365;
+function parseThemePreference(value, fallback = "system") {
+  return typeof value === "string" && THEME_PREFERENCES.includes(value) ? value : fallback;
+}
+function parseDensity(value, fallback = "comfortable") {
+  return typeof value === "string" && DENSITIES.includes(value) ? value : fallback;
+}
+function readCookie(header, name) {
+  if (!header) return void 0;
+  for (const part of header.split(";")) {
+    const trimmed = part.trim();
+    const eq = trimmed.indexOf("=");
+    if (eq === -1 || trimmed.slice(0, eq) !== name) continue;
+    const raw = trimmed.slice(eq + 1);
+    try {
+      return decodeURIComponent(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return void 0;
+}
+var COOKIE_NAME = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+var COOKIE_VALUE = /^[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]*$/;
+function serializeCookie(name, value, options = {}) {
+  if (!COOKIE_NAME.test(name)) throw new Error(`Invalid cookie name: ${JSON.stringify(name)}`);
+  if (!COOKIE_VALUE.test(value)) throw new Error(`Invalid cookie value for "${name}"`);
+  const secure = options.secure ? "; Secure" : "";
+  return `${name}=${value}; Path=/; Max-Age=${ONE_YEAR_SECONDS}; SameSite=Lax${secure}`;
+}
+function buildHtmlAttributes({ theme, density }) {
+  const attributes = {};
+  if (theme === "light" || theme === "dark") attributes["data-theme"] = theme;
+  if (density === "compact" || density === "spacious") attributes["data-density"] = density;
+  return attributes;
+}
+var htmlAttributes = Object.assign(buildHtmlAttributes, {
+  fromCookies(header) {
+    return buildHtmlAttributes({
+      theme: parseThemePreference(readCookie(header, THEME_COOKIE)),
+      density: parseDensity(readCookie(header, DENSITY_COOKIE))
+    });
+  }
+});
+
+// src/react/ThemeProvider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var DARK_QUERY = "(prefers-color-scheme: dark)";
+function subscribeToSystem(onChange) {
+  const query = typeof window === "undefined" ? void 0 : window.matchMedia?.(DARK_QUERY);
+  if (!query) return () => {
+  };
+  query.addEventListener("change", onChange);
+  return () => query.removeEventListener("change", onChange);
+}
+var systemPrefersDark = () => window.matchMedia?.(DARK_QUERY).matches ?? false;
+var serverSystemPrefersDark = () => false;
+function writeCookie(name, value) {
+  document.cookie = serializeCookie(name, value, { secure: window.location.protocol === "https:" });
+}
+var ThemeContext = createContext2(void 0);
+function ThemeProvider({
+  children,
+  defaultTheme = "system",
+  defaultDensity = "comfortable",
+  persist = true,
+  target
+}) {
+  const [theme, setThemeState] = useState(
+    () => parseThemePreference(defaultTheme)
+  );
+  const [density, setDensityState] = useState(() => parseDensity(defaultDensity));
+  const systemDark = useSyncExternalStore(
+    subscribeToSystem,
+    systemPrefersDark,
+    serverSystemPrefersDark
+  );
+  const resolvedTheme = theme === "system" ? systemDark ? "dark" : "light" : theme;
+  useEffect(() => {
+    const element = target ?? document.documentElement;
+    if (theme === "system") element.removeAttribute("data-theme");
+    else element.setAttribute("data-theme", theme);
+    if (density === "comfortable") element.removeAttribute("data-density");
+    else element.setAttribute("data-density", density);
+    return () => {
+      element.removeAttribute("data-theme");
+      element.removeAttribute("data-density");
+    };
+  }, [theme, density, target]);
+  const setTheme = useCallback(
+    (next) => {
+      const safe = parseThemePreference(next);
+      setThemeState(safe);
+      if (persist) writeCookie(THEME_COOKIE, safe);
+    },
+    [persist]
+  );
+  const setDensity = useCallback(
+    (next) => {
+      const safe = parseDensity(next);
+      setDensityState(safe);
+      if (persist) writeCookie(DENSITY_COOKIE, safe);
+    },
+    [persist]
+  );
+  const value = useMemo2(
+    () => ({ theme, resolvedTheme, setTheme, density, setDensity }),
+    [theme, resolvedTheme, setTheme, density, setDensity]
+  );
+  return /* @__PURE__ */ jsx2(ThemeContext.Provider, { value, children });
+}
+function useTheme() {
+  const context = useContext2(ThemeContext);
+  if (!context) throw new Error("useTheme must be used within a <ThemeProvider>");
+  return context;
+}
+export {
+  LocaleProvider,
+  ThemeProvider,
+  useLocale,
+  useTheme
+};