@almadar/ui 4.0.1 → 4.1.0

package/dist/avl/index.js

@@ -4084,12 +4084,42 @@ var init_EntitySchemaContext = __esm({
 function generateId() {
   return `slot-content-${++idCounter}-${Date.now()}`;
 }
+function aggregateSlot(sources) {
+  if (!sources) return null;
+  const entries = Object.entries(sources);
+  if (entries.length === 0) return null;
+  if (entries.length === 1) return entries[0][1];
+  const children = entries.map(([, entry]) => ({
+    type: entry.pattern,
+    ...entry.props
+  }));
+  const stackId = `slot-content-stack-${entries.map(([k]) => k).join("-")}`;
+  return {
+    id: stackId,
+    pattern: "stack",
+    props: {
+      direction: "vertical",
+      gap: "lg",
+      children
+    },
+    priority: 0,
+    animation: "fade",
+    sourceTrait: MULTI_SOURCE_STACK_TRAIT
+  };
+}
 function useUISlotManager() {
-  const [slots, setSlots] = useState(DEFAULT_SLOTS);
+  const [sources, setSources] = useState(DEFAULT_SOURCES);
   const subscribersRef = useRef(/* @__PURE__ */ new Set());
   const timersRef = useRef(/* @__PURE__ */ new Map());
   const traitIndexRef = useRef(/* @__PURE__ */ new Map());
   const traitSubscribersRef = useRef(/* @__PURE__ */ new Map());
+  const slots = useMemo(() => {
+    const out = { ...DEFAULT_SLOTS };
+    for (const slot of ALL_SLOTS) {
+      out[slot] = aggregateSlot(sources[slot]);
+    }
+    return out;
+  }, [sources]);
   useEffect(() => {
     return () => {
       timersRef.current.forEach((timer) => clearTimeout(timer));
@@ -4128,103 +4158,160 @@ function useUISlotManager() {
   const unindexTrait = useCallback((traitName) => {
     traitIndexRef.current.delete(traitName);
   }, []);
-  const render = useCallback((config) => {
-    const id = generateId();
-    const content = {
-      id,
-      pattern: config.pattern,
-      props: config.props ?? {},
-      priority: config.priority ?? 0,
-      animation: config.animation ?? "fade",
-      onDismiss: config.onDismiss,
-      sourceTrait: config.sourceTrait
-    };
-    if (config.autoDismissMs && config.autoDismissMs > 0) {
-      content.autoDismissAt = Date.now() + config.autoDismissMs;
-      const timer = setTimeout(() => {
-        setSlots((prev) => {
-          if (prev[config.target]?.id === id) {
-            content.onDismiss?.();
-            notifySubscribers(config.target, null);
-            return { ...prev, [config.target]: null };
-          }
+  const render = useCallback(
+    (config) => {
+      const id = generateId();
+      const sourceKey = config.sourceTrait ?? DEFAULT_SOURCE_KEY;
+      const content = {
+        id,
+        pattern: config.pattern,
+        props: config.props ?? {},
+        priority: config.priority ?? 0,
+        animation: config.animation ?? "fade",
+        onDismiss: config.onDismiss,
+        sourceTrait: config.sourceTrait
+      };
+      if (config.autoDismissMs && config.autoDismissMs > 0) {
+        content.autoDismissAt = Date.now() + config.autoDismissMs;
+        const timer = setTimeout(() => {
+          setSources((prev) => {
+            const slotSources = prev[config.target];
+            if (slotSources && slotSources[sourceKey]?.id === id) {
+              content.onDismiss?.();
+              const next = { ...slotSources };
+              delete next[sourceKey];
+              const updated = { ...prev, [config.target]: next };
+              notifySubscribers(config.target, aggregateSlot(next));
+              return updated;
+            }
+            return prev;
+          });
+          timersRef.current.delete(id);
+        }, config.autoDismissMs);
+        timersRef.current.set(id, timer);
+      }
+      setSources((prev) => {
+        const slotSources = prev[config.target] ?? {};
+        const existing = slotSources[sourceKey];
+        if (existing && existing.priority > content.priority) {
+          console.warn(
+            `[UISlots] Slot "${config.target}" source "${sourceKey}" already has higher priority content (${existing.priority} > ${content.priority})`
+          );
           return prev;
-        });
-        timersRef.current.delete(id);
-      }, config.autoDismissMs);
-      timersRef.current.set(id, timer);
-    }
-    setSlots((prev) => {
-      const existing = prev[config.target];
-      if (existing && existing.priority > content.priority) {
-        console.warn(
-          `[UISlots] Slot "${config.target}" already has higher priority content (${existing.priority} > ${content.priority})`
-        );
-        return prev;
-      }
-      if (content.sourceTrait) {
-        indexTraitRender(content.sourceTrait, content);
-        notifyTraitSubscribers(content.sourceTrait, content);
-      }
-      notifySubscribers(config.target, content);
-      return { ...prev, [config.target]: content };
-    });
-    return id;
-  }, [notifySubscribers, notifyTraitSubscribers, indexTraitRender]);
-  const clear = useCallback((slot) => {
-    setSlots((prev) => {
-      const content = prev[slot];
-      if (content) {
-        const timer = timersRef.current.get(content.id);
-        if (timer) {
-          clearTimeout(timer);
-          timersRef.current.delete(content.id);
         }
-        content.onDismiss?.();
+        const nextSources = {
+          ...slotSources,
+          [sourceKey]: content
+        };
+        const nextAll = { ...prev, [config.target]: nextSources };
         if (content.sourceTrait) {
-          unindexTrait(content.sourceTrait);
-          notifyTraitSubscribers(content.sourceTrait, null);
+          indexTraitRender(content.sourceTrait, content);
+          notifyTraitSubscribers(content.sourceTrait, content);
+        }
+        notifySubscribers(config.target, aggregateSlot(nextSources));
+        return nextAll;
+      });
+      return id;
+    },
+    [notifySubscribers, notifyTraitSubscribers, indexTraitRender]
+  );
+  const clear = useCallback(
+    (slot) => {
+      setSources((prev) => {
+        const slotSources = prev[slot];
+        if (!slotSources || Object.keys(slotSources).length === 0) {
+          return prev;
+        }
+        for (const content of Object.values(slotSources)) {
+          const timer = timersRef.current.get(content.id);
+          if (timer) {
+            clearTimeout(timer);
+            timersRef.current.delete(content.id);
+          }
+          content.onDismiss?.();
+          if (content.sourceTrait) {
+            unindexTrait(content.sourceTrait);
+            notifyTraitSubscribers(content.sourceTrait, null);
+          }
         }
         notifySubscribers(slot, null);
-      }
-      return { ...prev, [slot]: null };
-    });
-  }, [notifySubscribers, notifyTraitSubscribers, unindexTrait]);
-  const clearById = useCallback((id) => {
-    setSlots((prev) => {
-      const entry = Object.entries(prev).find(([, content]) => content?.id === id);
-      if (entry) {
-        const [slot, content] = entry;
-        const timer = timersRef.current.get(id);
+        return { ...prev, [slot]: {} };
+      });
+    },
+    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
+  );
+  const clearBySource = useCallback(
+    (slot, sourceTrait) => {
+      const sourceKey = sourceTrait;
+      setSources((prev) => {
+        const slotSources = prev[slot];
+        if (!slotSources || !(sourceKey in slotSources)) return prev;
+        const content = slotSources[sourceKey];
+        const timer = timersRef.current.get(content.id);
         if (timer) {
           clearTimeout(timer);
-          timersRef.current.delete(id);
+          timersRef.current.delete(content.id);
         }
         content.onDismiss?.();
         if (content.sourceTrait) {
           unindexTrait(content.sourceTrait);
           notifyTraitSubscribers(content.sourceTrait, null);
         }
-        notifySubscribers(slot, null);
-        return { ...prev, [slot]: null };
-      }
-      return prev;
-    });
-  }, [notifySubscribers, notifyTraitSubscribers, unindexTrait]);
+        const nextSources = { ...slotSources };
+        delete nextSources[sourceKey];
+        notifySubscribers(slot, aggregateSlot(nextSources));
+        return { ...prev, [slot]: nextSources };
+      });
+    },
+    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
+  );
+  const clearById = useCallback(
+    (id) => {
+      setSources((prev) => {
+        for (const slot of ALL_SLOTS) {
+          const slotSources = prev[slot];
+          if (!slotSources) continue;
+          const matchKey = Object.keys(slotSources).find(
+            (k) => slotSources[k].id === id
+          );
+          if (!matchKey) continue;
+          const content = slotSources[matchKey];
+          const timer = timersRef.current.get(id);
+          if (timer) {
+            clearTimeout(timer);
+            timersRef.current.delete(id);
+          }
+          content.onDismiss?.();
+          if (content.sourceTrait) {
+            unindexTrait(content.sourceTrait);
+            notifyTraitSubscribers(content.sourceTrait, null);
+          }
+          const nextSources = { ...slotSources };
+          delete nextSources[matchKey];
+          notifySubscribers(slot, aggregateSlot(nextSources));
+          return { ...prev, [slot]: nextSources };
+        }
+        return prev;
+      });
+    },
+    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
+  );
   const clearAll = useCallback(() => {
     timersRef.current.forEach((timer) => clearTimeout(timer));
     timersRef.current.clear();
-    setSlots((prev) => {
-      Object.entries(prev).forEach(([slot, content]) => {
-        if (content) {
+    setSources((prev) => {
+      for (const slot of ALL_SLOTS) {
+        const slotSources = prev[slot];
+        if (!slotSources) continue;
+        for (const content of Object.values(slotSources)) {
           content.onDismiss?.();
           if (content.sourceTrait) {
             notifyTraitSubscribers(content.sourceTrait, null);
           }
-          notifySubscribers(slot, null);
         }
-      });
-      return DEFAULT_SLOTS;
+        notifySubscribers(slot, null);
+      }
+      return DEFAULT_SOURCES;
     });
     traitIndexRef.current.clear();
   }, [notifySubscribers, notifyTraitSubscribers]);
@@ -4234,16 +4321,16 @@ function useUISlotManager() {
       subscribersRef.current.delete(callback);
     };
   }, []);
-  const hasContent = useCallback((slot) => {
-    return slots[slot] !== null;
-  }, [slots]);
-  const getContent = useCallback((slot) => {
-    return slots[slot];
-  }, [slots]);
+  const hasContent = useCallback(
+    (slot) => slots[slot] !== null,
+    [slots]
+  );
+  const getContent = useCallback(
+    (slot) => slots[slot],
+    [slots]
+  );
   const getTraitContent = useCallback(
-    (traitName) => {
-      return traitIndexRef.current.get(traitName) ?? null;
-    },
+    (traitName) => traitIndexRef.current.get(traitName) ?? null,
     []
   );
   const subscribeTrait = useCallback(
@@ -4269,6 +4356,7 @@ function useUISlotManager() {
     slots,
     render,
     clear,
+    clearBySource,
     clearById,
     clearAll,
     subscribe: subscribe2,
@@ -4278,24 +4366,40 @@ function useUISlotManager() {
     subscribeTrait
   };
 }
-var DEFAULT_SLOTS, idCounter;
+var DEFAULT_SOURCE_KEY, MULTI_SOURCE_STACK_TRAIT, ALL_SLOTS, DEFAULT_SLOTS, DEFAULT_SOURCES, idCounter;
 var init_useUISlots = __esm({
   "hooks/useUISlots.ts"() {
     "use client";
-    DEFAULT_SLOTS = {
-      main: null,
-      sidebar: null,
-      modal: null,
-      drawer: null,
-      overlay: null,
-      center: null,
-      toast: null,
-      "hud-top": null,
-      "hud-bottom": null,
-      "hud-left": null,
-      "hud-right": null,
-      floating: null
-    };
+    DEFAULT_SOURCE_KEY = "__default__";
+    MULTI_SOURCE_STACK_TRAIT = "__multi_source_stack__";
+    ALL_SLOTS = [
+      "main",
+      "sidebar",
+      "modal",
+      "drawer",
+      "overlay",
+      "center",
+      "toast",
+      "hud-top",
+      "hud-bottom",
+      "hud-left",
+      "hud-right",
+      "floating"
+    ];
+    DEFAULT_SLOTS = ALL_SLOTS.reduce(
+      (acc, slot) => {
+        acc[slot] = null;
+        return acc;
+      },
+      {}
+    );
+    DEFAULT_SOURCES = ALL_SLOTS.reduce(
+      (acc, slot) => {
+        acc[slot] = {};
+        return acc;
+      },
+      {}
+    );
     idCounter = 0;
   }
 });
@@ -51564,7 +51668,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
     canHandleEvent
   };
 }
-var DEFAULT_SOURCE_KEY = "__default__";
+var DEFAULT_SOURCE_KEY2 = "__default__";
 function slotEntriesInOrder(slot) {
   if (!slot) return [];
   const out = [];
@@ -51580,7 +51684,7 @@ var SlotsActionsContext = createContext(null);
 function SlotsProvider({ children }) {
   const [slots, setSlots] = useState({});
   const setSlotPatterns = useCallback((slot, patterns, source) => {
-    const sourceKey = source?.trait ?? DEFAULT_SOURCE_KEY;
+    const sourceKey = source?.trait ?? DEFAULT_SOURCE_KEY2;
     setSlots((prev) => {
       const prevSlot = prev[slot] ?? {};
       return {
@@ -51906,13 +52010,11 @@ function SlotBridge() {
   return null;
 }
 function applyServerEffects(effects, uiSlots, onNavigate) {
-  const perSlotRenders = /* @__PURE__ */ new Map();
   for (const eff of effects) {
     if (eff.type === "render-ui" && eff.slot && eff.pattern) {
       const patternRecord = eff.pattern;
       const { type: patternType, children, ...inlineProps } = patternRecord;
       const normalizedChildren = Array.isArray(children) ? children.map((c) => normalizeChild(c)) : children;
-      const sourceTrait = eff.traitName ?? "server";
       uiSlots.render({
         target: eff.slot,
         pattern: patternType,
@@ -51920,38 +52022,12 @@ function applyServerEffects(effects, uiSlots, onNavigate) {
           ...inlineProps,
           ...normalizedChildren !== void 0 ? { children: normalizedChildren } : {}
         },
-        sourceTrait
+        sourceTrait: eff.traitName ?? "server"
       });
-      const bucket = perSlotRenders.get(eff.slot) ?? [];
-      bucket.push({
-        sourceTrait,
-        pattern: {
-          type: patternType,
-          ...inlineProps,
-          ...normalizedChildren !== void 0 ? { children: normalizedChildren } : {}
-        }
-      });
-      perSlotRenders.set(eff.slot, bucket);
     } else if (eff.type === "navigate" && eff.route && onNavigate) {
       onNavigate(eff.route, eff.params);
     }
   }
-  for (const [slot, bucket] of perSlotRenders) {
-    const distinctSources = new Set(bucket.map((b) => b.sourceTrait));
-    if (distinctSources.size <= 1) continue;
-    uiSlots.render({
-      target: slot,
-      pattern: "stack",
-      props: {
-        direction: "vertical",
-        gap: "lg",
-        children: bucket.map((b) => b.pattern)
-      },
-      // Use a synthetic wrapper source trait; individual traits' frames
-      // already live in the per-trait index from the per-effect loop.
-      sourceTrait: "__multi_source_stack__"
-    });
-  }
 }
 function TraitInitializer({ traits: traits2, orbitalNames, onNavigate, onLocalFallback, persistence }) {
   const slotsActions = useSlotsActions();