@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/chunk-YHMRX6YA.js

@@ -0,0 +1,455 @@
+import { isNotificationSlot } from './chunk-P4ZFUQFF.js';
+import React, { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+import { RENDERED_SLOTS, isRenderBindingMarker } from '@almadar/core';
+import { createLogger } from '@almadar/logger';
+
+function expressionEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!expressionEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (a !== null && b !== null && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b) && !(a instanceof Date) && !(b instanceof Date)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+      if (!expressionEqual(
+        a[key],
+        b[key]
+      )) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isPlainSlotObject(value) {
+  if (value === null || value === void 0 || typeof value !== "object") return false;
+  if (Array.isArray(value)) return false;
+  if (React.isValidElement(value)) return false;
+  if (value instanceof Date) return false;
+  if (isRenderBindingMarker(value)) return false;
+  return true;
+}
+function shareValue(prev, next) {
+  if (Object.is(prev, next)) return { value: prev, equal: true };
+  const prevMarker = isRenderBindingMarker(prev) ? prev : void 0;
+  const nextMarker = isRenderBindingMarker(next) ? next : void 0;
+  if (prevMarker !== void 0 || nextMarker !== void 0) {
+    if (prevMarker !== void 0 && nextMarker !== void 0 && expressionEqual(prevMarker.expression, nextMarker.expression)) {
+      return { value: prev, equal: true };
+    }
+    return { value: next, equal: false };
+  }
+  if (prev instanceof Date || next instanceof Date) {
+    return prev instanceof Date && next instanceof Date && prev.getTime() === next.getTime() ? { value: prev, equal: true } : { value: next, equal: false };
+  }
+  if (typeof prev === "function" || typeof next === "function") return { value: next, equal: false };
+  if (React.isValidElement(prev) || React.isValidElement(next)) return { value: next, equal: false };
+  if (Array.isArray(prev) && Array.isArray(next)) {
+    let equal = prev.length === next.length;
+    const out = new Array(next.length);
+    for (let i = 0; i < next.length; i++) {
+      const child = shareValue(prev[i], next[i]);
+      out[i] = child.value;
+      if (!child.equal) equal = false;
+    }
+    return equal ? { value: prev, equal: true } : { value: out, equal: false };
+  }
+  if (isPlainSlotObject(prev) && isPlainSlotObject(next)) {
+    const prevKeys = Object.keys(prev);
+    const nextKeys = Object.keys(next);
+    let equal = prevKeys.length === nextKeys.length;
+    const out = {};
+    for (const key of nextKeys) {
+      if (!Object.prototype.hasOwnProperty.call(prev, key)) {
+        equal = false;
+        out[key] = next[key];
+        continue;
+      }
+      const child = shareValue(prev[key], next[key]);
+      out[key] = child.value;
+      if (!child.equal) equal = false;
+    }
+    return equal ? { value: prev, equal: true } : { value: out, equal: false };
+  }
+  return { value: next, equal: false };
+}
+function reconcileSlotProps(prev, next) {
+  if (typeof prev === "string") return { value: next, equal: prev === next };
+  if (typeof next === "string") return { value: next, equal: false };
+  const result = shareValue(prev, next);
+  return { value: result.value, equal: result.equal };
+}
+
+// src/hooks/useUISlots.ts
+var log = createLogger("almadar:ui:ui-slots");
+var DEFAULT_SOURCE_KEY = "__default__";
+var MULTI_SOURCE_STACK_TRAIT = "__multi_source_stack__";
+var ALL_SLOTS = RENDERED_SLOTS;
+var DEFAULT_SLOTS = ALL_SLOTS.reduce(
+  (acc, slot) => {
+    acc[slot] = null;
+    return acc;
+  },
+  {}
+);
+var DEFAULT_SOURCES = ALL_SLOTS.reduce(
+  (acc, slot) => {
+    acc[slot] = {};
+    return acc;
+  },
+  {}
+);
+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(
+    ([sourceKey, entry]) => (
+      // A bare-string payload (`(render-ui main "@trait.X")`) is kept as the
+      // raw string child — the children walker lifts `@trait.X` strings to
+      // TraitFrames — spreading it would explode it into indexed characters.
+      typeof entry.props === "string" ? entry.props : {
+        type: entry.pattern,
+        ...entry.props,
+        ...sourceKey !== DEFAULT_SOURCE_KEY && { _sourceTrait: sourceKey }
+      }
+    )
+  );
+  log.info("aggregateSlot:multi-source", {
+    writers: entries.map(([k]) => k).join(","),
+    patterns: entries.map(([, e]) => e.pattern).join(",")
+  });
+  const stackId = `slot-content-stack-${entries.map(([k]) => k).join("-")}`;
+  return {
+    id: stackId,
+    pattern: "stack",
+    props: {
+      direction: "vertical",
+      gap: "lg",
+      children
+    },
+    priority: 0,
+    sourceTrait: MULTI_SOURCE_STACK_TRAIT
+  };
+}
+function useUISlotManager() {
+  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));
+      timersRef.current.clear();
+    };
+  }, []);
+  const notifySubscribers = useCallback((slot, content) => {
+    subscribersRef.current.forEach((callback) => {
+      try {
+        callback(slot, content);
+      } catch (error) {
+        log.error("Subscriber error", { error: error instanceof Error ? error : String(error) });
+      }
+    });
+  }, []);
+  const notifyTraitSubscribers = useCallback(
+    (traitName, content) => {
+      const subs = traitSubscribersRef.current.get(traitName);
+      if (!subs) return;
+      subs.forEach((callback) => {
+        try {
+          callback(content);
+        } catch (error) {
+          log.error("Trait subscriber error", { traitName, error: error instanceof Error ? error : String(error) });
+        }
+      });
+    },
+    []
+  );
+  const indexTraitRender = useCallback(
+    (traitName, content) => {
+      traitIndexRef.current.set(traitName, content);
+    },
+    []
+  );
+  const unindexTrait = useCallback((traitName) => {
+    traitIndexRef.current.delete(traitName);
+  }, []);
+  const render = useCallback(
+    (config) => {
+      const sourceKey = config.sourceTrait ?? DEFAULT_SOURCE_KEY;
+      const id = `slot-content-${config.target}-${sourceKey}`;
+      const content = {
+        id,
+        pattern: config.pattern,
+        props: config.props ?? {},
+        priority: config.priority ?? 0,
+        onDismiss: config.onDismiss,
+        sourceTrait: config.sourceTrait,
+        slot: config.target,
+        transitionEvent: config.transitionEvent,
+        fromState: config.fromState,
+        entity: config.entity
+      };
+      if (config.autoDismissMs && config.autoDismissMs > 0) {
+        content.autoDismissAt = Date.now() + config.autoDismissMs;
+        const prevTimer = timersRef.current.get(id);
+        if (prevTimer) clearTimeout(prevTimer);
+        const timer = setTimeout(() => {
+          setSources((prev) => {
+            const slotSources = prev[config.target];
+            if (slotSources && slotSources[sourceKey] === content) {
+              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) {
+          log.warn("Slot already has higher priority content", {
+            slot: config.target,
+            sourceKey,
+            existingPriority: existing.priority,
+            newPriority: content.priority
+          });
+          return prev;
+        }
+        if (existing && existing.priority === content.priority && existing.pattern === content.pattern && existing.transitionEvent === content.transitionEvent && existing.fromState === content.fromState && existing.entity === content.entity && existing.nodeId === content.nodeId && existing.autoDismissAt === void 0 && content.autoDismissAt === void 0 && existing.onDismiss === void 0 === (content.onDismiss === void 0)) {
+          const reconciled = reconcileSlotProps(existing.props, content.props);
+          if (reconciled.equal) {
+            log.debug("slot:flush-bail", { slot: config.target, sourceKey, pattern: content.pattern });
+            return prev;
+          }
+          content.props = reconciled.value;
+        }
+        const nextSources = {
+          ...slotSources,
+          [sourceKey]: content
+        };
+        const nextAll = { ...prev, [config.target]: nextSources };
+        const priorWriters = Object.keys(slotSources);
+        if (priorWriters.length === 1 && priorWriters[0] !== sourceKey) {
+          log.warn("slot:contention", {
+            slot: config.target,
+            writers: [priorWriters[0], sourceKey],
+            patternTypes: [slotSources[priorWriters[0]].pattern, content.pattern]
+          });
+        }
+        if (content.sourceTrait && !isNotificationSlot(config.target)) {
+          indexTraitRender(content.sourceTrait, content);
+          notifyTraitSubscribers(content.sourceTrait, content);
+        }
+        log.info("slot:written", {
+          slot: config.target,
+          sourceKey,
+          sourceTrait: content.sourceTrait,
+          patternType: content.pattern,
+          priority: content.priority
+        });
+        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 && !isNotificationSlot(slot)) {
+            unindexTrait(content.sourceTrait);
+            notifyTraitSubscribers(content.sourceTrait, null);
+          }
+        }
+        notifySubscribers(slot, null);
+        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)) {
+          const embedded = traitIndexRef.current.get(sourceTrait);
+          if (embedded !== void 0 && embedded.slot === slot) {
+            unindexTrait(sourceTrait);
+            notifyTraitSubscribers(sourceTrait, null);
+            log.info("slot:cleared-embedded", { slot, sourceTrait, lastPatternType: embedded.pattern });
+            return prev;
+          }
+          log.debug("slot:clear-noop", { slot, sourceTrait, reason: !slotSources ? "no-slot" : "no-source" });
+          return prev;
+        }
+        const content = slotSources[sourceKey];
+        const timer = timersRef.current.get(content.id);
+        if (timer) {
+          clearTimeout(timer);
+          timersRef.current.delete(content.id);
+        }
+        content.onDismiss?.();
+        if (content.sourceTrait && !isNotificationSlot(slot)) {
+          unindexTrait(content.sourceTrait);
+          notifyTraitSubscribers(content.sourceTrait, null);
+        }
+        const nextSources = { ...slotSources };
+        delete nextSources[sourceKey];
+        log.info("slot:cleared", { slot, sourceTrait, lastPatternType: content.pattern });
+        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 && !isNotificationSlot(slot)) {
+            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();
+    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_SOURCES;
+    });
+    traitIndexRef.current.clear();
+  }, [notifySubscribers, notifyTraitSubscribers]);
+  const subscribe = useCallback((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const hasContent = useCallback(
+    (slot) => slots[slot] !== null,
+    [slots]
+  );
+  const getContent = useCallback(
+    (slot) => slots[slot] ?? null,
+    [slots]
+  );
+  const getTraitContent = useCallback(
+    (traitName) => traitIndexRef.current.get(traitName) ?? null,
+    []
+  );
+  const subscribeTrait = useCallback(
+    (traitName, callback) => {
+      let set = traitSubscribersRef.current.get(traitName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        traitSubscribersRef.current.set(traitName, set);
+      }
+      set.add(callback);
+      return () => {
+        const s = traitSubscribersRef.current.get(traitName);
+        if (!s) return;
+        s.delete(callback);
+        if (s.size === 0) {
+          traitSubscribersRef.current.delete(traitName);
+        }
+      };
+    },
+    []
+  );
+  const updateTraitContent = useCallback(
+    (traitName, content) => {
+      const id = `slot-content-trait-${traitName}`;
+      const fullContent = { ...content, id, sourceTrait: traitName };
+      indexTraitRender(traitName, fullContent);
+      notifyTraitSubscribers(traitName, fullContent);
+      return id;
+    },
+    [indexTraitRender, notifyTraitSubscribers]
+  );
+  return {
+    slots,
+    render,
+    clear,
+    clearBySource,
+    clearById,
+    clearAll,
+    subscribe,
+    hasContent,
+    getContent,
+    getTraitContent,
+    subscribeTrait,
+    updateTraitContent
+  };
+}
+
+export { ALL_SLOTS, DEFAULT_SLOTS, useUISlotManager };