@dxos/echo 0.8.4-main.937b3ca → 0.8.4-main.9735255

package/dist/lib/node-esm/testing/index.mjs

@@ -1,367 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import "../chunk-MOWUEW5P.mjs";
-import "../chunk-DMR7OAFK.mjs";
-import "../chunk-K37NA7PO.mjs";
-import "../chunk-AJEMYSIR.mjs";
-import {
-  Obj,
-  Ref,
-  Type_exports,
-  object,
-  relation
-} from "../chunk-NRN3ZW2T.mjs";
-import "../chunk-Y75VU7LB.mjs";
-import "../chunk-4PNXQA64.mjs";
-import "../chunk-ZBB67AKD.mjs";
-import "../chunk-UKGVOINP.mjs";
-import "../chunk-5OBN7GZW.mjs";
-import "../chunk-QYR67VBV.mjs";
-import "../chunk-QLI2EIJ2.mjs";
-import "../chunk-MOLNWFNL.mjs";
-import "../chunk-ILMLLM4R.mjs";
-import "../chunk-ANLVLWME.mjs";
-import {
-  EchoSchema,
-  PersistentSchema,
-  makeObject,
-  subscribe,
-  toJsonSchema
-} from "../chunk-LT3H4JOX.mjs";
-import "../chunk-W6QIEBTQ.mjs";
-import "../chunk-NBWL7UCZ.mjs";
-import "../chunk-FWTSPIFF.mjs";
-import {
-  getSchemaTypename
-} from "../chunk-YOLH5KS4.mjs";
-import "../chunk-XHJRMQZD.mjs";
-import "../chunk-YQ2NWGL5.mjs";
-import "../chunk-HSLMI22Q.mjs";
-
-// src/testing/test-data.ts
-import { DatabaseDirectory, ObjectStructure } from "@dxos/echo-protocol";
-import { DXN, ObjectId, PublicKey } from "@dxos/keys";
-
-// src/testing/test-schema.ts
-import * as Schema from "effect/Schema";
-(function(TestSchema2) {
-  TestSchema2.Expando = Schema.Struct({}, {
-    key: Schema.String,
-    value: Schema.Any
-  }).pipe(object({
-    typename: "example.com/type/Expando",
-    version: "0.1.0"
-  }));
-  const Nested = Schema.Struct({
-    field: Schema.String
-  });
-  class TestClass {
-    field = "value";
-    toJSON() {
-      return {
-        field: this.field
-      };
-    }
-  }
-  TestSchema2.TestClass = TestClass;
-  TestSchema2.ExampleSchema = Schema.Struct({
-    string: Schema.String,
-    number: Schema.Number,
-    boolean: Schema.Boolean,
-    null: Schema.Null,
-    undefined: Schema.Undefined,
-    stringArray: Schema.Array(Schema.String),
-    twoDimNumberArray: Schema.Array(Schema.Array(Schema.Number)),
-    nested: Nested,
-    nestedArray: Schema.Array(Nested),
-    nestedNullableArray: Schema.Array(Schema.Union(Nested, Schema.Null)),
-    reference: Schema.suspend(() => Ref(TestSchema2.Example)),
-    referenceArray: Schema.Array(Schema.suspend(() => Ref(TestSchema2.Example))),
-    classInstance: Schema.instanceOf(TestClass),
-    other: Schema.Any
-  }).pipe(Schema.partial);
-  TestSchema2.Example = TestSchema2.ExampleSchema.pipe(object({
-    typename: "example.com/type/Example",
-    version: "0.1.0"
-  }));
-  TestSchema2.MessageStruct = Schema.Struct({
-    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
-    // TODO(burdon): Support defaults (update create and create).
-    timestamp: Schema.String.pipe(Schema.propertySignature, Schema.withConstructorDefault(() => (/* @__PURE__ */ new Date()).toISOString()))
-  });
-  TestSchema2.Message = TestSchema2.MessageStruct.pipe(object({
-    typename: "example.com/type/Message",
-    version: "0.1.0"
-  }));
-  TestSchema2.Organization = Schema.Struct({
-    name: Schema.String,
-    properties: Schema.optional(Schema.Record({
-      key: Schema.String,
-      value: Schema.String
-    }))
-  }).pipe(object({
-    typename: "example.com/type/Organization",
-    version: "0.1.0"
-  }));
-  TestSchema2.Person = Schema.Struct({
-    name: Schema.String,
-    username: Schema.String,
-    email: Schema.String,
-    age: Schema.Number.pipe(Schema.optional),
-    tasks: Schema.Array(Schema.suspend(() => Ref(TestSchema2.Task))),
-    employer: Schema.optional(Ref(TestSchema2.Organization)),
-    address: Schema.Struct({
-      city: Schema.optional(Schema.String),
-      state: Schema.optional(Schema.String),
-      zip: Schema.optional(Schema.String),
-      coordinates: Schema.Struct({
-        lat: Schema.optional(Schema.Number),
-        lng: Schema.optional(Schema.Number)
-      })
-    }),
-    fields: Schema.Struct({
-      label: Schema.String,
-      value: Schema.String
-    }).pipe(Schema.Array, Schema.optional)
-  }).pipe(Schema.partial, object({
-    typename: "example.com/type/Person",
-    version: "0.1.0"
-  }));
-  TestSchema2.Task = Schema.Struct({
-    title: Schema.optional(Schema.String),
-    deadline: Schema.optional(Schema.String),
-    completed: Schema.optional(Schema.Boolean),
-    assignee: Schema.optional(Ref(TestSchema2.Person)),
-    previous: Schema.optional(Schema.suspend(() => Ref(TestSchema2.Task))),
-    subTasks: Schema.optional(Schema.Array(Schema.suspend(() => Ref(TestSchema2.Task)))),
-    description: Schema.optional(Schema.String)
-  }).pipe(Schema.partial, object({
-    typename: "example.com/type/Task",
-    version: "0.1.0"
-  }));
-  TestSchema2.HasManager = Schema.Struct({}).pipe(relation({
-    typename: "example.com/type/HasManager",
-    version: "0.1.0",
-    source: TestSchema2.Person,
-    target: TestSchema2.Person
-  }));
-  TestSchema2.EmployedBy = Schema.Struct({
-    role: Schema.String,
-    since: Schema.optional(Schema.String)
-  }).pipe(relation({
-    typename: "example.com/type/EmployedBy",
-    version: "0.1.0",
-    source: TestSchema2.Person,
-    target: TestSchema2.Organization
-  }));
-  (function(RecordType) {
-    RecordType[RecordType["UNDEFINED"] = 0] = "UNDEFINED";
-    RecordType[RecordType["PERSONAL"] = 1] = "PERSONAL";
-    RecordType[RecordType["WORK"] = 2] = "WORK";
-  })(TestSchema2.RecordType || (TestSchema2.RecordType = {}));
-  TestSchema2.Container = Schema.Struct({
-    objects: Schema.Array(Ref(Obj)),
-    records: Schema.Array(Schema.partial(Schema.Struct({
-      title: Schema.String,
-      description: Schema.String,
-      contacts: Schema.Array(Ref(TestSchema2.Person)),
-      type: Schema.Enums(TestSchema2.RecordType)
-    })))
-  }).pipe(Schema.partial, object({
-    typename: "example.com/type/Container",
-    version: "0.1.0"
-  }));
-})(TestSchema || (TestSchema = {}));
-var TestSchema;
-
-// src/testing/test-data.ts
-var spaceKey = PublicKey.random();
-var PEOPLE = {
-  alice: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Person).toString(),
-        data: {
-          name: "Alice"
-        }
-      })
-    }
-  }),
-  bob: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Person).toString(),
-        data: {
-          name: "Bob"
-        }
-      })
-    }
-  })
-};
-var ORGS = {
-  dxos: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Organization).toString(),
-        data: {
-          name: "DXOS",
-          founded: "2023"
-        }
-      })
-    }
-  }),
-  cyberdyne: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Organization).toString(),
-        data: {
-          name: "Cyberdyne Systems",
-          founded: "1984"
-        }
-      })
-    }
-  })
-};
-var WORKS_FOR = {
-  fredWorksForCyberdyne: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeRelation({
-        type: Type_exports.getDXN(TestSchema.EmployedBy).toString(),
-        source: {
-          "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects)[0]).toString()
-        },
-        target: {
-          "/": DXN.fromLocalObjectId(Object.keys(ORGS.cyberdyne.objects)[0]).toString()
-        },
-        data: {
-          since: "2020",
-          position: "Engineer"
-        }
-      })
-    }
-  }),
-  aliceWorksForAperture: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeRelation({
-        type: Type_exports.getDXN(TestSchema.EmployedBy).toString(),
-        source: {
-          "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects)[0]).toString()
-        },
-        target: {
-          "/": DXN.fromLocalObjectId(Object.keys(ORGS.dxos.objects)[0]).toString()
-        },
-        data: {
-          since: "2018",
-          position: "Research Scientist"
-        }
-      })
-    }
-  })
-};
-var TASKS = {
-  task1: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Task).toString(),
-        data: {
-          title: "Complete project documentation",
-          description: "Write comprehensive documentation for the new system",
-          status: "in-progress",
-          dueDate: "2023-12-31",
-          assignee: {
-            "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects)[0]).toString()
-          }
-        }
-      })
-    }
-  }),
-  task2: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type_exports.getDXN(TestSchema.Task).toString(),
-        data: {
-          title: "Run experiments",
-          description: "Conduct series of experiments on the portal device",
-          status: "pending",
-          dueDate: "2023-11-15",
-          assignee: {
-            "/": DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects)[0]).toString()
-          }
-        }
-      })
-    }
-  })
-};
-
-// src/testing/util.ts
-import { assertArgument } from "@dxos/invariant";
-import { deepMapValues } from "@dxos/util";
-var createEchoSchema = (schema, version = "0.1.0") => {
-  const jsonSchema = toJsonSchema(schema);
-  const typename = getSchemaTypename(schema);
-  assertArgument(typename, "typename", "Schema does not have a typename.");
-  const echoSchema = new EchoSchema(makeObject(PersistentSchema, {
-    typename,
-    version,
-    jsonSchema
-  }));
-  subscribe(echoSchema.persistentSchema, () => {
-    echoSchema._invalidate();
-  });
-  return echoSchema;
-};
-var prepareAstForCompare = (obj) => deepMapValues(obj, (value, recurse) => {
-  if (typeof value === "function") {
-    return null;
-  }
-  if (value instanceof RegExp) {
-    return value;
-  }
-  if (typeof value === "object") {
-    const clone = {
-      ...value
-    };
-    for (const sym of Object.getOwnPropertySymbols(clone)) {
-      clone[sym.toString()] = clone[sym];
-      delete clone[sym];
-    }
-    return recurse(clone);
-  }
-  return recurse(value);
-});
-var updateCounter = (...objects) => {
-  let updateCount = 0;
-  const unsubscribes = objects.map((obj) => subscribe(obj, () => {
-    updateCount++;
-  }));
-  const unsubscribeAll = () => {
-    for (const unsub of unsubscribes) {
-      unsub();
-    }
-  };
-  return {
-    // https://github.com/tc39/proposal-explicit-resource-management
-    [Symbol.dispose]: unsubscribeAll,
-    get count() {
-      return updateCount;
-    }
-  };
-};
-export {
-  ORGS,
-  PEOPLE,
-  TASKS,
-  TestSchema,
-  WORKS_FOR,
-  createEchoSchema,
-  prepareAstForCompare,
-  updateCounter
-};
-//# sourceMappingURL=index.mjs.map