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

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

@@ -0,0 +1,684 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  meta
+} from "./chunk-63N5JJXI.mjs";
+
+// src/types/capabilities.ts
+import * as Schema from "effect/Schema";
+import { Capability } from "@dxos/app-framework";
+(function(SpaceCapabilities2) {
+  SpaceCapabilities2.Settings = Capability.make(`${meta.id}.capability.settings`);
+  SpaceCapabilities2.StateSchema = Schema.mutable(Schema.Struct({
+    spaceNames: Schema.Record({
+      key: Schema.String,
+      value: Schema.String
+    }),
+    enabledEdgeReplication: Schema.Boolean
+  }));
+  SpaceCapabilities2.State = Capability.make(`${meta.id}.capability.state`);
+  SpaceCapabilities2.EphemeralState = Capability.make(`${meta.id}.capability.ephemeral-state`);
+  SpaceCapabilities2.SettingsSection = Capability.make(`${meta.id}.capability.settings-section`);
+  SpaceCapabilities2.OnCreateSpace = Capability.make(`${meta.id}.capability.on-space-created`);
+  SpaceCapabilities2.OnSchemaAdded = Capability.make(`${meta.id}.capability.on-schema-added`);
+  SpaceCapabilities2.Repair = Capability.make(`${meta.id}.capability.repair`);
+})(SpaceCapabilities || (SpaceCapabilities = {}));
+var SpaceCapabilities;
+
+// src/types/events.ts
+import { ActivationEvent } from "@dxos/app-framework";
+import { AppActivationEvents } from "@dxos/app-toolkit";
+(function(SpaceEvents2) {
+  SpaceEvents2.StateReady = AppActivationEvents.createStateEvent(`${meta.id}.event.state-ready`);
+  SpaceEvents2.SetupSettingsPanel = ActivationEvent.make(`${meta.id}.event.setup-settings-panel`);
+  SpaceEvents2.DefaultSpaceReady = ActivationEvent.make(`${meta.id}.event.default-space-ready`);
+  SpaceEvents2.SpaceCreated = ActivationEvent.make(`${meta.id}.event.space-created`);
+  SpaceEvents2.SchemaAdded = ActivationEvent.make(`${meta.id}.event.schema-added`);
+})(SpaceEvents || (SpaceEvents = {}));
+var SpaceEvents;
+
+// src/types/form.ts
+import * as Option from "effect/Option";
+import * as Schema2 from "effect/Schema";
+import { Type } from "@dxos/echo";
+import { EntityKind, SystemTypeAnnotation, createAnnotationHelper, getTypeAnnotation } from "@dxos/echo/internal";
+var TypeInputOptions = Schema2.Struct({
+  location: Schema2.Array(Schema2.Literal("database", "runtime")),
+  kind: Schema2.Array(Schema2.Literal("system", "user"))
+});
+var TypeInputOptionsAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/TypeInputOptions");
+var TypeInputOptionsAnnotation = createAnnotationHelper(TypeInputOptionsAnnotationId);
+var getTypenames = ({ annotation, space }) => {
+  const includeRuntime = annotation.location.includes("runtime");
+  const includeDatabase = annotation.location.includes("database");
+  const includeSystemType = annotation.kind.includes("system");
+  const includeUserType = annotation.kind.includes("user");
+  const runtimeTypenames = includeRuntime && space ? space.db.schemaRegistry.query({
+    location: [
+      "runtime"
+    ]
+  }).runSync().filter((schema) => {
+    const relation = getTypeAnnotation(schema)?.kind === EntityKind.Relation;
+    if (relation) {
+      return includeSystemType;
+    }
+    const system = SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false));
+    if (system) {
+      return includeSystemType;
+    }
+    return includeUserType;
+  }).map((schema) => Type.getTypename(schema)) : [];
+  const databaseTypenames = includeDatabase && space ? space.db.schemaRegistry.query({
+    location: [
+      "database"
+    ]
+  }).runSync().map((schema) => Type.getTypename(schema)) : [];
+  return Array.from(/* @__PURE__ */ new Set([
+    ...runtimeTypenames,
+    ...databaseTypenames
+  ])).sort();
+};
+
+// src/types/types.ts
+import * as Schema3 from "effect/Schema";
+import { Capability as Capability2, Plugin } from "@dxos/app-framework";
+import { SpaceSchema } from "@dxos/client/echo";
+import { CancellableInvitationObservable, Invitation } from "@dxos/client/invitations";
+import { Database, Obj, QueryAST, Type as Type2 } from "@dxos/echo";
+import { Collection, View } from "@dxos/echo";
+import { Operation } from "@dxos/operation";
+var SPACE_DIRECTORY_HANDLE = `${meta.id}.directory`;
+var SPACE_TYPE = "org.dxos.type.space";
+var SpaceSettingsSchema = Schema3.mutable(Schema3.Struct({
+  /**
+   * Show closed spaces.
+   */
+  showHidden: Schema3.Boolean
+}));
+var IconAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/plugin-space/annotation/Icon");
+var HueAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/plugin-space/annotation/Hue");
+var SpaceForm = Schema3.Struct({
+  name: Schema3.optional(Schema3.String.annotations({
+    title: "Name"
+  })),
+  icon: Schema3.optional(Schema3.String.annotations({
+    title: "Icon",
+    [IconAnnotationId]: true
+  })),
+  hue: Schema3.optional(Schema3.String.annotations({
+    title: "Color",
+    [HueAnnotationId]: true
+  })),
+  edgeReplication: Schema3.optional(Schema3.Boolean.annotations({
+    title: "Enable EDGE Replication"
+  }))
+});
+var COLLECTION_OPERATION = "org.dxos.plugin.collection.operation";
+(function(CollectionOperation2) {
+  CollectionOperation2.Create = Operation.make({
+    meta: {
+      key: `${COLLECTION_OPERATION}.create`,
+      name: "Create Collection"
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        name: Schema3.optional(Schema3.String)
+      }),
+      output: Schema3.Struct({
+        object: Collection.Collection
+      })
+    }
+  });
+})(CollectionOperation || (CollectionOperation = {}));
+var SPACE_OPERATION = `${meta.id}.operation`;
+(function(SpaceOperation2) {
+  SpaceOperation2.Create = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.create`,
+      name: "Create Space",
+      description: "Create a new space."
+    },
+    services: [
+      Capability2.Service,
+      Plugin.Service
+    ],
+    schema: {
+      input: SpaceForm,
+      output: Schema3.Struct({
+        id: Schema3.String,
+        subject: Schema3.Array(Schema3.String),
+        space: SpaceSchema
+      })
+    }
+  });
+  SpaceOperation2.Join = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.join`,
+      name: "Join Space",
+      description: "Join a space via invitation."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        invitationCode: Schema3.optional(Schema3.String),
+        onDone: Schema3.optional(Schema3.Any)
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.Open = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open`,
+      name: "Open Space",
+      description: "Open a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.Close = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.close`,
+      name: "Close Space",
+      description: "Close a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.Share = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.share`,
+      name: "Share Space",
+      description: "Share a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema,
+        type: Schema3.Enums(Invitation.Type),
+        authMethod: Schema3.Enums(Invitation.AuthMethod),
+        multiUse: Schema3.Boolean,
+        target: Schema3.optional(Schema3.String)
+      }),
+      output: Schema3.instanceOf(CancellableInvitationObservable)
+    }
+  });
+  SpaceOperation2.Lock = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.lock`,
+      name: "Lock Space",
+      description: "Lock a space to prevent modifications."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.Unlock = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.unlock`,
+      name: "Unlock Space",
+      description: "Unlock a space to allow modifications."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.OpenSettings = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-settings`,
+      name: "Open Space Settings",
+      description: "Open space settings."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.WaitForObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.wait-for-object`,
+      name: "Wait For Object",
+      description: "Wait for an object to be available."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        id: Schema3.optional(Schema3.String)
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.AddObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.add-object`,
+      name: "Add Object",
+      description: "Add an object to a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        object: Obj.Unknown.annotations({
+          description: "The object to add."
+        }),
+        target: Schema3.Union(Database.Database, Collection.Collection).annotations({
+          description: "The database or collection to add to."
+        }),
+        hidden: Schema3.optional(Schema3.Boolean),
+        targetNodeId: Schema3.optional(Schema3.String.annotations({
+          description: "Qualified graph node ID of the target collection."
+        }))
+      }),
+      output: Schema3.Struct({
+        id: Schema3.String,
+        subject: Schema3.Array(Schema3.String),
+        object: Obj.Unknown
+      })
+    }
+  });
+  SpaceOperation2.RemoveObjectsOutput = Schema3.Struct({
+    objects: Schema3.Array(Obj.Unknown).annotations({
+      description: "The removed objects."
+    }),
+    parentCollection: Collection.Collection.annotations({
+      description: "The collection removed from."
+    }),
+    indices: Schema3.Array(Schema3.Number).annotations({
+      description: "The indices the objects were at."
+    }),
+    nestedObjectsList: Schema3.Array(Schema3.Array(Obj.Unknown)).annotations({
+      description: "Nested objects that were removed."
+    }),
+    wasActive: Schema3.Array(Schema3.String).annotations({
+      description: "IDs of objects that were active before removal."
+    })
+  });
+  SpaceOperation2.RemoveObjects = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.remove-objects`,
+      name: "Remove Objects",
+      description: "Remove objects from a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        objects: Schema3.Array(Obj.Unknown).annotations({
+          description: "The objects to remove."
+        }),
+        target: Schema3.optional(Collection.Collection).annotations({
+          description: "The collection to remove from."
+        })
+      }),
+      output: SpaceOperation2.RemoveObjectsOutput
+    }
+  });
+  SpaceOperation2.DeleteFieldOutput = Schema3.Struct({
+    field: View.FieldSchema.annotations({
+      description: "The deleted field schema."
+    }),
+    // TODO(wittjosiah): This creates a type error with PropertySchema.
+    props: Schema3.Any.annotations({
+      description: "The deleted field properties."
+    }),
+    index: Schema3.Number.annotations({
+      description: "The index the field was at."
+    })
+  });
+  SpaceOperation2.DeleteField = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.delete-field`,
+      name: "Delete Field",
+      description: "Delete a field from a view."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        view: View.View.annotations({
+          description: "The view to delete the field from."
+        }),
+        fieldId: Schema3.String
+      }),
+      output: SpaceOperation2.DeleteFieldOutput
+    }
+  });
+  SpaceOperation2.OpenCreateObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-create-object`,
+      name: "Open Create Object Dialog",
+      description: "Open the create object dialog."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        target: Schema3.Union(Database.Database, Collection.Collection).annotations({
+          description: "The database or collection to create in."
+        }),
+        views: Schema3.optional(Schema3.Boolean),
+        typename: Schema3.optional(Schema3.String),
+        initialFormValues: Schema3.optional(Schema3.Any),
+        navigable: Schema3.optional(Schema3.Boolean),
+        targetNodeId: Schema3.optional(Schema3.String.annotations({
+          description: "Qualified graph node ID of the target collection."
+        })),
+        // TODO(wittjosiah): This is a function, is there a better way to handle this?
+        onCreateObject: Schema3.optional(Schema3.Any)
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.OpenCreateSpace = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-create-space`,
+      name: "Open Create Space Dialog",
+      description: "Open the create space dialog."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Void,
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.Migrate = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.migrate`,
+      name: "Migrate Space",
+      description: "Migrate a space to a new version."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema,
+        version: Schema3.optional(Schema3.String)
+      }),
+      output: Schema3.Boolean
+    }
+  });
+  SpaceOperation2.Snapshot = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.snapshot`,
+      name: "Create Snapshot",
+      description: "Create a snapshot of the space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        db: Database.Database,
+        query: QueryAST.Query.pipe(Schema3.optional)
+      }),
+      output: Schema3.Struct({
+        snapshot: Schema3.instanceOf(Blob)
+      })
+    }
+  });
+  SpaceOperation2.Rename = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.rename`,
+      name: "Rename Space",
+      description: "Rename a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema,
+        caller: Schema3.optional(Schema3.String)
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.RenameObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.rename-object`,
+      name: "Rename Object",
+      description: "Rename an object."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        object: Obj.Unknown,
+        caller: Schema3.optional(Schema3.String)
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.OpenMembers = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.open-members`,
+      name: "Open Members",
+      description: "Open the members panel for a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.GetShareLink = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.get-share-link`,
+      name: "Get Share Link",
+      description: "Get a shareable link for a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        space: SpaceSchema,
+        target: Schema3.optional(Schema3.String),
+        copyToClipboard: Schema3.optional(Schema3.Boolean)
+      }),
+      output: Schema3.String
+    }
+  });
+  SpaceOperation2.StoredSchemaForm = Schema3.Struct({
+    name: Schema3.optional(Schema3.String)
+  });
+  SpaceOperation2.AddSchema = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.add-schema`,
+      name: "Add Schema",
+      description: "Add a schema to the space."
+    },
+    services: [
+      Capability2.Service,
+      Plugin.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        db: Database.Database,
+        name: Schema3.optional(Schema3.String),
+        typename: Schema3.optional(Schema3.String),
+        version: Schema3.optional(Schema3.String),
+        // TODO(wittjosiah): Schema for schema?
+        schema: Schema3.Any,
+        show: Schema3.optional(Schema3.Boolean)
+      }),
+      output: Schema3.Struct({
+        id: Schema3.String,
+        object: Type2.PersistentType,
+        schema: Schema3.instanceOf(Type2.RuntimeType)
+      })
+    }
+  });
+  SpaceOperation2.AddRelation = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.add-relation`,
+      name: "Add Relation",
+      description: "Add a relation between objects."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        db: Database.Database,
+        // TODO(wittjosiah): Relation schema.
+        schema: Schema3.Any,
+        source: Obj.Unknown,
+        target: Obj.Unknown,
+        // TODO(wittjosiah): Type based on relation schema.
+        fields: Schema3.optional(Schema3.Record({
+          key: Schema3.String,
+          value: Schema3.Any
+        }))
+      }),
+      output: Schema3.Struct({
+        relation: Schema3.Any
+      })
+    }
+  });
+  SpaceOperation2.DuplicateObject = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.duplicate-object`,
+      name: "Duplicate Object",
+      description: "Duplicate an object."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        object: Obj.Unknown,
+        target: Schema3.Union(Database.Database, Collection.Collection)
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.RestoreField = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.restore-field`,
+      name: "Restore Field",
+      description: "Restore a deleted field to a view."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        view: View.View.annotations({
+          description: "The view to restore the field to."
+        }),
+        field: View.FieldSchema.annotations({
+          description: "The field schema to restore."
+        }),
+        // TODO(wittjosiah): This creates a type error with PropertySchema.
+        props: Schema3.Any.annotations({
+          description: "The field properties to restore."
+        }),
+        index: Schema3.Number.annotations({
+          description: "The index to restore the field at."
+        })
+      }),
+      output: Schema3.Void
+    }
+  });
+  SpaceOperation2.RestoreObjects = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}.restore-objects`,
+      name: "Restore Objects",
+      description: "Restore deleted objects to a space."
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        objects: Schema3.Array(Obj.Unknown).annotations({
+          description: "The objects to restore."
+        }),
+        parentCollection: Collection.Collection.annotations({
+          description: "The collection to restore to."
+        }),
+        indices: Schema3.Array(Schema3.Number).annotations({
+          description: "The indices to restore at."
+        }),
+        nestedObjectsList: Schema3.Array(Schema3.Array(Obj.Unknown)).annotations({
+          description: "Nested objects to restore."
+        }),
+        wasActive: Schema3.Array(Schema3.String).annotations({
+          description: "IDs of objects that were active before deletion."
+        })
+      }),
+      output: Schema3.Void
+    }
+  });
+})(SpaceOperation || (SpaceOperation = {}));
+var CollectionOperation;
+var SpaceOperation;
+
+export {
+  SpaceCapabilities,
+  SpaceEvents,
+  TypeInputOptions,
+  TypeInputOptionsAnnotationId,
+  TypeInputOptionsAnnotation,
+  getTypenames,
+  SPACE_DIRECTORY_HANDLE,
+  SPACE_TYPE,
+  SpaceSettingsSchema,
+  IconAnnotationId,
+  HueAnnotationId,
+  SpaceForm,
+  CollectionOperation,
+  SpaceOperation
+};
+//# sourceMappingURL=chunk-EVNSLSQS.mjs.map