@seedgrid/fe-components 0.2.4

package/dist/environment/SgEnvironmentProvider.js

@@ -0,0 +1,120 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { createLocalStorageStrategy, buildSgPersistenceKey, } from "./persistence";
+export { buildSgPersistenceKey, createLocalStorageStrategy, createApiPersistenceStrategy, createCompositePersistenceStrategy, } from "./persistence";
+const defaultNamespaceProvider = {
+    getNamespace: () => ""
+};
+const defaultEnvironment = {
+    namespaceProvider: defaultNamespaceProvider,
+    persistenceStrategy: createLocalStorageStrategy(),
+    persistence: {
+        scope: "app:unknown",
+        mode: "fallback",
+        stateVersion: 1
+    }
+};
+const SgEnvironmentContext = React.createContext(null);
+export function SgEnvironmentProvider(props) {
+    const value = React.useMemo(() => ({
+        namespaceProvider: props.value?.namespaceProvider ?? defaultNamespaceProvider,
+        persistenceStrategy: props.value?.persistenceStrategy ?? defaultEnvironment.persistenceStrategy,
+        persistence: {
+            scope: props.value?.persistence?.scope ?? defaultEnvironment.persistence.scope,
+            mode: props.value?.persistence?.mode ?? defaultEnvironment.persistence.mode,
+            stateVersion: props.value?.persistence?.stateVersion ?? defaultEnvironment.persistence.stateVersion
+        }
+    }), [
+        props.value?.namespaceProvider,
+        props.value?.persistenceStrategy,
+        props.value?.persistence?.scope,
+        props.value?.persistence?.mode,
+        props.value?.persistence?.stateVersion
+    ]);
+    return (_jsx(SgEnvironmentContext.Provider, { value: value, children: props.children }));
+}
+export function useSgEnvironment() {
+    return React.useContext(SgEnvironmentContext) ?? defaultEnvironment;
+}
+export function useSgNamespaceProvider() {
+    return useSgEnvironment().namespaceProvider;
+}
+export function useSgPersistence() {
+    const env = useSgEnvironment();
+    const namespace = env.namespaceProvider.getNamespace();
+    const fullKey = (baseKey) => buildSgPersistenceKey(baseKey, namespace, env.persistence.scope);
+    const load = React.useCallback(async (baseKey) => {
+        const key = fullKey(baseKey);
+        if (!key)
+            return null;
+        return await env.persistenceStrategy.load(key);
+    }, [env.persistenceStrategy, namespace, env.persistence.scope]);
+    const save = React.useCallback(async (baseKey, state) => {
+        const key = fullKey(baseKey);
+        if (!key)
+            return;
+        await env.persistenceStrategy.save(key, state);
+    }, [env.persistenceStrategy, namespace, env.persistence.scope]);
+    const clear = React.useCallback(async (baseKey) => {
+        const key = fullKey(baseKey);
+        if (!key)
+            return;
+        await env.persistenceStrategy.clear(key);
+    }, [env.persistenceStrategy, namespace, env.persistence.scope]);
+    return {
+        namespace,
+        scope: env.persistence.scope,
+        mode: env.persistence.mode,
+        stateVersion: env.persistence.stateVersion,
+        load,
+        save,
+        clear
+    };
+}
+export function useSgPersistentState(args) {
+    const { baseKey, defaultValue } = args;
+    const serialize = args.serialize ?? ((value) => value);
+    const deserialize = args.deserialize ?? ((value) => value);
+    const persistence = useSgPersistence();
+    const [value, setValue] = React.useState(defaultValue);
+    const [hydrated, setHydrated] = React.useState(false);
+    React.useEffect(() => {
+        let alive = true;
+        (async () => {
+            try {
+                const loaded = await persistence.load(baseKey);
+                if (!alive)
+                    return;
+                if (loaded !== null && loaded !== undefined) {
+                    setValue(deserialize(loaded));
+                }
+                else {
+                    setValue(defaultValue);
+                }
+                setHydrated(true);
+            }
+            catch {
+                if (!alive)
+                    return;
+                setValue(defaultValue);
+                setHydrated(true);
+            }
+        })();
+        return () => {
+            alive = false;
+        };
+    }, [baseKey, persistence.load, deserialize]);
+    const setAndPersist = React.useCallback((next) => {
+        setValue((prev) => {
+            const computed = typeof next === "function" ? next(prev) : next;
+            void persistence.save(baseKey, serialize(computed));
+            return computed;
+        });
+    }, [baseKey, persistence.save, serialize]);
+    const clear = React.useCallback(async () => {
+        await persistence.clear(baseKey);
+        setValue(defaultValue);
+    }, [baseKey, persistence.clear, defaultValue]);
+    return { value, setValue: setAndPersist, clear, hydrated };
+}

