jazz-tools 0.7.0-alpha.4 → 0.7.0-alpha.41

package/src/coValues/coList.ts

@@ -1,43 +1,64 @@
 import type { RawCoList } from "cojson";
 import { RawAccount } from "cojson";
-import type { Effect, Stream } from "effect";
 import type {
-    AccountCtx,
     CoValue,
-    EnsureItemNullable,
-    FieldDescriptor,
-    FieldDescriptorFor,
+    Schema,
+    SchemaFor,
     ID,
-    RefField,
-    SubclassedConstructor,
-    UnavailableError,
+    RefEncoded,
+    ClassOf,
+    UnCo,
+    CoValueClass,
 } from "../internal.js";
 import {
     Account,
     CoValueBase,
     Group,
-    ValueRef,
+    InitValues,
+    ItemsSym,
+    Ref,
+    SchemaInit,
+    co,
     inspect,
+    isRefEncoded,
     makeRefs,
 } from "../internal.js";
-import { Schema } from "@effect/schema";
+import { encodeSync, decodeSync } from "@effect/schema/Schema";
 
-export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
+/** @category CoValues */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class CoList<Item = any>
     extends Array<Item>
     implements CoValue<"CoList", RawCoList>
 {
+    static Of<Item>(item: Item): typeof CoList<Item> {
+        // TODO: cache superclass for item class
+        return class CoListOf extends CoList<Item> {
+            [co.items] = item;
+        };
+    }
+
+    /** @deprecated Use UPPERCASE `CoList.Of` instead! */
+    static of(..._args: never): never {
+        throw new Error("Can't use Array.of with CoLists");
+    }
+
     id!: ID<this>;
     _type!: "CoList";
     static {
         this.prototype._type = "CoList";
     }
     _raw!: RawCoList;
-
-    static _encoding: any;
-    get _encoding(): {
-        _item: FieldDescriptorFor<Item>;
+    _instanceID!: string;
+
+    /** @internal This is only a marker type and doesn't exist at runtime */
+    [ItemsSym]!: Item;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _schema: any;
+    get _schema(): {
+        [ItemsSym]: SchemaFor<Item>;
     } {
-        return (this.constructor as typeof CoList)._encoding;
+        return (this.constructor as typeof CoList)._schema;
     }
 
     get _owner(): Account | Group {
@@ -46,15 +67,16 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
             : Group.fromRaw(this._raw.group);
     }
 
+    /** @category Content */
     get _refs(): {
-        [idx: number]: NonNullable<Item> extends CoValue
-            ? ValueRef<NonNullable<Item>>
+        [idx: number]: Exclude<Item, null> extends CoValue
+            ? Ref<UnCo<Exclude<Item, null>>>
             : never;
     } & {
         length: number;
         [Symbol.iterator](): IterableIterator<
-            NonNullable<Item> extends CoValue
-                ? ValueRef<NonNullable<Item>>
+            Exclude<Item, null> extends CoValue
+                ? Ref<Exclude<Item, null>>
                 : never
         >;
     } {
@@ -63,17 +85,18 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
             () =>
                 Array.from(
                     { length: this._raw.entries().length },
-                    (_, idx) => idx
+                    (_, idx) => idx,
                 ),
             this._loadedAs,
-            (_idx) => (this._encoding._item as RefField<CoValue>).ref()
+            (_idx) => this._schema[ItemsSym] as RefEncoded<CoValue>,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ) as any;
     }
 
     get _edits(): {
         [idx: number]: {
             value?: Item;
-            ref?: Item extends CoValue ? ValueRef<Item> : never;
+            ref?: Item extends CoValue ? Ref<Item> : never;
             by?: Account;
             madeAt: Date;
         };
@@ -85,71 +108,59 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
         return Account.fromNode(this._raw.core.node);
     }
 
-    constructor(_init: undefined, options: { fromRaw: RawCoList });
-    constructor(init: Item[], options: { owner: Account | Group });
-    constructor(init: number);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [InitValues]?: any;
+
+    static get [Symbol.species]() {
+        return Array;
+    }
+
     constructor(
-        init: Item[] | undefined | number,
-        options?: { owner: Account | Group } | { fromRaw: RawCoList }
+        options:
+            | { init: Item[]; owner: Account | Group }
+            | { 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();
 
-        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 = init && this.toRawItems(init);
+        Object.defineProperty(this, "_instanceID", {
+            value: `instance-${Math.random().toString(36).slice(2)}`,
+            enumerable: false,
+        });
 
-            raw = rawOwner.createList(rawInit);
+        if ("owner" in options) {
+            this[InitValues] = {
+                init: options.init,
+                owner: options.owner,
+            };
+        } else if ("fromRaw" in options) {
+            Object.defineProperties(this, {
+                id: {
+                    value: options.fromRaw.id,
+                    enumerable: false,
+                },
+                _raw: { value: options.fromRaw, enumerable: false },
+            });
         }
 
-        Object.defineProperties(this, {
-            id: {
-                value: raw.id,
-                enumerable: false,
-            },
-            _raw: { value: raw, enumerable: false },
-        });
-
-        return new Proxy(this, CoListProxyHandler<Item>(this._encoding._item));
+        return new Proxy(this, CoListProxyHandler as ProxyHandler<this>);
     }
 
-    private toRawItems(items: Item[]) {
-        const itemDescriptor = this._encoding._item as FieldDescriptor;
-        const rawItems =
-            itemDescriptor === "json"
-                ? items
-                : "encoded" in itemDescriptor
-                  ? items?.map((e) =>
-                        Schema.encodeSync(itemDescriptor.encoded)(e)
-                    )
-                  : "ref" in itemDescriptor
-                    ? items?.map((v) => (v as unknown as CoValue).id)
-                    : (() => {
-                          throw new Error("Invalid element descriptor");
-                      })();
-        return rawItems;
+    static create<L extends CoList>(
+        this: ClassOf<L>,
+        items: UnCo<L[number]>[],
+        options: { owner: Account | Group },
+    ) {
+        return new this({ init: items, owner: options.owner });
     }
 
     push(...items: Item[]): number;
     /** @private For exact type compatibility with Array superclass */
     push(...items: Item[]): number;
     push(...items: Item[]): number {
-        for (const item of this.toRawItems(items as Item[])) {
+        for (const item of toRawItems(
+            items as Item[],
+            this._schema[ItemsSym],
+        )) {
             this._raw.append(item);
         }
 
@@ -160,7 +171,10 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
     /** @private For exact type compatibility with Array superclass */
     unshift(...items: Item[]): number;
     unshift(...items: Item[]): number {
-        for (const item of this.toRawItems(items as Item[])) {
+        for (const item of toRawItems(
+            items as Item[],
+            this._schema[ItemsSym],
+        )) {
             this._raw.prepend(item);
         }
 
@@ -183,21 +197,23 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
         return first;
     }
 
-    splice(start: number, deleteCount: number, ...items: Item[]): Item[];
-    splice(start: number, deleteCount: number, ...items: Item[]): Item[];
     splice(start: number, deleteCount: number, ...items: Item[]): Item[] {
         const deleted = this.slice(start, start + deleteCount);
 
         for (
-            let idxToDelete = start + deleteCount;
-            idxToDelete > start;
+            let idxToDelete = start + deleteCount - 1;
+            idxToDelete >= start;
             idxToDelete--
         ) {
             this._raw.delete(idxToDelete);
         }
 
-        let appendAfter = start;
-        for (const item of this.toRawItems(items as Item[])) {
+        let appendAfter = Math.max(start - 1, 0);
+        for (const item of toRawItems(
+            items as Item[],
+            this._schema[ItemsSym],
+        )) {
+            console.log(this._raw.asArray(), appendAfter);
             this._raw.append(item, appendAfter);
             appendAfter++;
         }
@@ -206,14 +222,14 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
     }
 
     toJSON() {
-        const itemDescriptor = this._encoding._item as FieldDescriptor;
+        const itemDescriptor = this._schema[ItemsSym] as Schema;
         if (itemDescriptor === "json") {
             return this._raw.asArray();
         } else if ("encoded" in itemDescriptor) {
             return this._raw
                 .asArray()
-                .map((e) => Schema.encodeSync(itemDescriptor.encoded)(e));
-        } else if ("ref" in itemDescriptor) {
+                .map((e) => encodeSync(itemDescriptor.encoded)(e));
+        } else if (isRefEncoded(itemDescriptor)) {
             return this.map((item) => (item as unknown as CoValue)?.toJSON());
         } else {
             return [];
@@ -224,104 +240,135 @@ export class CoList<Item extends EnsureItemNullable<Item, "Co.List"> = any>
         return this.toJSON();
     }
 
-    subscribe!: (listener: (update: this) => void) => () => void;
-    static {
-        this.prototype.subscribe = CoValueBase.prototype.subscribe as any;
-    }
-
-    subscribeEf!: () => Stream.Stream<this, "unavailable", never>;
-    static {
-        this.prototype.subscribeEf = CoValueBase.prototype.subscribeEf as any;
-    }
-
     static fromRaw<V extends CoList>(
-        this: SubclassedConstructor<V> & typeof CoList,
-        raw: RawCoList
+        this: ClassOf<V> & typeof CoList,
+        raw: RawCoList,
     ) {
-        return new this(undefined, { fromRaw: raw });
+        return new this({ fromRaw: raw });
     }
 
-    static loadEf = CoValueBase.loadEf as unknown as <V extends CoValue>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>
-    ) => Effect.Effect<V, UnavailableError, AccountCtx>;
-    static load = CoValueBase.load as unknown as <V extends CoValue>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>,
-        options: { as: Account | Group }
-    ) => Promise<V | undefined>;
-    static subscribeEf = CoValueBase.subscribeEf as unknown as <
-        V extends CoValue,
-    >(
-        this: SubclassedConstructor<V>,
-        id: ID<V>
-    ) => Stream.Stream<V, UnavailableError, AccountCtx>;
-    static subscribe = CoValueBase.subscribe as unknown as <V extends CoValue>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>,
-        options: { as: Account | Group },
-        onUpdate: (value: V) => void
-    ) => () => void;
-
-    static encoding<V extends CoList>(
+    static load = CoValueBase.load as CoValueClass['load'];
+    static loadEf = CoValueBase.loadEf as CoValueClass['loadEf'];
+    static subscribe = CoValueBase.subscribe as CoValueClass['subscribe'];
+    static subscribeEf = CoValueBase.subscribeEf as CoValueClass['subscribeEf'];
+
+    static schema<V extends CoList>(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this: { new (...args: any): V } & typeof CoList,
-        def: { _item: V["_encoding"]["_item"] }
+        def: { [ItemsSym]: V["_schema"][ItemsSym] },
     ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, def);
+        this._schema ||= {};
+        Object.assign(this._schema, def);
     }
 }
 
-function CoListProxyHandler<Item extends EnsureItemNullable<Item, "Co.List">>(
-    itemDescriptor: FieldDescriptor
-): ProxyHandler<CoList<Item>> {
-    return {
-        get(target, key, receiver) {
-            if (typeof key === "string" && !isNaN(+key)) {
-                const rawValue = target._raw.get(Number(key));
-                if (itemDescriptor === "json") {
-                    return rawValue;
-                } else if ("encoded" in itemDescriptor) {
-                    return rawValue === undefined
-                        ? undefined
-                        : Schema.decodeSync(itemDescriptor.encoded)(rawValue);
-                } else if ("ref" in itemDescriptor) {
-                    return rawValue === undefined
-                        ? undefined
-                        : new ValueRef(
-                              rawValue as unknown as ID<CoValue>,
-                              target._loadedAs,
-                              itemDescriptor.ref()
-                          ).accessFrom(receiver);
-                }
-            } else if (key === "length") {
-                return target._raw.entries().length;
-            } else {
-                return Reflect.get(target, key, receiver);
-            }
-        },
-        set(target, key, value, receiver) {
-            if (typeof key === "string" && !isNaN(+key)) {
-                let rawValue;
-                if (itemDescriptor === "json") {
-                    rawValue = value;
-                } else if ("encoded" in itemDescriptor) {
-                    rawValue = Schema.encodeSync(itemDescriptor.encoded)(value);
-                } else if ("ref" in itemDescriptor) {
-                    rawValue = value.id;
-                }
-                target._raw.replace(Number(key), rawValue);
-                return true;
-            } else {
-                return Reflect.set(target, key, value, receiver);
+function toRawItems<Item>(items: Item[], itemDescriptor: Schema) {
+    const rawItems =
+        itemDescriptor === "json"
+            ? items
+            : "encoded" in itemDescriptor
+              ? items?.map((e) => encodeSync(itemDescriptor.encoded)(e))
+              : isRefEncoded(itemDescriptor)
+                ? items?.map((v) => (v as unknown as CoValue).id)
+                : (() => {
+                      throw new Error("Invalid element descriptor");
+                  })();
+    return rawItems;
+}
+
+function init(list: CoList) {
+    if (list[InitValues]) {
+        const { init, owner } = list[InitValues];
+        const raw = owner._raw.createList(
+            toRawItems(init, list._schema[ItemsSym]),
+        );
+
+        Object.defineProperties(list, {
+            id: {
+                value: raw.id,
+                enumerable: false,
+            },
+            _raw: { value: raw, enumerable: false },
+        });
+        delete list[InitValues];
+    }
+}
+
+const CoListProxyHandler: ProxyHandler<CoList> = {
+    get(target, key, receiver) {
+        if (typeof key === "string" && !isNaN(+key)) {
+            const itemDescriptor = target._schema[ItemsSym] as Schema;
+            const rawValue = target._raw.get(Number(key));
+            if (itemDescriptor === "json") {
+                return rawValue;
+            } else if ("encoded" in itemDescriptor) {
+                return rawValue === undefined
+                    ? undefined
+                    : decodeSync(itemDescriptor.encoded)(rawValue);
+            } else if (isRefEncoded(itemDescriptor)) {
+                return rawValue === undefined
+                    ? undefined
+                    : new Ref(
+                          rawValue as unknown as ID<CoValue>,
+                          target._loadedAs,
+                          itemDescriptor,
+                      ).accessFrom(receiver, Number(key));
             }
-        },
-        has(target, key) {
-            if (typeof key === "string" && !isNaN(+key)) {
-                return Number(key) < target._raw.entries().length;
-            } else {
-                return Reflect.has(target, key);
+        } else if (key === "length") {
+            return target._raw.entries().length;
+        } else {
+            return Reflect.get(target, key, receiver);
+        }
+    },
+    set(target, key, value, receiver) {
+        if (
+            key === ItemsSym &&
+            typeof value === "object" &&
+            SchemaInit in value
+        ) {
+            (target.constructor as typeof CoList)._schema ||= {};
+            (target.constructor as typeof CoList)._schema[ItemsSym] =
+                value[SchemaInit];
+            init(target);
+            return true;
+        }
+        if (typeof key === "string" && !isNaN(+key)) {
+            const itemDescriptor = target._schema[ItemsSym] as Schema;
+            let rawValue;
+            if (itemDescriptor === "json") {
+                rawValue = value;
+            } else if ("encoded" in itemDescriptor) {
+                rawValue = encodeSync(itemDescriptor.encoded)(value);
+            } else if (isRefEncoded(itemDescriptor)) {
+                rawValue = value.id;
             }
-        },
-    };
-}
+            target._raw.replace(Number(key), rawValue);
+            return true;
+        } else {
+            return Reflect.set(target, key, value, receiver);
+        }
+    },
+    defineProperty(target, key, descriptor) {
+        if (
+            descriptor.value &&
+            key === ItemsSym &&
+            typeof descriptor.value === "object" &&
+            SchemaInit in descriptor.value
+        ) {
+            (target.constructor as typeof CoList)._schema ||= {};
+            (target.constructor as typeof CoList)._schema[ItemsSym] =
+                descriptor.value[SchemaInit];
+            init(target);
+            return true;
+        } else {
+            return Reflect.defineProperty(target, key, descriptor);
+        }
+    },
+    has(target, key) {
+        if (typeof key === "string" && !isNaN(+key)) {
+            return Number(key) < target._raw.entries().length;
+        } else {
+            return Reflect.has(target, key);
+        }
+    },
+};