@lerianstudio/sindarian-ui 1.2.0-beta.13 → 1.2.0-beta.14

package/dist/esm/theme/get-theme-script.d.ts

@@ -0,0 +1,3 @@
+import type { ThemePreference } from './theme-provider.js';
+export declare function getThemeScript(storageKey?: string, defaultTheme?: ThemePreference): string;
+//# sourceMappingURL=get-theme-script.d.ts.map

package/dist/esm/theme/get-theme-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-theme-script.d.ts","sourceRoot":"","sources":["../../../src/theme/get-theme-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAqCvD,wBAAgB,cAAc,CAC5B,UAAU,SAAoB,EAC9B,YAAY,GAAE,eAA0B,GACvC,MAAM,CAOR"}

package/dist/esm/theme/get-theme-script.js

@@ -0,0 +1,41 @@
+/**
+ * Pre-paint theme script (FOUC guard). Returns a minified IIFE string that
+ * reads the persisted preference from localStorage, resolves it the way
+ * ThemeProvider does, and toggles the `.dark` class on the page root element
+ * before first paint — so the page never flashes the wrong theme while React
+ * hydrates. ThemeProvider owns the class from mount onward.
+ *
+ * The resolution mirrors ThemeProvider's exactly: an exact "dark"/"light"/
+ * "system" stored value wins; anything else — absent or corrupted — falls back
+ * to `defaultTheme`, which is then resolved ("dark" → dark, "light" → light,
+ * "system" → the media query). Pass the SAME `defaultTheme` you give
+ * ThemeProvider, or the two disagree on a first visit.
+ * `get-theme-script.test.tsx` pins that agreement case by case.
+ *
+ * Server-safe: this module references no browser globals at module scope; the
+ * returned string runs in the browser only, inside a try/catch.
+ *
+ * Consumer usage — inject in the page <head>, ideally as the first script:
+ *
+ *   <script dangerouslySetInnerHTML={{ __html: getThemeScript() }} />
+ *
+ * A dark-by-default app passes both arguments:
+ *
+ *   <script dangerouslySetInnerHTML={{ __html: getThemeScript('app.theme', 'dark') }} />
+ */
+/**
+ * JSON string literal with `<` escaped, so no embedded value can close the
+ * inline <script> element it is written into. `<` is `<` to the JS parser,
+ * so the emitted script still compares against the original text.
+ */
+function jsString(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003C');
+}
+export function getThemeScript(storageKey = 'sindarian.theme', defaultTheme = 'system') {
+    // The storage read gets its OWN try/catch, mirroring ThemeProvider, which
+    // isolates the same read. A browser with site data blocked throws on
+    // getItem; if that escaped to the outer catch the class would never be
+    // applied at all and a dark user would flash light before hydration.
+    // Resolution starts from defaultTheme and storage only narrows it.
+    return `(function(){try{var r=${jsString(defaultTheme)};try{var t=localStorage.getItem(${jsString(storageKey)});if(t==="dark"||t==="light"||t==="system")r=t}catch(e){}var d=r==="dark"||(r==="system"&&matchMedia("(prefers-color-scheme: dark)").matches);document.documentElement.classList.toggle("dark",d)}catch(e){}})()`;
+}

package/dist/esm/theme/index.d.ts

@@ -0,0 +1,6 @@
+export { ThemeProvider, useTheme } from './theme-provider.js';
+export type { ThemePreference, ThemeProviderProps } from './theme-provider.js';
+export { getThemeScript } from './get-theme-script.js';
+export { ModeToggle } from './mode-toggle.js';
+export type { ModeToggleLabels, ModeToggleProps } from './mode-toggle.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/theme/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/theme/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC1D,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA"}

package/dist/esm/theme/index.js

@@ -0,0 +1,4 @@
+// Owned by lane theme-toasts-charts — see docs/plans/2026-08-26-sindarian-x-retirement/
+export { ThemeProvider, useTheme } from './theme-provider.js';
+export { getThemeScript } from './get-theme-script.js';
+export { ModeToggle } from './mode-toggle.js';

