jazz-tools 0.7.0-alpha.2 → 0.7.0-alpha.21

package/src/coValues/coList.ts

@@ -4,28 +4,47 @@ import type { Effect, Stream } from "effect";
 import type {
     AccountCtx,
     CoValue,
-    EnsureItemNullable,
-    FieldDescriptor,
-    FieldDescriptorFor,
+    ValidItem,
+    Schema,
+    SchemaFor,
     ID,
-    RefField,
+    RefEncoded,
     SubclassedConstructor,
     UnavailableError,
+    IfCo,
 } 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>
+export class CoList<Item extends ValidItem<Item, "CoList"> = any>
     extends Array<Item>
     implements CoValue<"CoList", RawCoList>
 {
+    static Of<Item extends ValidItem<Item, "CoList"> = any>(
+        item: IfCo<Item, Item>
+    ): typeof CoList<Item> {
+        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 {
@@ -33,11 +52,13 @@ export class CoList<Item extends EnsureItemNullable<Item, 'Co.List'> = any>
     }
     _raw!: RawCoList;
 
-    static _encoding: any;
-    get _encoding(): {
-        _item: FieldDescriptorFor<Item>;
+    /** @internal This is only a marker type and doesn't exist at runtime */
+    [ItemsSym]!: Item;
+    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 {
@@ -48,8 +69,13 @@ export class CoList<Item extends EnsureItemNullable<Item, 'Co.List'> = any>
 
     get _refs(): {
         [idx: number]: NonNullable<Item> extends CoValue
-            ? ValueRef<NonNullable<Item>>
+            ? Ref<NonNullable<Item>>
             : never;
+    } & {
+        length: number;
+        [Symbol.iterator](): IterableIterator<
+            NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never
+        >;
     } {
         return makeRefs<number>(
             (idx) => this._raw.get(idx) as unknown as ID<CoValue>,
@@ -59,14 +85,14 @@ export class CoList<Item extends EnsureItemNullable<Item, 'Co.List'> = any>
                     (_, idx) => idx
                 ),
             this._loadedAs,
-            (_idx) => (this._encoding._item as RefField<CoValue>).ref()
+            (_idx) => this._schema[ItemsSym] as RefEncoded<CoValue>
         ) 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;
         };
@@ -78,71 +104,50 @@ export class CoList<Item extends EnsureItemNullable<Item, 'Co.List'> = any>
         return Account.fromNode(this._raw.core.node);
     }
 
+    [InitValues]?: any;
+
+    static get [Symbol.species]() {
+        return Array;
+    }
+
     constructor(_init: undefined, options: { fromRaw: RawCoList });
     constructor(init: Item[], options: { owner: Account | Group });
-    constructor(init: number);
     constructor(
-        init: Item[] | undefined | number,
+        init: Item[] | undefined,
         options?: { 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);
-
-            raw = rawOwner.createList(rawInit);
+        if (init && "owner" in options) {
+            this[InitValues] = {
+                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));
-    }
-
-    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;
+        return new Proxy(this, CoListProxyHandler as ProxyHandler<this>);
     }
 
     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);
         }
 
@@ -153,7 +158,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);
         }
 
@@ -190,7 +198,10 @@ export class CoList<Item extends EnsureItemNullable<Item, 'Co.List'> = any>
         }
 
         let appendAfter = start;
-        for (const item of this.toRawItems(items as Item[])) {
+        for (const item of toRawItems(
+            items as Item[],
+            this._schema[ItemsSym]
+        )) {
             this._raw.append(item, appendAfter);
             appendAfter++;
         }
@@ -199,14 +210,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 [];
@@ -256,65 +267,122 @@ export class CoList<Item extends EnsureItemNullable<Item, 'Co.List'> = any>
         onUpdate: (value: V) => void
     ) => () => void;
 
-    static encoding<V extends CoList>(
+    static schema<V extends CoList>(
         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);
             }
-        },
-        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);
+        }
+    },
+};