@dxos/plugin-space 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

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

@@ -1,684 +0,0 @@
-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