@dxos/plugin-space 0.8.3 → 0.8.4-main.1068cf700f

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

@@ -0,0 +1,716 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  meta
+} from "./chunk-SL4BJSUG.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")),
+  registered: Schema2.Array(Schema2.Literal("registered", "unregistered"))
+});
+var TypeInputOptionsAnnotationId = 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 includeRegistered = annotation.registered.includes("registered");
+  const includeUnregistered = annotation.registered.includes("unregistered");
+  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;
+  }).filter((schema) => {
+    const registered = space?.properties.staticRecords?.includes(Type.getTypename(schema));
+    return registered ? includeRegistered : includeUnregistered;
+  }).map((schema) => Type.getTypename(schema)) : [];
+  const databaseTypenames = includeDatabase && includeRegistered && 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, QueryAST, Type as Type2 } from "@dxos/echo";
+import { Operation } from "@dxos/operation";
+import { Collection, FieldSchema, View } from "@dxos/schema";
+var SPACE_DIRECTORY_HANDLE = `${meta.id}/directory`;
+var SPACE_TYPE = "dxos.org/type/Space";
+var SpaceSettingsSchema = Schema3.mutable(Schema3.Struct({
+  /**
+   * Show closed spaces.
+   */
+  showHidden: Schema3.Boolean
+}));
+var IconAnnotationId = Symbol.for("@dxos/plugin-space/annotation/Icon");
+var HueAnnotationId = 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 = "dxos.org/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: Type2.Obj.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)
+      }),
+      output: Schema3.Struct({
+        id: Schema3.String,
+        subject: Schema3.Array(Schema3.String),
+        object: Type2.Obj
+      })
+    }
+  });
+  SpaceOperation2.RemoveObjectsOutput = Schema3.Struct({
+    objects: Schema3.Array(Type2.Obj).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(Type2.Obj)).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(Type2.Obj).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: 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),
+        // 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: Type2.Obj,
+        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),
+    typename: Schema3.String.pipe(Schema3.annotations({
+      title: "Select type (leave blank to create a new type)"
+    }), TypeInputOptionsAnnotation.set({
+      location: [
+        "runtime"
+      ],
+      kind: [
+        "user"
+      ],
+      registered: [
+        "unregistered"
+      ]
+    }), Schema3.optional)
+  });
+  SpaceOperation2.UseStaticSchema = Operation.make({
+    meta: {
+      key: `${SPACE_OPERATION}/use-static-schema`,
+      name: "Use Static Schema",
+      description: "Use a static schema in the space."
+    },
+    services: [
+      Capability2.Service,
+      Plugin.Service
+    ],
+    schema: {
+      input: Schema3.Struct({
+        db: Database.Database,
+        typename: Schema3.String,
+        show: Schema3.optional(Schema3.Boolean)
+      }),
+      output: Schema3.Struct({})
+    }
+  });
+  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: Type2.Obj,
+        target: Type2.Obj,
+        // 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: Type2.Obj,
+        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: 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(Type2.Obj).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(Type2.Obj)).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-NYSDQPNM.mjs.map