package/dist/environment/persistence.d.ts

@@ -0,0 +1,44 @@
+export type NamespaceProvider = {
+    getNamespace: () => string | null;
+};
+export type PersistenceStrategy = {
+    load: (key: string) => unknown | Promise<unknown>;
+    save: (key: string, state: unknown) => void | Promise<void>;
+    clear: (key: string) => void | Promise<void>;
+};
+export type SgPersistenceRecordDTO = {
+    protocolVersion: 1;
+    key: string;
+    scope: string;
+    stateVersion: number;
+    updatedAt: string;
+    state: unknown;
+};
+export type SgPersistenceMode = "strict" | "fallback" | "mirror";
+export type SgPersistenceConfig = {
+    scope: string;
+    mode: SgPersistenceMode;
+    stateVersion: number;
+};
+export type SgEnvironmentValue = {
+    namespaceProvider: NamespaceProvider;
+    persistenceStrategy: PersistenceStrategy;
+    persistence: SgPersistenceConfig;
+};
+export type SgEnvironment = SgEnvironmentValue;
+export declare function buildSgPersistenceKey(baseKey: string, namespace?: string | null, scope?: string | null): string | null;
+export declare function createLocalStorageStrategy(options?: {
+    prefix?: string;
+}): PersistenceStrategy;
+export declare function createApiPersistenceStrategy(args: {
+    baseUrl: string;
+    fetcher?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    scope: string;
+    stateVersion: number;
+}): PersistenceStrategy;
+export declare function createCompositePersistenceStrategy(args: {
+    mode: SgPersistenceMode;
+    primary: PersistenceStrategy;
+    secondary: PersistenceStrategy;
+}): PersistenceStrategy;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/environment/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../src/environment/persistence.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClD,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,eAAe,EAAE,CAAC,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEjE,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,iBAAiB,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,iBAMtG;AAED,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,mBAAmB,CA4B7F;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,mBAAmB,CAuCtB;AAED,wBAAgB,kCAAkC,CAAC,IAAI,EAAE;IACvD,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,mBAAmB,CAAC;CAChC,GAAG,mBAAmB,CA0DtB"}

package/dist/environment/persistence.js