package/dist/esm/theme/mode-toggle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ModeToggle — compact segmented light/system/dark control.
+ *
+ * Follows the lib's segmented canon: a `role="group"` with an aria-label, each
+ * segment a button carrying `aria-pressed`, the active segment marked with the
+ * `bg-secondary` tone. Icon-only segments and the group itself carry
+ * plain-English aria-labels by default; pass `labels` to localize them
+ * (`labels.group` names the whole control). Theme switches are instant — the
+ * 150ms transition is the local color-only hover affordance.
+ */
+import * as React from 'react';
+export interface ModeToggleLabels {
+    light?: string;
+    system?: string;
+    dark?: string;
+    /** aria-label for the whole control (the `role="group"`); default "Theme". */
+    group?: string;
+}
+export interface ModeToggleProps {
+    /** aria-label overrides for each segment and the group; default plain English. */
+    labels?: ModeToggleLabels;
+    className?: string;
+}
+export declare function ModeToggle({ labels, className }: ModeToggleProps): React.JSX.Element;
+//# sourceMappingURL=mode-toggle.d.ts.map

package/dist/esm/theme/mode-toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-toggle.d.ts","sourceRoot":"","sources":["../../../src/theme/mode-toggle.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,8EAA8E;IAC9E,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,MAAM,CAAC,EAAE,gBAAgB,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAkBD,wBAAgB,UAAU,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,eAAe,qBAqChE"}

package/dist/esm/theme/mode-toggle.js

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Monitor, Moon, Sun } from 'lucide-react';
+import { cn } from '../lib/utils.js';
+import { useTheme } from './theme-provider.js';
+const SEGMENTS = [
+    { value: 'light', icon: Sun },
+    { value: 'system', icon: Monitor },
+    { value: 'dark', icon: Moon }
+];
+const DEFAULT_LABELS = {
+    light: 'Light',
+    system: 'System',
+    dark: 'Dark',
+    group: 'Theme'
+};
+export function ModeToggle({ labels, className }) {
+    const { theme, setTheme } = useTheme();
+    const resolved = { ...DEFAULT_LABELS, ...labels };
+    return (_jsx("div", { role: "group", "aria-label": resolved.group, className: cn('border-input bg-card grid w-fit grid-cols-3 rounded-md border p-0.5 shadow-[var(--shadow-card)]', className), children: SEGMENTS.map(({ value, icon: Icon }) => {
+            const active = value === theme;
+            const label = resolved[value];
+            return (_jsx("button", { type: "button", "aria-pressed": active, "aria-label": label, title: label, onClick: () => setTheme(value), className: cn('focus-visible:ring-ring flex items-center justify-center rounded-sm px-2 py-1.5 transition-colors duration-150 ease-out focus-visible:ring-2 focus-visible:outline-none', active
+                    ? 'bg-secondary text-secondary-foreground'
+                    : 'text-muted-foreground hover:text-foreground'), children: _jsx(Icon, { className: "size-4", "aria-hidden": true }) }, value));
+        }) }));
+}

package/dist/esm/theme/theme-provider.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ThemeProvider — owns theme preference ('light' | 'dark' | 'system'),
+ * persists it to localStorage, applies the `.dark` class on
+ * `document.documentElement`, and resolves 'system' via
+ * `prefers-color-scheme`.
+ *
+ * SSR-safe: state initializes to `defaultTheme` and never reads
+ * window/localStorage during render. The persisted value is read inside an
+ * effect on mount, so first paint uses `defaultTheme`. Pair with
+ * `getThemeScript` in the document <head> to remove the flash before paint.
+ *
+ * Same-tab sync is handled by React context (every consumer reads the same
+ * provider state); cross-tab sync rides the native `storage` event. While the
+ * preference is 'system', `matchMedia('change')` keeps the resolved value live.
+ * Theme switches are instant by design — no global color transition.
+ */
+import * as React from 'react';
+export type ThemePreference = 'light' | 'dark' | 'system';
+type ThemeContextValue = {
+    /** The persisted preference (NOT the resolved light/dark value). */
+    theme: ThemePreference;
+    /** Persist a new preference; updates every consumer of this provider. */
+    setTheme: (next: ThemePreference) => void;
+    /** The effective mode after resolving 'system'. */
+    resolvedTheme: 'light' | 'dark';
+};
+export interface ThemeProviderProps {
+    children: React.ReactNode;
+    /** localStorage key holding the preference. */
+    storageKey?: string;
+    /** Preference used for the first (SSR / pre-hydration) paint. */
+    defaultTheme?: ThemePreference;
+}
+export declare function ThemeProvider({ children, storageKey, defaultTheme }: ThemeProviderProps): React.JSX.Element;
+/** Reads the theme context. Throws if used outside a ThemeProvider. */
+export declare function useTheme(): ThemeContextValue;
+export {};
+//# sourceMappingURL=theme-provider.d.ts.map

