jazz-tools 0.7.0-alpha.0

package/src/coValues/coList/coListOf.ts

@@ -0,0 +1,377 @@
+import {
+    CoValueCore,
+    JsonValue,
+    RawAccount,
+    RawCoList,
+    cojsonInternals,
+} from "cojson";
+import { CoValueSchema, ID, inspect } from "../../coValueInterfaces.js";
+import { SchemaWithOutput } from "../../schemaHelpers.js";
+import { CoListBase, CoListSchema } from "./coList.js";
+import { AST, Schema } from "@effect/schema";
+import { AnyAccount, ControlledAccount } from "../account/account.js";
+import { AnyGroup } from "../group/group.js";
+import {
+    constructorOfSchemaSym,
+    propertyIsCoValueSchema,
+} from "../resolution.js";
+import { ValueRef, makeRefs } from "../../refs.js";
+import { Account, controlledAccountFromNode } from "../account/accountOf.js";
+import { subscriptionsScopes } from "../../subscriptionScope.js";
+import { SharedCoValueConstructor } from "../construction.js";
+import { pipeArguments } from "effect/Pipeable";
+import { Group } from "../group/groupOf.js";
+import { Stream } from "effect";
+import { UnavailableError } from "../../errors.js";
+
+export function CoListOf<
+    Item extends CoValueSchema | SchemaWithOutput<JsonValue>,
+>(itemSchema: Item) {
+    const decodeItem = Schema.decodeSync(itemSchema);
+    const encodeItem = Schema.encodeSync(itemSchema);
+
+    class CoListOfItem
+        extends Array<
+            Item extends CoValueSchema
+                ? Schema.Schema.To<Item> | undefined
+                : Schema.Schema.To<Item>
+        >
+        implements CoListBase<Item>
+    {
+        static get ast() {
+            return AST.setAnnotation(
+                Schema.instanceOf(this).ast,
+                constructorOfSchemaSym,
+                this
+            );
+        }
+        static [Schema.TypeId]: Schema.Schema.Variance<
+            CoListOfItem,
+            CoListOfItem,
+            never
+        >[Schema.TypeId];
+        static pipe() {
+            // eslint-disable-next-line prefer-rest-params
+            return pipeArguments(this, arguments);
+        }
+        static type = "CoList" as const;
+
+        id!: ID<this>;
+        _type!: "CoList";
+        _owner!: AnyAccount | AnyGroup;
+        _refs!: CoListBase<Item>["_refs"];
+        _edits!: CoListBase<Item>["_edits"];
+        _raw!: RawCoList;
+        _loadedAs!: ControlledAccount;
+        _schema!: typeof CoListOfItem;
+
+        constructor(_init: undefined, options: { fromRaw: RawCoList });
+        constructor(
+            init: Schema.Schema.From<Item>[],
+            options: { owner: AnyAccount | AnyGroup }
+        );
+        constructor(init: number);
+        constructor(
+            init: Schema.Schema.From<Item>[] | undefined | number,
+            options?: { owner: AnyAccount | AnyGroup } | { fromRaw: RawCoList }
+        ) {
+            if (typeof init === "number") {
+                // this might be called from an intrinsic, like map, trying to create an empty array
+                // passing `0` as the only parameter
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return new Array(init) as any;
+            }
+
+            super();
+
+            const itemsAreCoValues = propertyIsCoValueSchema(itemSchema);
+
+            if (!options) {
+                throw new Error("Must provide options");
+            }
+
+            let raw: RawCoList;
+
+            if ("fromRaw" in options) {
+                raw = options.fromRaw;
+            } else {
+                const rawOwner = options.owner._raw;
+
+                const rawInit = itemsAreCoValues
+                    ? init?.map((item) => item.id)
+                    : init?.map((item) => encodeItem(item));
+
+                raw = rawOwner.createList(rawInit);
+            }
+
+            const refs = itemsAreCoValues
+                ? makeRefs<{ [key: number]: Schema.Schema.To<Item> }>(
+                      (idx) => raw.get(idx),
+                      () =>
+                          Array.from(
+                              { length: raw.entries().length },
+                              (_, idx) => idx
+                          ),
+                      controlledAccountFromNode(raw.core.node),
+                      (_idx) => itemSchema
+                  )
+                : [];
+
+            const getEdits = () =>
+                new Proxy(this, {
+                    get: (target, key, receiver) => {
+                        if (typeof key === "string" && !isNaN(+key)) {
+                            const rawEdit = raw.editAt(Number(key));
+                            if (!rawEdit) return undefined;
+
+                            return {
+                                get value() {
+                                    if (itemsAreCoValues) {
+                                        return this.ref?.accessFrom(receiver);
+                                    } else {
+                                        return (
+                                            rawEdit?.value &&
+                                            decodeItem(rawEdit?.value)
+                                        );
+                                    }
+                                },
+
+                                get ref() {
+                                    if (itemsAreCoValues) {
+                                        return (
+                                            rawEdit?.value &&
+                                            new ValueRef(
+                                                rawEdit?.value as ID<CoListOfItem>,
+                                                receiver._loadedAs,
+                                                itemSchema
+                                            )
+                                        );
+                                    }
+                                },
+
+                                get by() {
+                                    if (
+                                        cojsonInternals.isAccountID(rawEdit.by)
+                                    ) {
+                                        return new ValueRef(
+                                            rawEdit.by as unknown as ID<AnyAccount>,
+                                            receiver._loadedAs,
+                                            Account
+                                        ).accessFrom(receiver);
+                                    }
+                                },
+
+                                madeAt: rawEdit.at,
+                                tx: rawEdit.tx,
+                            };
+                        } else if (key === "length") {
+                            return raw.entries().length;
+                        }
+                        return Reflect.get(target, key, receiver);
+                    },
+                });
+
+            Object.defineProperties(this, {
+                id: { value: raw.id, enumerable: false },
+                _type: { value: "CoList", enumerable: false },
+                _owner: {
+                    get: () =>
+                        raw.group instanceof RawAccount
+                            ? Account.fromRaw(raw.group)
+                            : Group.fromRaw(raw.group),
+                    enumerable: false,
+                },
+                _refs: { value: refs, enumerable: false },
+                _edits: { get: getEdits, enumerable: false },
+                _raw: { value: raw, enumerable: false },
+                _loadedAs: {
+                    get: () => controlledAccountFromNode(raw.core.node),
+                    enumerable: false,
+                },
+                _schema: { value: this.constructor, enumerable: false },
+            });
+
+            return new Proxy(this, {
+                get(target, key, receiver) {
+                    if (typeof key === "string" && !isNaN(+key)) {
+                        if (itemsAreCoValues) {
+                            return target._refs[Number(key)]?.accessFrom(
+                                receiver
+                            );
+                        } else {
+                            return decodeItem(raw.get(Number(key)));
+                        }
+                    } else if (key === "length") {
+                        return raw.entries().length;
+                    }
+                    const prop = Reflect.get(target, key, receiver);
+                    if (typeof prop === "function") {
+                        return prop.bind(receiver);
+                    }
+                    return prop;
+                },
+                set(target, key, value, receiver) {
+                    if (typeof key === "string" && !isNaN(+key)) {
+                        if (itemsAreCoValues) {
+                            raw.replace(Number(key), value.id);
+                            subscriptionsScopes
+                                .get(receiver)
+                                ?.onRefAccessedOrSet(value.id);
+                            return true;
+                        } else {
+                            raw.replace(
+                                Number(key),
+                                encodeItem(value) as JsonValue
+                            );
+                            return true;
+                        }
+                    } else {
+                        return Reflect.set(target, key, value);
+                    }
+                },
+                has(target, key) {
+                    if (typeof key === "string" && !isNaN(+key)) {
+                        return Number(key) < raw.entries().length;
+                    } else {
+                        return Reflect.has(target, key);
+                    }
+                },
+            });
+        }
+
+        static fromRaw(raw: RawCoList): CoListOfItem {
+            return new CoListOfItem(undefined, { fromRaw: raw });
+        }
+
+        push(
+            ...items: (Item extends CoValueSchema
+                ? Schema.Schema.To<Item> | undefined
+                : Schema.Schema.To<Item>)[]
+        ): number {
+            let rawItems;
+            if (propertyIsCoValueSchema(itemSchema)) {
+                rawItems = items.map((item) => item.id);
+            } else {
+                rawItems = items.map((item) => encodeItem(item));
+            }
+
+            for (const item of rawItems) {
+                this._raw.append(item);
+            }
+
+            return this._raw.entries().length;
+        }
+
+        unshift(
+            ...items: (Item extends CoValueSchema
+                ? Schema.Schema.To<Item> | undefined
+                : Schema.Schema.To<Item>)[]
+        ): number {
+            let rawItems;
+            if (propertyIsCoValueSchema(itemSchema)) {
+                rawItems = items.map((item) => item.id);
+            } else {
+                rawItems = items.map((item) => encodeItem(item));
+            }
+
+            for (const item of rawItems) {
+                this._raw.prepend(item);
+            }
+
+            return this._raw.entries().length;
+        }
+
+        pop(): Schema.Schema.To<Item> | undefined {
+            const last = this[this.length - 1];
+
+            this._raw.delete(this.length - 1);
+
+            return last;
+        }
+
+        shift(): Schema.Schema.To<Item> | undefined {
+            const first = this[0];
+
+            this._raw.delete(0);
+
+            return first;
+        }
+
+        splice(
+            start: number,
+            deleteCount: number,
+            ...items: (Item extends CoValueSchema
+                ? Schema.Schema.To<Item> | undefined
+                : Schema.Schema.To<Item>)[]
+        ): (Item extends CoValueSchema
+            ? Schema.Schema.To<Item> | undefined
+            : Schema.Schema.To<Item>)[] {
+            const deleted = this.slice(start, start + deleteCount);
+
+            for (
+                let idxToDelete = start + deleteCount;
+                idxToDelete > start;
+                idxToDelete--
+            ) {
+                this._raw.delete(idxToDelete);
+            }
+
+            let rawItems;
+            if (propertyIsCoValueSchema(itemSchema)) {
+                rawItems = items.map((item) => item.id);
+            } else {
+                rawItems = items.map((item) => encodeItem(item));
+            }
+
+            let appendAfter = start;
+            for (const item of rawItems) {
+                this._raw.append(item, appendAfter);
+                appendAfter++;
+            }
+
+            return deleted;
+        }
+
+        static load = SharedCoValueConstructor.load;
+        static loadEf = SharedCoValueConstructor.loadEf;
+        static subscribe = SharedCoValueConstructor.subscribe;
+        static subscribeEf = SharedCoValueConstructor.subscribeEf;
+
+        toJSON() {
+            return this.map((item) =>
+                typeof item === "object" &&
+                "toJSON" in item &&
+                typeof item.toJSON === "function"
+                    ? item.toJSON()
+                    : item
+            );
+        }
+
+        [inspect]() {
+            return this.toJSON();
+        }
+
+        static as<SubClass>() {
+            return CoListOfItem as unknown as CoListSchema<SubClass, Item>;
+        }
+
+        subscribe(listener: (update: this) => void): () => void {
+            return SharedCoValueConstructor.prototype.subscribe.call(
+                this,
+                listener as unknown as (
+                    update: SharedCoValueConstructor
+                ) => void
+            );
+        }
+
+        subscribeEf() {
+            return SharedCoValueConstructor.prototype.subscribeEf.call(
+                this
+            ) as unknown as Stream.Stream<this, UnavailableError, never>;
+        }
+    }
+
+    return CoListOfItem as CoListSchema<CoListOfItem, Item> & {
+        as<SubClass>(): CoListSchema<SubClass, Item>;
+    };
+}

