@igstack/app-catalog-frontend-core 6.6.0 → 6.7.0

package/dist/esm/modules/dismiss/DismissStack.d.ts

@@ -0,0 +1,102 @@
+/**
+ * One Escape key, one answer: dismiss the layer on top.
+ *
+ * Before this existed, Escape was handled in six independent places, and each
+ * one had to know about the others to avoid double-firing — the detail card
+ * bound Escape only `enabled: !isGalleryOpen`, the gallery installed its own
+ * capture-phase listener specifically to beat Radix to the event, and the
+ * screenshot dialog cancelled Radix's own Escape by reading the gallery's
+ * fullscreen state through a ref. Every new overlay had to learn that dance,
+ * and getting it wrong stayed invisible until someone pressed Escape in the
+ * wrong order. It was wrong: a dialog opened over the card had no say, so
+ * Escape closed the card out from under it and navigated away.
+ *
+ * A layer now says only "I am dismissable, and this element is me". The stack
+ * decides who Escape belongs to, and no layer needs to know another exists.
+ *
+ * "On top" is DOCUMENT ORDER, the last enabled layer in the document. Two
+ * cheaper keys were tried first and both broke:
+ *
+ * - Registration order. React runs a child's effects before its parent's, so
+ *   an overlay nested inside another registers FIRST and the container looks
+ *   newer: Escape in the screenshot viewer closed the card under it.
+ * - Activation time. On a cold deep link the dialog's route resolves before
+ *   the catalog arrives, so the card it sits over mounts LATER and looks
+ *   newer: Escape closed the card first, and the card took focus back off the
+ *   dialog's first field.
+ *
+ * Document order has neither problem because it is what "on top" means on
+ * screen: a portal appends to the end of `<body>`, a child route renders after
+ * its parent's page, and a nested layer is a descendant — and a descendant
+ * follows its ancestor in document order. None of it depends on when anything
+ * mounted.
+ *
+ * `useDismissable` works with or without a provider above it, on purpose. A
+ * hook that silently did nothing outside a provider would be the same class of
+ * bug this module exists to delete — every render site, including tests and
+ * stories, would have to remember a wrapper, and forgetting it would look like
+ * working code with dead Escape handling. So an app-wide stack is the default
+ * and `DismissStackProvider` is only for scoping.
+ */
+interface DismissEntry {
+    /** The layer's root element; its position in the document is its rank. */
+    layer: {
+        readonly current: HTMLElement | null;
+    };
+    /** Called when Escape belongs to this layer. */
+    onDismiss: () => void;
+    /**
+     * A layer can stay registered and opt out — a collapsed panel, a closed
+     * popover. Skipped when choosing the top rather than unregistering.
+     */
+    enabled: boolean;
+}
+export interface DismissStackApi {
+    /** Adds an entry and returns its unregister function. */
+    register: (entry: DismissEntry) => () => void;
+    /** Dismisses the top layer; reports whether there was one. */
+    dismissTop: () => boolean;
+    /**
+     * The top layer's element, or null when nothing is open. For a layer that
+     * takes focus on mount: it should only do so while it is on top, or it
+     * steals the caret from whatever was opened over it.
+     */
+    topElement: () => HTMLElement | null;
+}
+/**
+ * Scopes a stack to a subtree.
+ *
+ * Only needed when overlays inside must not compete with overlays outside —
+ * two independently mounted apps on one page, for instance. The app does not
+ * need it for ordinary nesting; the default stack already handles that.
+ */
+export declare function DismissStackProvider({ children, }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Declare this layer dismissable by Escape.
+ *
+ * ```tsx
+ * const ref = useRef<HTMLDivElement>(null)
+ * useDismissable(ref, onClose)                      // always dismissable
+ * useDismissable(ref, close, { enabled: isOpen })   // only while open
+ * return <div ref={ref} role="dialog">…</div>
+ * ```
+ *
+ * `ref` is the layer's root element, and it is required rather than optional
+ * because it IS the ordering: the last enabled layer in the document owns
+ * Escape. Call the hook once per layer, unconditionally; nothing else
+ * coordinates with any other layer, and adding one above an existing layer
+ * needs no change to it.
+ */
+export declare function useDismissable(layer: {
+    readonly current: HTMLElement | null;
+}, onDismiss: () => void, { enabled }?: {
+    enabled?: boolean;
+}): void;
+/**
+ * The stack itself, for a component that owns its own key handling or focus
+ * and wants stack ordering instead of inventing its own.
+ */
+export declare function useDismissStack(): DismissStackApi;
+export {};

package/dist/esm/modules/dismiss/DismissStack.js

@@ -0,0 +1,82 @@
+import "react/jsx-runtime";
+import { use, createContext, useRef, useEffect } from "react";
+function isAfter(a, b) {
+  return (b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0;
+}
+function createStack() {
+  const entries = [];
+  const top = () => {
+    let best;
+    for (const entry of entries) {
+      const el = entry.layer.current;
+      if (!entry.enabled || !(el == null ? void 0 : el.isConnected)) continue;
+      const bestEl = best == null ? void 0 : best.layer.current;
+      if (!bestEl || isAfter(el, bestEl)) best = entry;
+    }
+    return best;
+  };
+  const dismissTop = () => {
+    const entry = top();
+    if (!entry) return false;
+    entry.onDismiss();
+    return true;
+  };
+  const topElement = () => {
+    var _a;
+    return ((_a = top()) == null ? void 0 : _a.layer.current) ?? null;
+  };
+  const onKeyDown = (event) => {
+    if (event.key !== "Escape") return;
+    if (event.defaultPrevented) return;
+    if (!dismissTop()) return;
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  const register = (entry) => {
+    if (entries.length === 0) {
+      document.addEventListener("keydown", onKeyDown);
+    }
+    entries.push(entry);
+    return () => {
+      const i = entries.indexOf(entry);
+      if (i !== -1) entries.splice(i, 1);
+      if (entries.length === 0) {
+        document.removeEventListener("keydown", onKeyDown);
+        return;
+      }
+      queueMicrotask(() => {
+        var _a;
+        if (document.activeElement && document.activeElement !== document.body)
+          return;
+        (_a = topElement()) == null ? void 0 : _a.focus();
+      });
+    };
+  };
+  return { register, dismissTop, topElement };
+}
+let appStack = null;
+function getAppStack() {
+  appStack ?? (appStack = createStack());
+  return appStack;
+}
+const DismissStackContext = createContext(null);
+function useDismissable(layer, onDismiss, { enabled = true } = {}) {
+  const scoped = use(DismissStackContext);
+  const stack = scoped ?? getAppStack();
+  const entryRef = useRef({ layer, onDismiss, enabled });
+  useEffect(() => {
+    entryRef.current.layer = layer;
+    entryRef.current.onDismiss = onDismiss;
+    entryRef.current.enabled = enabled;
+  }, [layer, onDismiss, enabled]);
+  useEffect(() => stack.register(entryRef.current), [stack]);
+}
+function useDismissStack() {
+  const scoped = use(DismissStackContext);
+  return scoped ?? getAppStack();
+}
+export {
+  useDismissStack,
+  useDismissable
+};
+//# sourceMappingURL=DismissStack.js.map

package/dist/esm/modules/dismiss/DismissStack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DismissStack.js","sources":["../../../../src/modules/dismiss/DismissStack.tsx"],"sourcesContent":["import { createContext, use, useEffect, useMemo, useRef } from 'react'\n\n/**\n * One Escape key, one answer: dismiss the layer on top.\n *\n * Before this existed, Escape was handled in six independent places, and each\n * one had to know about the others to avoid double-firing — the detail card\n * bound Escape only `enabled: !isGalleryOpen`, the gallery installed its own\n * capture-phase listener specifically to beat Radix to the event, and the\n * screenshot dialog cancelled Radix's own Escape by reading the gallery's\n * fullscreen state through a ref. Every new overlay had to learn that dance,\n * and getting it wrong stayed invisible until someone pressed Escape in the\n * wrong order. It was wrong: a dialog opened over the card had no say, so\n * Escape closed the card out from under it and navigated away.\n *\n * A layer now says only \"I am dismissable, and this element is me\". The stack\n * decides who Escape belongs to, and no layer needs to know another exists.\n *\n * \"On top\" is DOCUMENT ORDER, the last enabled layer in the document. Two\n * cheaper keys were tried first and both broke:\n *\n * - Registration order. React runs a child's effects before its parent's, so\n *   an overlay nested inside another registers FIRST and the container looks\n *   newer: Escape in the screenshot viewer closed the card under it.\n * - Activation time. On a cold deep link the dialog's route resolves before\n *   the catalog arrives, so the card it sits over mounts LATER and looks\n *   newer: Escape closed the card first, and the card took focus back off the\n *   dialog's first field.\n *\n * Document order has neither problem because it is what \"on top\" means on\n * screen: a portal appends to the end of `<body>`, a child route renders after\n * its parent's page, and a nested layer is a descendant — and a descendant\n * follows its ancestor in document order. None of it depends on when anything\n * mounted.\n *\n * `useDismissable` works with or without a provider above it, on purpose. A\n * hook that silently did nothing outside a provider would be the same class of\n * bug this module exists to delete — every render site, including tests and\n * stories, would have to remember a wrapper, and forgetting it would look like\n * working code with dead Escape handling. So an app-wide stack is the default\n * and `DismissStackProvider` is only for scoping.\n */\n\ninterface DismissEntry {\n  /** The layer's root element; its position in the document is its rank. */\n  layer: { readonly current: HTMLElement | null }\n  /** Called when Escape belongs to this layer. */\n  onDismiss: () => void\n  /**\n   * A layer can stay registered and opt out — a collapsed panel, a closed\n   * popover. Skipped when choosing the top rather than unregistering.\n   */\n  enabled: boolean\n}\n\nexport interface DismissStackApi {\n  /** Adds an entry and returns its unregister function. */\n  register: (entry: DismissEntry) => () => void\n  /** Dismisses the top layer; reports whether there was one. */\n  dismissTop: () => boolean\n  /**\n   * The top layer's element, or null when nothing is open. For a layer that\n   * takes focus on mount: it should only do so while it is on top, or it\n   * steals the caret from whatever was opened over it.\n   */\n  topElement: () => HTMLElement | null\n}\n\nfunction isAfter(a: HTMLElement, b: HTMLElement): boolean {\n  // A descendant reports FOLLOWING as well as CONTAINED_BY, so this one test\n  // covers both \"rendered later\" and \"nested inside\".\n  return (b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0\n}\n\nfunction createStack(): DismissStackApi {\n  const entries: DismissEntry[] = []\n\n  const top = (): DismissEntry | undefined => {\n    let best: DismissEntry | undefined\n    for (const entry of entries) {\n      const el = entry.layer.current\n      // Not in the document yet, or already gone: not something on screen.\n      if (!entry.enabled || !el?.isConnected) continue\n      const bestEl = best?.layer.current\n      if (!bestEl || isAfter(el, bestEl)) best = entry\n    }\n    return best\n  }\n\n  const dismissTop = () => {\n    const entry = top()\n    if (!entry) return false\n    entry.onDismiss()\n    return true\n  }\n\n  const topElement = () => top()?.layer.current ?? null\n\n  const onKeyDown = (event: KeyboardEvent) => {\n    if (event.key !== 'Escape') return\n    // Something closer to the event already dealt with it — a text field\n    // cancelling an edit, say. Honoured rather than overridden: the element the\n    // user is typing in is more specific than any layer containing it.\n    //\n    // This check is the reason the listener below is on the BUBBLE phase. In\n    // capture it would run before every component handler, so `defaultPrevented`\n    // would always be false and a field could never keep Escape for itself.\n    if (event.defaultPrevented) return\n    if (!dismissTop()) return\n    // Claim it, so a handler further out does not also act.\n    event.preventDefault()\n    event.stopPropagation()\n  }\n\n  const register = (entry: DismissEntry) => {\n    if (entries.length === 0) {\n      // Bubble, on the document: every component handler and React's own\n      // delegated handlers run first, so the innermost thing that wants Escape\n      // gets it. Radix is the one exception — it listens with `capture: true`,\n      // so it runs BEFORE this. `DialogContent` bridges that by asking the\n      // stack from inside Radix's own escape callback.\n      document.addEventListener('keydown', onKeyDown)\n    }\n    entries.push(entry)\n    return () => {\n      const i = entries.indexOf(entry)\n      if (i !== -1) entries.splice(i, 1)\n      if (entries.length === 0) {\n        document.removeEventListener('keydown', onKeyDown)\n        return\n      }\n      // When a layer closes, the caret it held goes with it and lands on\n      // <body>, where the next Tab walks whatever is behind every overlay and\n      // Escape still works only because this listener is on the document.\n      // Hand it to the layer that is now on top. Only from <body>: if\n      // something already restored focus — Radix returns it to the trigger —\n      // that choice is more specific than this one and stands.\n      queueMicrotask(() => {\n        if (document.activeElement && document.activeElement !== document.body)\n          return\n        topElement()?.focus()\n      })\n    }\n  }\n\n  return { register, dismissTop, topElement }\n}\n\n/**\n * The app-wide stack, used whenever no provider scopes one.\n *\n * Module-level so two sibling overlays coordinate even if neither sits under a\n * provider — which is the whole point. Created lazily so importing this module\n * never touches `document`, keeping it safe in a non-DOM environment.\n */\nlet appStack: DismissStackApi | null = null\nfunction getAppStack(): DismissStackApi {\n  appStack ??= createStack()\n  return appStack\n}\n\nconst DismissStackContext = createContext<DismissStackApi | null>(null)\n\n/**\n * Scopes a stack to a subtree.\n *\n * Only needed when overlays inside must not compete with overlays outside —\n * two independently mounted apps on one page, for instance. The app does not\n * need it for ordinary nesting; the default stack already handles that.\n */\nexport function DismissStackProvider({\n  children,\n}: {\n  children: React.ReactNode\n}) {\n  const api = useMemo(() => createStack(), [])\n  return <DismissStackContext value={api}>{children}</DismissStackContext>\n}\n\n/**\n * Declare this layer dismissable by Escape.\n *\n * ```tsx\n * const ref = useRef<HTMLDivElement>(null)\n * useDismissable(ref, onClose)                      // always dismissable\n * useDismissable(ref, close, { enabled: isOpen })   // only while open\n * return <div ref={ref} role=\"dialog\">…</div>\n * ```\n *\n * `ref` is the layer's root element, and it is required rather than optional\n * because it IS the ordering: the last enabled layer in the document owns\n * Escape. Call the hook once per layer, unconditionally; nothing else\n * coordinates with any other layer, and adding one above an existing layer\n * needs no change to it.\n */\nexport function useDismissable(\n  layer: { readonly current: HTMLElement | null },\n  onDismiss: () => void,\n  { enabled = true }: { enabled?: boolean } = {},\n): void {\n  const scoped = use(DismissStackContext)\n  const stack = scoped ?? getAppStack()\n\n  // A stable entry whose fields are refreshed in place. Handing `register` a\n  // new object whenever the callback identity changed would churn the stack on\n  // every render for no benefit.\n  const entryRef = useRef<DismissEntry>({ layer, onDismiss, enabled })\n  useEffect(() => {\n    entryRef.current.layer = layer\n    entryRef.current.onDismiss = onDismiss\n    entryRef.current.enabled = enabled\n  }, [layer, onDismiss, enabled])\n\n  useEffect(() => stack.register(entryRef.current), [stack])\n}\n\n/**\n * The stack itself, for a component that owns its own key handling or focus\n * and wants stack ordering instead of inventing its own.\n */\nexport function useDismissStack(): DismissStackApi {\n  const scoped = use(DismissStackContext)\n  return scoped ?? getAppStack()\n}\n"],"names":[],"mappings":";;AAoEA,SAAS,QAAQ,GAAgB,GAAyB;AAGxD,UAAQ,EAAE,wBAAwB,CAAC,IAAI,KAAK,iCAAiC;AAC/E;AAEA,SAAS,cAA+B;AACtC,QAAM,UAA0B,CAAA;AAEhC,QAAM,MAAM,MAAgC;AAC1C,QAAI;AACJ,eAAW,SAAS,SAAS;AAC3B,YAAM,KAAK,MAAM,MAAM;AAEvB,UAAI,CAAC,MAAM,WAAW,EAAC,yBAAI,aAAa;AACxC,YAAM,SAAS,6BAAM,MAAM;AAC3B,UAAI,CAAC,UAAU,QAAQ,IAAI,MAAM,EAAG,QAAO;AAAA,IAC7C;AACA,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,MAAM;AACvB,UAAM,QAAQ,IAAA;AACd,QAAI,CAAC,MAAO,QAAO;AACnB,UAAM,UAAA;AACN,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,MAAA;;AAAM,sBAAA,MAAA,mBAAO,MAAM,YAAW;AAAA;AAEjD,QAAM,YAAY,CAAC,UAAyB;AAC1C,QAAI,MAAM,QAAQ,SAAU;AAQ5B,QAAI,MAAM,iBAAkB;AAC5B,QAAI,CAAC,aAAc;AAEnB,UAAM,eAAA;AACN,UAAM,gBAAA;AAAA,EACR;AAEA,QAAM,WAAW,CAAC,UAAwB;AACxC,QAAI,QAAQ,WAAW,GAAG;AAMxB,eAAS,iBAAiB,WAAW,SAAS;AAAA,IAChD;AACA,YAAQ,KAAK,KAAK;AAClB,WAAO,MAAM;AACX,YAAM,IAAI,QAAQ,QAAQ,KAAK;AAC/B,UAAI,MAAM,GAAI,SAAQ,OAAO,GAAG,CAAC;AACjC,UAAI,QAAQ,WAAW,GAAG;AACxB,iBAAS,oBAAoB,WAAW,SAAS;AACjD;AAAA,MACF;AAOA,qBAAe,MAAM;;AACnB,YAAI,SAAS,iBAAiB,SAAS,kBAAkB,SAAS;AAChE;AACF,yBAAA,MAAA,mBAAc;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,EAAE,UAAU,YAAY,WAAA;AACjC;AASA,IAAI,WAAmC;AACvC,SAAS,cAA+B;AACtC,0BAAa,YAAA;AACb,SAAO;AACT;AAEA,MAAM,sBAAsB,cAAsC,IAAI;AAkC/D,SAAS,eACd,OACA,WACA,EAAE,UAAU,KAAA,IAAgC,IACtC;AACN,QAAM,SAAS,IAAI,mBAAmB;AACtC,QAAM,QAAQ,UAAU,YAAA;AAKxB,QAAM,WAAW,OAAqB,EAAE,OAAO,WAAW,SAAS;AACnE,YAAU,MAAM;AACd,aAAS,QAAQ,QAAQ;AACzB,aAAS,QAAQ,YAAY;AAC7B,aAAS,QAAQ,UAAU;AAAA,EAC7B,GAAG,CAAC,OAAO,WAAW,OAAO,CAAC;AAE9B,YAAU,MAAM,MAAM,SAAS,SAAS,OAAO,GAAG,CAAC,KAAK,CAAC;AAC3D;AAMO,SAAS,kBAAmC;AACjD,QAAM,SAAS,IAAI,mBAAmB;AACtC,SAAO,UAAU,YAAA;AACnB;"}

package/dist/esm/modules/extensions/ExtensionsContext.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { PluginRegistration } from './types.js';
+interface ExtensionsContextProps {
+    children: ReactNode;
+    value?: readonly PluginRegistration[];
+}
+export declare function ExtensionsContext({ children, value }: ExtensionsContextProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Registered plugins, or an empty list.
+ *
+ * Empty is the open-source default and has to stay a first-class state: every
+ * slot renders nothing and every wrapper passes its children through, so the UI
+ * is identical to one with no slots at all. Slots are additive — a slot must
+ * never be the only route to something the core itself needs.
+ */
+export declare function useExtensions(): readonly PluginRegistration[];
+export {};

package/dist/esm/modules/extensions/ExtensionsContext.js

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, use } from "react";
+const ExtensionsInternalContext = createContext(void 0);
+function ExtensionsContext({ children, value }) {
+  return /* @__PURE__ */ jsx(ExtensionsInternalContext, { value, children });
+}
+function useExtensions() {
+  return use(ExtensionsInternalContext) ?? EMPTY;
+}
+const EMPTY = [];
+export {
+  ExtensionsContext,
+  useExtensions
+};
+//# sourceMappingURL=ExtensionsContext.js.map

package/dist/esm/modules/extensions/ExtensionsContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionsContext.js","sources":["../../../../src/modules/extensions/ExtensionsContext.tsx"],"sourcesContent":["import { createContext, use } from 'react'\nimport type { ReactNode } from 'react'\nimport type { PluginRegistration } from './types'\n\nconst ExtensionsInternalContext = createContext<\n  readonly PluginRegistration[] | undefined\n>(undefined)\n\ninterface ExtensionsContextProps {\n  children: ReactNode\n  value?: readonly PluginRegistration[]\n}\n\nexport function ExtensionsContext({ children, value }: ExtensionsContextProps) {\n  return (\n    <ExtensionsInternalContext value={value}>\n      {children}\n    </ExtensionsInternalContext>\n  )\n}\n\n/**\n * Registered plugins, or an empty list.\n *\n * Empty is the open-source default and has to stay a first-class state: every\n * slot renders nothing and every wrapper passes its children through, so the UI\n * is identical to one with no slots at all. Slots are additive — a slot must\n * never be the only route to something the core itself needs.\n */\nexport function useExtensions(): readonly PluginRegistration[] {\n  return use(ExtensionsInternalContext) ?? EMPTY\n}\n\n// Module-level constant: a fresh `[]` per call would be a new identity every\n// render and defeat memoisation in anything downstream of it.\nconst EMPTY: readonly PluginRegistration[] = []\n"],"names":[],"mappings":";;AAIA,MAAM,4BAA4B,cAEhC,MAAS;AAOJ,SAAS,kBAAkB,EAAE,UAAU,SAAiC;AAC7E,SACE,oBAAC,2BAAA,EAA0B,OACxB,SAAA,CACH;AAEJ;AAUO,SAAS,gBAA+C;AAC7D,SAAO,IAAI,yBAAyB,KAAK;AAC3C;AAIA,MAAM,QAAuC,CAAA;"}

package/dist/esm/modules/extensions/factories.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Binds one feature's slot spec, so each slot names itself exactly once and the
+ * name is checked against that feature's own spec.
+ *
+ *   const mkSlot = slotFactory<AppCatalogSlots>()
+ *   export const ResourceDetailAccessActions = mkSlot('resourceDetailAccessActions')
+ *                                               // ^ typo here is a compile error
+ */
+export declare function slotFactory<TSpec>(): <TName extends keyof TSpec & string>(name: TName) => {
+    (props: TSpec[TName]): import('react').ReactNode;
+    displayName: string;
+};
+export declare function wrapperFactory<TSpec>(): <TName extends keyof TSpec & string>(name: TName) => {
+    (props: TSpec[TName] & {
+        children: import('react').ReactNode;
+    }): import('react').ReactNode;
+    displayName: string;
+};

package/dist/esm/modules/extensions/factories.js

@@ -0,0 +1,12 @@
+import { makeWrapper, makeSlot } from "./makeSlot.js";
+function slotFactory() {
+  return (name) => makeSlot(name);
+}
+function wrapperFactory() {
+  return (name) => makeWrapper(name);
+}
+export {
+  slotFactory,
+  wrapperFactory
+};
+//# sourceMappingURL=factories.js.map

package/dist/esm/modules/extensions/factories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.js","sources":["../../../../src/modules/extensions/factories.ts"],"sourcesContent":["import { makeSlot, makeWrapper } from './makeSlot'\n\n/**\n * Binds one feature's slot spec, so each slot names itself exactly once and the\n * name is checked against that feature's own spec.\n *\n *   const mkSlot = slotFactory<AppCatalogSlots>()\n *   export const ResourceDetailAccessActions = mkSlot('resourceDetailAccessActions')\n *                                               // ^ typo here is a compile error\n */\nexport function slotFactory<TSpec>() {\n  return <TName extends keyof TSpec & string>(name: TName) =>\n    makeSlot<TSpec[TName]>(name)\n}\n\nexport function wrapperFactory<TSpec>() {\n  return <TName extends keyof TSpec & string>(name: TName) =>\n    makeWrapper<TSpec[TName]>(name)\n}\n"],"names":[],"mappings":";AAUO,SAAS,cAAqB;AACnC,SAAO,CAAqC,SAC1C,SAAuB,IAAI;AAC/B;AAEO,SAAS,iBAAwB;AACtC,SAAO,CAAqC,SAC1C,YAA0B,IAAI;AAClC;"}

package/dist/esm/modules/extensions/features/resourceDetail.d.ts

@@ -0,0 +1,92 @@
+import { Resource } from '@igstack/app-catalog-backend-core';
+import { PluginUser } from '../types.js';
+/**
+ * Leaf slots on the resource detail card.
+ *
+ * Payloads are additive-only. Adding a field is invisible to existing plugins;
+ * renaming or removing one breaks them at compile time on their next core bump,
+ * which is the intended moment for that to surface.
+ */
+export interface ResourceDetailSlots {
+    /**
+     * Actions on the detail card's header band.
+     *
+     * The band and not a tab panel: tab panels mount only while active and
+     * Overview is first, so a slot inside a tab is invisible until a second click.
+     */
+    resourceDetailAccessActions: {
+        /** The resource on screen — a top-level app OR one of its sub-resources. */
+        resource: Resource;
+        /** Present only on a sub-resource view. Its absence is how a plugin tells the two apart. */
+        parent?: Resource;
+        /** Children of `parent ?? resource`: the family's sub-resources. */
+        subResources: Resource[];
+        user: PluginUser | null;
+    };
+    /**
+     * One cell per row of the sub-resources table, in a column of its own.
+     *
+     * Called once per rendered row, which is the opposite shape to
+     * `resourceDetailAccessActions` — that one is called once and handed the whole
+     * list. Use this when the action belongs to a single child.
+     *
+     * Two things to know before filling it. The table renders EVERY row with no
+     * virtualisation, so a contribution here is mounted as many times as the
+     * family has children (hundreds, in a large catalog) — keep the cell cheap and
+     * defer anything expensive until it is interacted with. And the column only
+     * appears when a plugin actually fills it, so a build with no plugin renders
+     * the table exactly as before.
+     */
+    resourceSubResourceRowActions: {
+        /** The child this row is showing. */
+        resource: Resource;
+        /** The entry the row hangs off. Always present here, unlike the header slot. */
+        parent: Resource;
+        user: PluginUser | null;
+    };
+}
+/**
+ * Wrappers on the resource detail card.
+ *
+ * `resourceDetailProvider` is mounted inside the panel's `key={shownSlug}`
+ * subtree, so anything a plugin provides here is scoped to the resource on
+ * screen and is discarded when the card navigates. That is what lets two slots
+ * share per-resource state without the plugin writing any cleanup.
+ */
+export interface ResourceDetailWrappers {
+    resourceDetailProvider: {
+        resource: Resource;
+        parent?: Resource;
+    };
+}
+export declare const ResourceDetailAccessActions: {
+    (props: {
+        /** The resource on screen — a top-level app OR one of its sub-resources. */
+        resource: Resource;
+        /** Present only on a sub-resource view. Its absence is how a plugin tells the two apart. */
+        parent?: Resource;
+        /** Children of `parent ?? resource`: the family's sub-resources. */
+        subResources: Resource[];
+        user: PluginUser | null;
+    }): import('react').ReactNode;
+    displayName: string;
+};
+export declare const ResourceSubResourceRowActions: {
+    (props: {
+        /** The child this row is showing. */
+        resource: Resource;
+        /** The entry the row hangs off. Always present here, unlike the header slot. */
+        parent: Resource;
+        user: PluginUser | null;
+    }): import('react').ReactNode;
+    displayName: string;
+};
+export declare const ResourceDetailProvider: {
+    (props: {
+        resource: Resource;
+        parent?: Resource;
+    } & {
+        children: import('react').ReactNode;
+    }): import('react').ReactNode;
+    displayName: string;
+};

package/dist/esm/modules/extensions/features/resourceDetail.js

@@ -0,0 +1,14 @@
+import { wrapperFactory, slotFactory } from "../factories.js";
+const mkSlot = slotFactory();
+const mkWrapper = wrapperFactory();
+const ResourceDetailAccessActions = mkSlot("resourceDetailAccessActions");
+const ResourceSubResourceRowActions = mkSlot(
+  "resourceSubResourceRowActions"
+);
+const ResourceDetailProvider = mkWrapper("resourceDetailProvider");
+export {
+  ResourceDetailAccessActions,
+  ResourceDetailProvider,
+  ResourceSubResourceRowActions
+};
+//# sourceMappingURL=resourceDetail.js.map

package/dist/esm/modules/extensions/features/resourceDetail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceDetail.js","sources":["../../../../../src/modules/extensions/features/resourceDetail.ts"],"sourcesContent":["import type { Resource } from '@igstack/app-catalog-backend-core'\nimport { slotFactory, wrapperFactory } from '../factories'\nimport type { PluginUser } from '../types'\n\n/**\n * Leaf slots on the resource detail card.\n *\n * Payloads are additive-only. Adding a field is invisible to existing plugins;\n * renaming or removing one breaks them at compile time on their next core bump,\n * which is the intended moment for that to surface.\n */\nexport interface ResourceDetailSlots {\n  /**\n   * Actions on the detail card's header band.\n   *\n   * The band and not a tab panel: tab panels mount only while active and\n   * Overview is first, so a slot inside a tab is invisible until a second click.\n   */\n  resourceDetailAccessActions: {\n    /** The resource on screen — a top-level app OR one of its sub-resources. */\n    resource: Resource\n    /** Present only on a sub-resource view. Its absence is how a plugin tells the two apart. */\n    parent?: Resource\n    /** Children of `parent ?? resource`: the family's sub-resources. */\n    subResources: Resource[]\n    user: PluginUser | null\n  }\n\n  /**\n   * One cell per row of the sub-resources table, in a column of its own.\n   *\n   * Called once per rendered row, which is the opposite shape to\n   * `resourceDetailAccessActions` — that one is called once and handed the whole\n   * list. Use this when the action belongs to a single child.\n   *\n   * Two things to know before filling it. The table renders EVERY row with no\n   * virtualisation, so a contribution here is mounted as many times as the\n   * family has children (hundreds, in a large catalog) — keep the cell cheap and\n   * defer anything expensive until it is interacted with. And the column only\n   * appears when a plugin actually fills it, so a build with no plugin renders\n   * the table exactly as before.\n   */\n  resourceSubResourceRowActions: {\n    /** The child this row is showing. */\n    resource: Resource\n    /** The entry the row hangs off. Always present here, unlike the header slot. */\n    parent: Resource\n    user: PluginUser | null\n  }\n}\n\n/**\n * Wrappers on the resource detail card.\n *\n * `resourceDetailProvider` is mounted inside the panel's `key={shownSlug}`\n * subtree, so anything a plugin provides here is scoped to the resource on\n * screen and is discarded when the card navigates. That is what lets two slots\n * share per-resource state without the plugin writing any cleanup.\n */\nexport interface ResourceDetailWrappers {\n  resourceDetailProvider: {\n    resource: Resource\n    parent?: Resource\n  }\n}\n\nconst mkSlot = slotFactory<ResourceDetailSlots>()\nconst mkWrapper = wrapperFactory<ResourceDetailWrappers>()\n\nexport const ResourceDetailAccessActions = mkSlot('resourceDetailAccessActions')\nexport const ResourceSubResourceRowActions = mkSlot(\n  'resourceSubResourceRowActions',\n)\nexport const ResourceDetailProvider = mkWrapper('resourceDetailProvider')\n"],"names":[],"mappings":";AAkEA,MAAM,SAAS,YAAA;AACf,MAAM,YAAY,eAAA;AAEX,MAAM,8BAA8B,OAAO,6BAA6B;AACxE,MAAM,gCAAgC;AAAA,EAC3C;AACF;AACO,MAAM,yBAAyB,UAAU,wBAAwB;"}

package/dist/esm/modules/extensions/index.d.ts

@@ -0,0 +1,79 @@
+import { ReactNode } from 'react';
+import { ResourceDetailSlots, ResourceDetailWrappers } from './features/resourceDetail.js';
+import { PluginUser } from './types.js';
+export { ExtensionsContext, useExtensions } from './ExtensionsContext.js';
+export { slotFactory, wrapperFactory } from './factories.js';
+export { makeSlot, makeWrapper } from './makeSlot.js';
+export type { PluginUser, PluginRegistration } from './types.js';
+export type { AssertDisjoint } from './types.js';
+export { ResourceDetailAccessActions, ResourceSubResourceRowActions, ResourceDetailProvider, } from './features/resourceDetail.js';
+export type { ResourceDetailSlots, ResourceDetailWrappers, } from './features/resourceDetail.js';
+/**
+ * Every leaf slot in the core, composed from the per-feature specs.
+ *
+ * Adding a feature means a new `features/<name>.ts` plus one member here and one
+ * line in the guard below. No existing feature file is touched.
+ */
+export type SlotSpec = ResourceDetailSlots;
+/** Every wrapper slot in the core. */
+export type WrapperSpec = ResourceDetailWrappers;
+/**
+ * A plugin's leaf-slot handlers. Each receives exactly its slot's payload.
+ *
+ * Registering an unknown slot, or reading a field the slot does not pass, is a
+ * compile error — which is the whole point of composing `SlotSpec` rather than
+ * typing handlers as `(props: unknown)`.
+ */
+export type PluginSlots = {
+    [N in keyof SlotSpec]?: (props: SlotSpec[N]) => ReactNode;
+};
+/** A plugin's wrapper handlers. `children` is injected by the core. */
+export type PluginWrappers = {
+    [N in keyof WrapperSpec]?: (props: WrapperSpec[N] & {
+        children: ReactNode;
+    }) => ReactNode;
+};
+/**
+ * One deployment-specific feature's contribution to the core's UI.
+ *
+ * Passed to `<App extensions={[...]} />` as an array, not a keyed map: a map
+ * holds one value per key, so a second plugin at the same slot would silently
+ * replace the first and two wrappers around one subtree would be impossible.
+ *
+ * The array must be a module-level constant. The core iterates it in render
+ * order, so rebuilding it per render would change hook call order inside the
+ * plugins and violate the rules of hooks.
+ */
+export interface AcPlugin {
+    /** Identity, used in error reports and test assertions. */
+    name: string;
+    slots?: PluginSlots;
+    wrappers?: PluginWrappers;
+}
+/**
+ * Whether any registered plugin fills this slot.
+ *
+ * For the cases where rendering the slot is not enough and the core has to
+ * change its own layout around it — a table column, say, which would otherwise
+ * be an empty column with a header and no cells in every build that registers
+ * nothing. Rendering an empty slot costs nothing; reserving space for one is
+ * what this is for.
+ *
+ * Use it ONLY for layout. A slot must never be the only route to something the
+ * core itself needs, so branching behaviour on a plugin's presence is a design
+ * smell even where branching layout is not.
+ */
+export declare function useSlotFilled(slot: keyof SlotSpec): boolean;
+/**
+ * The signed-in user, reduced to what slots are given.
+ *
+ * One place, so two slots cannot disagree about the shape — and deliberately a
+ * projection rather than the real user object: the core's `User` is free to grow
+ * fields, and handing a plugin the whole thing would make every one of them part
+ * of the published slot contract.
+ *
+ * Returns `null` with no `AuthProvider` above it. The detail card renders inside
+ * the catalog panel, which some suites mount outside the provider, and throwing
+ * there would make a plugin's presence break unrelated tests.
+ */
+export declare function usePluginUser(): PluginUser | null;

package/dist/esm/modules/extensions/index.js

@@ -0,0 +1,26 @@
+import { useMemo } from "react";
+import { useOptionalUser } from "../auth/AuthContext.js";
+import { useExtensions } from "./ExtensionsContext.js";
+import { ExtensionsContext } from "./ExtensionsContext.js";
+function useSlotFilled(slot) {
+  return useExtensions().some((plugin) => {
+    var _a;
+    return Boolean((_a = plugin.slots) == null ? void 0 : _a[slot]);
+  });
+}
+function usePluginUser() {
+  const user = useOptionalUser();
+  return useMemo(
+    // `?? false`, because admin is a capability: absent must read as "not an
+    // admin", never as undefined leaking into a plugin's own check.
+    () => user ? { email: user.email, isAdmin: user.isAdmin ?? false } : null,
+    [user]
+  );
+}
+export {
+  ExtensionsContext,
+  useExtensions,
+  usePluginUser,
+  useSlotFilled
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/modules/extensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/modules/extensions/index.ts"],"sourcesContent":["import { useMemo } from 'react'\nimport type { ReactNode } from 'react'\n// Relative, not `~`: this file is on the published entry's graph and therefore\n// in every consumer's program, and `~` is the CORE's alias — a consumer only\n// resolves it if it has mapped it, which the example app has not.\nimport { useOptionalUser } from '../auth/AuthContext'\nimport type {\n  ResourceDetailSlots,\n  ResourceDetailWrappers,\n} from './features/resourceDetail'\nimport type { AssertDisjoint, PluginUser } from './types'\n\nimport { useExtensions } from './ExtensionsContext'\n\nexport { ExtensionsContext, useExtensions } from './ExtensionsContext'\nexport { slotFactory, wrapperFactory } from './factories'\nexport { makeSlot, makeWrapper } from './makeSlot'\nexport type { PluginUser, PluginRegistration } from './types'\nexport type { AssertDisjoint } from './types'\nexport {\n  ResourceDetailAccessActions,\n  ResourceSubResourceRowActions,\n  ResourceDetailProvider,\n} from './features/resourceDetail'\nexport type {\n  ResourceDetailSlots,\n  ResourceDetailWrappers,\n} from './features/resourceDetail'\n\n/**\n * Every leaf slot in the core, composed from the per-feature specs.\n *\n * Adding a feature means a new `features/<name>.ts` plus one member here and one\n * line in the guard below. No existing feature file is touched.\n */\nexport type SlotSpec = ResourceDetailSlots\n\n/** Every wrapper slot in the core. */\nexport type WrapperSpec = ResourceDetailWrappers\n\n// Guard: with a second feature this becomes\n// `AssertDisjoint<ResourceDetailSlots, ServiceDeskSlots>` and fails with the\n// duplicated id spelled out in the error. With one feature it is trivially true,\n// and is kept so the next feature inherits the check rather than inventing it.\nconst _slotIdsAreDisjoint: AssertDisjoint<SlotSpec, Record<never, never>> = true\nvoid _slotIdsAreDisjoint\n\n/**\n * A plugin's leaf-slot handlers. Each receives exactly its slot's payload.\n *\n * Registering an unknown slot, or reading a field the slot does not pass, is a\n * compile error — which is the whole point of composing `SlotSpec` rather than\n * typing handlers as `(props: unknown)`.\n */\nexport type PluginSlots = {\n  [N in keyof SlotSpec]?: (props: SlotSpec[N]) => ReactNode\n}\n\n/** A plugin's wrapper handlers. `children` is injected by the core. */\nexport type PluginWrappers = {\n  [N in keyof WrapperSpec]?: (\n    props: WrapperSpec[N] & { children: ReactNode },\n  ) => ReactNode\n}\n\n/**\n * One deployment-specific feature's contribution to the core's UI.\n *\n * Passed to `<App extensions={[...]} />` as an array, not a keyed map: a map\n * holds one value per key, so a second plugin at the same slot would silently\n * replace the first and two wrappers around one subtree would be impossible.\n *\n * The array must be a module-level constant. The core iterates it in render\n * order, so rebuilding it per render would change hook call order inside the\n * plugins and violate the rules of hooks.\n */\nexport interface AcPlugin {\n  /** Identity, used in error reports and test assertions. */\n  name: string\n  slots?: PluginSlots\n  wrappers?: PluginWrappers\n}\n\n/**\n * Whether any registered plugin fills this slot.\n *\n * For the cases where rendering the slot is not enough and the core has to\n * change its own layout around it — a table column, say, which would otherwise\n * be an empty column with a header and no cells in every build that registers\n * nothing. Rendering an empty slot costs nothing; reserving space for one is\n * what this is for.\n *\n * Use it ONLY for layout. A slot must never be the only route to something the\n * core itself needs, so branching behaviour on a plugin's presence is a design\n * smell even where branching layout is not.\n */\nexport function useSlotFilled(slot: keyof SlotSpec): boolean {\n  return useExtensions().some((plugin) => Boolean(plugin.slots?.[slot]))\n}\n\n/**\n * The signed-in user, reduced to what slots are given.\n *\n * One place, so two slots cannot disagree about the shape — and deliberately a\n * projection rather than the real user object: the core's `User` is free to grow\n * fields, and handing a plugin the whole thing would make every one of them part\n * of the published slot contract.\n *\n * Returns `null` with no `AuthProvider` above it. The detail card renders inside\n * the catalog panel, which some suites mount outside the provider, and throwing\n * there would make a plugin's presence break unrelated tests.\n */\nexport function usePluginUser(): PluginUser | null {\n  const user = useOptionalUser()\n  return useMemo(\n    // `?? false`, because admin is a capability: absent must read as \"not an\n    // admin\", never as undefined leaking into a plugin's own check.\n    () => (user ? { email: user.email, isAdmin: user.isAdmin ?? false } : null),\n    [user],\n  )\n}\n"],"names":[],"mappings":";;;;AAgGO,SAAS,cAAc,MAA+B;AAC3D,SAAO,cAAA,EAAgB,KAAK,CAAC,WAAA;;AAAW,oBAAQ,YAAO,UAAP,mBAAe,KAAK;AAAA,GAAC;AACvE;AAcO,SAAS,gBAAmC;AACjD,QAAM,OAAO,gBAAA;AACb,SAAO;AAAA;AAAA;AAAA,IAGL,MAAO,OAAO,EAAE,OAAO,KAAK,OAAO,SAAS,KAAK,WAAW,MAAA,IAAU;AAAA,IACtE,CAAC,IAAI;AAAA,EAAA;AAET;"}

package/dist/esm/modules/extensions/makeSlot.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+/**
+ * Builds the component the core renders at one leaf slot.
+ *
+ * Every registered plugin contributing to this slot renders, in array order, so
+ * two plugins can occupy the same point. Each is isolated: one plugin throwing
+ * removes only its own node.
+ *
+ * Each contribution also gets its own `Suspense`. Without it a plugin that
+ * suspends — any `useSuspenseQuery`, any lazy import — bubbles to the nearest
+ * boundary above, which for the detail card is `AppCatalogPage`'s
+ * `<Suspense fallback={null}>`; the whole card would then vanish until the
+ * plugin's data arrived.
+ */
+export declare function makeSlot<TProps>(slotName: string): {
+    (props: TProps): ReactNode;
+    displayName: string;
+};
+/**
+ * Builds the component the core renders *around* a subtree.
+ *
+ * Folded right-to-left so the FIRST plugin in the array ends up outermost, which
+ * makes nesting order readable from the array itself.
+ *
+ * Note both fallbacks differ from a leaf slot's: they are the accumulated
+ * children, never `null`. A wrapper only decorates — usually by providing
+ * context — so neither a broken one nor a suspending one may blank the core
+ * subtree it was wrapping.
+ *
+ * The `Suspense` matters as much as the boundary. Without it a wrapper that
+ * suspends bubbles to the nearest boundary above, which for the detail card is
+ * `AppCatalogPage`'s `<Suspense fallback={null}>` — so one plugin fetching
+ * something would make the entire card disappear until it resolved. Falling
+ * back to `acc` instead renders the core subtree immediately, just without the
+ * decoration, and it arrives when the plugin is ready.
+ *
+ * A consequence worth stating: while suspended, descendants see no context from
+ * this wrapper. A wrapper whose children cannot cope with that should not
+ * suspend — it should render children and fetch inside its own subtree.
+ */
+export declare function makeWrapper<TProps>(wrapperName: string): {
+    (props: TProps & {
+        children: ReactNode;
+    }): ReactNode;
+    displayName: string;
+};

package/dist/esm/modules/extensions/makeSlot.js

@@ -0,0 +1,62 @@
+import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { ErrorBoundary } from "react-error-boundary";
+import { useExtensions } from "./ExtensionsContext.js";
+function reportSlotError(plugin, slot, error) {
+  console.error(`[plugin:${plugin}] slot "${slot}" failed to render`, error);
+}
+const call = (fn, props) => fn(props);
+function Contribution({
+  render,
+  props
+}) {
+  return call(render, props);
+}
+function makeSlot(slotName) {
+  function Slot(props) {
+    const plugins = useExtensions();
+    return plugins.map((plugin) => {
+      var _a;
+      const render = (_a = plugin.slots) == null ? void 0 : _a[slotName];
+      if (!render) return null;
+      return /* @__PURE__ */ jsx(
+        ErrorBoundary,
+        {
+          fallbackRender: () => null,
+          onError: (error) => reportSlotError(plugin.name, slotName, error),
+          children: /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(Contribution, { render, props }) })
+        },
+        plugin.name
+      );
+    });
+  }
+  Slot.displayName = `Slot(${slotName})`;
+  return Slot;
+}
+function makeWrapper(wrapperName) {
+  function Wrapper(props) {
+    const plugins = useExtensions();
+    const { children, ...rest } = props;
+    return plugins.reduceRight((acc, plugin) => {
+      var _a;
+      const render = (_a = plugin.wrappers) == null ? void 0 : _a[wrapperName];
+      if (!render) return acc;
+      return /* @__PURE__ */ jsx(
+        ErrorBoundary,
+        {
+          fallbackRender: () => acc,
+          onError: (error) => reportSlotError(plugin.name, wrapperName, error),
+          children: /* @__PURE__ */ jsx(Suspense, { fallback: acc, children: /* @__PURE__ */ jsx(Contribution, { render, props: { ...rest, children: acc } }) })
+        },
+        plugin.name
+      );
+    }, children);
+  }
+  Wrapper.displayName = `SlotWrapper(${wrapperName})`;
+  return Wrapper;
+}
+export {
+  makeSlot,
+  makeWrapper
+};
+//# sourceMappingURL=makeSlot.js.map

package/dist/esm/modules/extensions/makeSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeSlot.js","sources":["../../../../src/modules/extensions/makeSlot.tsx"],"sourcesContent":["import { Suspense } from 'react'\nimport { ErrorBoundary } from 'react-error-boundary'\nimport type { ReactNode } from 'react'\nimport { useExtensions } from './ExtensionsContext'\nimport type { OpaqueRenderer } from './types'\n\n/**\n * Reported when a plugin's render throws.\n *\n * Deliberately not swallowed. With a `null` fallback and no report, a crashing\n * plugin is indistinguishable from an unregistered one — the button is simply\n * absent, in production and in tests alike. Routing it through `console.error`\n * is what makes `getGlobalError()` in the test kit able to assert it.\n */\nfunction reportSlotError(plugin: string, slot: string, error: unknown): void {\n  console.error(`[plugin:${plugin}] slot \"${slot}\" failed to render`, error)\n}\n\nconst call = (fn: OpaqueRenderer, props: unknown): ReactNode =>\n  (fn as (p: unknown) => ReactNode)(props)\n\n/**\n * Invokes a plugin's handler from inside its own component.\n *\n * Not an inline `{call(render, props)}`: that expression is evaluated while the\n * surrounding `Slot` renders, which is BEFORE React mounts the ErrorBoundary\n * around it. A boundary only catches errors thrown by its descendants, so an\n * inline call escaped the boundary entirely and took the host down with it.\n * Putting the invocation in a child component is what moves the throw inside.\n */\nfunction Contribution({\n  render,\n  props,\n}: {\n  render: OpaqueRenderer\n  props: unknown\n}): ReactNode {\n  return call(render, props)\n}\n\n/**\n * Builds the component the core renders at one leaf slot.\n *\n * Every registered plugin contributing to this slot renders, in array order, so\n * two plugins can occupy the same point. Each is isolated: one plugin throwing\n * removes only its own node.\n *\n * Each contribution also gets its own `Suspense`. Without it a plugin that\n * suspends — any `useSuspenseQuery`, any lazy import — bubbles to the nearest\n * boundary above, which for the detail card is `AppCatalogPage`'s\n * `<Suspense fallback={null}>`; the whole card would then vanish until the\n * plugin's data arrived.\n */\nexport function makeSlot<TProps>(slotName: string) {\n  function Slot(props: TProps): ReactNode {\n    const plugins = useExtensions()\n\n    return plugins.map((plugin) => {\n      const render = plugin.slots?.[slotName]\n      if (!render) return null\n      return (\n        <ErrorBoundary\n          key={plugin.name}\n          fallbackRender={() => null}\n          onError={(error) => reportSlotError(plugin.name, slotName, error)}\n        >\n          <Suspense fallback={null}>\n            <Contribution render={render} props={props} />\n          </Suspense>\n        </ErrorBoundary>\n      )\n    })\n  }\n  Slot.displayName = `Slot(${slotName})`\n  return Slot\n}\n\n/**\n * Builds the component the core renders *around* a subtree.\n *\n * Folded right-to-left so the FIRST plugin in the array ends up outermost, which\n * makes nesting order readable from the array itself.\n *\n * Note both fallbacks differ from a leaf slot's: they are the accumulated\n * children, never `null`. A wrapper only decorates — usually by providing\n * context — so neither a broken one nor a suspending one may blank the core\n * subtree it was wrapping.\n *\n * The `Suspense` matters as much as the boundary. Without it a wrapper that\n * suspends bubbles to the nearest boundary above, which for the detail card is\n * `AppCatalogPage`'s `<Suspense fallback={null}>` — so one plugin fetching\n * something would make the entire card disappear until it resolved. Falling\n * back to `acc` instead renders the core subtree immediately, just without the\n * decoration, and it arrives when the plugin is ready.\n *\n * A consequence worth stating: while suspended, descendants see no context from\n * this wrapper. A wrapper whose children cannot cope with that should not\n * suspend — it should render children and fetch inside its own subtree.\n */\nexport function makeWrapper<TProps>(wrapperName: string) {\n  function Wrapper(props: TProps & { children: ReactNode }): ReactNode {\n    const plugins = useExtensions()\n    const { children, ...rest } = props\n\n    return plugins.reduceRight<ReactNode>((acc, plugin) => {\n      const render = plugin.wrappers?.[wrapperName]\n      if (!render) return acc\n      return (\n        <ErrorBoundary\n          key={plugin.name}\n          fallbackRender={() => acc}\n          onError={(error) => reportSlotError(plugin.name, wrapperName, error)}\n        >\n          <Suspense fallback={acc}>\n            <Contribution render={render} props={{ ...rest, children: acc }} />\n          </Suspense>\n        </ErrorBoundary>\n      )\n    }, children)\n  }\n  Wrapper.displayName = `SlotWrapper(${wrapperName})`\n  return Wrapper\n}\n"],"names":[],"mappings":";;;;AAcA,SAAS,gBAAgB,QAAgB,MAAc,OAAsB;AAC3E,UAAQ,MAAM,WAAW,MAAM,WAAW,IAAI,sBAAsB,KAAK;AAC3E;AAEA,MAAM,OAAO,CAAC,IAAoB,UAC/B,GAAiC,KAAK;AAWzC,SAAS,aAAa;AAAA,EACpB;AAAA,EACA;AACF,GAGc;AACZ,SAAO,KAAK,QAAQ,KAAK;AAC3B;AAeO,SAAS,SAAiB,UAAkB;AACjD,WAAS,KAAK,OAA0B;AACtC,UAAM,UAAU,cAAA;AAEhB,WAAO,QAAQ,IAAI,CAAC,WAAW;;AAC7B,YAAM,UAAS,YAAO,UAAP,mBAAe;AAC9B,UAAI,CAAC,OAAQ,QAAO;AACpB,aACE;AAAA,QAAC;AAAA,QAAA;AAAA,UAEC,gBAAgB,MAAM;AAAA,UACtB,SAAS,CAAC,UAAU,gBAAgB,OAAO,MAAM,UAAU,KAAK;AAAA,UAEhE,UAAA,oBAAC,YAAS,UAAU,MAClB,8BAAC,cAAA,EAAa,QAAgB,OAAc,EAAA,CAC9C;AAAA,QAAA;AAAA,QANK,OAAO;AAAA,MAAA;AAAA,IASlB,CAAC;AAAA,EACH;AACA,OAAK,cAAc,QAAQ,QAAQ;AACnC,SAAO;AACT;AAwBO,SAAS,YAAoB,aAAqB;AACvD,WAAS,QAAQ,OAAoD;AACnE,UAAM,UAAU,cAAA;AAChB,UAAM,EAAE,UAAU,GAAG,KAAA,IAAS;AAE9B,WAAO,QAAQ,YAAuB,CAAC,KAAK,WAAW;;AACrD,YAAM,UAAS,YAAO,aAAP,mBAAkB;AACjC,UAAI,CAAC,OAAQ,QAAO;AACpB,aACE;AAAA,QAAC;AAAA,QAAA;AAAA,UAEC,gBAAgB,MAAM;AAAA,UACtB,SAAS,CAAC,UAAU,gBAAgB,OAAO,MAAM,aAAa,KAAK;AAAA,UAEnE,UAAA,oBAAC,UAAA,EAAS,UAAU,KAClB,8BAAC,cAAA,EAAa,QAAgB,OAAO,EAAE,GAAG,MAAM,UAAU,IAAA,GAAO,EAAA,CACnE;AAAA,QAAA;AAAA,QANK,OAAO;AAAA,MAAA;AAAA,IASlB,GAAG,QAAQ;AAAA,EACb;AACA,UAAQ,cAAc,eAAe,WAAW;AAChD,SAAO;AACT;"}