package/dist/esm/theme/theme-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-provider.d.ts","sourceRoot":"","sources":["../../../src/theme/theme-provider.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;AAgBzD,KAAK,iBAAiB,GAAG;IACvB,oEAAoE;IACpE,KAAK,EAAE,eAAe,CAAA;IACtB,yEAAyE;IACzE,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAA;IACzC,mDAAmD;IACnD,aAAa,EAAE,OAAO,GAAG,MAAM,CAAA;CAChC,CAAA;AAID,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,iEAAiE;IACjE,YAAY,CAAC,EAAE,eAAe,CAAA;CAC/B;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,UAA8B,EAC9B,YAAuB,EACxB,EAAE,kBAAkB,qBAwEpB;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,IAAI,iBAAiB,CAM5C"}

package/dist/esm/theme/theme-provider.js

@@ -0,0 +1,98 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ThemeProvider — owns theme preference ('light' | 'dark' | 'system'),
+ * persists it to localStorage, applies the `.dark` class on
+ * `document.documentElement`, and resolves 'system' via
+ * `prefers-color-scheme`.
+ *
+ * SSR-safe: state initializes to `defaultTheme` and never reads
+ * window/localStorage during render. The persisted value is read inside an
+ * effect on mount, so first paint uses `defaultTheme`. Pair with
+ * `getThemeScript` in the document <head> to remove the flash before paint.
+ *
+ * Same-tab sync is handled by React context (every consumer reads the same
+ * provider state); cross-tab sync rides the native `storage` event. While the
+ * preference is 'system', `matchMedia('change')` keeps the resolved value live.
+ * Theme switches are instant by design — no global color transition.
+ */
+import * as React from 'react';
+const DARK_QUERY = '(prefers-color-scheme: dark)';
+function isThemePreference(value) {
+    return value === 'light' || value === 'dark' || value === 'system';
+}
+function systemPrefersDark() {
+    if (typeof window === 'undefined' ||
+        typeof window.matchMedia !== 'function') {
+        return false;
+    }
+    return window.matchMedia(DARK_QUERY).matches;
+}
+const ThemeContext = React.createContext(null);
+export function ThemeProvider({ children, storageKey = 'sindarian.theme', defaultTheme = 'system' }) {
+    const [theme, setThemeState] = React.useState(defaultTheme);
+    const [resolvedTheme, setResolvedTheme] = React.useState(defaultTheme === 'dark' ? 'dark' : 'light');
+    const setTheme = React.useCallback((next) => {
+        setThemeState(next);
+        if (typeof window === 'undefined')
+            return;
+        try {
+            window.localStorage.setItem(storageKey, next);
+        }
+        catch {
+            // Storage unavailable (private mode, quota). In-memory state still works.
+        }
+    }, [storageKey]);
+    // Read the persisted preference once on mount (effect, never render).
+    React.useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        try {
+            const stored = window.localStorage.getItem(storageKey);
+            if (isThemePreference(stored))
+                setThemeState(stored);
+        }
+        catch {
+            // Ignore; keep defaultTheme.
+        }
+    }, [storageKey]);
+    // Apply the resolved class; while 'system', track prefers-color-scheme live.
+    React.useEffect(() => {
+        if (typeof document === 'undefined')
+            return;
+        const apply = (dark) => {
+            document.documentElement.classList.toggle('dark', dark);
+            setResolvedTheme(dark ? 'dark' : 'light');
+        };
+        apply(theme === 'system' ? systemPrefersDark() : theme === 'dark');
+        if (theme !== 'system' || typeof window.matchMedia !== 'function') {
+            return;
+        }
+        const media = window.matchMedia(DARK_QUERY);
+        const onChange = (event) => apply(event.matches);
+        media.addEventListener('change', onChange);
+        return () => media.removeEventListener('change', onChange);
+    }, [theme]);
+    // Cross-tab sync: the native `storage` event only fires in OTHER tabs.
+    React.useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const onStorage = (event) => {
+            if (event.key !== storageKey)
+                return;
+            setThemeState(isThemePreference(event.newValue) ? event.newValue : defaultTheme);
+        };
+        window.addEventListener('storage', onStorage);
+        return () => window.removeEventListener('storage', onStorage);
+    }, [storageKey, defaultTheme]);
+    const value = React.useMemo(() => ({ theme, setTheme, resolvedTheme }), [theme, setTheme, resolvedTheme]);
+    return _jsx(ThemeContext.Provider, { value: value, children: children });
+}
+/** Reads the theme context. Throws if used outside a ThemeProvider. */
+export function useTheme() {
+    const context = React.useContext(ThemeContext);
+    if (context === null) {
+        throw new Error('useTheme must be used within a ThemeProvider');
+    }
+    return context;
+}

