@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.8360d9e660

package/dist/lib/node-esm/operation-resolver-IL2AHNPN.mjs

@@ -0,0 +1,808 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  CREATE_OBJECT_DIALOG,
+  CREATE_SPACE_DIALOG,
+  JOIN_DIALOG,
+  OBJECT_RENAME_POPOVER,
+  SPACE_RENAME_POPOVER
+} from "./chunk-5KTTTTEX.mjs";
+import {
+  COMPOSER_SPACE_LOCK,
+  cloneObject,
+  getNestedObjects
+} from "./chunk-GEGWQVZX.mjs";
+import {
+  SpaceCapabilities,
+  SpaceEvents,
+  SpaceOperation
+} from "./chunk-EVNSLSQS.mjs";
+import {
+  meta
+} from "./chunk-63N5JJXI.mjs";
+
+// src/capabilities/operation-resolver/operation-resolver.ts
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Capabilities, Capability, Plugin, UndoMapping } from "@dxos/app-framework";
+import { AppCapabilities, LayoutOperation, getCollectionsPath, getObjectPath, getTypePath } from "@dxos/app-toolkit";
+import { SpaceState, getSpace } from "@dxos/client/echo";
+import { Database, Obj, Query, Ref, Relation } from "@dxos/echo";
+import { Collection } from "@dxos/echo";
+import { EchoDatabaseImpl, Serializer } from "@dxos/echo-db";
+import { invariant } from "@dxos/invariant";
+import { Migrations } from "@dxos/migrations";
+import { OperationResolver } from "@dxos/operation";
+import { Operation } from "@dxos/operation";
+import { ClientCapabilities } from "@dxos/plugin-client/types";
+import { ObservabilityOperation } from "@dxos/plugin-observability/types";
+import { ViewAnnotation } from "@dxos/schema";
+import { EdgeReplicationSetting } from "@dxos/protocols/proto/dxos/echo/metadata";
+import { getSpacePath } from "@dxos/app-toolkit";
+import { iconValues } from "@dxos/react-ui-pickers/icons";
+import { CollectionModel, ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from "@dxos/schema";
+import { hues } from "@dxos/ui-theme";
+import { isNonNullable } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/capabilities/operation-resolver/operation-resolver.ts";
+var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(function* ({ createInvitationUrl, observability }) {
+  const capabilityManager = yield* Capability.Service;
+  const resolve = (typename) => capabilityManager.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
+  return [
+    Capability.contributes(Capabilities.UndoMapping, [
+      UndoMapping.make({
+        operation: SpaceOperation.DeleteField,
+        inverse: SpaceOperation.RestoreField,
+        deriveContext: (input, output) => ({
+          view: input.view,
+          field: output.field,
+          props: output.props,
+          index: output.index
+        }),
+        message: [
+          "field deleted label",
+          {
+            ns: meta.id
+          }
+        ]
+      }),
+      UndoMapping.make({
+        operation: SpaceOperation.RemoveObjects,
+        inverse: SpaceOperation.RestoreObjects,
+        deriveContext: (_input, output) => ({
+          objects: output.objects,
+          parentCollection: output.parentCollection,
+          indices: output.indices,
+          nestedObjectsList: output.nestedObjectsList,
+          wasActive: output.wasActive
+        }),
+        message: (input, _output) => {
+          const ns = Obj.getTypename(input.objects[0]);
+          return ns && input.objects.length === 1 ? [
+            "object deleted label",
+            {
+              ns
+            }
+          ] : [
+            "objects deleted label",
+            {
+              ns: meta.id
+            }
+          ];
+        }
+      })
+    ]),
+    Capability.contributes(Capabilities.OperationResolver, [
+      //
+      // Open
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Open,
+        handler: (input) => Effect.promise(async () => {
+          await input.space.open();
+        })
+      }),
+      //
+      // Close
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Close,
+        handler: (input) => Effect.promise(async () => {
+          await input.space.close();
+        })
+      }),
+      //
+      // Join
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Join,
+        handler: Effect.fnUntraced(function* (input) {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: JOIN_DIALOG,
+            blockAlign: "start",
+            props: {
+              initialInvitationCode: input.invitationCode,
+              onDone: input.onDone
+            }
+          });
+        })
+      }),
+      //
+      // WaitForObject
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.WaitForObject,
+        handler: Effect.fnUntraced(function* (input) {
+          yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+            ...current,
+            awaiting: input.id
+          }));
+        })
+      }),
+      //
+      // OpenSettings
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.OpenSettings,
+        handler: Effect.fnUntraced(function* (input) {
+          yield* Operation.invoke(LayoutOperation.Open, {
+            subject: [
+              `${getSpacePath(input.space.id)}/settings`
+            ],
+            workspace: getSpacePath(input.space.id)
+          });
+        })
+      }),
+      //
+      // RemoveObjects
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.RemoveObjects,
+        handler: Effect.fnUntraced(function* (input) {
+          const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
+          const objects = input.objects;
+          const space = getSpace(objects[0]);
+          invariant(space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space), void 0, {
+            F: __dxlog_file,
+            L: 169,
+            S: this,
+            A: [
+              "space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space)",
+              ""
+            ]
+          });
+          const parentCollection = input.target ?? space.properties[Collection.Collection.typename]?.target;
+          const nestedObjectsList = yield* Effect.promise(() => Promise.all(objects.map((obj) => getNestedObjects(obj, resolve))));
+          const indices = objects.map((obj) => Obj.instanceOf(Collection.Collection, parentCollection) ? parentCollection.objects.findIndex((ref) => ref.target === obj) : -1);
+          const wasActive = objects.flatMap((obj, i) => [
+            obj,
+            ...nestedObjectsList[i]
+          ]).filter(Obj.isObject).map((object) => layout.active.find((graphId) => graphId.endsWith(object.id))).filter(isNonNullable);
+          for (let i = 0; i < objects.length; i++) {
+            const obj = objects[i];
+            const nestedObjects = nestedObjectsList[i];
+            const index = parentCollection.objects.findIndex((ref) => ref.target === obj);
+            if (index !== -1) {
+              Obj.change(parentCollection, (c) => {
+                c.objects.splice(index, 1);
+              });
+            }
+            for (const nestedObject of nestedObjects) {
+              if (Obj.isObject(nestedObject)) {
+                Obj.getDatabase(nestedObject)?.remove(nestedObject);
+              } else if (Relation.isRelation(nestedObject)) {
+                const db2 = Obj.getDatabase(Relation.getSource(nestedObject));
+                db2?.remove(nestedObject);
+              }
+            }
+            const db = Obj.getDatabase(obj);
+            db?.remove(obj);
+          }
+          if (wasActive.length > 0) {
+            yield* Operation.invoke(LayoutOperation.Close, {
+              subject: wasActive
+            });
+          }
+          return {
+            objects,
+            parentCollection,
+            indices,
+            nestedObjectsList,
+            wasActive
+          };
+        })
+      }),
+      //
+      // DeleteField
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.DeleteField,
+        handler: Effect.fnUntraced(function* (input) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const view = input.view;
+          const db = Obj.getDatabase(view);
+          invariant(db, void 0, {
+            F: __dxlog_file,
+            L: 243,
+            S: this,
+            A: [
+              "db",
+              ""
+            ]
+          });
+          const typename = getTypenameFromQuery(view.query.ast);
+          invariant(typename, void 0, {
+            F: __dxlog_file,
+            L: 245,
+            S: this,
+            A: [
+              "typename",
+              ""
+            ]
+          });
+          const schema = yield* Effect.promise(() => db.schemaRegistry.query({
+            typename
+          }).firstOrUndefined());
+          invariant(schema, void 0, {
+            F: __dxlog_file,
+            L: 247,
+            S: this,
+            A: [
+              "schema",
+              ""
+            ]
+          });
+          const projection = new ProjectionModel({
+            registry,
+            view,
+            baseSchema: schema.jsonSchema,
+            change: createEchoChangeCallback(view, schema)
+          });
+          const result = projection.deleteFieldProjection(input.fieldId);
+          return {
+            field: result.deleted.field,
+            props: result.deleted.props,
+            index: result.index
+          };
+        })
+      }),
+      //
+      // OpenCreateObject
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.OpenCreateObject,
+        handler: Effect.fnUntraced(function* (input) {
+          const ephemeralState = yield* Capabilities.getAtomValue(SpaceCapabilities.EphemeralState);
+          const navigable = input.navigable ?? true;
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: CREATE_OBJECT_DIALOG,
+            blockAlign: "start",
+            props: {
+              target: input.target,
+              views: input.views,
+              typename: input.typename,
+              initialFormValues: input.initialFormValues,
+              onCreateObject: input.onCreateObject,
+              targetNodeId: input.targetNodeId,
+              shouldNavigate: navigable ? (object) => {
+                const isCollection = Obj.instanceOf(Collection.Collection, object);
+                return !isCollection || ephemeralState.navigableCollections;
+              } : () => false
+            }
+          });
+        })
+      }),
+      //
+      // AddObject
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.AddObject,
+        handler: Effect.fnUntraced(function* (input) {
+          const target = input.target;
+          const object = input.object;
+          const db = Database.isDatabase(target) ? target : Obj.getDatabase(target);
+          invariant(db, "Database not found.", {
+            F: __dxlog_file,
+            L: 306,
+            S: this,
+            A: [
+              "db",
+              "'Database not found.'"
+            ]
+          });
+          yield* CollectionModel.add({
+            object,
+            target: Database.isDatabase(target) ? void 0 : target,
+            hidden: input.hidden
+          }).pipe(Effect.provide(Database.layer(db)));
+          const typename = Obj.getTypename(object);
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "space.object.add",
+            properties: {
+              spaceId: db.spaceId,
+              objectId: object.id,
+              typename: Obj.getTypename(object)
+            }
+          });
+          const [schema] = db.schemaRegistry.query({
+            typename,
+            location: [
+              "runtime"
+            ]
+          }).runSync();
+          const isViewSchema = schema !== void 0 && ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false));
+          const view = isViewSchema ? yield* Effect.promise(() => object.view.load()) : void 0;
+          const viewTargetTypename = view ? getTypenameFromQuery(view.query.ast) : void 0;
+          const subject = getSubjectPathForNewObject({
+            spaceId: db.spaceId,
+            objectId: object.id,
+            nodeId: input.targetNodeId,
+            typename,
+            viewTargetTypename
+          });
+          return {
+            id: Obj.getDXN(object).toString(),
+            subject: [
+              subject
+            ],
+            object
+          };
+        })
+      }),
+      //
+      // Share
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Share,
+        handler: Effect.fnUntraced(function* (input) {
+          const { space, type, authMethod, multiUse, target } = input;
+          const invitation = space.share({
+            type,
+            authMethod,
+            multiUse,
+            target
+          });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "space.share",
+            properties: {
+              spaceId: space.id
+            }
+          });
+          return invitation;
+        })
+      }),
+      //
+      // Lock
+      // TODO(wittjosiah): This appears to be unused.
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Lock,
+        handler: Effect.fnUntraced(function* ({ space }) {
+          Obj.change(space.properties, (p) => {
+            p[COMPOSER_SPACE_LOCK] = true;
+          });
+          if (observability) {
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: "space.lock",
+              properties: {
+                spaceId: space.id
+              }
+            });
+          }
+        })
+      }),
+      //
+      // Unlock
+      // TODO(wittjosiah): This appears to be unused.
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Unlock,
+        handler: Effect.fnUntraced(function* ({ space }) {
+          Obj.change(space.properties, (p) => {
+            p[COMPOSER_SPACE_LOCK] = false;
+          });
+          if (observability) {
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: "space.unlock",
+              properties: {
+                spaceId: space.id
+              }
+            });
+          }
+        })
+      }),
+      //
+      // OpenCreateSpace
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.OpenCreateSpace,
+        handler: Effect.fnUntraced(function* () {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: CREATE_SPACE_DIALOG,
+            blockAlign: "start"
+          });
+        })
+      }),
+      //
+      // Create
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Create,
+        handler: Effect.fnUntraced(function* ({ name, hue: hue_, icon: icon_, edgeReplication }) {
+          const client = yield* Capability.get(ClientCapabilities.Client);
+          const hue = hue_ ?? hues[Math.floor(Math.random() * hues.length)];
+          const icon = icon_ ?? iconValues[Math.floor(Math.random() * iconValues.length)];
+          const space = yield* Effect.promise(() => client.spaces.create({
+            name,
+            hue,
+            icon
+          }));
+          if (edgeReplication) {
+            yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
+          }
+          yield* Effect.promise(() => space.waitUntilReady());
+          const collection = Obj.make(Collection.Collection, {
+            objects: []
+          });
+          Obj.change(space.properties, (p) => {
+            p[Collection.Collection.typename] = Ref.make(collection);
+            if (Migrations.versionProperty) {
+              p[Migrations.versionProperty] = Migrations.targetVersion;
+            }
+          });
+          yield* Plugin.activate(SpaceEvents.SpaceCreated);
+          const onCreateSpaceCallbacks = yield* Capability.getAll(SpaceCapabilities.OnCreateSpace);
+          yield* Effect.all(onCreateSpaceCallbacks.map((onCreateSpace) => onCreateSpace({
+            space,
+            isDefault: false,
+            rootCollection: collection
+          })));
+          if (observability) {
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: "space.create",
+              properties: {
+                spaceId: space.id
+              }
+            });
+          }
+          return {
+            id: space.id,
+            subject: [
+              space.id
+            ],
+            space
+          };
+        })
+      }),
+      //
+      // Migrate
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Migrate,
+        handler: Effect.fnUntraced(function* (input) {
+          const { space, version: targetVersion } = input;
+          if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+            yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+              ...current,
+              sdkMigrationRunning: {
+                ...current.sdkMigrationRunning,
+                [space.id]: true
+              }
+            }));
+            yield* Effect.promise(() => space.internal.migrate());
+            yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+              ...current,
+              sdkMigrationRunning: {
+                ...current.sdkMigrationRunning,
+                [space.id]: false
+              }
+            }));
+          }
+          const result = yield* Effect.promise(() => Migrations.migrate(space, targetVersion));
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "space.migrate",
+            properties: {
+              spaceId: space.id,
+              targetVersion,
+              version: Migrations.versionProperty ? space.properties[Migrations.versionProperty] : void 0
+            }
+          });
+          return result;
+        })
+      }),
+      //
+      // Snapshot
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Snapshot,
+        handler: (input) => Effect.promise(async () => {
+          const db = input.db;
+          invariant(db instanceof EchoDatabaseImpl, "Database must be an instance of EchoDatabaseImpl", {
+            F: __dxlog_file,
+            L: 506,
+            S: this,
+            A: [
+              "db instanceof EchoDatabaseImpl",
+              "'Database must be an instance of EchoDatabaseImpl'"
+            ]
+          });
+          const backup = await new Serializer().export(db, input.query && Query.fromAst(input.query));
+          return {
+            snapshot: new Blob([
+              JSON.stringify(backup, null, 2)
+            ], {
+              type: "application/json"
+            })
+          };
+        })
+      }),
+      //
+      // Rename
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.Rename,
+        handler: Effect.fnUntraced(function* (input) {
+          yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+            subject: SPACE_RENAME_POPOVER,
+            anchorId: input.caller ?? "",
+            props: input.space
+          });
+        })
+      }),
+      //
+      // RenameObject
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.RenameObject,
+        handler: Effect.fnUntraced(function* (input) {
+          const object = input.object;
+          yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+            subject: OBJECT_RENAME_POPOVER,
+            anchorId: input.caller ?? "",
+            props: object
+          });
+        })
+      }),
+      //
+      // OpenMembers
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.OpenMembers,
+        handler: Effect.fnUntraced(function* (input) {
+          yield* Operation.invoke(LayoutOperation.Open, {
+            subject: [
+              `${getSpacePath(input.space.id)}/settings`
+            ],
+            workspace: getSpacePath(input.space.id)
+          });
+        })
+      }),
+      //
+      // GetShareLink
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.GetShareLink,
+        handler: Effect.fnUntraced(function* (input) {
+          const { Invitation, InvitationEncoder } = yield* Effect.promise(() => import("@dxos/react-client/invitations"));
+          const invitation = yield* Operation.invoke(SpaceOperation.Share, {
+            space: input.space,
+            type: Invitation.Type.DELEGATED,
+            authMethod: Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
+            multiUse: true,
+            target: input.target
+          });
+          const invitationCode = yield* Effect.tryPromise(() => new Promise((resolve2) => {
+            invitation.subscribe((inv) => {
+              if (inv.state === Invitation.State.CONNECTING) {
+                resolve2(InvitationEncoder.encode(inv));
+              }
+            });
+          }));
+          const url = createInvitationUrl(invitationCode);
+          if (input.copyToClipboard) {
+            yield* Effect.tryPromise(() => navigator.clipboard.writeText(url));
+          }
+          return url;
+        })
+      }),
+      //
+      // AddSchema
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.AddSchema,
+        handler: Effect.fnUntraced(function* (input) {
+          const db = input.db;
+          const schemas = yield* Effect.promise(() => db.schemaRegistry.register([
+            input.schema
+          ]));
+          const schema = schemas[0];
+          Obj.change(schema.persistentSchema, (s) => {
+            if (input.name) {
+              s.name = input.name;
+            }
+            if (input.typename) {
+              s.typename = input.typename;
+            }
+            if (input.version) {
+              s.version = input.version;
+            }
+          });
+          yield* Plugin.activate(SpaceEvents.SchemaAdded);
+          const onSchemaAdded = yield* Capability.getAll(SpaceCapabilities.OnSchemaAdded);
+          yield* Effect.all(onSchemaAdded.map((callback) => callback({
+            db,
+            schema,
+            show: input.show
+          })), {
+            concurrency: "unbounded"
+          });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+            name: "space.schema.add",
+            properties: {
+              spaceId: db.spaceId,
+              objectId: schema.id,
+              typename: schema.typename
+            }
+          });
+          return {
+            id: schema.id,
+            object: schema.persistentSchema,
+            schema
+          };
+        })
+      }),
+      //
+      // AddRelation
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.AddRelation,
+        handler: (input) => Effect.sync(() => {
+          const db = input.db;
+          const relation = db.add(Relation.make(input.schema, {
+            [Relation.Source]: input.source,
+            [Relation.Target]: input.target,
+            ...input.fields
+          }));
+          return {
+            relation
+          };
+        })
+      }),
+      //
+      // DuplicateObject
+      // TODO(wittjosiah): This appears to be unused.
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.DuplicateObject,
+        handler: Effect.fnUntraced(function* (input) {
+          const object = input.object;
+          const db = Obj.getDatabase(object);
+          invariant(db, "Database not found.", {
+            F: __dxlog_file,
+            L: 662,
+            S: this,
+            A: [
+              "db",
+              "'Database not found.'"
+            ]
+          });
+          const newObject = yield* Effect.promise(() => cloneObject(object, resolve, db));
+          yield* Operation.invoke(SpaceOperation.AddObject, {
+            object: newObject,
+            target: db
+          });
+        })
+      }),
+      //
+      // RestoreField (inverse of DeleteField)
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.RestoreField,
+        handler: Effect.fnUntraced(function* (input) {
+          const registry = yield* Capability.get(Capabilities.AtomRegistry);
+          const view = input.view;
+          const db = Obj.getDatabase(view);
+          invariant(db, void 0, {
+            F: __dxlog_file,
+            L: 677,
+            S: this,
+            A: [
+              "db",
+              ""
+            ]
+          });
+          const typename = getTypenameFromQuery(view.query.ast);
+          invariant(typename, void 0, {
+            F: __dxlog_file,
+            L: 679,
+            S: this,
+            A: [
+              "typename",
+              ""
+            ]
+          });
+          const schema = yield* Effect.promise(() => db.schemaRegistry.query({
+            typename
+          }).firstOrUndefined());
+          invariant(schema, void 0, {
+            F: __dxlog_file,
+            L: 681,
+            S: this,
+            A: [
+              "schema",
+              ""
+            ]
+          });
+          const projection = new ProjectionModel({
+            registry,
+            view,
+            baseSchema: schema.jsonSchema,
+            change: createEchoChangeCallback(view, schema)
+          });
+          projection.setFieldProjection({
+            field: input.field,
+            props: input.props
+          }, input.index);
+        })
+      }),
+      //
+      // RestoreObjects (inverse of RemoveObjects)
+      //
+      OperationResolver.make({
+        operation: SpaceOperation.RestoreObjects,
+        handler: Effect.fnUntraced(function* (input) {
+          const objects = input.objects;
+          const parentCollection = input.parentCollection;
+          const indices = input.indices;
+          const nestedObjectsList = input.nestedObjectsList;
+          const wasActive = input.wasActive;
+          const space = getSpace(objects[0]);
+          invariant(space, void 0, {
+            F: __dxlog_file,
+            L: 709,
+            S: this,
+            A: [
+              "space",
+              ""
+            ]
+          });
+          const restoredObjects = objects.map((obj) => space.db.add(obj));
+          nestedObjectsList.flat().forEach((obj) => {
+            if (Obj.isObject(obj)) {
+              space.db.add(obj);
+            } else if (Relation.isRelation(obj)) {
+              space.db.add(obj);
+            }
+          });
+          Obj.change(parentCollection, (c) => {
+            indices.forEach((index, i) => {
+              if (index !== -1) {
+                c.objects.splice(index, 0, Ref.make(restoredObjects[i]));
+              }
+            });
+          });
+          if (wasActive.length > 0) {
+            yield* Operation.invoke(LayoutOperation.Open, {
+              subject: wasActive
+            });
+          }
+        })
+      })
+    ])
+  ];
+}));
+var getSubjectPathForNewObject = (props) => {
+  const { nodeId, typename, viewTargetTypename, spaceId, objectId } = props;
+  if (typeof nodeId === "string") {
+    return `${nodeId}/${objectId}`;
+  }
+  if (typename === Collection.Collection.typename) {
+    return getCollectionsPath(spaceId, objectId);
+  }
+  if (viewTargetTypename) {
+    return getTypePath(spaceId, viewTargetTypename, objectId);
+  }
+  return getObjectPath(spaceId, typename, objectId);
+};
+export {
+  operation_resolver_default as default
+};
+//# sourceMappingURL=operation-resolver-IL2AHNPN.mjs.map