@dxos/plugin-space 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

package/dist/lib/node-esm/RecordArticle-SSJ7PULS.mjs

@@ -0,0 +1,117 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  meta
+} from "./chunk-BDEFTL6K.mjs";
+
+// src/components/RecordArticle.tsx
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import React, { useMemo } from "react";
+import { Surface } from "@dxos/app-framework/react";
+import { Filter, Ref, Relation } from "@dxos/echo";
+import { getSpace, useQuery } from "@dxos/react-client/echo";
+import { useTranslation } from "@dxos/react-ui";
+import { Masonry } from "@dxos/react-ui-masonry";
+import { StackItem } from "@dxos/react-ui-stack";
+import { mx } from "@dxos/react-ui-theme";
+import { isNonNullable } from "@dxos/util";
+var RecordArticle = ({ subject }) => {
+  var _effect = _useSignals();
+  try {
+    const { t } = useTranslation(meta.id);
+    const space = getSpace(subject);
+    const data = useMemo(() => ({
+      subject
+    }), [
+      subject
+    ]);
+    const related = useRelatedObjects(space, subject, {
+      references: true,
+      relations: true
+    });
+    const singleColumn = related.length === 1;
+    return /* @__PURE__ */ React.createElement(StackItem.Content, null, /* @__PURE__ */ React.createElement("div", {
+      role: "none",
+      className: mx("flex flex-col gap-4 p-4 is-full overflow-y-auto")
+    }, /* @__PURE__ */ React.createElement("div", {
+      role: "none",
+      className: mx("flex is-full card-max-width")
+    }, /* @__PURE__ */ React.createElement(Surface, {
+      role: "section",
+      data,
+      limit: 1
+    })), related.length > 0 && /* @__PURE__ */ React.createElement("div", {
+      role: "none",
+      className: mx("flex flex-col gap-1", singleColumn ? "card-max-width" : "is-full")
+    }, /* @__PURE__ */ React.createElement("label", {
+      className: "mbs-2 text-sm text-description"
+    }, t("related objects label")), /* @__PURE__ */ React.createElement(Masonry.Root, {
+      items: related,
+      render: Card,
+      columnCount: singleColumn ? 1 : void 0,
+      intrinsicHeight: true
+    }))));
+  } finally {
+    _effect.f();
+  }
+};
+var Card = ({ data: subject }) => {
+  var _effect = _useSignals();
+  try {
+    const data = useMemo(() => ({
+      subject
+    }), [
+      subject
+    ]);
+    return /* @__PURE__ */ React.createElement(Surface, {
+      role: "card",
+      data,
+      limit: 1
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var useRelatedObjects = (space, record, options = {}) => {
+  const objects = useQuery(space, Filter.everything());
+  return useMemo(() => {
+    if (!record) {
+      return [];
+    }
+    const related = [];
+    if (options.references) {
+      const getReferences = (obj) => {
+        return Object.getOwnPropertyNames(obj).map((name) => obj[name]).filter((value) => Ref.isRef(value));
+      };
+      const references = getReferences(record);
+      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);
+      const referenceSources = objects.filter((obj) => {
+        const refs = getReferences(obj);
+        return refs.some((ref) => ref.target === record);
+      });
+      related.push(...referenceTargets, ...referenceSources);
+    }
+    if (options.relations) {
+      const isValidRelation = (obj) => {
+        try {
+          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);
+        } catch {
+          return false;
+        }
+      };
+      const relations = objects.filter((obj) => Relation.isRelation(obj)).filter((obj) => isValidRelation(obj));
+      const targetObjects = relations.filter((relation) => Relation.getTarget(relation) === record).map((relation) => Relation.getSource(relation));
+      const sourceObjects = relations.filter((relation) => Relation.getSource(relation) === record).map((relation) => Relation.getTarget(relation));
+      related.push(...targetObjects, ...sourceObjects);
+    }
+    return related;
+  }, [
+    record,
+    objects
+  ]);
+};
+var RecordArticle_default = RecordArticle;
+export {
+  RecordArticle,
+  RecordArticle_default as default
+};
+//# sourceMappingURL=RecordArticle-SSJ7PULS.mjs.map

package/dist/lib/node-esm/RecordArticle-SSJ7PULS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/RecordArticle.tsx"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport React, { useMemo } from 'react';\n\nimport { Surface } from '@dxos/app-framework/react';\nimport { type SurfaceComponentProps } from '@dxos/app-framework/react';\nimport { type Entity, Filter, type Obj, Ref, Relation } from '@dxos/echo';\nimport { type Space, getSpace, useQuery } from '@dxos/react-client/echo';\nimport { useTranslation } from '@dxos/react-ui';\nimport { Masonry } from '@dxos/react-ui-masonry';\nimport { StackItem } from '@dxos/react-ui-stack';\nimport { mx } from '@dxos/react-ui-theme';\nimport { isNonNullable } from '@dxos/util';\n\nimport { meta } from '../meta';\n\nexport const RecordArticle = ({ subject }: SurfaceComponentProps) => {\n  const { t } = useTranslation(meta.id);\n  const space = getSpace(subject);\n  const data = useMemo(() => ({ subject }), [subject]);\n  const related = useRelatedObjects(space, subject, {\n    references: true,\n    relations: true,\n  });\n  const singleColumn = related.length === 1;\n\n  return (\n    <StackItem.Content>\n      <div role='none' className={mx('flex flex-col gap-4 p-4 is-full overflow-y-auto')}>\n        <div role='none' className={mx('flex is-full card-max-width')}>\n          <Surface role='section' data={data} limit={1} />\n        </div>\n\n        {related.length > 0 && (\n          <div role='none' className={mx('flex flex-col gap-1', singleColumn ? 'card-max-width' : 'is-full')}>\n            <label className='mbs-2 text-sm text-description'>{t('related objects label')}</label>\n            <Masonry.Root<Entity.Unknown>\n              items={related}\n              render={Card}\n              columnCount={singleColumn ? 1 : undefined}\n              intrinsicHeight\n            />\n          </div>\n        )}\n      </div>\n    </StackItem.Content>\n  );\n};\n\nconst Card = ({ data: subject }: { data: Entity.Unknown }) => {\n  const data = useMemo(() => ({ subject }), [subject]);\n  return <Surface role='card' data={data} limit={1} />;\n};\n\n// TODO(wittjosiah): This is a hack. ECHO needs to have a back reference index to easily query for related objects.\nconst useRelatedObjects = (\n  space?: Space,\n  record?: Obj.Any,\n  options: { references?: boolean; relations?: boolean } = {},\n) => {\n  const objects = useQuery(space, Filter.everything());\n  return useMemo(() => {\n    if (!record) {\n      return [];\n    }\n\n    const related: Entity.Unknown[] = [];\n\n    // TODO(burdon): Change Person => Organization to relations.\n    if (options.references) {\n      const getReferences = (obj: Entity.Unknown): Ref.Any[] => {\n        return Object.getOwnPropertyNames(obj)\n          .map((name) => obj[name as keyof Obj.Any])\n          .filter((value) => Ref.isRef(value)) as Ref.Any[];\n      };\n\n      const references = getReferences(record);\n      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);\n      const referenceSources = objects.filter((obj) => {\n        const refs = getReferences(obj);\n        return refs.some((ref) => ref.target === record);\n      });\n\n      related.push(...referenceTargets, ...referenceSources);\n    }\n\n    if (options.relations) {\n      // TODO(dmaretskyi): Workaround until https://github.com/dxos/dxos/pull/10100 lands.\n      const isValidRelation = (obj: Relation.Any) => {\n        try {\n          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);\n        } catch {\n          return false;\n        }\n      };\n\n      const relations = objects.filter((obj) => Relation.isRelation(obj)).filter((obj) => isValidRelation(obj));\n      const targetObjects = relations\n        .filter((relation) => Relation.getTarget(relation) === record)\n        .map((relation) => Relation.getSource(relation));\n      const sourceObjects = relations\n        .filter((relation) => Relation.getSource(relation) === record)\n        .map((relation) => Relation.getTarget(relation));\n\n      related.push(...targetObjects, ...sourceObjects);\n    }\n\n    return related;\n  }, [record, objects]);\n};\n\nexport default RecordArticle;\n"],
+  "mappings": "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",
+  "names": ["React", "useMemo", "Surface", "Filter", "Ref", "Relation", "getSpace", "useQuery", "useTranslation", "Masonry", "StackItem", "mx", "isNonNullable", "RecordArticle", "subject", "t", "useTranslation", "meta", "id", "space", "getSpace", "data", "useMemo", "related", "useRelatedObjects", "references", "relations", "singleColumn", "length", "StackItem", "Content", "div", "role", "className", "mx", "Surface", "limit", "label", "Masonry", "Root", "items", "render", "Card", "columnCount", "undefined", "intrinsicHeight", "record", "options", "objects", "useQuery", "Filter", "everything", "getReferences", "obj", "Object", "getOwnPropertyNames", "map", "name", "filter", "value", "Ref", "isRef", "referenceTargets", "ref", "target", "isNonNullable", "referenceSources", "refs", "some", "push", "isValidRelation", "Relation", "isRelation", "getSource", "getTarget", "targetObjects", "relation", "sourceObjects"]
+}