package/dist/esm/toast/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { ToastActionElement } from '../components/ui/toast/index.js';
+/** Extra toast props for the severity helpers (the variant is fixed per helper). */
+export interface ToastOptions {
+    /** Optional action element rendered inside the toast. */
+    action?: ToastActionElement;
+    /**
+     * Originating error code, when the toast was raised from an API failure.
+     * Accepted for call-site compatibility; sindarian-ui's toast has no slot for
+     * it, so it is not rendered. Put it in `description` if it must be visible.
+     */
+    errorCode?: string;
+}
+export declare function successToast(title: string, description?: string, opts?: Partial<ToastOptions>): void;
+export declare function errorToast(title: string, description?: string, opts?: Partial<ToastOptions>): void;
+export declare function warningToast(title: string, description?: string, opts?: Partial<ToastOptions>): void;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/toast/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/toast/helpers.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAE/D,oFAAoF;AACpF,MAAM,WAAW,YAAY;IAC3B,yDAAyD;IACzD,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAWD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,IAAI,CAEN;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,IAAI,CAEN;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,IAAI,CAEN"}

package/dist/esm/toast/helpers.js

@@ -0,0 +1,29 @@
+'use client';
+/**
+ * Severity toast helpers — thin wrappers over sindarian-ui's own toast
+ * machinery (`@/hooks/use-toast`), which renders through `<Toaster />`.
+ *
+ * The bare `toast` is deliberately NOT re-exported here: sindarian-ui already
+ * exports it from the main barrel, and one name must resolve to one function.
+ * Call `toast({ title, description, variant })` directly when a helper does not
+ * fit.
+ *
+ * Variant mapping — one helper per severity, onto sindarian-ui's own variants:
+ *
+ *   successToast → 'success'      (green)
+ *   errorToast   → 'destructive'  (red)
+ *   warningToast → 'warning'      (amber)
+ */
+import { toast } from '../hooks/use-toast.js';
+function raise(variant, title, description, opts) {
+    toast({ action: opts?.action, variant, title, description });
+}
+export function successToast(title, description, opts) {
+    raise('success', title, description, opts);
+}
+export function errorToast(title, description, opts) {
+    raise('destructive', title, description, opts);
+}
+export function warningToast(title, description, opts) {
+    raise('warning', title, description, opts);
+}