@@ -0,0 +1,149 @@
+export function buildSgPersistenceKey(baseKey, namespace, scope) {
+    const resolved = namespace ?? "";
+    if (!resolved)
+        return null;
+    const resolvedScope = (scope ?? "").trim();
+    if (!resolvedScope)
+        return `sg:${resolved}:${baseKey}`;
+    return `sg:${resolved}:${resolvedScope}:${baseKey}`;
+}
+export function createLocalStorageStrategy(options) {
+    const prefix = options?.prefix ?? "";
+    const full = (key) => (prefix ? `${prefix}${key}` : key);
+    return {
+        load: (key) => {
+            try {
+                const raw = window.localStorage.getItem(full(key));
+                if (raw == null)
+                    return null;
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        save: (key, state) => {
+            try {
+                window.localStorage.setItem(full(key), JSON.stringify(state));
+            }
+            catch {
+                // ignore
+            }
+        },
+        clear: (key) => {
+            try {
+                window.localStorage.removeItem(full(key));
+            }
+            catch {
+                // ignore
+            }
+        }
+    };
+}
+export function createApiPersistenceStrategy(args) {
+    const fetcher = args.fetcher ?? fetch;
+    const base = args.baseUrl.replace(/\/$/, "");
+    const version = args.stateVersion;
+    const scope = args.scope;
+    return {
+        load: async (key) => {
+            const res = await fetcher(`${base}/sg/persistence?key=${encodeURIComponent(key)}`, {
+                method: "GET"
+            });
+            if (!res.ok)
+                throw new Error(`SG persistence load failed (${res.status})`);
+            const data = (await res.json());
+            if (!data?.found || !data.record)
+                return null;
+            return data.record.state;
+        },
+        save: async (key, state) => {
+            const record = {
+                protocolVersion: 1,
+                key,
+                scope,
+                stateVersion: version,
+                updatedAt: new Date().toISOString(),
+                state
+            };
+            const res = await fetcher(`${base}/sg/persistence`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ record })
+            });
+            if (!res.ok)
+                throw new Error(`SG persistence save failed (${res.status})`);
+        },
+        clear: async (key) => {
+            const res = await fetcher(`${base}/sg/persistence?key=${encodeURIComponent(key)}`, {
+                method: "DELETE"
+            });
+            if (!res.ok)
+                throw new Error(`SG persistence clear failed (${res.status})`);
+        }
+    };
+}
+export function createCompositePersistenceStrategy(args) {
+    const { mode, primary, secondary } = args;
+    return {
+        load: async (key) => {
+            if (mode === "strict")
+                return await primary.load(key);
+            if (mode === "mirror") {
+                try {
+                    const remote = await primary.load(key);
+                    if (remote !== null && remote !== undefined)
+                        return remote;
+                }
+                catch {
+                    // ignore and fallback
+                }
+                return await secondary.load(key);
+            }
+            try {
+                return await primary.load(key);
+            }
+            catch {
+                return await secondary.load(key);
+            }
+        },
+        save: async (key, state) => {
+            if (mode === "strict") {
+                await primary.save(key, state);
+                return;
+            }
+            if (mode === "mirror") {
+                await Promise.allSettled([
+                    Promise.resolve(primary.save(key, state)),
+                    Promise.resolve(secondary.save(key, state))
+                ]);
+                return;
+            }
+            try {
+                await primary.save(key, state);
+            }
+            catch {
+                await secondary.save(key, state);
+            }
+        },
+        clear: async (key) => {
+            if (mode === "strict") {
+                await primary.clear(key);
+                return;
+            }
+            if (mode === "mirror") {
+                await Promise.allSettled([
+                    Promise.resolve(primary.clear(key)),
+                    Promise.resolve(secondary.clear(key))
+                ]);
+                return;
+            }
+            try {
+                await primary.clear(key);
+            }
+            catch {
+                await secondary.clear(key);
+            }
+        }
+    };
+}

package/dist/gadgets/clock/SgClock.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import type { SgClockTheme } from "./themes/types";
+export type SgClockProps = {
+    variant?: "digital" | "analog";
+    size?: "sm" | "md" | "lg" | number;
+    timezone?: string;
+    locale?: string;
+    format?: "12h" | "24h";
+    showSeconds?: boolean;
+    digitalStyle?: "default" | "segment" | "roller3d" | "flip";
+    secondHandMode?: "step" | "smooth";
+    themeId?: string;
+    theme?: SgClockTheme;
+    className?: string;
+    centerOverlay?: React.ReactNode;
+};
+export declare function SgClock(props: SgClockProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SgClock.d.ts.map

package/dist/gadgets/clock/SgClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SgClock.d.ts","sourceRoot":"","sources":["../../../src/gadgets/clock/SgClock.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAenD,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC/B,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IAC3D,cAAc,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACjC,CAAC;AAsrBF,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,2CA4C1C"}