@dxos/app-framework 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/dist/lib/node-esm/chunk-JPWVIQ5I.mjs

@@ -0,0 +1,595 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  capabilities_exports
+} from "./chunk-G3RTFSNG.mjs";
+
+// src/helpers.ts
+var topologicalSort = (nodes) => {
+  const getDependencies = (nodeId, seen = /* @__PURE__ */ new Set(), path = /* @__PURE__ */ new Set()) => {
+    if (path.has(nodeId)) {
+      throw new Error(`Circular dependency detected involving ${nodeId}`);
+    }
+    if (seen.has(nodeId)) {
+      return [];
+    }
+    const node = nodes.find((n) => n.id === nodeId);
+    if (!node) {
+      throw new Error(`Node ${nodeId} not found but is listed as a dependency`);
+    }
+    const newPath = /* @__PURE__ */ new Set([
+      ...path,
+      nodeId
+    ]);
+    const newSeen = /* @__PURE__ */ new Set([
+      ...seen,
+      nodeId
+    ]);
+    const dependsOn = node.dependsOn ?? [];
+    return [
+      ...dependsOn.flatMap((depId) => getDependencies(depId, newSeen, newPath)),
+      nodeId
+    ];
+  };
+  const allDependencies = nodes.map((node) => node.id).flatMap((id) => getDependencies(id)).filter((id, index, self) => self.indexOf(id) === index);
+  return allDependencies.map((id) => nodes.find((node) => node.id === id)).filter((node) => node !== void 0);
+};
+
+// src/ui/hooks/useSurface.ts
+import { useContext as useContext3 } from "react";
+import { raise as raise2 } from "@dxos/debug";
+
+// src/ui/components/PluginManager/PluginManagerProvider.ts
+import { createContext, useContext } from "react";
+import { raise } from "@dxos/debug";
+var PluginManagerContext = createContext(void 0);
+var usePluginManager = () => useContext(PluginManagerContext) ?? raise(new Error("Missing PluginManagerContext"));
+var PluginManagerProvider = PluginManagerContext.Provider;
+
+// src/ui/components/Surface/context.ts
+import { createContext as createContext2 } from "react";
+var SurfaceContext = createContext2(void 0);
+
+// src/ui/components/Surface/SurfaceComponent.tsx
+import { useAtomValue } from "@effect-atom/atom-react";
+import React3, { Fragment, Profiler, Suspense, forwardRef as forwardRef2, memo, useEffect, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { log } from "@dxos/log";
+import { ErrorBoundary } from "@dxos/react-error-boundary";
+import { useDefaultValue } from "@dxos/react-hooks";
+import { byPosition } from "@dxos/util";
+
+// src/ui/components/Surface/SurfaceInfo.tsx
+import React, { cloneElement, forwardRef, useCallback, useLayoutEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { addEventListener, combine } from "@dxos/async";
+import { useMergeRefs } from "@dxos/react-hooks";
+var SurfaceInfo = /* @__PURE__ */ forwardRef(({ children }, forwardedRef) => {
+  const [rect, setRect] = useState(null);
+  const [expand, setExpand] = useState(false);
+  const info = useSurface();
+  const [root, setRoot] = useState(null);
+  const measureRef = useCallback((node) => setRoot(node), []);
+  const mergedRef = useMergeRefs([
+    measureRef,
+    forwardedRef
+  ]);
+  const childWithRef = /* @__PURE__ */ cloneElement(children, {
+    ref: mergedRef
+  });
+  useLayoutEffect(() => {
+    if (!root) {
+      setRect(null);
+      return;
+    }
+    const measure = () => {
+      setRect(root.getBoundingClientRect());
+    };
+    const observer = new ResizeObserver(measure);
+    observer.observe(root);
+    measure();
+    return combine(addEventListener(window, "scroll", measure, true), addEventListener(window, "resize", measure), () => {
+      observer.disconnect();
+    });
+  }, [
+    root
+  ]);
+  const padding = 0;
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, childWithRef, rect && /* @__PURE__ */ createPortal(
+    /* @__PURE__ */ React.createElement("div", {
+      role: "none",
+      className: "z-[100] fixed flex flex-col-reverse scrollbar-none overflow-auto pointer-events-none",
+      style: {
+        top: rect.top + padding,
+        left: rect.left + padding,
+        width: rect.width - padding * 2,
+        height: rect.height - padding * 2
+      }
+    }, expand ? /* @__PURE__ */ React.createElement("div", {
+      className: "absolute inset-0 bg-deck-surface border border-green-500 cursor-pointer pointer-events-auto overflow-auto",
+      onPointerDown: (ev) => ev.stopPropagation(),
+      onClick: (ev) => {
+        ev.stopPropagation();
+        setExpand(false);
+      }
+    }, /* @__PURE__ */ React.createElement("pre", {
+      className: "p-2 text-xs text-description font-mono"
+    }, JSON.stringify({
+      info
+    }, null, 2))) : /* @__PURE__ */ React.createElement("span", {
+      className: "absolute right-1 bottom-0 flex items-center p-1 text-green-500 opacity-80 hover:opacity-100 text-xl cursor-pointer pointer-events-auto",
+      title: info.id,
+      onPointerDown: (ev) => ev.stopPropagation(),
+      onClick: (ev) => {
+        ev.stopPropagation();
+        setExpand(true);
+      }
+    }, "\u24D8")),
+    // TODO(burdon): Create well-known element to gather all debug portals.
+    document.body
+  ));
+});
+
+// src/ui/components/Surface/SurfaceProfilerContext.tsx
+import React2, { createContext as createContext3, useContext as useContext2, useMemo, useRef, useSyncExternalStore } from "react";
+var MAX_ENTRIES = 500;
+var SurfaceProfilerStore = class {
+  _entries = [];
+  _listeners = /* @__PURE__ */ new Set();
+  _snapshot = [];
+  _pendingNotify = false;
+  /** Records an entry and schedules a deferred notification to avoid re-render loops. */
+  record(entry) {
+    this._entries.push(entry);
+    if (this._entries.length > MAX_ENTRIES) {
+      this._entries = this._entries.slice(-MAX_ENTRIES);
+    }
+    this._snapshot = [
+      ...this._entries
+    ];
+    this._scheduleNotify();
+  }
+  clear() {
+    this._entries = [];
+    this._snapshot = [];
+    this._notifySync();
+  }
+  subscribe = (listener) => {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => {
+    return this._snapshot;
+  };
+  /**
+  * Defers notification to the next animation frame to break the
+  * Profiler onRender → record → notify → re-render → onRender loop.
+  */
+  _scheduleNotify() {
+    if (!this._pendingNotify) {
+      this._pendingNotify = true;
+      requestAnimationFrame(() => {
+        this._pendingNotify = false;
+        this._notifySync();
+      });
+    }
+  }
+  _notifySync() {
+    for (const listener of this._listeners) {
+      listener();
+    }
+  }
+};
+var SurfaceProfilerContext = /* @__PURE__ */ createContext3(void 0);
+var SurfaceProfilerProvider = ({ children }) => {
+  const storeRef = useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = new SurfaceProfilerStore();
+  }
+  return /* @__PURE__ */ React2.createElement(SurfaceProfilerContext.Provider, {
+    value: {
+      store: storeRef.current
+    }
+  }, children);
+};
+var useSurfaceProfilerCallback = () => {
+  const store = useContext2(SurfaceProfilerContext)?.store;
+  return useMemo(() => {
+    if (!store) {
+      return void 0;
+    }
+    return (id, phase, actualDuration, baseDuration, startTime, commitTime) => {
+      store.record({
+        id,
+        phase,
+        actualDuration,
+        baseDuration,
+        startTime,
+        commitTime,
+        timestamp: Date.now()
+      });
+    };
+  }, [
+    store
+  ]);
+};
+var useSurfaceProfilerEntries = () => {
+  const context = useContext2(SurfaceProfilerContext);
+  return useSyncExternalStore(context?.store.subscribe ?? noop, context?.store.getSnapshot ?? emptySnapshot);
+};
+var useSurfaceProfilerStats = () => {
+  const entries = useSurfaceProfilerEntries();
+  const statsMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    let stats = statsMap.get(entry.id);
+    if (!stats) {
+      stats = {
+        id: entry.id,
+        mountCount: 0,
+        updateCount: 0,
+        totalRenders: 0,
+        avgActualDuration: 0,
+        maxActualDuration: 0,
+        avgBaseDuration: 0,
+        lastActualDuration: 0,
+        lastCommitTime: 0
+      };
+      statsMap.set(entry.id, stats);
+    }
+    if (entry.phase === "mount") {
+      stats.mountCount++;
+    } else {
+      stats.updateCount++;
+    }
+    stats.totalRenders++;
+    stats.avgActualDuration = (stats.avgActualDuration * (stats.totalRenders - 1) + entry.actualDuration) / stats.totalRenders;
+    stats.avgBaseDuration = (stats.avgBaseDuration * (stats.totalRenders - 1) + entry.baseDuration) / stats.totalRenders;
+    stats.maxActualDuration = Math.max(stats.maxActualDuration, entry.actualDuration);
+    stats.lastActualDuration = entry.actualDuration;
+    stats.lastCommitTime = entry.commitTime;
+  }
+  return [
+    ...statsMap.values()
+  ].sort((a, b) => b.maxActualDuration - a.maxActualDuration);
+};
+var useSurfaceProfilerClear = () => {
+  const store = useContext2(SurfaceProfilerContext)?.store;
+  return useMemo(() => store ? () => store.clear() : void 0, [
+    store
+  ]);
+};
+var noop = () => () => {
+};
+var EMPTY_SNAPSHOT = [];
+var emptySnapshot = () => EMPTY_SNAPSHOT;
+
+// src/ui/components/Surface/SurfaceComponent.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/ui/components/Surface/SurfaceComponent.tsx";
+var DEBUG = import.meta.env.VITE_DEBUG;
+var DEFAULT_PLACEHOLDER = /* @__PURE__ */ React3.createElement(Fragment, null);
+var WebComponentWrapper = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({ id, role, data, limit, definition, ...rest }, forwardedRef) => {
+  const containerRef = useRef2(null);
+  const elementRef = useRef2(null);
+  const propsRef = useRef2({
+    id,
+    role,
+    data,
+    limit,
+    ...rest
+  });
+  propsRef.current = {
+    id,
+    role,
+    data,
+    limit,
+    ...rest
+  };
+  useEffect(() => {
+    if (!containerRef.current || elementRef.current) {
+      return;
+    }
+    const element = document.createElement(definition.tagName);
+    elementRef.current = element;
+    Object.assign(element, propsRef.current);
+    containerRef.current.appendChild(element);
+    if (typeof forwardedRef === "function") {
+      forwardedRef(element);
+    } else if (forwardedRef) {
+      forwardedRef.current = element;
+    }
+    return () => {
+      if (elementRef.current && containerRef.current?.contains(elementRef.current)) {
+        containerRef.current.removeChild(elementRef.current);
+      }
+      if (typeof forwardedRef === "function") {
+        forwardedRef(null);
+      } else if (forwardedRef) {
+        forwardedRef.current = null;
+      }
+      elementRef.current = null;
+    };
+  }, [
+    definition.tagName,
+    forwardedRef
+  ]);
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element) {
+      return;
+    }
+    Object.assign(element, propsRef.current);
+  });
+  return /* @__PURE__ */ React3.createElement("div", {
+    ref: containerRef
+  });
+}));
+WebComponentWrapper.displayName = "WebComponentWrapper";
+var SurfaceContextProvider = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({ id, role, data, limit, fallback = ErrorFallback, definition, ...rest }, forwardedRef) => {
+  const contextValue = useMemo2(() => ({
+    id,
+    role,
+    data
+  }), [
+    id,
+    role,
+    data
+  ]);
+  const onProfilerRender = useSurfaceProfilerCallback();
+  const profilerId = `surface/${id}/${role}`;
+  if (definition.kind === "web-component") {
+    return /* @__PURE__ */ React3.createElement(ErrorBoundary, {
+      name: "surface",
+      resetKeys: [
+        data
+      ],
+      FallbackComponent: fallback
+    }, /* @__PURE__ */ React3.createElement(SurfaceContext.Provider, {
+      value: contextValue
+    }, /* @__PURE__ */ React3.createElement(WebComponentWrapper, {
+      id,
+      role,
+      data,
+      limit,
+      definition,
+      ref: forwardedRef,
+      ...rest
+    })));
+  }
+  const Component = definition.component;
+  const debug = DEBUG || "__DX_DEBUG__" in window;
+  if (debug) {
+    return /* @__PURE__ */ React3.createElement(ErrorBoundary, {
+      name: "surface",
+      resetKeys: [
+        data
+      ],
+      FallbackComponent: fallback
+    }, /* @__PURE__ */ React3.createElement("div", {
+      role: "none",
+      className: "contents",
+      "data-id": id,
+      "data-role": role
+    }, /* @__PURE__ */ React3.createElement(SurfaceContext.Provider, {
+      value: contextValue
+    }, /* @__PURE__ */ React3.createElement(SurfaceInfo, {
+      ref: forwardedRef
+    }, onProfilerRender && !profilerId.includes("org.dxos.plugin.debug") ? /* @__PURE__ */ React3.createElement(Profiler, {
+      id: profilerId,
+      onRender: onProfilerRender
+    }, /* @__PURE__ */ React3.createElement(Component, {
+      id,
+      role,
+      data,
+      limit,
+      ...rest
+    })) : /* @__PURE__ */ React3.createElement(Component, {
+      id,
+      role,
+      data,
+      limit,
+      ...rest
+    })))));
+  }
+  return /* @__PURE__ */ React3.createElement(ErrorBoundary, {
+    name: "surface",
+    resetKeys: [
+      data
+    ],
+    FallbackComponent: fallback
+  }, /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: "contents",
+    "data-id": id,
+    "data-role": role
+  }, /* @__PURE__ */ React3.createElement(SurfaceContext.Provider, {
+    value: contextValue
+  }, /* @__PURE__ */ React3.createElement(Component, {
+    id,
+    role,
+    data,
+    limit,
+    ...rest,
+    ref: forwardedRef
+  }))));
+}));
+SurfaceContextProvider.displayName = "SurfaceContextProvider";
+var SurfaceComponent = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef2(({ id: _id, role, type, data: dataProp, limit, placeholder = DEFAULT_PLACEHOLDER, ...rest }, forwardedRef) => {
+  const data = useDefaultValue(dataProp, () => ({}));
+  const surfaces = useSurfaces();
+  const effectiveRole = role ?? type?.role;
+  if (effectiveRole == null) {
+    if (DEBUG) {
+      log.warn("Surface has neither `role` nor `type` prop", {
+        id: _id
+      }, {
+        F: __dxlog_file,
+        L: 201,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+    return null;
+  }
+  const definitions = findCandidates(surfaces, {
+    role: effectiveRole,
+    data
+  });
+  const candidates = limit ? definitions.slice(0, limit) : definitions;
+  if (DEBUG && candidates.length === 0) {
+    log.warn("no candidates for surface", {
+      role: effectiveRole,
+      data
+    }, {
+      F: __dxlog_file,
+      L: 210,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return null;
+  }
+  return /* @__PURE__ */ React3.createElement(Suspense, {
+    fallback: placeholder
+  }, candidates.map((definition) => /* @__PURE__ */ React3.createElement(SurfaceContextProvider, {
+    key: definition.id,
+    id: definition.id,
+    role: effectiveRole,
+    data,
+    limit,
+    definition,
+    ref: forwardedRef,
+    ...rest
+  })));
+}));
+SurfaceComponent.displayName = "Surface";
+var ErrorFallback = ({ error }) => {
+  const { message } = error instanceof Error ? error : {
+    message: String(error)
+  };
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "alert",
+    "data-testid": "error-boundary-fallback"
+  }, /* @__PURE__ */ React3.createElement("h1", {
+    className: "flex gap-2 text-sm mt-2 text-info-text"
+  }, message));
+};
+var findCandidates = (surfaces, { role, data }) => {
+  return Object.values(surfaces).filter((definition) => Array.isArray(definition.role) ? definition.role.includes(role) : definition.role === role).filter(({ filter }) => filter ? filter(data ?? {}, role) : true).toSorted(byPosition);
+};
+var useSurfaces = () => {
+  const manager = usePluginManager();
+  const surfacesByModule = useAtomValue(manager.capabilities.atomByModule(capabilities_exports.ReactSurface));
+  return useMemo2(() => {
+    const result = [];
+    for (const [moduleId, surfaces] of Object.entries(surfacesByModule)) {
+      for (const def of surfaces.flat()) {
+        result.push({
+          ...def,
+          id: `${moduleId}.${def.id}`
+        });
+      }
+    }
+    return result;
+  }, [
+    surfacesByModule
+  ]);
+};
+function isSurfaceAvailable(capabilityManager, { role, type, data }) {
+  const effectiveRole = role ?? type?.role;
+  if (effectiveRole == null) {
+    return false;
+  }
+  const surfaces = capabilityManager.getAll(capabilities_exports.ReactSurface);
+  const candidates = findCandidates(surfaces.flat(), {
+    role: effectiveRole,
+    data
+  });
+  return candidates.length > 0;
+}
+
+// src/ui/components/Surface/types.ts
+var isSurfaceFilter = (value) => typeof value === "object" && value !== null && Array.isArray(value.bindings);
+var makeType = (role) => ({
+  role
+});
+var expandBindings = (filter) => {
+  const bindings = filter.bindings;
+  const roles = Array.from(new Set(bindings.map((binding) => binding.role)));
+  const guard = (data, role) => {
+    if (role != null) {
+      return bindings.some((entry) => entry.role === role && entry.guard(data));
+    }
+    return bindings.some((entry) => entry.guard(data));
+  };
+  return {
+    role: roles.length === 1 ? roles[0] : roles,
+    guard
+  };
+};
+function create(definition) {
+  if (isSurfaceFilter(definition.filter)) {
+    const { id, filter, component, position } = definition;
+    const { role, guard } = expandBindings(filter);
+    return {
+      kind: "react",
+      id,
+      role,
+      position,
+      component,
+      filter: guard
+    };
+  }
+  return {
+    ...definition,
+    kind: "react"
+  };
+}
+function createWeb(definition) {
+  if (isSurfaceFilter(definition.filter)) {
+    const { id, filter, tagName, position } = definition;
+    const { role, guard } = expandBindings(filter);
+    return {
+      kind: "web-component",
+      id,
+      role,
+      position,
+      tagName,
+      filter: guard
+    };
+  }
+  return {
+    ...definition,
+    kind: "web-component"
+  };
+}
+
+// src/ui/components/Surface/index.ts
+(function(Surface2) {
+  Surface2.create = create;
+  Surface2.createWeb = createWeb;
+  Surface2.Context = SurfaceContext;
+  Surface2.Surface = SurfaceComponent;
+  Surface2.isAvailable = isSurfaceAvailable;
+  Surface2.makeType = makeType;
+  Surface2.isFilter = isSurfaceFilter;
+  Surface2.ProfilerProvider = SurfaceProfilerProvider;
+  Surface2.useProfilerCallback = useSurfaceProfilerCallback;
+  Surface2.useProfilerEntries = useSurfaceProfilerEntries;
+  Surface2.useProfilerStats = useSurfaceProfilerStats;
+  Surface2.useProfilerClear = useSurfaceProfilerClear;
+})(Surface || (Surface = {}));
+var Surface;
+
+// src/ui/hooks/useSurface.ts
+var useSurface = () => {
+  return useContext3(Surface.Context) ?? raise2(new Error("Missing SurfaceContext"));
+};
+
+export {
+  topologicalSort,
+  useSurface,
+  usePluginManager,
+  PluginManagerProvider,
+  SurfaceComponent,
+  Surface
+};
+//# sourceMappingURL=chunk-JPWVIQ5I.mjs.map