package/dist/esm/toast/index.d.ts

@@ -0,0 +1,3 @@
+export { successToast, errorToast, warningToast } from './helpers.js';
+export type { ToastOptions } from './helpers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/toast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/toast/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAClE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA"}

package/dist/esm/toast/index.js

@@ -0,0 +1,4 @@
+// Owned by lane theme-toasts-charts — see docs/plans/2026-08-26-sindarian-x-retirement/
+// NOTE: the bare `toast` is NOT re-exported here — sindarian-ui's main barrel
+// already exports it from `@/hooks/use-toast`.
+export { successToast, errorToast, warningToast } from './helpers.js';

package/dist/esm/types/metadata-type.d.ts

@@ -0,0 +1,2 @@
+export type Metadata = Record<string, any>;
+//# sourceMappingURL=metadata-type.d.ts.map

package/dist/esm/types/metadata-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-type.d.ts","sourceRoot":"","sources":["../../../src/types/metadata-type.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA"}

package/dist/esm/types/metadata-type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/countries.cjs

@@ -0,0 +1,17 @@
+'use strict'
+
+/**
+ * The country/state dataset, loaded through CommonJS on purpose.
+ *
+ * A plain `import ... from './countries.json'` compiles fine, but Node's ESM
+ * loader rejects it without an `with { type: 'json' }` attribute — and that
+ * attribute cannot be written once for a dual build: TypeScript refuses it in
+ * any file that compiles to a `require` call (TS2856). Since a JSON `require`
+ * needs no attribute in either output, the one-line load lives here, in a
+ * `.cjs` file that is CommonJS inside `dist/` and inside `dist/esm/` alike.
+ *
+ * Without this, `import '@lerianstudio/sindarian-ui'` throws
+ * ERR_IMPORT_ATTRIBUTE_MISSING under any native-ESM consumer — Vitest, which
+ * externalises ESM dependencies, being the one the apps actually hit.
+ */
+module.exports = require('../public/countries.json')

package/dist/esm/utils/countries.d.cts

@@ -0,0 +1,14 @@
+/** Shape of `src/public/countries.json`, loaded by `countries.cjs`. */
+type RawCountry = {
+  code2: string
+  code3: string
+  name: string
+  capital: string
+  region: string
+  subregion: string
+  states: { code: string; name: string; subdivision: string | null }[]
+}
+
+declare const countries: RawCountry[]
+
+export = countries

package/dist/esm/utils/country-utils.d.ts

@@ -0,0 +1,17 @@
+export type CountryType = {
+    code: string;
+    name: string;
+    states: StateType[];
+};
+export type StateType = {
+    name: string;
+    code: string;
+};
+declare const getCountries: () => {
+    code: any;
+    name: any;
+    states: any;
+}[];
+declare const getStateCountry: (country: string) => StateType[];
+export { getCountries, getStateCountry };
+//# sourceMappingURL=country-utils.d.ts.map

package/dist/esm/utils/country-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"country-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/country-utils.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,QAAA,MAAM,YAAY;;;;GASjB,CAAA;AAED,QAAA,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,SAAS,EASnD,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,CAAA"}

package/dist/esm/utils/country-utils.js

@@ -0,0 +1,18 @@
+import countriesJson from './countries.cjs';
+const getCountries = () => {
+    return countriesJson.map((country) => ({
+        code: country.code2,
+        name: country.name,
+        states: country.states.map((state) => ({
+            name: state.name,
+            code: state.code
+        }))
+    }));
+};
+const getStateCountry = (country) => {
+    const selectedCountry = getCountries().find((countryItem) => countryItem.code === country || countryItem.name === country);
+    if (!selectedCountry)
+        return [];
+    return selectedCountry.states || [];
+};
+export { getCountries, getStateCountry };

package/dist/esm/utils/currency-codes.d.ts

@@ -0,0 +1,5 @@
+export declare const currencyCodes: string[];
+export declare const currencyObjects: {
+    code: string;
+}[];
+//# sourceMappingURL=currency-codes.d.ts.map

