@dxos/plugin-space 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

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

@@ -0,0 +1,750 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  SPACE_TYPE,
+  SpaceOperation
+} from "./chunk-3DWZCVVQ.mjs";
+import {
+  meta
+} from "./chunk-SL4BJSUG.mjs";
+
+// src/util.tsx
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { SpaceState, isSpace } from "@dxos/client/echo";
+import { Feed, Filter, JsonSchema, Obj, Query, Ref, Type } from "@dxos/echo";
+import { Collection } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { Migrations } from "@dxos/migrations";
+import { Operation } from "@dxos/operation";
+import { Graph, Node } from "@dxos/plugin-graph";
+import { ATTENDABLE_PATH_SEPARATOR } from "@dxos/react-ui-attention/types";
+import { Expando, ManagedCollection } from "@dxos/schema";
+import { createFilename } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/util.tsx";
+var CACHEABLE_PROPS = [
+  "label",
+  "icon",
+  "role"
+];
+var ACCEPT_ECHO_CLASS = /* @__PURE__ */ new Set([
+  "echo"
+]);
+var META_NS = {
+  ns: meta.id
+};
+var PERSONAL_SPACE_LABEL = [
+  "personal space label",
+  META_NS
+];
+var UNNAMED_SPACE_LABEL = [
+  "unnamed space label",
+  META_NS
+];
+var SETTINGS_PANEL_LABEL = [
+  "settings panel label",
+  META_NS
+];
+var MIGRATE_SPACE_LABEL = [
+  "migrate space label",
+  META_NS
+];
+var CREATE_OBJECT_IN_SPACE_LABEL = [
+  "create object in space label",
+  META_NS
+];
+var RENAME_SPACE_LABEL = [
+  "rename space label",
+  META_NS
+];
+var ADD_VIEW_TO_SCHEMA_LABEL = [
+  "add view to schema label",
+  META_NS
+];
+var SNAPSHOT_BY_SCHEMA_LABEL = [
+  "snapshot by schema label",
+  META_NS
+];
+var CREATE_OBJECT_IN_COLLECTION_LABEL = [
+  "create object in collection label",
+  META_NS
+];
+var CREATE_OBJECT_IN_SYSTEM_COLLECTION_LABEL = [
+  "create object in system collection label",
+  META_NS
+];
+var COPY_LINK_LABEL = [
+  "copy link label",
+  META_NS
+];
+var EXPOSE_OBJECT_LABEL = [
+  "expose object label",
+  META_NS
+];
+var CAN_DROP_FALSE = () => false;
+var CAN_DROP_SPACE = (source) => Obj.isObject(source.item.data) || isSpace(source.item.data);
+var CAN_DROP_OBJECT = (source) => Node.isGraphNode(source.item) && Obj.isObject(source.item.data);
+var SPACES = `${meta.id}-spaces`;
+var COMPOSER_SPACE_LOCK = `${meta.id}/lock`;
+var SHARED = "shared-spaces";
+var SCHEMA_GRAPH_NODE_PARTIALS = {
+  role: "branch",
+  canDrop: CAN_DROP_FALSE
+};
+var getSchemaGraphNodePartials = () => SCHEMA_GRAPH_NODE_PARTIALS;
+function createFactory(create, keyFn) {
+  const cache = /* @__PURE__ */ new Map();
+  return (...args) => {
+    const key = keyFn ? keyFn(...args) : args[0];
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const value2 = create(...args);
+    cache.set(key, value2);
+    return value2;
+  };
+}
+var getAcceptPersistenceKey = createFactory((spaceId) => /* @__PURE__ */ new Set([
+  spaceId
+]));
+var rearrangeCache = /* @__PURE__ */ new Map();
+var blockInstructionCache = /* @__PURE__ */ new Map();
+var spaceRearrangeCache = /* @__PURE__ */ new Map();
+var collectionPartialsCache = /* @__PURE__ */ new Map();
+var systemCollectionPartialsCache = /* @__PURE__ */ new Map();
+var spaceActionsCache = /* @__PURE__ */ new Map();
+var getDynamicLabel = createFactory((key, ns, extra) => [
+  key,
+  {
+    ns,
+    ...extra
+  }
+], (key, ns, extra) => `${key}\0${ns}${extra ? `\0${JSON.stringify(extra)}` : ""}`);
+var constructSpaceNode = ({ space, navigable = false, personal, namesCache, resolve, graph, spacesOrder }) => {
+  const hasPendingMigration = checkPendingMigration(space);
+  const collection = space.state.get() === SpaceState.SPACE_READY && space.properties[Collection.Collection.typename]?.target;
+  const partials = space.state.get() === SpaceState.SPACE_READY && Obj.instanceOf(Collection.Collection, collection) ? getCollectionGraphNodePartials({
+    collection,
+    db: space.db,
+    resolve
+  }) : {};
+  let onRearrange;
+  if (graph && spacesOrder) {
+    onRearrange = spaceRearrangeCache.get(space.id);
+    if (!onRearrange) {
+      onRearrange = (nextOrder) => {
+        Graph.sortEdges(graph, Node.RootId, "outbound", nextOrder.map(({ id }) => id));
+        Obj.change(spacesOrder, (mutableOrder) => {
+          mutableOrder.order = nextOrder.map(({ id }) => id);
+        });
+      };
+      spaceRearrangeCache.set(space.id, onRearrange);
+    }
+  }
+  return {
+    id: space.id,
+    type: SPACE_TYPE,
+    cacheable: CACHEABLE_PROPS,
+    data: space,
+    properties: {
+      ...partials,
+      label: getSpaceDisplayName(space, {
+        personal,
+        namesCache
+      }),
+      description: space.state.get() === SpaceState.SPACE_READY && space.properties.description,
+      hue: space.state.get() === SpaceState.SPACE_READY && space.properties.hue,
+      icon: space.state.get() === SpaceState.SPACE_READY && space.properties.icon ? `ph--${space.properties.icon}--regular` : void 0,
+      iconHue: space.state.get() === SpaceState.SPACE_READY && space.properties.iconHue,
+      disabled: !navigable || space.state.get() !== SpaceState.SPACE_READY || hasPendingMigration,
+      disposition: "workspace",
+      testId: "spacePlugin.space",
+      onRearrange,
+      // TODO(wittjosiah): Find a way to only allow space as source for rearranging.
+      canDrop: CAN_DROP_SPACE
+    },
+    nodes: [
+      {
+        id: `settings${ATTENDABLE_PATH_SEPARATOR}${space.id}`,
+        type: `${meta.id}/settings`,
+        data: null,
+        properties: {
+          label: SETTINGS_PANEL_LABEL,
+          icon: "ph--faders--regular",
+          disposition: "alternate-tree"
+        }
+      }
+    ]
+  };
+};
+var createObjectNode = ({ db, object, disposition, droppable = true, navigable = false, managedCollectionChild = false, resolve, parentCollection }) => {
+  const type = Obj.getTypename(object);
+  if (!type) {
+    return null;
+  }
+  const metadataKey = Obj.instanceOf(Feed.Feed, object) ? object.kind ?? type : type;
+  const metadata = resolve(metadataKey);
+  const partials = Obj.instanceOf(Collection.Collection, object) ? getCollectionGraphNodePartials({
+    collection: object,
+    db,
+    resolve
+  }) : Obj.instanceOf(ManagedCollection.ManagedCollection, object) ? getSystemCollectionNodePartials({
+    collection: object,
+    db,
+    resolve
+  }) : Obj.instanceOf(Type.PersistentType, object) ? getSchemaGraphNodePartials() : metadata.graphProps;
+  const label = object.name || Obj.getLabel(object) || // TODO(wittjosiah): Remove metadata labels.
+  metadata.label?.(object) || getDynamicLabel("object name placeholder", metadataKey, {
+    default: "New item"
+  });
+  const selectable = !Obj.instanceOf(Type.PersistentType, object) && !Obj.instanceOf(ManagedCollection.ManagedCollection, object) && !Obj.instanceOf(Collection.Collection, object) || navigable && Obj.instanceOf(Collection.Collection, object);
+  let onRearrange;
+  if (parentCollection) {
+    const collectionId = Obj.getDXN(parentCollection).toString();
+    onRearrange = rearrangeCache.get(collectionId);
+    if (!onRearrange) {
+      onRearrange = (nextOrder) => {
+        Obj.change(parentCollection, (c) => {
+          c.objects = nextOrder.filter(Obj.isObject).map(Ref.make);
+        });
+      };
+      rearrangeCache.set(collectionId, onRearrange);
+    }
+  }
+  const objectId = Obj.getDXN(object).toString();
+  const blockInstructionKey = `${objectId}:${managedCollectionChild}`;
+  let blockInstruction = blockInstructionCache.get(blockInstructionKey);
+  if (!blockInstruction) {
+    blockInstruction = (source, instruction) => {
+      if (source.item.properties.managedCollectionChild) {
+        return true;
+      }
+      if (Obj.instanceOf(ManagedCollection.ManagedCollection, object)) {
+        return !instruction.type.startsWith("reorder");
+      }
+      return managedCollectionChild;
+    };
+    blockInstructionCache.set(blockInstructionKey, blockInstruction);
+  }
+  const canDrop = droppable ? CAN_DROP_OBJECT : CAN_DROP_FALSE;
+  return {
+    id: Obj.getDXN(object).toString(),
+    type,
+    cacheable: CACHEABLE_PROPS,
+    data: object,
+    properties: {
+      label,
+      icon: metadata.icon ?? "ph--placeholder--regular",
+      iconHue: metadata.iconHue,
+      disposition,
+      testId: "spacePlugin.object",
+      persistenceClass: "echo",
+      persistenceKey: db.spaceId,
+      selectable,
+      managedCollectionChild,
+      onRearrange,
+      blockInstruction,
+      canDrop,
+      ...partials
+    }
+  };
+};
+var createStaticSchemaNode = ({ schema, space }) => {
+  return {
+    id: `${space.id}/${Type.getTypename(schema)}`,
+    type: `${meta.id}/static-schema`,
+    data: schema,
+    properties: {
+      label: getDynamicLabel("typename label", Type.getTypename(schema), {
+        count: 2,
+        default: Type.getTypename(schema)
+      }),
+      icon: "ph--database--regular",
+      iconHue: "green",
+      role: "branch",
+      selectable: false,
+      canDrop: CAN_DROP_FALSE,
+      space
+    }
+  };
+};
+var constructSpaceActions = ({ space, migrating }) => {
+  const state = space.state.get();
+  const hasPendingMigration = checkPendingMigration(space);
+  const isMigrating = migrating || Migrations.running(space);
+  const cached = spaceActionsCache.get(space.id);
+  if (cached && cached.state === state && cached.hasPendingMigration === hasPendingMigration && cached.migrating === isMigrating) {
+    return cached.actions;
+  }
+  const getId = (id) => `${id}/${space.id}`;
+  const actions = [];
+  if (hasPendingMigration) {
+    actions.push({
+      id: getId(SpaceOperation.Migrate.meta.key),
+      type: Node.ActionGroupType,
+      data: () => Operation.invoke(SpaceOperation.Migrate, {
+        space
+      }),
+      properties: {
+        label: MIGRATE_SPACE_LABEL,
+        icon: "ph--database--regular",
+        disposition: "list-item-primary",
+        disabled: isMigrating
+      }
+    });
+  }
+  if (state === SpaceState.SPACE_READY && !hasPendingMigration) {
+    actions.push({
+      id: getId(SpaceOperation.OpenCreateObject.meta.key),
+      type: Node.ActionType,
+      data: () => Operation.invoke(SpaceOperation.OpenCreateObject, {
+        target: space.db
+      }),
+      properties: {
+        label: CREATE_OBJECT_IN_SPACE_LABEL,
+        icon: "ph--plus--regular",
+        disposition: "list-item-primary",
+        testId: "spacePlugin.createObject"
+      }
+    }, {
+      id: getId(SpaceOperation.Rename.meta.key),
+      type: Node.ActionType,
+      data: (params) => Operation.invoke(SpaceOperation.Rename, {
+        space,
+        caller: params?.caller
+      }),
+      properties: {
+        label: RENAME_SPACE_LABEL,
+        icon: "ph--pencil-simple-line--regular",
+        keyBinding: {
+          macos: "shift+F6",
+          windows: "shift+F6"
+        }
+      }
+    });
+  }
+  spaceActionsCache.set(space.id, {
+    state,
+    hasPendingMigration,
+    migrating: isMigrating,
+    actions
+  });
+  return actions;
+};
+var createStaticSchemaActions = ({ schema, space, deletable }) => {
+  const getId = (id) => `${space.id}/${Type.getTypename(schema)}/${id}`;
+  const actions = [
+    {
+      id: getId(SpaceOperation.AddObject.meta.key),
+      type: Node.ActionType,
+      data: () => Operation.invoke(SpaceOperation.OpenCreateObject, {
+        target: space.db,
+        views: true,
+        initialFormValues: {
+          typename: Type.getTypename(schema)
+        }
+      }),
+      properties: {
+        label: ADD_VIEW_TO_SCHEMA_LABEL,
+        icon: "ph--plus--regular",
+        disposition: "list-item-primary",
+        testId: "spacePlugin.addViewToSchema"
+      }
+    },
+    {
+      id: getId(SpaceOperation.RenameObject.meta.key),
+      type: Node.ActionType,
+      data: () => Effect.fail(new Error("Not implemented")),
+      properties: {
+        label: getDynamicLabel("rename object label", Type.getTypename(Type.PersistentType)),
+        icon: "ph--pencil-simple-line--regular",
+        disabled: true,
+        disposition: "list-item",
+        testId: "spacePlugin.renameObject"
+      }
+    },
+    {
+      id: getId(SpaceOperation.RemoveObjects.meta.key),
+      type: Node.ActionType,
+      data: () => Effect.sync(() => {
+        const index = space.properties.staticRecords.findIndex((typename) => typename === Type.getTypename(schema));
+        if (index > -1) {
+          Obj.change(space.properties, (p) => {
+            p.staticRecords.splice(index, 1);
+          });
+        }
+      }),
+      properties: {
+        label: getDynamicLabel("delete object label", Type.getTypename(Type.PersistentType)),
+        icon: "ph--trash--regular",
+        disposition: "list-item",
+        disabled: !deletable,
+        testId: "spacePlugin.deleteObject"
+      }
+    },
+    {
+      id: getId(SpaceOperation.Snapshot.meta.key),
+      type: Node.ActionType,
+      data: Effect.fnUntraced(function* () {
+        const result = yield* Operation.invoke(SpaceOperation.Snapshot, {
+          db: space.db,
+          query: Query.select(Filter.type(schema)).ast
+        });
+        if (result.snapshot) {
+          yield* Effect.tryPromise(() => downloadBlob(result.snapshot, createFilename({
+            parts: [
+              space.id,
+              Type.getTypename(schema)
+            ],
+            ext: "json"
+          })));
+        }
+      }),
+      properties: {
+        label: SNAPSHOT_BY_SCHEMA_LABEL,
+        icon: "ph--camera--regular",
+        disposition: "list-item"
+      }
+    }
+  ];
+  return actions;
+};
+var constructObjectActions = ({ object, graph, resolve, capabilities, deletable = true, navigable = false, shareableLinkOrigin }) => {
+  const db = Obj.getDatabase(object);
+  invariant(db, "Database not found", {
+    F: __dxlog_file,
+    L: 582,
+    S: void 0,
+    A: [
+      "db",
+      "'Database not found'"
+    ]
+  });
+  const typename = Obj.getTypename(object);
+  invariant(typename, "Object has no typename", {
+    F: __dxlog_file,
+    L: 584,
+    S: void 0,
+    A: [
+      "typename",
+      "'Object has no typename'"
+    ]
+  });
+  const getId = (id) => `${id}/${Obj.getDXN(object).toString()}`;
+  const metadataKey = Match.value(object).pipe(Match.when(Obj.instanceOf(Feed.Feed), (feed) => feed.kind ?? Obj.getTypename(feed)), Match.when(Obj.instanceOf(ManagedCollection.ManagedCollection), (managed) => {
+    const [, feedKind] = managed.key.split("~") ?? [];
+    return feedKind ?? managed.key;
+  }), Match.orElse((obj) => Obj.getTypename(obj)));
+  const managedCollection = Option.some(object).pipe(Option.filter(Obj.instanceOf(ManagedCollection.ManagedCollection)), Option.getOrUndefined);
+  const metadata = metadataKey ? resolve(metadataKey) : {};
+  const createObject = metadata.createObject;
+  const inputSchema = metadata.inputSchema;
+  const actions = [
+    ...Obj.instanceOf(Collection.Collection, object) ? [
+      {
+        id: getId(SpaceOperation.OpenCreateObject.meta.key),
+        type: Node.ActionType,
+        data: () => Operation.invoke(SpaceOperation.OpenCreateObject, {
+          target: object
+        }),
+        properties: {
+          label: CREATE_OBJECT_IN_COLLECTION_LABEL,
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.createObject"
+        }
+      }
+    ] : [],
+    ...Obj.instanceOf(Type.PersistentType, object) ? [
+      {
+        id: getId(SpaceOperation.AddObject.meta.key),
+        type: Node.ActionType,
+        data: () => Operation.invoke(SpaceOperation.OpenCreateObject, {
+          target: db,
+          views: true,
+          initialFormValues: {
+            typename: object.typename
+          }
+        }),
+        properties: {
+          label: ADD_VIEW_TO_SCHEMA_LABEL,
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.addViewToSchema"
+        }
+      },
+      {
+        id: getId(SpaceOperation.Snapshot.meta.key),
+        type: Node.ActionType,
+        data: Effect.fnUntraced(function* () {
+          const result = yield* Operation.invoke(SpaceOperation.Snapshot, {
+            db,
+            query: Query.select(Filter.type(JsonSchema.toEffectSchema(object.jsonSchema))).ast
+          });
+          if (result.snapshot) {
+            yield* Effect.promise(() => downloadBlob(result.snapshot, createFilename({
+              parts: [
+                db.spaceId,
+                object.typename
+              ],
+              ext: "json"
+            })));
+          }
+        }),
+        properties: {
+          label: SNAPSHOT_BY_SCHEMA_LABEL,
+          icon: "ph--camera--regular",
+          disposition: "list-item"
+        }
+      }
+    ] : [],
+    ...createObject && managedCollection ? [
+      {
+        id: getId(SpaceOperation.OpenCreateObject.meta.key),
+        type: Node.ActionType,
+        data: Effect.fnUntraced(function* () {
+          if (inputSchema) {
+            yield* Operation.invoke(SpaceOperation.OpenCreateObject, {
+              target: db,
+              typename: managedCollection ? metadataKey : void 0
+            });
+          } else {
+            const createdObject = yield* createObject({}, {
+              db,
+              capabilities
+            });
+            const addResult = yield* Operation.invoke(SpaceOperation.AddObject, {
+              target: db,
+              hidden: true,
+              object: createdObject
+            });
+            if (addResult.id) {
+              yield* Operation.invoke(LayoutOperation.Open, {
+                subject: [
+                  addResult.id
+                ]
+              });
+            }
+          }
+        }),
+        properties: {
+          label: CREATE_OBJECT_IN_SYSTEM_COLLECTION_LABEL,
+          icon: "ph--plus--regular",
+          disposition: "list-item-primary",
+          testId: "spacePlugin.createObject"
+        }
+      }
+    ] : [],
+    ...managedCollection ? [] : [
+      {
+        id: getId(SpaceOperation.RenameObject.meta.key),
+        type: Node.ActionType,
+        data: (params) => Operation.invoke(SpaceOperation.RenameObject, {
+          object,
+          caller: params?.caller
+        }),
+        properties: {
+          label: getDynamicLabel("rename object label", metadataKey),
+          icon: "ph--pencil-simple-line--regular",
+          disposition: "list-item",
+          // TODO(wittjosiah): Not working.
+          // keyBinding: {
+          //   macos: 'shift+F6',
+          // },
+          testId: "spacePlugin.renameObject"
+        }
+      },
+      {
+        id: getId(SpaceOperation.RemoveObjects.meta.key),
+        type: Node.ActionType,
+        data: Effect.fnUntraced(function* () {
+          const collection = Graph.getConnections(graph, Obj.getDXN(object).toString(), Node.childRelation("inbound")).find((node) => Obj.instanceOf(Collection.Collection, node.data))?.data;
+          yield* Operation.invoke(SpaceOperation.RemoveObjects, {
+            objects: [
+              object
+            ],
+            target: collection
+          });
+        }),
+        properties: {
+          label: getDynamicLabel("delete object label", metadataKey),
+          icon: "ph--trash--regular",
+          disposition: "list-item",
+          disabled: !deletable,
+          // TODO(wittjosiah): This is a browser shortcut.
+          // keyBinding: object instanceof CollectionType ? undefined : 'shift+meta+Backspace',
+          testId: "spacePlugin.deleteObject"
+        }
+      }
+    ],
+    ...navigable || !Obj.instanceOf(Collection.Collection, object) && !Obj.instanceOf(ManagedCollection.ManagedCollection, object) && !Obj.instanceOf(Type.PersistentType, object) ? [
+      {
+        id: getId("copy-link"),
+        type: Node.ActionType,
+        data: () => Effect.promise(async () => {
+          const url = `${shareableLinkOrigin}/${db.spaceId}/${Obj.getDXN(object).toString()}`;
+          await navigator.clipboard.writeText(url);
+        }),
+        properties: {
+          label: COPY_LINK_LABEL,
+          icon: "ph--link--regular",
+          disposition: "list-item",
+          testId: "spacePlugin.copyLink"
+        }
+      }
+    ] : [],
+    // TODO(wittjosiah): Factor out and apply to all nodes.
+    {
+      id: getId(LayoutOperation.Expose.meta.key),
+      type: Node.ActionType,
+      data: () => Operation.invoke(LayoutOperation.Expose, {
+        subject: Obj.getDXN(object).toString()
+      }),
+      properties: {
+        label: EXPOSE_OBJECT_LABEL,
+        icon: "ph--eye--regular",
+        disposition: "heading-list-item",
+        testId: "spacePlugin.exposeObject"
+      }
+    }
+  ];
+  return actions;
+};
+var checkPendingMigration = (space) => {
+  return space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION || space.state.get() === SpaceState.SPACE_READY && !!Migrations.versionProperty && space.properties[Migrations.versionProperty] !== Migrations.targetVersion;
+};
+var getSpaceDisplayName = (space, { personal, namesCache = {} } = {}) => {
+  return space.state.get() === SpaceState.SPACE_READY && (space.properties.name?.length ?? 0) > 0 ? space.properties.name : namesCache[space.id] ? namesCache[space.id] : personal ? PERSONAL_SPACE_LABEL : UNNAMED_SPACE_LABEL;
+};
+var downloadBlob = async (blob, filename) => {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+};
+var buildCollectionPartials = (collection, db, resolve) => ({
+  acceptPersistenceClass: ACCEPT_ECHO_CLASS,
+  acceptPersistenceKey: getAcceptPersistenceKey(db.spaceId),
+  role: "branch",
+  onTransferStart: (child, index) => {
+    Obj.change(collection, (c) => {
+      if (!c.objects.find((object) => object.target === child.data)) {
+        if (typeof index !== "undefined") {
+          c.objects.splice(index, 0, Ref.make(child.data));
+        } else {
+          c.objects.push(Ref.make(child.data));
+        }
+      }
+    });
+  },
+  onTransferEnd: (child, _destination) => {
+    Obj.change(collection, (c) => {
+      const index = c.objects.findIndex((object) => object.target === child.data);
+      if (index > -1) {
+        c.objects.splice(index, 1);
+      }
+    });
+  },
+  onCopy: async (child, index) => {
+    const newObject = await cloneObject(child.data, resolve, db);
+    db.add(newObject);
+    Obj.change(collection, (c) => {
+      if (typeof index !== "undefined") {
+        c.objects.splice(index, 0, Ref.make(newObject));
+      } else {
+        c.objects.push(Ref.make(newObject));
+      }
+    });
+  }
+});
+var getCollectionGraphNodePartials = ({ collection, db, resolve }) => {
+  const id = Obj.getDXN(collection).toString();
+  let cached = collectionPartialsCache.get(id);
+  if (!cached) {
+    cached = buildCollectionPartials(collection, db, resolve);
+    collectionPartialsCache.set(id, cached);
+  }
+  return cached;
+};
+var getSystemCollectionNodePartials = ({ collection, db, resolve }) => {
+  const cacheKey = `${db.spaceId}:${collection.key}`;
+  let cached = systemCollectionPartialsCache.get(cacheKey);
+  if (!cached) {
+    const [, feedKind] = collection.key.split("~");
+    const metadataKey = feedKind ?? collection.key;
+    const metadata = resolve(metadataKey);
+    cached = {
+      label: getDynamicLabel("typename label", metadataKey, {
+        count: 2
+      }),
+      icon: metadata.icon,
+      iconHue: metadata.iconHue,
+      acceptPersistenceClass: ACCEPT_ECHO_CLASS,
+      acceptPersistenceKey: getAcceptPersistenceKey(db.spaceId),
+      role: "branch"
+    };
+    systemCollectionPartialsCache.set(cacheKey, cached);
+  }
+  return cached;
+};
+var getNestedObjects = async (object, resolve) => {
+  const type = Obj.getTypename(object);
+  if (!type) {
+    return [];
+  }
+  const metadata = resolve(type);
+  const loadReferences = metadata?.loadReferences;
+  if (typeof loadReferences !== "function") {
+    return [];
+  }
+  const objects = await loadReferences(object);
+  const nested = await Promise.all(objects.map((object2) => getNestedObjects(object2, resolve)));
+  return [
+    ...objects,
+    ...nested.flat()
+  ];
+};
+var cloneObject = async (object, resolve, newDb) => {
+  const schema = Obj.getSchema(object);
+  const typename = schema ? Type.getTypename(schema) ?? Expando.Expando.typename : Expando.Expando.typename;
+  const metadata = resolve(typename);
+  const serializer = metadata.serializer;
+  invariant(serializer, `No serializer for type: ${typename}`, {
+    F: __dxlog_file,
+    L: 953,
+    S: void 0,
+    A: [
+      "serializer",
+      "`No serializer for type: ${typename}`"
+    ]
+  });
+  const content = await serializer.serialize({
+    object
+  });
+  return serializer.deserialize({
+    content,
+    db: newDb,
+    newId: true
+  });
+};
+
+export {
+  SPACES,
+  COMPOSER_SPACE_LOCK,
+  SHARED,
+  constructSpaceNode,
+  createObjectNode,
+  createStaticSchemaNode,
+  constructSpaceActions,
+  createStaticSchemaActions,
+  constructObjectActions,
+  getSpaceDisplayName,
+  getNestedObjects,
+  cloneObject
+};
+//# sourceMappingURL=chunk-WW6YYBRG.mjs.map