jazz-tools 0.7.0-alpha.9 → 0.7.3

package/src/coValues/coList.ts

@@ -1,41 +1,47 @@
 import type { RawCoList } from "cojson";
 import { RawAccount } from "cojson";
-import type { Effect, Stream } from "effect";
 import type {
-    AccountCtx,
     CoValue,
-    ValidItem,
-    Encoding,
-    EncodingFor,
+    Schema,
+    SchemaFor,
     ID,
     RefEncoded,
-    SubclassedConstructor,
+    UnCo,
+    CoValueClass,
+    DepthsIn,
+    DeeplyLoaded,
     UnavailableError,
-    IsVal,
+    AccountCtx,
+    CoValueFromRaw,
 } from "../internal.js";
 import {
     Account,
-    CoValueBase,
     Group,
     InitValues,
     ItemsSym,
     Ref,
     SchemaInit,
-    val,
+    co,
+    ensureCoValueLoaded,
     inspect,
+    isRefEncoded,
+    loadCoValue,
+    loadCoValueEf,
     makeRefs,
+    subscribeToCoValue,
+    subscribeToCoValueEf,
+    subscribeToExistingCoValue,
 } from "../internal.js";
-import { Schema } from "@effect/schema";
-
-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> {
+import { encodeSync, decodeSync } from "@effect/schema/Schema";
+import { Effect, Stream } from "effect";
+
+/** @category CoValues */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class CoList<Item = any> extends Array<Item> implements CoValue {
+    static Of<Item>(item: Item): typeof CoList<Item> {
+        // TODO: cache superclass for item class
         return class CoListOf extends CoList<Item> {
-            [val.items] = item;
+            [co.items] = item;
         };
     }
 
@@ -50,14 +56,16 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
         this.prototype._type = "CoList";
     }
     _raw!: RawCoList;
+    _instanceID!: string;
 
     /** @internal This is only a marker type and doesn't exist at runtime */
     [ItemsSym]!: Item;
-    static _encoding: any;
-    get _encoding(): {
-        [ItemsSym]: EncodingFor<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 {
@@ -66,14 +74,17 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
             : Group.fromRaw(this._raw.group);
     }
 
+    /** @category Content */
     get _refs(): {
-        [idx: number]: NonNullable<Item> extends CoValue
-            ? Ref<NonNullable<Item>>
+        [idx: number]: Exclude<Item, null> extends CoValue
+            ? Ref<UnCo<Exclude<Item, null>>>
             : never;
     } & {
         length: number;
         [Symbol.iterator](): IterableIterator<
-            NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never
+            Exclude<Item, null> extends CoValue
+                ? Ref<Exclude<Item, null>>
+                : never
         >;
     } {
         return makeRefs<number>(
@@ -81,10 +92,11 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
             () =>
                 Array.from(
                     { length: this._raw.entries().length },
-                    (_, idx) => idx
+                    (_, idx) => idx,
                 ),
             this._loadedAs,
-            (_idx) => this._encoding[ItemsSym] as RefEncoded<CoValue>
+            (_idx) => this._schema[ItemsSym] as RefEncoded<CoValue>,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ) as any;
     }
 
@@ -103,30 +115,28 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
         return Account.fromNode(this._raw.core.node);
     }
 
-    [InitValues]?: {
-        init: Item[];
-        owner: Account | Group;
-    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [InitValues]?: any;
 
     static get [Symbol.species]() {
         return Array;
     }
 
-    constructor(_init: undefined, options: { fromRaw: RawCoList });
-    constructor(init: Item[], options: { owner: Account | Group });
     constructor(
-        init: Item[] | undefined,
-        options?: { owner: Account | Group } | { fromRaw: RawCoList }
+        options:
+            | { init: Item[]; owner: Account | Group }
+            | { fromRaw: RawCoList },
     ) {
         super();
 
-        if (!options) {
-            throw new Error("Must provide options");
-        }
+        Object.defineProperty(this, "_instanceID", {
+            value: `instance-${Math.random().toString(36).slice(2)}`,
+            enumerable: false,
+        });
 
-        if (init && "owner" in options) {
+        if ("owner" in options) {
             this[InitValues] = {
-                init,
+                init: options.init,
                 owner: options.owner,
             };
         } else if ("fromRaw" in options) {
@@ -142,13 +152,21 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
         return new Proxy(this, CoListProxyHandler as ProxyHandler<this>);
     }
 
+    static create<L extends CoList>(
+        this: CoValueClass<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 toRawItems(
             items as Item[],
-            this._encoding[ItemsSym]
+            this._schema[ItemsSym],
         )) {
             this._raw.append(item);
         }
@@ -162,7 +180,7 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
     unshift(...items: Item[]): number {
         for (const item of toRawItems(
             items as Item[],
-            this._encoding[ItemsSym]
+            this._schema[ItemsSym],
         )) {
             this._raw.prepend(item);
         }
@@ -186,24 +204,23 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = 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;
+        let appendAfter = Math.max(start - 1, 0);
         for (const item of toRawItems(
             items as Item[],
-            this._encoding[ItemsSym]
+            this._schema[ItemsSym],
         )) {
+            console.log(this._raw.asArray(), appendAfter);
             this._raw.append(item, appendAfter);
             appendAfter++;
         }
@@ -212,14 +229,14 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = any>
     }
 
     toJSON() {
-        const itemDescriptor = this._encoding[ItemsSym] as Encoding;
+        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 [];
@@ -230,61 +247,93 @@ export class CoList<Item extends ValidItem<Item, "CoList"> = 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: CoValueClass<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 schema<V extends CoList>(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this: { new (...args: any): V } & typeof CoList,
-        def: { [ItemsSym]: V["_encoding"][ItemsSym] }
+        def: { [ItemsSym]: V["_schema"][ItemsSym] },
     ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, def);
+        this._schema ||= {};
+        Object.assign(this._schema, def);
+    }
+
+    /** @category Subscription & Loading */
+    static load<L extends CoList, Depth>(
+        this: CoValueClass<L>,
+        id: ID<L>,
+        as: Account,
+        depth: Depth & DepthsIn<L>,
+    ): Promise<DeeplyLoaded<L, Depth> | undefined> {
+        return loadCoValue(this, id, as, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static loadEf<L extends CoList, Depth>(
+        this: CoValueClass<L>,
+        id: ID<L>,
+        depth: Depth & DepthsIn<L>,
+    ): Effect.Effect<DeeplyLoaded<L, Depth>, UnavailableError, AccountCtx> {
+        return loadCoValueEf<L, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribe<L extends CoList, Depth>(
+        this: CoValueClass<L>,
+        id: ID<L>,
+        as: Account,
+        depth: Depth & DepthsIn<L>,
+        listener: (value: DeeplyLoaded<L, Depth>) => void,
+    ): () => void {
+        return subscribeToCoValue<L, Depth>(this, id, as, depth, listener);
+    }
+
+    /** @category Subscription & Loading */
+    static subscribeEf<L extends CoList, Depth>(
+        this: CoValueClass<L>,
+        id: ID<L>,
+        depth: Depth & DepthsIn<L>,
+    ): Stream.Stream<DeeplyLoaded<L, Depth>, UnavailableError, AccountCtx> {
+        return subscribeToCoValueEf<L, Depth>(this, id, depth);
+    }
+
+    /** @category Subscription & Loading */
+    ensureLoaded<L extends CoList, Depth>(
+        this: L,
+        depth: Depth & DepthsIn<L>,
+    ): Promise<DeeplyLoaded<L, Depth> | undefined> {
+        return ensureCoValueLoaded(this, depth);
+    }
+
+    /** @category Subscription & Loading */
+    subscribe<L extends CoList, Depth>(
+        this: L,
+        depth: Depth & DepthsIn<L>,
+        listener: (value: DeeplyLoaded<L, Depth>) => void,
+    ): () => void {
+        return subscribeToExistingCoValue(this, depth, listener);
+    }
+
+    /** @category Type Helpers */
+    castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
+        cl: Cl,
+    ): InstanceType<Cl> {
+        return cl.fromRaw(this._raw) as InstanceType<Cl>;
     }
 }
 
-function toRawItems<Item>(items: Item[], itemDescriptor: Encoding) {
+function toRawItems<Item>(items: Item[], itemDescriptor: Schema) {
     const rawItems =
         itemDescriptor === "json"
             ? items
             : "encoded" in itemDescriptor
-              ? items?.map((e) => Schema.encodeSync(itemDescriptor.encoded)(e))
-              : "ref" 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");
@@ -296,7 +345,7 @@ function init(list: CoList) {
     if (list[InitValues]) {
         const { init, owner } = list[InitValues];
         const raw = owner._raw.createList(
-            toRawItems(init, list._encoding[ItemsSym])
+            toRawItems(init, list._schema[ItemsSym]),
         );
 
         Object.defineProperties(list, {
@@ -313,22 +362,22 @@ function init(list: CoList) {
 const CoListProxyHandler: ProxyHandler<CoList> = {
     get(target, key, receiver) {
         if (typeof key === "string" && !isNaN(+key)) {
-            const itemDescriptor = target._encoding[ItemsSym] as Encoding;
+            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
-                    : Schema.decodeSync(itemDescriptor.encoded)(rawValue);
-            } else if ("ref" in itemDescriptor) {
+                    : 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);
+                          itemDescriptor,
+                      ).accessFrom(receiver, Number(key));
             }
         } else if (key === "length") {
             return target._raw.entries().length;
@@ -342,20 +391,20 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
             typeof value === "object" &&
             SchemaInit in value
         ) {
-            (target.constructor as typeof CoList)._encoding ||= {};
-            (target.constructor as typeof CoList)._encoding[ItemsSym] =
+            (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._encoding[ItemsSym] as Encoding;
+            const itemDescriptor = target._schema[ItemsSym] as Schema;
             let rawValue;
             if (itemDescriptor === "json") {
                 rawValue = value;
             } else if ("encoded" in itemDescriptor) {
-                rawValue = Schema.encodeSync(itemDescriptor.encoded)(value);
-            } else if ("ref" in itemDescriptor) {
+                rawValue = encodeSync(itemDescriptor.encoded)(value);
+            } else if (isRefEncoded(itemDescriptor)) {
                 rawValue = value.id;
             }
             target._raw.replace(Number(key), rawValue);
@@ -371,8 +420,8 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
             typeof descriptor.value === "object" &&
             SchemaInit in descriptor.value
         ) {
-            (target.constructor as typeof CoList)._encoding ||= {};
-            (target.constructor as typeof CoList)._encoding[ItemsSym] =
+            (target.constructor as typeof CoList)._schema ||= {};
+            (target.constructor as typeof CoList)._schema[ItemsSym] =
                 descriptor.value[SchemaInit];
             init(target);
             return true;