package/dist/esm/utils/currency-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency-codes.d.ts","sourceRoot":"","sources":["../../../src/utils/currency-codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,UAmLzB,CAAA;AAED,eAAO,MAAM,eAAe;;GAA0C,CAAA"}

package/dist/esm/utils/currency-codes.js

@@ -0,0 +1,181 @@
+export const currencyCodes = [
+    'AED',
+    'AFN',
+    'ALL',
+    'AMD',
+    'ANG',
+    'AOA',
+    'ARS',
+    'AUD',
+    'AWG',
+    'AZN',
+    'BAM',
+    'BBD',
+    'BDT',
+    'BGN',
+    'BHD',
+    'BIF',
+    'BMD',
+    'BND',
+    'BOB',
+    'BOV',
+    'BRL',
+    'BSD',
+    'BTN',
+    'BWP',
+    'BYR',
+    'BZD',
+    'CAD',
+    'CDF',
+    'CHE',
+    'CHF',
+    'CHW',
+    'CLF',
+    'CLP',
+    'CNY',
+    'COP',
+    'COU',
+    'CRC',
+    'CUC',
+    'CUP',
+    'CVE',
+    'CZK',
+    'DJF',
+    'DKK',
+    'DOP',
+    'DZD',
+    'EGP',
+    'ERN',
+    'ETB',
+    'EUR',
+    'FJD',
+    'FKP',
+    'GBP',
+    'GEL',
+    'GHS',
+    'GIP',
+    'GMD',
+    'GNF',
+    'GTQ',
+    'GYD',
+    'HKD',
+    'HNL',
+    'HRK',
+    'HTG',
+    'HUF',
+    'IDR',
+    'ILS',
+    'INR',
+    'IQD',
+    'IRR',
+    'ISK',
+    'JMD',
+    'JOD',
+    'JPY',
+    'KES',
+    'KGS',
+    'KHR',
+    'KMF',
+    'KPW',
+    'KRW',
+    'KWD',
+    'KYD',
+    'KZT',
+    'LAK',
+    'LBP',
+    'LKR',
+    'LRD',
+    'LSL',
+    'LTL',
+    'LVL',
+    'LYD',
+    'MAD',
+    'MDL',
+    'MGA',
+    'MKD',
+    'MMK',
+    'MNT',
+    'MOP',
+    'MRO',
+    'MUR',
+    'MVR',
+    'MWK',
+    'MXN',
+    'MXV',
+    'MYR',
+    'MZN',
+    'NAD',
+    'NGN',
+    'NIO',
+    'NOK',
+    'NPR',
+    'NZD',
+    'OMR',
+    'PAB',
+    'PEN',
+    'PGK',
+    'PHP',
+    'PKR',
+    'PLN',
+    'PYG',
+    'QAR',
+    'RON',
+    'RSD',
+    'RUB',
+    'RWF',
+    'SAR',
+    'SBD',
+    'SCR',
+    'SDG',
+    'SEK',
+    'SGD',
+    'SHP',
+    'SLL',
+    'SOS',
+    'SRD',
+    'SSP',
+    'STD',
+    'SYP',
+    'SZL',
+    'THB',
+    'TJS',
+    'TMT',
+    'TND',
+    'TOP',
+    'TRY',
+    'TTD',
+    'TWD',
+    'TZS',
+    'UAH',
+    'UGX',
+    'USD',
+    'USN',
+    'USS',
+    'UYI',
+    'UYU',
+    'UZS',
+    'VEF',
+    'VND',
+    'VUV',
+    'WST',
+    'XAF',
+    'XAG',
+    'XAU',
+    'XBA',
+    'XBB',
+    'XBC',
+    'XBD',
+    'XCD',
+    'XDR',
+    'XFU',
+    'XOF',
+    'XPD',
+    'XPF',
+    'XPT',
+    'XTS',
+    'XXX',
+    'YER',
+    'ZAR',
+    'ZMW'
+];
+export const currencyObjects = currencyCodes.map((code) => ({ code }));