@appstrata/react 0.1.0

package/dist/deep-equal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Deep equality comparison for plain objects, arrays, and primitives.
+ *
+ * Used by ContextStore to determine which parts of AppContext
+ * actually changed, enabling granular re-renders.
+ *
+ * @internal
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=deep-equal.d.ts.map

package/dist/deep-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../src/deep-equal.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAkBzD"}

package/dist/deep-equal.js

@@ -0,0 +1,28 @@
+/**
+ * Deep equality comparison for plain objects, arrays, and primitives.
+ *
+ * Used by ContextStore to determine which parts of AppContext
+ * actually changed, enabling granular re-renders.
+ *
+ * @internal
+ */
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        if (!deepEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Core React hooks for AppStrata.
+ *
+ * All hooks must be used within an AppStrataProvider.
+ */
+import { LifecyclePhase, type AppContext, type Capability, type SignagePlayer, type Resource, type DeviceInfo, type Source } from "@appstrata/core";
+/**
+ * Access the complete AppContext.
+ * Re-renders on ANY context change.
+ *
+ * Returns null while waiting for the player READY message.
+ *
+ * @example
+ * ```tsx
+ * const context = useAppContext();
+ * if (!context) return <div>Loading...</div>;
+ * return <h1>{context.config.title as string}</h1>;
+ * ```
+ */
+export declare function useAppContext(): AppContext | null;
+/**
+ * Access just the config portion of AppContext.
+ * Only re-renders when config actually changes (deep comparison).
+ *
+ * @typeParam T - The expected config shape
+ *
+ * @example
+ * ```tsx
+ * const config = useConfig<{ title: string; bgcolor: string }>();
+ * if (!config) return null;
+ * return <h1 style={{ background: config.bgcolor }}>{config.title}</h1>;
+ * ```
+ */
+export declare function useConfig<T extends Record<string, unknown> = Record<string, unknown>>(): T | null;
+/**
+ * Access just the resources from AppContext.
+ * Only re-renders when resources actually change (deep comparison).
+ *
+ * @example
+ * ```tsx
+ * const resources = useResources();
+ * const fonts = resources?.filter(r => r.category === "font");
+ * ```
+ */
+export declare function useResources(): Resource[] | null;
+/**
+ * Result of useResource hook.
+ */
+export interface UseResourceResult {
+    /** Resolved URI (including data URIs for inline sources). Null if not found or not loaded. */
+    uri: string | null;
+    /** Raw Source object. Null if not found or not loaded. */
+    source: Source | null;
+    /** Full Resource object for advanced access. Null if not found or not loaded. */
+    resource: Resource | null;
+}
+/**
+ * Look up a single resource by category and name, returning a ready-to-use URI.
+ * Only re-renders when resources actually change (deep comparison).
+ *
+ * Optionally resolves a named variant instead of the main source.
+ *
+ * @param category - Resource category (e.g. "font", "image")
+ * @param name - Resource name (e.g. "heading", "logo")
+ * @param variant - Optional variant name (e.g. "thumbnail")
+ * @returns Object with `uri`, `source`, and `resource` fields
+ *
+ * @example
+ * ```tsx
+ * const { uri: fontUri } = useResource("font", "heading");
+ * const { uri: logoUri } = useResource("image", "logo");
+ *
+ * // With variant:
+ * const { uri: thumbUri } = useResource("image", "logo", "thumbnail");
+ * ```
+ */
+export declare function useResource(category: string, name: string, variant?: string): UseResourceResult;
+/**
+ * Load all font resources from the player context.
+ *
+ * Injects `<link>` stylesheet elements for every resource with
+ * `category === "font"`. Re-loads when the resource list changes
+ * (e.g. during CMS live preview).
+ *
+ * @returns `true` once all font stylesheets have loaded, `false` while loading
+ *
+ * @example
+ * ```tsx
+ * const fontsLoaded = useFonts();
+ * if (!fontsLoaded) return <div>Loading fonts...</div>;
+ * ```
+ */
+export declare function useFonts(): boolean;
+/**
+ * Load all stylesheet resources from the player context.
+ *
+ * Injects `<link>` stylesheet elements for every resource with
+ * `category === "stylesheet"`. Re-loads when the resource list changes
+ * (e.g. during CMS live preview).
+ *
+ * @returns `true` once all stylesheets have loaded, `false` while loading
+ *
+ * @example
+ * ```tsx
+ * const stylesLoaded = useStylesheets();
+ * if (!stylesLoaded) return <div>Loading styles...</div>;
+ * ```
+ */
+export declare function useStylesheets(): boolean;
+/**
+ * Access just the device information from AppContext.
+ * Only re-renders when device info actually changes (deep comparison).
+ *
+ * @example
+ * ```tsx
+ * const device = useDevice();
+ * if (!device) return null;
+ * return <footer>Playing on: {device.name}</footer>;
+ * ```
+ */
+export declare function useDevice(): DeviceInfo | null;
+/**
+ * Access the SignagePlayer instance directly.
+ * Returns a stable reference (singleton) -- never triggers re-renders.
+ *
+ * Use this for imperative operations or capabilities not covered by
+ * dedicated hooks.
+ *
+ * @example
+ * ```tsx
+ * const player = usePlayer();
+ * const handleComplete = () => player.notifyComplete();
+ * ```
+ */
+export declare function usePlayer(): SignagePlayer;
+/**
+ * Check if a capability is available.
+ *
+ * Returns a tri-state value:
+ * - `null` while the player hasn't initialized yet (pre-READY)
+ * - `true` when the capability is supported
+ * - `false` when the capability is NOT supported
+ *
+ * Re-renders on any context change (delegates to useAppContext internally).
+ *
+ * @param capability - The capability to check (e.g., "storage", "proxy")
+ *
+ * @example
+ * ```tsx
+ * const hasStorage = useCapability("storage");
+ * if (hasStorage === null) return <div>Initializing...</div>;
+ * if (hasStorage) { ... }
+ * ```
+ */
+export declare function useCapability(capability: Capability): boolean | null;
+/**
+ * Lifecycle callbacks interface.
+ */
+export interface LifecycleCallbacks {
+    /** Called when app is about to become visible */
+    onShow?: () => void | (() => void);
+    /** Called when app is now visible and should start playback */
+    onStart?: () => void | (() => void);
+    /** Called when app is about to be hidden */
+    onHide?: () => void | (() => void);
+    /** Called when app is now hidden and should stop playback */
+    onStop?: () => void | (() => void);
+}
+/**
+ * Subscribe to lifecycle events.
+ * Callbacks can optionally return cleanup functions.
+ *
+ * Auto-subscribes on mount, auto-cleans up on unmount.
+ *
+ * **Note:** Because `useEffect` runs after paint, handlers for transient phases
+ * like `Show` and `Hide` may not fire if the phase has already passed by the
+ * time the effect registers them. Use `onStart`/`onStop` for work that must
+ * not be skipped, or read `useLifecyclePhase()` to derive state from the
+ * current phase.
+ *
+ * @example
+ * ```tsx
+ * useLifecycle({
+ *   onStart: () => {
+ *     const interval = setInterval(tick, 1000);
+ *     return () => clearInterval(interval); // cleanup
+ *   },
+ *   onStop: () => console.log("Stopped"),
+ * });
+ * ```
+ */
+export declare function useLifecycle(callbacks: LifecycleCallbacks): void;
+/**
+ * Read the current lifecycle phase reactively.
+ *
+ * Re-renders whenever the phase transitions. Returns `LifecyclePhase.None`
+ * before the handshake completes.
+ *
+ * @example
+ * ```tsx
+ * const phase = useLifecyclePhase();
+ * const isPlaying = phase === LifecyclePhase.Start;
+ * const isVisible = phase === LifecyclePhase.Show || phase === LifecyclePhase.Start;
+ * ```
+ */
+export declare function useLifecyclePhase(): LifecyclePhase;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAE,KAAK,MAAM,EAAgB,MAAM,iBAAiB,CAAC;AA8BlK;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAOjD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAOjG;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,QAAQ,EAAE,GAAG,IAAI,CAOhD;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,8FAA8F;IAC9F,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,0DAA0D;IAC1D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,iFAAiF;IACjF,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAiB/F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAkBlC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAkBxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,IAAI,UAAU,GAAG,IAAI,CAO7C;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,IAAI,aAAa,CAGzC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,GAAG,IAAI,CAIpE;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;IACnC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;IACpC,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;IACnC,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAoChE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAgBlD"}

package/dist/hooks.js

@@ -0,0 +1,321 @@
+/**
+ * Core React hooks for AppStrata.
+ *
+ * All hooks must be used within an AppStrataProvider.
+ */
+import { useContext, useSyncExternalStore, useState, useEffect, useRef, useMemo } from "react";
+import { AppStrataContext } from "./provider.js";
+import { createLogger } from "@appstrata/core";
+import { resolveSourceUri, loadFonts, loadStylesheets } from "@appstrata/utils";
+const logger = createLogger("ReactHooks");
+// ═══════════════════════════════════════════════════════════════════════════
+// INTERNAL HELPER
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Internal hook to access the AppStrata React context.
+ * Throws if used outside of AppStrataProvider.
+ *
+ * @internal
+ */
+function useAppStrataContext() {
+    const context = useContext(AppStrataContext);
+    if (!context) {
+        throw new Error("AppStrata hooks must be used within <AppStrataProvider>. " +
+            "Wrap your app with <AppStrataProvider> in your root component.");
+    }
+    return context;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// CONTEXT HOOKS (useSyncExternalStore-based)
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Access the complete AppContext.
+ * Re-renders on ANY context change.
+ *
+ * Returns null while waiting for the player READY message.
+ *
+ * @example
+ * ```tsx
+ * const context = useAppContext();
+ * if (!context) return <div>Loading...</div>;
+ * return <h1>{context.config.title as string}</h1>;
+ * ```
+ */
+export function useAppContext() {
+    const { store } = useAppStrataContext();
+    return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+/**
+ * Access just the config portion of AppContext.
+ * Only re-renders when config actually changes (deep comparison).
+ *
+ * @typeParam T - The expected config shape
+ *
+ * @example
+ * ```tsx
+ * const config = useConfig<{ title: string; bgcolor: string }>();
+ * if (!config) return null;
+ * return <h1 style={{ background: config.bgcolor }}>{config.title}</h1>;
+ * ```
+ */
+export function useConfig() {
+    const { store } = useAppStrataContext();
+    return useSyncExternalStore(store.subscribeConfig, store.getConfigSnapshot, store.getConfigSnapshot);
+}
+/**
+ * Access just the resources from AppContext.
+ * Only re-renders when resources actually change (deep comparison).
+ *
+ * @example
+ * ```tsx
+ * const resources = useResources();
+ * const fonts = resources?.filter(r => r.category === "font");
+ * ```
+ */
+export function useResources() {
+    const { store } = useAppStrataContext();
+    return useSyncExternalStore(store.subscribeResources, store.getResourcesSnapshot, store.getResourcesSnapshot);
+}
+/**
+ * Look up a single resource by category and name, returning a ready-to-use URI.
+ * Only re-renders when resources actually change (deep comparison).
+ *
+ * Optionally resolves a named variant instead of the main source.
+ *
+ * @param category - Resource category (e.g. "font", "image")
+ * @param name - Resource name (e.g. "heading", "logo")
+ * @param variant - Optional variant name (e.g. "thumbnail")
+ * @returns Object with `uri`, `source`, and `resource` fields
+ *
+ * @example
+ * ```tsx
+ * const { uri: fontUri } = useResource("font", "heading");
+ * const { uri: logoUri } = useResource("image", "logo");
+ *
+ * // With variant:
+ * const { uri: thumbUri } = useResource("image", "logo", "thumbnail");
+ * ```
+ */
+export function useResource(category, name, variant) {
+    const resources = useResources();
+    return useMemo(() => {
+        if (!resources)
+            return { uri: null, source: null, resource: null };
+        const resource = resources.find(r => r.category === category && r.name === name) ?? null;
+        if (!resource)
+            return { uri: null, source: null, resource: null };
+        const source = variant
+            ? (resource.variants?.[variant]?.source ?? null)
+            : resource.source;
+        const uri = source ? resolveSourceUri(source) : null;
+        return { uri, source, resource };
+    }, [resources, category, name, variant]);
+}
+/**
+ * Load all font resources from the player context.
+ *
+ * Injects `<link>` stylesheet elements for every resource with
+ * `category === "font"`. Re-loads when the resource list changes
+ * (e.g. during CMS live preview).
+ *
+ * @returns `true` once all font stylesheets have loaded, `false` while loading
+ *
+ * @example
+ * ```tsx
+ * const fontsLoaded = useFonts();
+ * if (!fontsLoaded) return <div>Loading fonts...</div>;
+ * ```
+ */
+export function useFonts() {
+    const resources = useResources();
+    const [loaded, setLoaded] = useState(false);
+    useEffect(() => {
+        if (!resources)
+            return;
+        const fonts = resources.filter(r => r.category === "font");
+        if (fonts.length === 0) {
+            setLoaded(true);
+            return;
+        }
+        setLoaded(false);
+        loadFonts(resources).then(() => setLoaded(true));
+    }, [resources]);
+    return loaded;
+}
+/**
+ * Load all stylesheet resources from the player context.
+ *
+ * Injects `<link>` stylesheet elements for every resource with
+ * `category === "stylesheet"`. Re-loads when the resource list changes
+ * (e.g. during CMS live preview).
+ *
+ * @returns `true` once all stylesheets have loaded, `false` while loading
+ *
+ * @example
+ * ```tsx
+ * const stylesLoaded = useStylesheets();
+ * if (!stylesLoaded) return <div>Loading styles...</div>;
+ * ```
+ */
+export function useStylesheets() {
+    const resources = useResources();
+    const [loaded, setLoaded] = useState(false);
+    useEffect(() => {
+        if (!resources)
+            return;
+        const sheets = resources.filter(r => r.category === "stylesheet");
+        if (sheets.length === 0) {
+            setLoaded(true);
+            return;
+        }
+        setLoaded(false);
+        loadStylesheets(resources).then(() => setLoaded(true));
+    }, [resources]);
+    return loaded;
+}
+/**
+ * Access just the device information from AppContext.
+ * Only re-renders when device info actually changes (deep comparison).
+ *
+ * @example
+ * ```tsx
+ * const device = useDevice();
+ * if (!device) return null;
+ * return <footer>Playing on: {device.name}</footer>;
+ * ```
+ */
+export function useDevice() {
+    const { store } = useAppStrataContext();
+    return useSyncExternalStore(store.subscribeDevice, store.getDeviceSnapshot, store.getDeviceSnapshot);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// PLAYER ACCESS
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Access the SignagePlayer instance directly.
+ * Returns a stable reference (singleton) -- never triggers re-renders.
+ *
+ * Use this for imperative operations or capabilities not covered by
+ * dedicated hooks.
+ *
+ * @example
+ * ```tsx
+ * const player = usePlayer();
+ * const handleComplete = () => player.notifyComplete();
+ * ```
+ */
+export function usePlayer() {
+    const { player } = useAppStrataContext();
+    return player;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// CAPABILITY CHECK
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Check if a capability is available.
+ *
+ * Returns a tri-state value:
+ * - `null` while the player hasn't initialized yet (pre-READY)
+ * - `true` when the capability is supported
+ * - `false` when the capability is NOT supported
+ *
+ * Re-renders on any context change (delegates to useAppContext internally).
+ *
+ * @param capability - The capability to check (e.g., "storage", "proxy")
+ *
+ * @example
+ * ```tsx
+ * const hasStorage = useCapability("storage");
+ * if (hasStorage === null) return <div>Initializing...</div>;
+ * if (hasStorage) { ... }
+ * ```
+ */
+export function useCapability(capability) {
+    const context = useAppContext();
+    if (context === null)
+        return null; // Not yet initialized
+    return context.hasCapability(capability);
+}
+/**
+ * Subscribe to lifecycle events.
+ * Callbacks can optionally return cleanup functions.
+ *
+ * Auto-subscribes on mount, auto-cleans up on unmount.
+ *
+ * **Note:** Because `useEffect` runs after paint, handlers for transient phases
+ * like `Show` and `Hide` may not fire if the phase has already passed by the
+ * time the effect registers them. Use `onStart`/`onStop` for work that must
+ * not be skipped, or read `useLifecyclePhase()` to derive state from the
+ * current phase.
+ *
+ * @example
+ * ```tsx
+ * useLifecycle({
+ *   onStart: () => {
+ *     const interval = setInterval(tick, 1000);
+ *     return () => clearInterval(interval); // cleanup
+ *   },
+ *   onStop: () => console.log("Stopped"),
+ * });
+ * ```
+ */
+export function useLifecycle(callbacks) {
+    const { player } = useAppStrataContext();
+    // Use refs to always call the latest callbacks without re-subscribing
+    const callbacksRef = useRef(callbacks);
+    callbacksRef.current = callbacks;
+    useEffect(() => {
+        const cleanups = [];
+        player.onShow(() => {
+            const cleanup = callbacksRef.current.onShow?.();
+            if (typeof cleanup === "function")
+                cleanups.push(cleanup);
+        });
+        player.onStart(() => {
+            const cleanup = callbacksRef.current.onStart?.();
+            if (typeof cleanup === "function")
+                cleanups.push(cleanup);
+        });
+        player.onHide(() => {
+            const cleanup = callbacksRef.current.onHide?.();
+            if (typeof cleanup === "function")
+                cleanups.push(cleanup);
+        });
+        player.onStop(() => {
+            const cleanup = callbacksRef.current.onStop?.();
+            if (typeof cleanup === "function")
+                cleanups.push(cleanup);
+        });
+        logger.info("Lifecycle hooks registered");
+        return () => {
+            cleanups.forEach((cleanup) => cleanup());
+        };
+    }, [player]);
+}
+/**
+ * Read the current lifecycle phase reactively.
+ *
+ * Re-renders whenever the phase transitions. Returns `LifecyclePhase.None`
+ * before the handshake completes.
+ *
+ * @example
+ * ```tsx
+ * const phase = useLifecyclePhase();
+ * const isPlaying = phase === LifecyclePhase.Start;
+ * const isVisible = phase === LifecyclePhase.Show || phase === LifecyclePhase.Start;
+ * ```
+ */
+export function useLifecyclePhase() {
+    const { player } = useAppStrataContext();
+    const [phase, setPhase] = useState(player.lifecyclePhase);
+    useEffect(() => {
+        // Sync in case the phase changed between render and effect
+        setPhase(player.lifecyclePhase);
+        player.onInit(() => setPhase(player.lifecyclePhase));
+        player.onShow(() => setPhase(player.lifecyclePhase));
+        player.onStart(() => setPhase(player.lifecyclePhase));
+        player.onHide(() => setPhase(player.lifecyclePhase));
+        player.onStop(() => setPhase(player.lifecyclePhase));
+    }, [player]);
+    return phase;
+}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @appstrata/react - React hooks and components for AppStrata Digital Signage SDK
+ *
+ * Provides React hooks for app developers to interact with the SignagePlayer runtime.
+ * All hooks must be used within an AppStrataProvider.
+ *
+ * @example
+ * ```tsx
+ * import { AppStrataProvider, useAppContext, useLifecyclePhase, LifecyclePhase } from "@appstrata/react";
+ *
+ * function App() {
+ *   const context = useAppContext();
+ *   const phase = useLifecyclePhase();
+ *
+ *   if (!context) return <div>Loading...</div>;
+ *   return <>
+ *     <h1>{context.config.title as string}</h1>
+ *     <p>Phase: {phase}</p>
+ *   </>;
+ * }
+ *
+ * root.render(
+ *   <AppStrataProvider>
+ *     <App />
+ *   </AppStrataProvider>
+ * );
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { LifecyclePhase } from "@appstrata/core";
+export { AppStrataProvider } from "./provider.js";
+export type { AppStrataProviderProps } from "./provider.js";
+export { useAppContext, useConfig, useResources, useResource, useFonts, useStylesheets, useDevice, usePlayer, useCapability, useLifecycle, useLifecyclePhase, } from "./hooks.js";
+export type { LifecycleCallbacks, UseResourceResult } from "./hooks.js";
+export { useStorage } from "./use-storage.js";
+export type { StorageFallbackAdapter, UseStorageOptions, UseStorageKeyResult, UseStorageFullResult, } from "./use-storage.js";
+export { useProxy } from "./use-proxy.js";
+export type { UseProxyOptions, UseProxyResult } from "./use-proxy.js";
+export { useMediaCache } from "./use-media-cache.js";
+export type { UseMediaCacheOptions, UseMediaCacheResult } from "./use-media-cache.js";
+export { useStatic } from "./use-static.js";
+export type { UseStaticResult } from "./use-static.js";
+export { useInteraction } from "./use-interaction.js";
+export type { UseInteractionResult } from "./use-interaction.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,YAAY,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,EACL,aAAa,EACb,SAAS,EACT,YAAY,EACZ,WAAW,EACX,QAAQ,EACR,cAAc,EACd,SAAS,EACT,SAAS,EACT,aAAa,EACb,YAAY,EACZ,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGxE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EACV,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGtE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGtF,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGvD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,46 @@
+/**
+ * @appstrata/react - React hooks and components for AppStrata Digital Signage SDK
+ *
+ * Provides React hooks for app developers to interact with the SignagePlayer runtime.
+ * All hooks must be used within an AppStrataProvider.
+ *
+ * @example
+ * ```tsx
+ * import { AppStrataProvider, useAppContext, useLifecyclePhase, LifecyclePhase } from "@appstrata/react";
+ *
+ * function App() {
+ *   const context = useAppContext();
+ *   const phase = useLifecyclePhase();
+ *
+ *   if (!context) return <div>Loading...</div>;
+ *   return <>
+ *     <h1>{context.config.title as string}</h1>
+ *     <p>Phase: {phase}</p>
+ *   </>;
+ * }
+ *
+ * root.render(
+ *   <AppStrataProvider>
+ *     <App />
+ *   </AppStrataProvider>
+ * );
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Re-export LifecyclePhase for convenience (avoids needing @appstrata/core import)
+export { LifecyclePhase } from "@appstrata/core";
+// Provider
+export { AppStrataProvider } from "./provider.js";
+// Core hooks
+export { useAppContext, useConfig, useResources, useResource, useFonts, useStylesheets, useDevice, usePlayer, useCapability, useLifecycle, useLifecyclePhase, } from "./hooks.js";
+// Storage hook
+export { useStorage } from "./use-storage.js";
+// Proxy hook
+export { useProxy } from "./use-proxy.js";
+// Media Cache hook
+export { useMediaCache } from "./use-media-cache.js";
+// Static hook
+export { useStatic } from "./use-static.js";
+// Interaction hook
+export { useInteraction } from "./use-interaction.js";