jazz-tools 0.7.0-alpha.6 → 0.7.0-alpha.7

package/src/coValues/coList.ts

@@ -11,21 +11,39 @@ import type {
     RefEncoded,
     SubclassedConstructor,
     UnavailableError,
+    IsVal,
 } from "../internal.js";
 import {
     Account,
     CoValueBase,
     Group,
+    InitValues,
+    ItemsSym,
     Ref,
+    SchemaInit,
+    val,
     inspect,
     makeRefs,
 } from "../internal.js";
 import { Schema } from "@effect/schema";
 
-export class CoList<Item extends ValidItem<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: IsVal<Item, Item>
+    ): typeof CoList<Item> {
+        return class CoListOf extends CoList<Item> {
+            [val.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,9 +51,11 @@ export class CoList<Item extends ValidItem<Item, "Co.List"> = any>
     }
     _raw!: RawCoList;
 
+    /** @internal This is only a marker type and doesn't exist at runtime */
+    [ItemsSym]!: Item;
     static _encoding: any;
     get _encoding(): {
-        _item: EncodingFor<Item>;
+        [ItemsSym]: EncodingFor<Item>;
     } {
         return (this.constructor as typeof CoList)._encoding;
     }
@@ -53,9 +73,7 @@ export class CoList<Item extends ValidItem<Item, "Co.List"> = any>
     } & {
         length: number;
         [Symbol.iterator](): IterableIterator<
-            NonNullable<Item> extends CoValue
-                ? Ref<NonNullable<Item>>
-                : never
+            NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never
         >;
     } {
         return makeRefs<number>(
@@ -66,7 +84,7 @@ export class CoList<Item extends ValidItem<Item, "Co.List"> = any>
                     (_, idx) => idx
                 ),
             this._loadedAs,
-            (_idx) => (this._encoding._item as RefEncoded<CoValue>).ref()
+            (_idx) => this._encoding[ItemsSym] as RefEncoded<CoValue>
         ) as any;
     }
 
@@ -85,71 +103,53 @@ export class CoList<Item extends ValidItem<Item, "Co.List"> = any>
         return Account.fromNode(this._raw.core.node);
     }
 
+    [InitValues]?: {
+        init: Item[];
+        owner: Account | Group;
+    };
+
+    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 Encoding;
-        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._encoding[ItemsSym]
+        )) {
             this._raw.append(item);
         }
 
@@ -160,7 +160,10 @@ export class CoList<Item extends ValidItem<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._encoding[ItemsSym]
+        )) {
             this._raw.prepend(item);
         }
 
@@ -197,7 +200,10 @@ export class CoList<Item extends ValidItem<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._encoding[ItemsSym]
+        )) {
             this._raw.append(item, appendAfter);
             appendAfter++;
         }
@@ -206,7 +212,7 @@ export class CoList<Item extends ValidItem<Item, "Co.List"> = any>
     }
 
     toJSON() {
-        const itemDescriptor = this._encoding._item as Encoding;
+        const itemDescriptor = this._encoding[ItemsSym] as Encoding;
         if (itemDescriptor === "json") {
             return this._raw.asArray();
         } else if ("encoded" in itemDescriptor) {
@@ -265,63 +271,120 @@ export class CoList<Item extends ValidItem<Item, "Co.List"> = any>
 
     static encoding<V extends CoList>(
         this: { new (...args: any): V } & typeof CoList,
-        def: { _item: V["_encoding"]["_item"] }
+        def: { [ItemsSym]: V["_encoding"][ItemsSym] }
     ) {
         this._encoding ||= {};
         Object.assign(this._encoding, def);
     }
 }
 
-function CoListProxyHandler<Item extends ValidItem<Item, "Co.List">>(
-    itemDescriptor: Encoding
-): 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 Ref(
-                              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: Encoding) {
+    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;
+}
+
+function init(list: CoList) {
+    if (list[InitValues]) {
+        const { init, owner } = list[InitValues];
+        const raw = owner._raw.createList(
+            toRawItems(init, list._encoding[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._encoding[ItemsSym] as Encoding;
+            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 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)._encoding ||= {};
+            (target.constructor as typeof CoList)._encoding[ItemsSym] =
+                value[SchemaInit];
+            init(target);
+            return true;
+        }
+        if (typeof key === "string" && !isNaN(+key)) {
+            const itemDescriptor = target._encoding[ItemsSym] as Encoding;
+            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);
+        }
+    },
+    defineProperty(target, key, descriptor) {
+        if (
+            descriptor.value &&
+            key === ItemsSym &&
+            typeof descriptor.value === "object" &&
+            SchemaInit in descriptor.value
+        ) {
+            (target.constructor as typeof CoList)._encoding ||= {};
+            (target.constructor as typeof CoList)._encoding[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);
+        }
+    },
+};