@almadar/ui 1.0.30 → 1.0.32

package/dist/{ThemeContext-lI5bo85E.d.ts → ThemeContext-D9xUORq5.d.ts}

@@ -56,6 +56,8 @@ interface ThemeProviderProps {
     defaultTheme?: string;
     /** Default color mode */
     defaultMode?: ColorMode;
+    /** Optional target element ref — when provided, theme attributes are applied to this element instead of document.documentElement */
+    targetRef?: React__default.RefObject<HTMLElement>;
 }
 /**
  * Unified ThemeProvider component

package/dist/chunk-45CTDYBT.js

@@ -0,0 +1,174 @@
+// lib/verificationRegistry.ts
+var checks = /* @__PURE__ */ new Map();
+var transitions = [];
+var bridgeHealth = null;
+var MAX_TRANSITIONS = 500;
+var listeners = /* @__PURE__ */ new Set();
+function notifyListeners() {
+  listeners.forEach((l) => l());
+  exposeOnWindow();
+}
+function registerCheck(id, label, status = "pending", details) {
+  checks.set(id, { id, label, status, details, updatedAt: Date.now() });
+  notifyListeners();
+}
+function updateCheck(id, status, details) {
+  const check = checks.get(id);
+  if (check) {
+    check.status = status;
+    if (details !== void 0) check.details = details;
+    check.updatedAt = Date.now();
+  } else {
+    checks.set(id, { id, label: id, status, details, updatedAt: Date.now() });
+  }
+  notifyListeners();
+}
+function getAllChecks() {
+  return Array.from(checks.values());
+}
+function recordTransition(trace) {
+  const entry = {
+    ...trace,
+    id: `t-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  };
+  transitions.push(entry);
+  if (transitions.length > MAX_TRANSITIONS) {
+    transitions.shift();
+  }
+  if (entry.event === "INIT") {
+    const hasFetch = entry.effects.some((e) => e.type === "fetch");
+    const checkId = `init-fetch-${entry.traitName}`;
+    if (hasFetch) {
+      registerCheck(
+        checkId,
+        `INIT transition for "${entry.traitName}" has fetch effect`,
+        "pass"
+      );
+    } else {
+      const hasRenderUI = entry.effects.some((e) => e.type === "render-ui");
+      if (hasRenderUI) {
+        registerCheck(
+          checkId,
+          `INIT transition for "${entry.traitName}" missing fetch effect`,
+          "fail",
+          "Entity-bound render-ui without a fetch effect will show empty data"
+        );
+      }
+    }
+  }
+  const failedEffects = entry.effects.filter((e) => e.status === "failed");
+  if (failedEffects.length > 0) {
+    registerCheck(
+      `effects-${entry.id}`,
+      `Effects failed in ${entry.traitName}: ${entry.from} -> ${entry.to}`,
+      "fail",
+      failedEffects.map((e) => `${e.type}: ${e.error}`).join("; ")
+    );
+  }
+  notifyListeners();
+}
+function getTransitions() {
+  return [...transitions];
+}
+function getTransitionsForTrait(traitName) {
+  return transitions.filter((t) => t.traitName === traitName);
+}
+function updateBridgeHealth(health) {
+  bridgeHealth = { ...health };
+  const checkId = "server-bridge";
+  if (health.connected) {
+    registerCheck(checkId, "Server bridge connected", "pass");
+  } else {
+    registerCheck(
+      checkId,
+      "Server bridge disconnected",
+      "fail",
+      health.lastError || "Bridge is not connected"
+    );
+  }
+  notifyListeners();
+}
+function getBridgeHealth() {
+  return bridgeHealth ? { ...bridgeHealth } : null;
+}
+function getSummary() {
+  const allChecks = getAllChecks();
+  return {
+    totalChecks: allChecks.length,
+    passed: allChecks.filter((c) => c.status === "pass").length,
+    failed: allChecks.filter((c) => c.status === "fail").length,
+    warnings: allChecks.filter((c) => c.status === "warn").length,
+    pending: allChecks.filter((c) => c.status === "pending").length
+  };
+}
+function getSnapshot() {
+  return {
+    checks: getAllChecks(),
+    transitions: getTransitions(),
+    bridge: getBridgeHealth(),
+    summary: getSummary()
+  };
+}
+function subscribeToVerification(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function exposeOnWindow() {
+  if (typeof window === "undefined") return;
+  if (!window.__orbitalVerification) {
+    window.__orbitalVerification = {
+      getSnapshot,
+      getChecks: getAllChecks,
+      getTransitions,
+      getBridge: getBridgeHealth,
+      getSummary,
+      waitForTransition
+    };
+  }
+}
+function waitForTransition(event, timeoutMs = 1e4) {
+  return new Promise((resolve) => {
+    const existing = transitions.find((t) => t.event === event);
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      unsub();
+      resolve(null);
+    }, timeoutMs);
+    const unsub = subscribeToVerification(() => {
+      const found = transitions.find((t) => t.event === event);
+      if (found) {
+        clearTimeout(timeout);
+        unsub();
+        resolve(found);
+      }
+    });
+  });
+}
+function bindEventBus(eventBus) {
+  if (typeof window === "undefined") return;
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    window.__orbitalVerification.sendEvent = (event, payload) => {
+      eventBus.emit(event, payload);
+    };
+  }
+}
+function bindTraitStateGetter(getter) {
+  if (typeof window === "undefined") return;
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    window.__orbitalVerification.getTraitState = getter;
+  }
+}
+function clearVerification() {
+  checks.clear();
+  transitions.length = 0;
+  bridgeHealth = null;
+  notifyListeners();
+}
+exposeOnWindow();
+
+export { bindEventBus, bindTraitStateGetter, clearVerification, getAllChecks, getBridgeHealth, getSnapshot, getSummary, getTransitions, getTransitionsForTrait, recordTransition, registerCheck, subscribeToVerification, updateBridgeHealth, updateCheck, waitForTransition };

package/dist/{chunk-4UFNDD6B.js → chunk-BTXQJGFB.js}

@@ -1,7 +1,7 @@
+import { useUISlotManager } from './chunk-7NEWMNNU.js';
 import { createContext, useMemo, useState, useEffect, useCallback, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
-// context/ThemeContext.tsx
 var BUILT_IN_THEMES = [
   {
     name: "wireframe",
@@ -118,7 +118,8 @@ var ThemeProvider = ({
   children,
   themes = [],
   defaultTheme = "wireframe",
-  defaultMode = "system"
+  defaultMode = "system",
+  targetRef
 }) => {
   const availableThemes = useMemo(() => {
     const themeMap = /* @__PURE__ */ new Map();
@@ -126,8 +127,9 @@ var ThemeProvider = ({
     themes.forEach((t) => themeMap.set(t.name, t));
     return Array.from(themeMap.values());
   }, [themes]);
+  const isScoped = !!targetRef;
   const [theme, setThemeState] = useState(() => {
-    if (typeof window === "undefined") return defaultTheme;
+    if (isScoped || typeof window === "undefined") return defaultTheme;
     const stored = localStorage.getItem(THEME_STORAGE_KEY);
     const validThemes = [
       ...BUILT_IN_THEMES.map((t) => t.name),
@@ -139,7 +141,7 @@ var ThemeProvider = ({
     return defaultTheme;
   });
   const [mode, setModeState] = useState(() => {
-    if (typeof window === "undefined") return defaultMode;
+    if (isScoped || typeof window === "undefined") return defaultMode;
     const stored = localStorage.getItem(MODE_STORAGE_KEY);
     if (stored === "light" || stored === "dark" || stored === "system") {
       return stored;
@@ -167,17 +169,25 @@ var ThemeProvider = ({
     return void 0;
   }, [mode]);
   useEffect(() => {
+    if (isScoped) {
+      if (targetRef?.current) {
+        targetRef.current.setAttribute("data-theme", appliedTheme);
+        targetRef.current.classList.remove("light", "dark");
+        targetRef.current.classList.add(resolvedMode);
+      }
+      return;
+    }
     const root = document.documentElement;
     root.setAttribute("data-theme", appliedTheme);
     root.classList.remove("light", "dark");
     root.classList.add(resolvedMode);
-  }, [appliedTheme, resolvedMode]);
+  }, [appliedTheme, resolvedMode, targetRef, isScoped]);
   const setTheme = useCallback(
     (newTheme) => {
       const validTheme = availableThemes.find((t) => t.name === newTheme);
       if (validTheme) {
         setThemeState(newTheme);
-        if (typeof window !== "undefined") {
+        if (!isScoped && typeof window !== "undefined") {
           localStorage.setItem(THEME_STORAGE_KEY, newTheme);
         }
       } else {
@@ -190,7 +200,7 @@ var ThemeProvider = ({
   );
   const setMode = useCallback((newMode) => {
     setModeState(newMode);
-    if (typeof window !== "undefined") {
+    if (!isScoped && typeof window !== "undefined") {
       localStorage.setItem(MODE_STORAGE_KEY, newMode);
     }
   }, []);
@@ -242,5 +252,28 @@ function useTheme() {
   return context;
 }
 var ThemeContext_default = ThemeContext;
+var UISlotContext = createContext(null);
+function UISlotProvider({ children }) {
+  const slotManager = useUISlotManager();
+  const contextValue = useMemo(() => slotManager, [slotManager]);
+  return /* @__PURE__ */ jsx(UISlotContext.Provider, { value: contextValue, children });
+}
+function useUISlots() {
+  const context = useContext(UISlotContext);
+  if (!context) {
+    throw new Error(
+      "useUISlots must be used within a UISlotProvider. Make sure your component tree is wrapped with <UISlotProvider>."
+    );
+  }
+  return context;
+}
+function useSlotContent(slot) {
+  const { getContent } = useUISlots();
+  return getContent(slot);
+}
+function useSlotHasContent(slot) {
+  const { hasContent } = useUISlots();
+  return hasContent(slot);
+}
 
-export { BUILT_IN_THEMES, ThemeContext_default, ThemeProvider, useTheme };
+export { BUILT_IN_THEMES, ThemeContext_default, ThemeProvider, UISlotContext, UISlotProvider, useSlotContent, useSlotHasContent, useTheme, useUISlots };