package/src/coValues/coList/internalDocs.ts

@@ -0,0 +1 @@
+export { CoListBase } from "./coList.js";

package/src/coValues/coMap/coMap.ts

@@ -0,0 +1,110 @@
+import { CoValue, CoValueSchema } from "../../coValueInterfaces.js";
+import { CojsonInternalTypes, JsonValue, RawCoMap } from "cojson";
+import { ValueRef } from "../../refs.js";
+import {
+    PropertySignatureWithOutput,
+    SchemaWithInputAndOutput,
+    SchemaWithOutput,
+} from "../../schemaHelpers.js";
+import { Schema } from "@effect/schema";
+import { Simplify } from "effect/Types";
+import { AnyAccount } from "../account/account.js";
+
+export type IndexSignature = {
+    key: SchemaWithInputAndOutput<string, string>;
+    value: CoMapFieldValue;
+};
+
+export type NoIndexSignature = {
+    key: never;
+    value: never;
+};
+
+/**
+ *  @category Schemas & CoValues - CoMap
+ */
+export interface CoMapBase<
+    Fields extends CoMapFields,
+    IdxSig extends IndexSignature = never,
+> extends CoValue<"CoMap", RawCoMap> {
+    /** @category Referenced CoValues */
+    readonly _refs: {
+        [Key in keyof Fields as NonNullable<
+            Schema.Schema.To<Fields[Key]>
+        > extends CoValue
+            ? Key
+            : never]: ValueRef<NonNullable<Schema.Schema.To<Fields[Key]>>>;
+    } & {
+        [Key in Schema.Schema.To<IdxSig["key"]>]: NonNullable<
+            Schema.Schema.To<IdxSig["value"]>
+        > extends CoValue
+            ? ValueRef<NonNullable<Schema.Schema.To<IdxSig["value"]>>>
+            : never;
+    };
+
+    readonly _edits: {
+        [Key in keyof Fields]: {
+            value?: Schema.Schema.To<Fields[Key]>;
+            ref?: NonNullable<Schema.Schema.To<Fields[Key]>> extends CoValue
+                ? ValueRef<Schema.Schema.To<Fields[Key]>>
+                : never;
+            by?: AnyAccount;
+            madeAt: Date;
+            tx: CojsonInternalTypes.TransactionID;
+        };
+    } & {
+        [Key in Schema.Schema.To<IdxSig["key"]>]: {
+            value?: Schema.Schema.To<IdxSig["value"]>;
+            ref?: Schema.Schema.To<IdxSig["value"]> extends CoValueSchema<
+                infer Self,
+                infer Value
+            >
+                ? ValueRef<Self & Value>
+                : never;
+            by?: AnyAccount;
+            madeAt: Date;
+            tx: CojsonInternalTypes.TransactionID;
+        };
+    };
+}
+
+/**
+ *  @category Schemas & CoValues - CoMap
+ */
+export type CoMap<
+    Fields extends CoMapFields,
+    IdxSig extends IndexSignature | NoIndexSignature = NoIndexSignature,
+> = {
+    /** @category Specified fields */
+    [Key in keyof Fields]: Schema.Schema.To<Fields[Key]>;
+} & {
+    [Key in Schema.Schema.To<IdxSig["key"]>]: Schema.Schema.To<IdxSig["value"]>;
+} & CoMapBase<Fields, IdxSig>;
+
+/** @category Schemas & CoValues - CoMap */
+export interface CoMapSchema<
+    Self,
+    Fields extends CoMapFields,
+    IdxSig extends IndexSignature | NoIndexSignature,
+> extends CoValueSchema<
+        Self,
+        CoMap<Fields, IdxSig>,
+        "CoMap",
+        Simplify<CoMapInit<Fields, IdxSig>>
+    > {}
+
+export type CoMapFieldValue =
+    | SchemaWithOutput<CoValue | undefined>
+    | SchemaWithOutput<JsonValue>
+    | PropertySignatureWithOutput<CoValue | JsonValue | undefined>;
+
+export type CoMapFields = {
+    [key: string]: CoMapFieldValue;
+};
+
+export type CoMapInit<
+    Fields extends CoMapFields,
+    IdxSig extends IndexSignature = never,
+> = Schema.ToStruct<Fields> & {
+    [Key in Schema.Schema.To<IdxSig["key"]>]: Schema.Schema.To<IdxSig["value"]>;
+};