@dxos/plugin-space 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

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

@@ -1,715 +0,0 @@
-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, Common } from "@dxos/app-framework";
-(function(SpaceEvents2) {
-  SpaceEvents2.StateReady = Common.ActivationEvent.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-MPL6NHQX.mjs.map