@dxos/app-framework 0.6.11 → 0.6.12-main.5cc132e

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,676 @@
+import {
+  SurfaceProvider,
+  meta_default as meta_default2,
+  parseRootSurfacePlugin,
+  parseSurfacePlugin,
+  useSurfaceRoot
+} from "./chunk-YYV26N3W.mjs";
+import {
+  IntentAction,
+  IntentProvider,
+  meta_default,
+  parseIntentPlugin,
+  parseIntentResolverPlugin,
+  useIntent,
+  useIntentDispatcher,
+  useIntentResolver
+} from "./chunk-J45KR4DI.mjs";
+import {
+  definePlugin,
+  filterPlugins,
+  findPlugin,
+  getPlugin,
+  resolvePlugin
+} from "./chunk-S5CI6EUQ.mjs";
+
+// packages/sdk/app-framework/src/plugins/common/file.ts
+var defaultFileTypes = {
+  images: [
+    "png",
+    "jpg",
+    "jpeg",
+    "gif"
+  ],
+  media: [
+    "mp3",
+    "mp4",
+    "mov",
+    "avi"
+  ],
+  text: [
+    "pdf",
+    "txt",
+    "md"
+  ]
+};
+var parseFileManagerPlugin = (plugin) => {
+  return plugin.provides.file ? plugin : void 0;
+};
+
+// packages/sdk/app-framework/src/plugins/common/graph.ts
+var parseGraphPlugin = (plugin) => plugin.provides.graph?.root ? plugin : void 0;
+var parseGraphBuilderPlugin = (plugin) => plugin.provides.graph?.builder ? plugin : void 0;
+var parseGraphSerializerPlugin = (plugin) => plugin.provides.graph?.serializer ? plugin : void 0;
+
+// packages/sdk/app-framework/src/plugins/common/layout.ts
+import { z } from "zod";
+var Toast = z.object({
+  id: z.string(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+  // TODO(wittjosiah): `icon` should be string to be parsed by an `Icon` component.
+  icon: z.any().optional(),
+  duration: z.number().optional(),
+  closeLabel: z.string().optional(),
+  actionLabel: z.string().optional(),
+  actionAlt: z.string().optional(),
+  onAction: z.function().optional()
+});
+var LayoutMode = z.union([
+  z.literal("deck"),
+  z.literal("solo"),
+  z.literal("fullscreen")
+]);
+var isLayoutMode = (value) => LayoutMode.safeParse(value).success;
+var Layout = z.object({
+  layoutMode: z.union([
+    z.literal("deck"),
+    z.literal("solo"),
+    z.literal("fullscreen")
+  ]),
+  sidebarOpen: z.boolean(),
+  complementarySidebarOpen: z.boolean(),
+  /**
+  * @deprecated
+  */
+  complementarySidebarContent: z.any().optional().describe("DEPRECATED. Data to be passed to the complementary sidebar Surface."),
+  dialogOpen: z.boolean(),
+  dialogContent: z.any().optional().describe("Data to be passed to the dialog Surface."),
+  // TODO(wittjosiah): Custom properties?
+  dialogBlockAlign: z.union([
+    z.literal("start"),
+    z.literal("center")
+  ]).optional(),
+  popoverOpen: z.boolean(),
+  popoverContent: z.any().optional().describe("Data to be passed to the popover Surface."),
+  popoverAnchorId: z.string().optional(),
+  toasts: z.array(Toast),
+  scrollIntoView: z.string().optional().describe("The identifier of a component to scroll into view when it is mounted.")
+});
+var parseLayoutPlugin = (plugin) => {
+  const { success } = Layout.safeParse(plugin.provides.layout);
+  return success ? plugin : void 0;
+};
+var LAYOUT_ACTION = "dxos.org/plugin/layout";
+var LayoutAction;
+(function(LayoutAction2) {
+  LayoutAction2[LayoutAction2["SET_LAYOUT"] = `${LAYOUT_ACTION}/set-layout`] = "SET_LAYOUT";
+  LayoutAction2[LayoutAction2["SET_LAYOUT_MODE"] = `${LAYOUT_ACTION}/set-layout-mode`] = "SET_LAYOUT_MODE";
+  LayoutAction2[LayoutAction2["SCROLL_INTO_VIEW"] = `${LAYOUT_ACTION}/scroll-into-view`] = "SCROLL_INTO_VIEW";
+  LayoutAction2[LayoutAction2["UPDATE_PLANK_SIZE"] = `${LAYOUT_ACTION}/update-plank-size`] = "UPDATE_PLANK_SIZE";
+})(LayoutAction || (LayoutAction = {}));
+
+// packages/sdk/app-framework/src/plugins/common/metadata.ts
+var parseMetadataRecordsPlugin = (plugin) => {
+  return plugin.provides.metadata?.records ? plugin : void 0;
+};
+var parseMetadataResolverPlugin = (plugin) => {
+  return plugin.provides.metadata?.resolver ? plugin : void 0;
+};
+
+// packages/sdk/app-framework/src/plugins/common/navigation.ts
+import { z as z2 } from "zod";
+import { S } from "@dxos/echo-schema";
+var SLUG_LIST_SEPARATOR = "+";
+var SLUG_ENTRY_SEPARATOR = "_";
+var SLUG_KEY_VALUE_SEPARATOR = "-";
+var SLUG_PATH_SEPARATOR = "~";
+var SLUG_COLLECTION_INDICATOR = "";
+var LayoutEntrySchema = S.mutable(S.Struct({
+  id: S.String,
+  path: S.optional(S.String)
+}));
+var LayoutPartSchema = S.Union(S.Literal("sidebar"), S.Literal("main"), S.Literal("solo"), S.Literal("complementary"), S.Literal("fullScreen"));
+var LayoutPartsSchema = S.partial(S.mutable(S.Record(LayoutPartSchema, S.mutable(S.Array(LayoutEntrySchema)))));
+var LayoutCoordinateSchema = S.mutable(S.Struct({
+  part: LayoutPartSchema,
+  entryId: S.String
+}));
+var PartAdjustmentSchema = S.Union(S.Literal("increment-start"), S.Literal("increment-end"), S.Literal("solo"));
+var LayoutAdjustmentSchema = S.mutable(S.Struct({
+  layoutCoordinate: LayoutCoordinateSchema,
+  type: PartAdjustmentSchema
+}));
+var ActiveParts = z2.record(z2.string(), z2.union([
+  z2.string(),
+  z2.array(z2.string())
+]));
+var Attention = z2.object({
+  attended: z2.set(z2.string()).optional().describe("Ids of items which have focus.")
+});
+var LocationProvidesSchema = S.mutable(S.Struct({
+  location: S.Struct({
+    active: LayoutPartsSchema,
+    closed: S.Array(S.String)
+  })
+}));
+var isLayoutParts = (value) => {
+  return S.is(LayoutPartsSchema)(value);
+};
+var isLayoutAdjustment = (value) => {
+  return S.is(LayoutAdjustmentSchema)(value);
+};
+var parseNavigationPlugin = (plugin) => {
+  const location = plugin.provides?.location;
+  if (!location) {
+    return void 0;
+  }
+  if (S.is(LocationProvidesSchema)({
+    location
+  })) {
+    return plugin;
+  }
+  return void 0;
+};
+var openIds = (layout) => {
+  return Object.values(layout).flatMap((part) => part?.map((entry) => entry.id) ?? []).filter((id) => id !== void 0);
+};
+var firstIdInPart = (layout, part) => {
+  if (!layout) {
+    return void 0;
+  }
+  return layout[part]?.at(0)?.id;
+};
+var indexInPart = (layout, layoutCoordinate) => {
+  if (!layout || !layoutCoordinate) {
+    return void 0;
+  }
+  const { part, entryId } = layoutCoordinate;
+  return layout[part]?.findIndex((entry) => entry.id === entryId);
+};
+var partLength = (layout, part) => {
+  if (!layout || !part) {
+    return 0;
+  }
+  return layout[part]?.length ?? 0;
+};
+var NAVIGATION_ACTION = "dxos.org/plugin/navigation";
+var NavigationAction;
+(function(NavigationAction2) {
+  NavigationAction2[NavigationAction2["OPEN"] = `${NAVIGATION_ACTION}/open`] = "OPEN";
+  NavigationAction2[NavigationAction2["ADD_TO_ACTIVE"] = `${NAVIGATION_ACTION}/add-to-active`] = "ADD_TO_ACTIVE";
+  NavigationAction2[NavigationAction2["SET"] = `${NAVIGATION_ACTION}/set`] = "SET";
+  NavigationAction2[NavigationAction2["ADJUST"] = `${NAVIGATION_ACTION}/adjust`] = "ADJUST";
+  NavigationAction2[NavigationAction2["CLOSE"] = `${NAVIGATION_ACTION}/close`] = "CLOSE";
+  NavigationAction2[NavigationAction2["EXPOSE"] = `${NAVIGATION_ACTION}/expose`] = "EXPOSE";
+})(NavigationAction || (NavigationAction = {}));
+
+// packages/sdk/app-framework/src/plugins/common/settings.ts
+var parseSettingsPlugin = (plugin) => {
+  return typeof plugin.provides.settings === "object" ? plugin : void 0;
+};
+var SETTINGS_ACTION = "dxos.org/plugin/settings";
+var SettingsAction;
+(function(SettingsAction2) {
+  SettingsAction2[SettingsAction2["OPEN"] = `${SETTINGS_ACTION}/open`] = "OPEN";
+})(SettingsAction || (SettingsAction = {}));
+
+// packages/sdk/app-framework/src/plugins/common/translations.ts
+import { z as z3 } from "zod";
+var ResourceKey = z3.union([
+  z3.string(),
+  z3.record(z3.any())
+]);
+var ResourceLanguage = z3.record(ResourceKey);
+var Resource = z3.record(ResourceLanguage);
+var parseTranslationsPlugin = (plugin) => {
+  const { success } = z3.array(Resource).safeParse(plugin.provides.translations);
+  return success ? plugin : void 0;
+};
+
+// packages/sdk/app-framework/src/plugins/PluginHost/plugin.ts
+var pluginMeta = (meta) => meta;
+var Plugin;
+(function(Plugin2) {
+  Plugin2.lazy = (p, props) => {
+    return () => p().then(({ default: definition }) => {
+      return definition(props);
+    });
+  };
+})(Plugin || (Plugin = {}));
+
+// packages/sdk/app-framework/src/plugins/PluginHost/PluginContext.tsx
+import { createContext, useContext, useMemo } from "react";
+import { nonNullable } from "@dxos/util";
+var PluginContext = /* @__PURE__ */ createContext({
+  ready: false,
+  core: [],
+  enabled: [],
+  plugins: [],
+  available: [],
+  setPlugin: () => {
+  }
+});
+var usePlugins = () => useContext(PluginContext);
+var usePlugin = (id) => {
+  const { plugins } = usePlugins();
+  return findPlugin(plugins, id);
+};
+var useResolvePlugin = (predicate) => {
+  const { plugins } = usePlugins();
+  return resolvePlugin(plugins, predicate);
+};
+var useResolvePlugins = (predicate) => {
+  const { plugins } = usePlugins();
+  return useMemo(() => plugins.map(predicate).filter(nonNullable), [
+    plugins,
+    predicate
+  ]);
+};
+var PluginProvider = PluginContext.Provider;
+
+// packages/sdk/app-framework/src/plugins/PluginHost/PluginHost.tsx
+import React3, { useEffect, useState } from "react";
+import { LocalStorageStore } from "@dxos/local-storage";
+import { log } from "@dxos/log";
+
+// packages/sdk/app-framework/src/plugins/SurfacePlugin/helpers.ts
+var isObject = (data) => !!data && typeof data === "object";
+
+// packages/sdk/app-framework/src/plugins/SurfacePlugin/ErrorBoundary.tsx
+import React, { Component } from "react";
+var ErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      error: void 0
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      error
+    };
+  }
+  componentDidUpdate(prevProps) {
+    if (prevProps.data !== this.props.data) {
+      this.resetError();
+    }
+  }
+  render() {
+    if (this.state.error) {
+      return /* @__PURE__ */ React.createElement(this.props.fallback, {
+        data: this.props.data,
+        error: this.state.error,
+        reset: this.resetError
+      });
+    }
+    return this.props.children;
+  }
+  resetError() {
+    this.setState({
+      error: void 0
+    });
+  }
+};
+
+// packages/sdk/app-framework/src/plugins/SurfacePlugin/Surface.tsx
+import React2, { forwardRef, Fragment, isValidElement, Suspense } from "react";
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { raise } from "@dxos/debug";
+var Surface = /* @__PURE__ */ forwardRef(({ role, name = role, fallback, placeholder, ...rest }, forwardedRef) => {
+  const props = {
+    role,
+    name,
+    fallback,
+    ...rest
+  };
+  const context = useContext2(SurfaceContext);
+  const data = props.data ?? (name && context?.surfaces?.[name]?.data || {});
+  const resolver = /* @__PURE__ */ React2.createElement(SurfaceResolver, {
+    ...props,
+    ref: forwardedRef
+  });
+  const suspense = placeholder ? /* @__PURE__ */ React2.createElement(Suspense, {
+    fallback: placeholder
+  }, resolver) : resolver;
+  return fallback ? /* @__PURE__ */ React2.createElement(ErrorBoundary, {
+    data,
+    fallback
+  }, suspense) : suspense;
+});
+var SurfaceContext = /* @__PURE__ */ createContext2(null);
+var useSurface = () => useContext2(SurfaceContext) ?? raise(new Error("Surface context not found"));
+var SurfaceResolver = /* @__PURE__ */ forwardRef((props, forwardedRef) => {
+  const { components } = useSurfaceRoot();
+  const parent = useContext2(SurfaceContext);
+  const nodes = resolveNodes(components, props, parent, forwardedRef);
+  const currentContext = {
+    ...props,
+    surfaces: {
+      ...props.name && parent?.surfaces?.[props.name]?.surfaces || {},
+      ...props.surfaces
+    }
+  };
+  return /* @__PURE__ */ React2.createElement(SurfaceContext.Provider, {
+    value: currentContext
+  }, nodes);
+});
+var resolveNodes = (components, props, context, forwardedRef) => {
+  const data = {
+    ...props.name && context?.surfaces?.[props.name]?.data || {},
+    ...props.data
+  };
+  const nodes = Object.entries(components).map(([key, component]) => {
+    const result = component({
+      ...props,
+      data
+    }, forwardedRef);
+    if (!result || typeof result !== "object") {
+      return void 0;
+    }
+    return "node" in result ? [
+      key,
+      result
+    ] : /* @__PURE__ */ isValidElement(result) ? [
+      key,
+      {
+        node: result
+      }
+    ] : void 0;
+  }).filter((result) => Boolean(result)).sort(([, a], [, b]) => {
+    const aDisposition = a.disposition ?? "default";
+    const bDisposition = b.disposition ?? "default";
+    if (aDisposition === bDisposition) {
+      return 0;
+    } else if (aDisposition === "hoist" || bDisposition === "fallback") {
+      return -1;
+    } else if (bDisposition === "hoist" || aDisposition === "fallback") {
+      return 1;
+    }
+    return 0;
+  }).map(([key, result]) => /* @__PURE__ */ React2.createElement(Fragment, {
+    key
+  }, result.node));
+  return props.limit ? nodes.slice(0, props.limit) : nodes;
+};
+
+// packages/sdk/app-framework/src/plugins/PluginHost/PluginHost.tsx
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/app-framework/src/plugins/PluginHost/PluginHost.tsx";
+var parsePluginHost = (plugin) => plugin.provides.plugins ? plugin : void 0;
+var PLUGIN_HOST = "dxos.org/plugin/host";
+var PluginHost = ({ order, plugins: definitions, core = [], defaults = [], fallback = DefaultFallback, placeholder = null }) => {
+  const state = new LocalStorageStore(PLUGIN_HOST, {
+    ready: false,
+    core,
+    enabled: [
+      ...defaults
+    ],
+    plugins: [],
+    available: order.filter(({ id }) => !core.includes(id)),
+    setPlugin: (id, enabled) => {
+      if (enabled) {
+        state.values.enabled.push(id);
+      } else {
+        const index = state.values.enabled.findIndex((enabled2) => enabled2 === id);
+        index !== -1 && state.values.enabled.splice(index, 1);
+      }
+    }
+  });
+  state.prop({
+    key: "enabled",
+    type: LocalStorageStore.json()
+  });
+  return {
+    meta: {
+      id: PLUGIN_HOST,
+      name: "Plugin host"
+    },
+    provides: {
+      plugins: state.values,
+      context: ({ children }) => /* @__PURE__ */ React3.createElement(PluginProvider, {
+        value: state.values
+      }, children),
+      root: () => {
+        return /* @__PURE__ */ React3.createElement(ErrorBoundary, {
+          fallback
+        }, /* @__PURE__ */ React3.createElement(Root, {
+          order,
+          core,
+          definitions,
+          state: state.values,
+          placeholder
+        }));
+      }
+    }
+  };
+};
+var DefaultFallback = ({ error }) => {
+  return /* @__PURE__ */ React3.createElement("div", {
+    style: {
+      padding: "1rem"
+    }
+  }, /* @__PURE__ */ React3.createElement("h1", {
+    style: {
+      fontSize: "1.2rem",
+      fontWeight: 700,
+      margin: "0.5rem 0"
+    }
+  }, error.message), /* @__PURE__ */ React3.createElement("pre", null, error.stack));
+};
+var Root = ({ order, core: corePluginIds, definitions, state, placeholder }) => {
+  const [error, setError] = useState();
+  useEffect(() => {
+    log("initializing plugins", {
+      enabled: state.enabled
+    }, {
+      F: __dxlog_file,
+      L: 102,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const timeout = setTimeout(async () => {
+      try {
+        const enabledIds = [
+          ...corePluginIds,
+          ...state.enabled
+        ].sort((a, b) => {
+          const indexA = order.findIndex(({ id }) => id === a);
+          const indexB = order.findIndex(({ id }) => id === b);
+          return indexA - indexB;
+        });
+        const enabled = await Promise.all(enabledIds.map((id) => definitions[id]).filter((definition) => Boolean(definition)).map((definition) => definition()));
+        const plugins = await Promise.all(enabled.map(async (definition) => {
+          const plugin = await initializePlugin(definition).catch((err) => {
+            log.error("Failed to initialize plugin:", {
+              id: definition.meta.id,
+              err
+            }, {
+              F: __dxlog_file,
+              L: 122,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            return void 0;
+          });
+          return plugin;
+        })).then((plugins2) => plugins2.filter((plugin) => Boolean(plugin)));
+        log("plugins initialized", {
+          plugins
+        }, {
+          F: __dxlog_file,
+          L: 128,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        await Promise.all(enabled.map((pluginDefinition) => pluginDefinition.ready?.(plugins)));
+        log("plugins ready", {
+          plugins
+        }, {
+          F: __dxlog_file,
+          L: 131,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        state.plugins = plugins;
+        state.ready = true;
+      } catch (err) {
+        setError(err);
+      }
+    });
+    return () => {
+      clearTimeout(timeout);
+      state.ready = false;
+    };
+  }, []);
+  if (error) {
+    throw error;
+  }
+  if (!state.ready) {
+    return /* @__PURE__ */ React3.createElement(React3.Fragment, null, placeholder);
+  }
+  const ComposedContext = composeContext(state.plugins);
+  return /* @__PURE__ */ React3.createElement(ComposedContext, null, rootComponents(state.plugins));
+};
+var initializePlugin = async (pluginDefinition) => {
+  const provides = await pluginDefinition.initialize?.();
+  return {
+    ...pluginDefinition,
+    provides: {
+      ...pluginDefinition.provides,
+      ...provides
+    }
+  };
+};
+var rootComponents = (plugins) => {
+  return plugins.map((plugin) => {
+    const Component2 = plugin.provides.root;
+    if (Component2) {
+      return /* @__PURE__ */ React3.createElement(Component2, {
+        key: plugin.meta.id
+      });
+    } else {
+      return null;
+    }
+  }).filter((node) => Boolean(node));
+};
+var composeContext = (plugins) => {
+  return compose(plugins.map((p) => p.provides.context).filter(Boolean));
+};
+var compose = (contexts) => {
+  return [
+    ...contexts
+  ].reduce((Acc, Next) => ({ children }) => /* @__PURE__ */ React3.createElement(Acc, null, /* @__PURE__ */ React3.createElement(Next, null, children)));
+};
+
+// packages/sdk/app-framework/src/App.tsx
+import React4 from "react";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/app-framework/src/App.tsx";
+var createApp = ({ order, plugins, core = order.map(({ id }) => id), ...params }) => {
+  const host = PluginHost({
+    order: [
+      meta_default2,
+      meta_default,
+      ...order
+    ],
+    plugins: {
+      ...plugins,
+      [meta_default2.id]: Plugin.lazy(() => import("./plugin-K3KCPCTJ.mjs")),
+      [meta_default.id]: Plugin.lazy(() => import("./plugin-MM66VRCO.mjs"))
+    },
+    core: [
+      meta_default2.id,
+      meta_default.id,
+      ...core
+    ],
+    ...params
+  });
+  invariant(host.provides?.context, void 0, {
+    F: __dxlog_file2,
+    L: 51,
+    S: void 0,
+    A: [
+      "host.provides?.context",
+      ""
+    ]
+  });
+  invariant(host.provides?.root, void 0, {
+    F: __dxlog_file2,
+    L: 52,
+    S: void 0,
+    A: [
+      "host.provides?.root",
+      ""
+    ]
+  });
+  const Context = host.provides.context;
+  const Root2 = host.provides.root;
+  return () => /* @__PURE__ */ React4.createElement(Context, null, /* @__PURE__ */ React4.createElement(Root2, null));
+};
+export {
+  ActiveParts,
+  Attention,
+  ErrorBoundary,
+  IntentAction,
+  IntentProvider,
+  Layout,
+  LayoutAction,
+  NavigationAction,
+  Plugin,
+  PluginHost,
+  PluginProvider,
+  Resource,
+  ResourceKey,
+  ResourceLanguage,
+  SLUG_COLLECTION_INDICATOR,
+  SLUG_ENTRY_SEPARATOR,
+  SLUG_KEY_VALUE_SEPARATOR,
+  SLUG_LIST_SEPARATOR,
+  SLUG_PATH_SEPARATOR,
+  SettingsAction,
+  Surface,
+  SurfaceProvider,
+  Toast,
+  createApp,
+  defaultFileTypes,
+  definePlugin,
+  filterPlugins,
+  findPlugin,
+  firstIdInPart,
+  getPlugin,
+  indexInPart,
+  initializePlugin,
+  isLayoutAdjustment,
+  isLayoutMode,
+  isLayoutParts,
+  isObject,
+  openIds,
+  parseFileManagerPlugin,
+  parseGraphBuilderPlugin,
+  parseGraphPlugin,
+  parseGraphSerializerPlugin,
+  parseIntentPlugin,
+  parseIntentResolverPlugin,
+  parseLayoutPlugin,
+  parseMetadataRecordsPlugin,
+  parseMetadataResolverPlugin,
+  parseNavigationPlugin,
+  parsePluginHost,
+  parseRootSurfacePlugin,
+  parseSettingsPlugin,
+  parseSurfacePlugin,
+  parseTranslationsPlugin,
+  partLength,
+  pluginMeta,
+  resolvePlugin,
+  useIntent,
+  useIntentDispatcher,
+  useIntentResolver,
+  usePlugin,
+  usePlugins,
+  useResolvePlugin,
+  useResolvePlugins,
+  useSurface,
+  useSurfaceRoot
+};
+//# sourceMappingURL=index.mjs.map