@almadar/ui 4.0.1 → 4.2.1

package/dist/components/index.js

@@ -17221,6 +17221,16 @@ function statusVariant2(value) {
   if (["new", "created", "scheduled", "queued", "info"].includes(v)) return "info";
   return "default";
 }
+function resolveBadgeVariant(field, value) {
+  const fromMap = field.colorMap?.[value];
+  if (fromMap) {
+    const normalised = fromMap === "destructive" ? "danger" : fromMap;
+    if (BADGE_VARIANTS.has(normalised)) {
+      return normalised;
+    }
+  }
+  return statusVariant2(value);
+}
 function formatDate2(value) {
   if (!value) return "";
   const d = new Date(String(value));
@@ -17434,7 +17444,7 @@ function DataGrid({
                       if (val === void 0 || val === null) return null;
                       return /* @__PURE__ */ jsxs(HStack, { gap: "xs", className: "items-center", children: [
                         field.icon && /* @__PURE__ */ jsx(Icon, { name: field.icon, size: "xs" }),
-                        /* @__PURE__ */ jsx(Badge, { variant: statusVariant2(String(val)), children: String(val) })
+                        /* @__PURE__ */ jsx(Badge, { variant: resolveBadgeVariant(field, String(val)), children: String(val) })
                       ] }, field.name);
                     }) })
                   ] }),
@@ -17527,7 +17537,7 @@ function DataGrid({
     )
   ] });
 }
-var gapStyles6;
+var BADGE_VARIANTS, gapStyles6;
 var init_DataGrid = __esm({
   "components/molecules/DataGrid.tsx"() {
     "use client";
@@ -17542,6 +17552,17 @@ var init_DataGrid = __esm({
     init_Button();
     init_Icon();
     init_InfiniteScrollSentinel();
+    BADGE_VARIANTS = /* @__PURE__ */ new Set([
+      "default",
+      "primary",
+      "secondary",
+      "success",
+      "warning",
+      "danger",
+      "error",
+      "info",
+      "neutral"
+    ]);
     gapStyles6 = {
       none: "gap-0",
       sm: "gap-2",
@@ -40600,30 +40621,76 @@ function useDeepAgentGeneration() {
 
 // hooks/index.ts
 init_useEventBus();
-var 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
-};
+var DEFAULT_SOURCE_KEY = "__default__";
+var MULTI_SOURCE_STACK_TRAIT = "__multi_source_stack__";
+var ALL_SLOTS2 = [
+  "main",
+  "sidebar",
+  "modal",
+  "drawer",
+  "overlay",
+  "center",
+  "toast",
+  "hud-top",
+  "hud-bottom",
+  "hud-left",
+  "hud-right",
+  "floating"
+];
+var DEFAULT_SLOTS = ALL_SLOTS2.reduce(
+  (acc, slot) => {
+    acc[slot] = null;
+    return acc;
+  },
+  {}
+);
+var DEFAULT_SOURCES = ALL_SLOTS2.reduce(
+  (acc, slot) => {
+    acc[slot] = {};
+    return acc;
+  },
+  {}
+);
 var idCounter = 0;
 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_SLOTS2) {
+      out[slot] = aggregateSlot(sources[slot]);
+    }
+    return out;
+  }, [sources]);
   useEffect(() => {
     return () => {
       timersRef.current.forEach((timer) => clearTimeout(timer));
@@ -40662,103 +40729,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_SLOTS2) {
+          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_SLOTS2) {
+        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]);
@@ -40768,16 +40892,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(
@@ -40803,6 +40927,7 @@ function useUISlotManager() {
     slots,
     render,
     clear,
+    clearBySource,
     clearById,
     clearAll,
     subscribe: subscribe2,

package/dist/components/molecules/DataGrid.d.ts

@@ -24,6 +24,16 @@ export interface DataGridField {
     variant?: 'h3' | 'h4' | 'body' | 'caption' | 'badge' | 'small' | 'progress';
     /** Optional format function name: 'date', 'currency', 'number', 'boolean' */
     format?: 'date' | 'currency' | 'number' | 'boolean' | 'percent';
+    /**
+     * Per-value color mapping for `variant: 'badge'`. Keys are exact field
+     * values; values are Badge variant names. Accepts the shadcn-style
+     * `destructive` alias and normalises it to `danger` at render time. When
+     * present, takes precedence over the built-in `statusVariant` heuristic.
+     *
+     * Example:
+     *   colorMap: { active: 'success', pending: 'warning', failed: 'destructive' }
+     */
+    colorMap?: Record<string, string>;
 }
 export interface DataGridItemAction {
     /** Button label */