package/dist/lib/node-esm/app-graph-builder-T6VJKIOA.mjs

@@ -0,0 +1,518 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  getActiveSpace
+} from "./chunk-7EV4SN47.mjs";
+import {
+  SpaceCapabilities
+} from "./chunk-WWGV5FJM.mjs";
+import {
+  SHARED,
+  SPACES,
+  atomFromQuery,
+  constructObjectActions,
+  constructSpaceActions,
+  constructSpaceNode,
+  createObjectNode,
+  createStaticSchemaActions,
+  createStaticSchemaNode
+} from "./chunk-I6FZP42D.mjs";
+import {
+  SPACE_TYPE,
+  SpaceAction
+} from "./chunk-X34VDVMY.mjs";
+import {
+  meta
+} from "./chunk-BDEFTL6K.mjs";
+
+// src/capabilities/app-graph-builder.ts
+import { Atom } from "@effect-atom/atom-react";
+import * as Array from "effect/Array";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { Capabilities, contributes, createIntent } from "@dxos/app-framework";
+import { SpaceState, getSpace, isSpace } from "@dxos/client/echo";
+import { DXN, Filter, Obj, Type } from "@dxos/echo";
+import { log } from "@dxos/log";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from "@dxos/plugin-deck/types";
+import { ROOT_ID, atomFromObservable, atomFromSignal, createExtension } from "@dxos/plugin-graph";
+import { Collection, View, ViewAnnotation, getTypenameFromQuery } from "@dxos/schema";
+import { isNonNullable } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/capabilities/app-graph-builder.ts";
+var app_graph_builder_default = ((context) => {
+  const resolve = (get) => (typename) => context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+  const spacesNode = {
+    id: SPACES,
+    type: SPACES,
+    cacheable: [
+      "label",
+      "role"
+    ],
+    properties: {
+      label: [
+        "spaces label",
+        {
+          ns: meta.id
+        }
+      ],
+      icon: "ph--planet--regular",
+      testId: "spacePlugin.spaces",
+      role: "branch",
+      disposition: "collection",
+      disabled: true,
+      childrenPersistenceClass: "echo",
+      onRearrangeChildren: async (nextOrder) => {
+        const { graph } = context.getCapability(Capabilities.AppGraph);
+        const client = context.getCapability(ClientCapabilities.Client);
+        graph.sortEdges(SPACES, "outbound", nextOrder.map(({ id }) => id));
+        const { objects: [spacesOrder] } = await client.spaces.default.db.query(Filter.type(Type.Expando, {
+          key: SHARED
+        })).run();
+        if (spacesOrder) {
+          spacesOrder.order = nextOrder.map(({ id }) => id);
+        } else {
+          log.warn("spaces order object not found", void 0, {
+            F: __dxlog_file,
+            L: 74,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    }
+  };
+  return contributes(Capabilities.AppGraphBuilder, [
+    // Primary actions.
+    createExtension({
+      id: `${meta.id}/primary-actions`,
+      position: "hoist",
+      actions: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => node2.id === ROOT_ID ? Option.some(node2) : Option.none()), Option.map(() => [
+        {
+          id: SpaceAction.OpenCreateSpace._tag,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+            await dispatch(createIntent(SpaceAction.OpenCreateSpace));
+          },
+          properties: {
+            label: [
+              "create space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--plus--regular",
+            testId: "spacePlugin.createSpace",
+            disposition: "menu"
+          }
+        },
+        {
+          id: SpaceAction.Join._tag,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+            await dispatch(createIntent(SpaceAction.Join));
+          },
+          properties: {
+            label: [
+              "join space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sign-in--regular",
+            testId: "spacePlugin.joinSpace",
+            disposition: "menu"
+          }
+        },
+        {
+          id: SpaceAction.OpenMembers._tag,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+            const client = context.getCapability(ClientCapabilities.Client);
+            const space = getActiveSpace(context) ?? client.spaces.default;
+            await dispatch(createIntent(SpaceAction.OpenMembers, {
+              space
+            }));
+          },
+          properties: {
+            label: [
+              "share space label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--users--regular",
+            testId: "spacePlugin.shareSpace",
+            keyBinding: {
+              macos: "meta+.",
+              windows: "alt+."
+            }
+          }
+        },
+        {
+          id: SpaceAction.OpenSettings._tag,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+            const client = context.getCapability(ClientCapabilities.Client);
+            const space = getActiveSpace(context) ?? client.spaces.default;
+            await dispatch(createIntent(SpaceAction.OpenSettings, {
+              space
+            }));
+          },
+          properties: {
+            label: [
+              "open current space settings label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--faders--regular",
+            keyBinding: {
+              macos: "meta+shift+,",
+              windows: "ctrl+shift+,"
+            }
+          }
+        }
+      ]), Option.getOrElse(() => [])))
+    }),
+    // Create spaces group node.
+    createExtension({
+      id: `${meta.id}/root`,
+      position: "hoist",
+      connector: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => node2.id === ROOT_ID ? Option.some(node2) : Option.none()), Option.map(() => [
+        spacesNode
+      ]), Option.getOrElse(() => [])))
+    }),
+    // Create space nodes.
+    createExtension({
+      id: SPACES,
+      connector: (node) => {
+        let query;
+        return Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => node2.id === SPACES ? Option.some(node2) : Option.none()), Option.map(() => {
+          const state = context.getCapability(SpaceCapabilities.State);
+          const client = context.getCapability(ClientCapabilities.Client);
+          const spacesAtom = atomFromObservable(client.spaces);
+          const isReadyAtom = atomFromObservable(client.spaces.isReady);
+          const spaces = get(spacesAtom);
+          const isReady = get(isReadyAtom);
+          if (!spaces || !isReady) {
+            return [];
+          }
+          const settings = get(context.capabilities(Capabilities.SettingsStore))[0]?.getStore(meta.id)?.value;
+          try {
+            if (!query) {
+              query = client.spaces.default.db.query(Filter.type(Type.Expando, {
+                key: SHARED
+              }));
+            }
+            const [spacesOrder] = get(atomFromQuery(query));
+            return get(atomFromSignal(() => {
+              const order = spacesOrder?.order ?? [];
+              const orderMap = new Map(order.map((id, index) => [
+                id,
+                index
+              ]));
+              return [
+                ...spaces.filter((space) => orderMap.has(space.id)).sort((a, b) => orderMap.get(a.id) - orderMap.get(b.id)),
+                ...spaces.filter((space) => !orderMap.has(space.id))
+              ].filter((space) => settings?.showHidden ? true : space.state.get() !== SpaceState.SPACE_INACTIVE).map((space) => constructSpaceNode({
+                space,
+                navigable: state.navigableCollections,
+                personal: space === client.spaces.default,
+                namesCache: state.spaceNames,
+                resolve: resolve(get)
+              }));
+            }));
+          } catch {
+            return [];
+          }
+        }), Option.getOrElse(() => [])));
+      }
+    }),
+    // Create space actions.
+    createExtension({
+      id: `${meta.id}/actions`,
+      actions: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => node2.type === SPACE_TYPE && isSpace(node2.data) ? Option.some(node2.data) : Option.none()), Option.flatMap((space) => {
+        const [dispatcher] = get(context.capabilities(Capabilities.IntentDispatcher));
+        const [client] = get(context.capabilities(ClientCapabilities.Client));
+        const [state] = get(context.capabilities(SpaceCapabilities.State));
+        if (!dispatcher || !client || !state) {
+          return Option.none();
+        } else {
+          return Option.some({
+            space,
+            dispatch: dispatcher.dispatchPromise,
+            personal: space === client.spaces.default,
+            migrating: state.sdkMigrationRunning[space.id]
+          });
+        }
+      }), Option.map((params) => constructSpaceActions(params)), Option.getOrElse(() => [])))
+    }),
+    // Create nodes for objects in the root collection of a space.
+    createExtension({
+      id: `${meta.id}/root-collection`,
+      connector: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => node2.type === SPACE_TYPE && isSpace(node2.data) ? Option.some(node2.data) : Option.none()), Option.map((space) => {
+        const state = context.getCapability(SpaceCapabilities.State);
+        const spaceState = get(atomFromObservable(space.state));
+        if (spaceState !== SpaceState.SPACE_READY) {
+          return [];
+        }
+        const collection = get(atomFromSignal(() => space.properties[Collection.Collection.typename]?.target));
+        if (!collection) {
+          return [];
+        }
+        return get(atomFromSignal(() => Function.pipe(collection.objects, Array.map((object) => object.target), Array.filter(isNonNullable), Array.map((object) => createObjectNode({
+          space,
+          object,
+          resolve: resolve(get),
+          navigable: state.navigableCollections
+        })), Array.filter(isNonNullable))));
+      }), Option.getOrElse(() => [])))
+    }),
+    // Create nodes for objects in a collection or by its DXN.
+    createExtension({
+      id: `${meta.id}/objects`,
+      connector: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => Obj.instanceOf(Collection.Collection, node2.data) ? Option.some(node2.data) : Option.none()), Option.map((collection) => {
+        const state = context.getCapability(SpaceCapabilities.State);
+        const space = getSpace(collection);
+        return get(atomFromSignal(() => Function.pipe(collection.objects, Array.map((object) => object.target), Array.filter(isNonNullable), Array.map((object) => space && createObjectNode({
+          object,
+          space,
+          resolve: resolve(get),
+          navigable: state.navigableCollections
+        })), Array.filter(isNonNullable))));
+      }), Option.getOrElse(() => []))),
+      resolver: (id) => {
+        let query;
+        return Atom.make((get) => {
+          const client = context.getCapability(ClientCapabilities.Client);
+          const dxn = DXN.tryParse(id)?.asEchoDXN();
+          if (!dxn || !dxn.spaceId) {
+            return null;
+          }
+          const space = client.spaces.get(dxn.spaceId);
+          if (!space) {
+            return null;
+          }
+          if (!query) {
+            query = space.db.query(Filter.ids(dxn.echoId));
+          }
+          const object = get(atomFromQuery(query)).at(0);
+          if (!Obj.isObject(object)) {
+            return null;
+          }
+          return createObjectNode({
+            object,
+            space,
+            resolve: resolve(get),
+            disposition: "hidden"
+          });
+        });
+      }
+    }),
+    // Create object nodes for schema-based system collections.
+    createExtension({
+      id: `${meta.id}/system-collections`,
+      connector: (node) => {
+        const client = context.getCapability(ClientCapabilities.Client);
+        let query;
+        return Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => Obj.instanceOf(Collection.Managed, node2.data) ? Option.some(node2.data) : Option.none()), Option.flatMap((collection) => {
+          const space = getSpace(collection);
+          const schema = client.graph.schemaRegistry.schemas.find((schema2) => Type.getTypename(schema2) === collection.key);
+          return space && schema ? Option.some({
+            space,
+            schema
+          }) : Option.none();
+        }), Option.map(({ space, schema }) => {
+          if (!query) {
+            query = space.db.query(Filter.type(schema));
+          }
+          return get(atomFromQuery(query)).map((object) => createObjectNode({
+            object,
+            space,
+            managedCollectionChild: true,
+            resolve: resolve(get)
+          })).filter(isNonNullable);
+        }), Option.getOrElse(() => [])));
+      }
+    }),
+    // Create branch nodes for static schema record types.
+    createExtension({
+      id: `${meta.id}/static-schemas`,
+      connector: (node) => {
+        const client = context.getCapability(ClientCapabilities.Client);
+        return Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => Obj.instanceOf(Collection.Managed, node2.data) && node2.data.key === Type.getTypename(Type.PersistentType) ? Option.some(node2.data) : Option.none()), Option.flatMap((collection) => {
+          const space = getSpace(collection);
+          return space?.properties.staticRecords ? Option.some(space) : Option.none();
+        }), Option.map((space) => {
+          return get(atomFromSignal(() => space.properties.staticRecords ?? [])).map((typename) => client.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename)).filter(isNonNullable).map((schema) => createStaticSchemaNode({
+            schema,
+            space
+          }));
+        }), Option.getOrElse(() => [])));
+      }
+    }),
+    // Create actions for static schema record types.
+    createExtension({
+      id: `${meta.id}/static-schema-actions`,
+      actions: (node) => {
+        let query;
+        return Atom.make((get) => {
+          const schemas = get(context.capabilities(ClientCapabilities.Schema)).flat().filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+          const filter2 = Filter.or(...schemas.map((schema) => Filter.type(schema)));
+          return Function.pipe(get(node), Option.flatMap((node2) => {
+            const space = isSpace(node2.properties.space) ? node2.properties.space : void 0;
+            return space && Schema.isSchema(node2.data) ? Option.some({
+              space,
+              schema: node2.data
+            }) : Option.none();
+          }), Option.map(({ space, schema }) => {
+            if (!query) {
+              query = space.db.query(filter2);
+            }
+            const objects = get(atomFromQuery(query));
+            const filteredViews = get(atomFromSignal(() => objects.filter((viewObject) => getTypenameFromQuery(viewObject.view.target?.query.ast) === Type.getTypename(schema))));
+            const deletable = filteredViews.length === 0;
+            const [dispatcher] = get(context.capabilities(Capabilities.IntentDispatcher));
+            if (!dispatcher) {
+              return [];
+            }
+            return createStaticSchemaActions({
+              schema,
+              space,
+              dispatch: dispatcher.dispatchPromise,
+              deletable
+            });
+          }), Option.getOrElse(() => []));
+        });
+      }
+    }),
+    // Create nodes for views of record types.
+    createExtension({
+      id: `${meta.id}/schema-views`,
+      connector: (node) => {
+        let query;
+        return Atom.make((get) => {
+          const schemas = get(context.capabilities(ClientCapabilities.Schema)).flat().filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+          const filter2 = Filter.or(...schemas.map((schema) => Filter.type(schema)));
+          return Function.pipe(get(node), Option.flatMap((node2) => {
+            const space = getSpace(node2.data) ?? (isSpace(node2.properties.space) ? node2.properties.space : void 0);
+            return space && (Obj.instanceOf(Type.PersistentType, node2.data) || Schema.isSchema(node2.data)) ? Option.some({
+              space,
+              schema: node2.data
+            }) : Option.none();
+          }), Option.map(({ space, schema }) => {
+            if (!query) {
+              query = space.db.query(filter2);
+            }
+            const typename = Schema.isSchema(schema) ? Type.getTypename(schema) : schema.typename;
+            return get(atomFromQuery(query)).filter((object) => get(atomFromSignal(() => getTypenameFromQuery(object.view.target?.query.ast) === typename))).map((object) => get(atomFromSignal(() => createObjectNode({
+              object,
+              space,
+              resolve: resolve(get),
+              droppable: false
+            })))).filter(isNonNullable);
+          }), Option.getOrElse(() => []));
+        });
+      }
+    }),
+    // Create collection actions and action groups.
+    createExtension({
+      id: `${meta.id}/object-actions`,
+      actions: (node) => {
+        let query;
+        return Atom.make((get) => {
+          const schemas = get(context.capabilities(ClientCapabilities.Schema)).flat().filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+          const filter2 = Filter.or(...schemas.map((schema) => Filter.type(schema)));
+          return Function.pipe(get(node), Option.flatMap((node2) => {
+            const space = getSpace(node2.data);
+            return space && Obj.isObject(node2.data) && Obj.getTypename(node2.data) === node2.type ? Option.some({
+              space,
+              object: node2.data
+            }) : Option.none();
+          }), Option.flatMap(({ space, object }) => {
+            const isSchema2 = Obj.instanceOf(Type.PersistentType, object);
+            if (!query && isSchema2) {
+              query = space.db.query(filter2);
+            }
+            let deletable = !isSchema2 && // Don't allow system collections to be deleted.
+            !Obj.instanceOf(Collection.Managed, object);
+            if (isSchema2 && query) {
+              const objects = get(atomFromQuery(query));
+              const filteredViews = get(atomFromSignal(() => objects.filter((viewObject) => getTypenameFromQuery(viewObject.view.target?.query.ast) === object.typename)));
+              deletable = filteredViews.length === 0;
+            }
+            const [dispatcher] = get(context.capabilities(Capabilities.IntentDispatcher));
+            const [appGraph] = get(context.capabilities(Capabilities.AppGraph));
+            const [state] = get(context.capabilities(SpaceCapabilities.State));
+            if (!dispatcher || !appGraph || !state) {
+              return Option.none();
+            } else {
+              return Option.some({
+                object,
+                graph: appGraph.graph,
+                dispatch: dispatcher.dispatchPromise,
+                resolve: resolve(get),
+                deletable,
+                navigable: get(atomFromSignal(() => state.navigableCollections))
+              });
+            }
+          }), Option.map((params) => constructObjectActions(params)), Option.getOrElse(() => []));
+        });
+      }
+    }),
+    // View selected objects.
+    createExtension({
+      id: `${meta.id}/selected-objects`,
+      connector: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => Obj.instanceOf(View.View, node2.data) ? Option.some(node2) : Option.none()), Option.map((node2) => [
+        {
+          id: [
+            node2.id,
+            "selected-objects"
+          ].join(ATTENDABLE_PATH_SEPARATOR),
+          type: PLANK_COMPANION_TYPE,
+          data: "selected-objects",
+          properties: {
+            label: [
+              "companion selected objects label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--tree-view--regular",
+            disposition: "hidden"
+          }
+        }
+      ]), Option.getOrElse(() => [])))
+    }),
+    // Object settings plank companion.
+    createExtension({
+      id: `${meta.id}/settings`,
+      connector: (node) => Atom.make((get) => Function.pipe(get(node), Option.flatMap((node2) => Obj.isObject(node2.data) ? Option.some(node2) : Option.none()), Option.map((node2) => [
+        {
+          id: [
+            node2.id,
+            "settings"
+          ].join(ATTENDABLE_PATH_SEPARATOR),
+          type: PLANK_COMPANION_TYPE,
+          data: "settings",
+          properties: {
+            label: [
+              "object settings label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sliders--regular",
+            disposition: "hidden",
+            position: "fallback"
+          }
+        }
+      ]), Option.getOrElse(() => [])))
+    })
+  ]);
+});
+export {
+  app_graph_builder_default as default
+};
+//# sourceMappingURL=app-graph-builder-T6VJKIOA.mjs.map