jazz-tools 0.7.0-alpha.36 → 0.7.0-alpha.38

package/src/coValues/coList.ts

@@ -1,17 +1,15 @@
 import type { RawCoList } from "cojson";
 import { RawAccount } from "cojson";
-import type { Effect, Stream } from "effect";
 import type {
-    AccountCtx,
     CoValue,
     Schema,
     SchemaFor,
     ID,
     RefEncoded,
     ClassOf,
-    UnavailableError,
     UnCo,
-    RequireOptions} from "../internal.js";
+    CoValueClass,
+} from "../internal.js";
 import {
     Account,
     CoValueBase,
@@ -28,6 +26,7 @@ import {
 import { encodeSync, decodeSync } from "@effect/schema/Schema";
 
 /** @category CoValues */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class CoList<Item = any>
     extends Array<Item>
     implements CoValue<"CoList", RawCoList>
@@ -54,6 +53,7 @@ export class CoList<Item = any>
 
     /** @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>;
@@ -69,13 +69,15 @@ export class CoList<Item = any>
 
     /** @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>(
@@ -83,10 +85,11 @@ export class CoList<Item = any>
             () =>
                 Array.from(
                     { length: this._raw.entries().length },
-                    (_, idx) => idx
+                    (_, idx) => idx,
                 ),
             this._loadedAs,
-            (_idx) => this._schema[ItemsSym] as RefEncoded<CoValue>
+            (_idx) => this._schema[ItemsSym] as RefEncoded<CoValue>,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ) as any;
     }
 
@@ -105,6 +108,7 @@ export class CoList<Item = any>
         return Account.fromNode(this._raw.core.node);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [InitValues]?: any;
 
     static get [Symbol.species]() {
@@ -114,11 +118,14 @@ export class CoList<Item = any>
     constructor(
         options:
             | { init: Item[]; owner: Account | Group }
-            | { fromRaw: RawCoList }
+            | { fromRaw: RawCoList },
     ) {
         super();
 
-        Object.defineProperty(this, "_instanceID", {value: `instance-${Math.random().toString(36).slice(2)}`, enumerable: false});
+        Object.defineProperty(this, "_instanceID", {
+            value: `instance-${Math.random().toString(36).slice(2)}`,
+            enumerable: false,
+        });
 
         if ("owner" in options) {
             this[InitValues] = {
@@ -141,7 +148,7 @@ export class CoList<Item = any>
     static create<L extends CoList>(
         this: ClassOf<L>,
         items: UnCo<L[number]>[],
-        options: {owner: Account | Group}
+        options: { owner: Account | Group },
     ) {
         return new this({ init: items, owner: options.owner });
     }
@@ -152,7 +159,7 @@ export class CoList<Item = any>
     push(...items: Item[]): number {
         for (const item of toRawItems(
             items as Item[],
-            this._schema[ItemsSym]
+            this._schema[ItemsSym],
         )) {
             this._raw.append(item);
         }
@@ -166,7 +173,7 @@ export class CoList<Item = any>
     unshift(...items: Item[]): number {
         for (const item of toRawItems(
             items as Item[],
-            this._schema[ItemsSym]
+            this._schema[ItemsSym],
         )) {
             this._raw.prepend(item);
         }
@@ -204,7 +211,7 @@ export class CoList<Item = any>
         let appendAfter = Math.max(start - 1, 0);
         for (const item of toRawItems(
             items as Item[],
-            this._schema[ItemsSym]
+            this._schema[ItemsSym],
         )) {
             console.log(this._raw.asArray(), appendAfter);
             this._raw.append(item, appendAfter);
@@ -233,49 +240,22 @@ export class CoList<Item = any>
         return this.toJSON();
     }
 
-    subscribe!: (listener: (update: this) => void, options?: RequireOptions<this>) => () => void;
-    static {
-        this.prototype.subscribe = CoValueBase.prototype.subscribe as any;
-    }
-
-    subscribeEf!: (options?: RequireOptions<this>) => Stream.Stream<this, "unavailable", never>;
-    static {
-        this.prototype.subscribeEf = CoValueBase.prototype.subscribeEf as any;
-    }
-
     static fromRaw<V extends CoList>(
         this: ClassOf<V> & typeof CoList,
-        raw: RawCoList
+        raw: RawCoList,
     ) {
         return new this({ fromRaw: raw });
     }
 
-    static loadEf = CoValueBase.loadEf as unknown as <V extends CoValue>(
-        this: ClassOf<V>,
-        id: ID<V>
-    ) => Effect.Effect<V, UnavailableError, AccountCtx>;
-    static load = CoValueBase.load as unknown as <V extends CoValue>(
-        this: ClassOf<V>,
-        id: ID<V>,
-        options: { as: Account | Group }
-    ) => Promise<V | undefined>;
-    static subscribeEf = CoValueBase.subscribeEf as unknown as <
-        V extends CoValue,
-    >(
-        this: ClassOf<V>,
-        id: ID<V>,
-        options?: { require?: (value: V) => boolean | undefined }
-    ) => Stream.Stream<V, UnavailableError, AccountCtx>;
-    static subscribe = CoValueBase.subscribe as unknown as <V extends CoValue>(
-        this: ClassOf<V>,
-        id: ID<V>,
-        options: { as: Account | Group, require?: (value: V) => boolean | undefined },
-        onUpdate: (value: V) => void
-    ) => () => void;
+    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: { [ItemsSym]: V["_schema"][ItemsSym] }
+        def: { [ItemsSym]: V["_schema"][ItemsSym] },
     ) {
         this._schema ||= {};
         Object.assign(this._schema, def);
@@ -300,7 +280,7 @@ function init(list: CoList) {
     if (list[InitValues]) {
         const { init, owner } = list[InitValues];
         const raw = owner._raw.createList(
-            toRawItems(init, list._schema[ItemsSym])
+            toRawItems(init, list._schema[ItemsSym]),
         );
 
         Object.defineProperties(list, {
@@ -331,7 +311,7 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
                     : new Ref(
                           rawValue as unknown as ID<CoValue>,
                           target._loadedAs,
-                          itemDescriptor
+                          itemDescriptor,
                       ).accessFrom(receiver, Number(key));
             }
         } else if (key === "length") {

package/src/coValues/coMap.ts

@@ -80,6 +80,7 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
     declare _raw: RawCoMap;
 
     /** @internal */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static _schema: any;
     /** @internal */
     get _schema() {
@@ -120,7 +121,8 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
             this._loadedAs,
             (key) =>
                 (this._schema[key] ||
-                    this._schema[ItemsSym]) as RefEncoded<CoValue>
+                    this._schema[ItemsSym]) as RefEncoded<CoValue>,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ) as any;
     }
 
@@ -144,17 +146,17 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
                               : new Ref(
                                     rawEdit.value as ID<CoValue>,
                                     target._loadedAs,
-                                    descriptor
+                                    descriptor,
                                 ).accessFrom(
                                     target,
-                                    "_edits." + key.toString() + ".value"
+                                    "_edits." + key.toString() + ".value",
                                 ),
                     ref:
                         descriptor !== "json" && isRefEncoded(descriptor)
                             ? new Ref(
                                   rawEdit.value as ID<CoValue>,
                                   target._loadedAs,
-                                  descriptor
+                                  descriptor,
                               )
                             : undefined,
                     by:
@@ -162,10 +164,10 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
                         new Ref(
                             rawEdit.by as ID<Account>,
                             target._loadedAs,
-                            Account
+                            Account,
                         ).accessFrom(
                             target,
-                            "_edits." + key.toString() + ".by"
+                            "_edits." + key.toString() + ".by",
                         ),
                     madeAt: rawEdit.at,
                 };
@@ -181,11 +183,13 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
     }
 
     /** @internal */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [InitValues]?: any;
 
     /** @internal */
     constructor(
-        options: { fromRaw: RawCoMap } | { init: any; owner: Account | Group }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        options: { fromRaw: RawCoMap } | { init: any; owner: Account | Group },
     ) {
         super();
 
@@ -213,7 +217,7 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
     static create<M extends CoMap>(
         this: ClassOf<M>,
         init: Simplify<CoMapInit<M>>,
-        options: { owner: Account | Group }
+        options: { owner: Account | Group },
     ) {
         return new this({ init, owner: options.owner });
     }
@@ -227,6 +231,7 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
             if (descriptor == "json" || "encode" in descriptor) {
                 return [key, this._raw.get(key)];
             } else if (isRefEncoded(descriptor)) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const jsonedRef = (this as any)[tKey]?.toJSON();
                 return [key, jsonedRef];
             } else {
@@ -246,9 +251,10 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
     }
 
     /** @internal */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     rawFromInit<Fields extends object = Record<string, any>>(
         init: Simplify<CoMapInit<Fields>> | undefined,
-        owner: Account | Group
+        owner: Account | Group,
     ) {
         const rawOwner = owner._raw;
 
@@ -272,7 +278,8 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
                     }
                 } else if ("encoded" in descriptor) {
                     rawInit[key] = encodeSync(descriptor.encoded)(
-                        initValue as any
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        initValue as any,
                     );
                 }
             }
@@ -293,30 +300,29 @@ export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
     }
 }
 
-export type CoKeys<Fields extends object> = Exclude<
-    keyof Fields & string,
+export type CoKeys<Map extends object> = Exclude<
+    keyof Map & string,
     keyof CoMap
 >;
 
-export type CoMapInit<Fields extends object> = {
-    [Key in CoKeys<Fields> as undefined extends Fields[Key]
+export type CoMapInit<Map extends object> = {
+    [Key in CoKeys<Map> as undefined extends Map[Key]
         ? never
-        : null extends Fields[Key]
-          ? never
-          : IfCo<Fields[Key], Key>]: Fields[Key];
-} & { [Key in CoKeys<Fields> as IfCo<Fields[Key], Key>]?: Fields[Key] };
+        : IfCo<Map[Key], Key>]: Map[Key];
+} & { [Key in CoKeys<Map> as IfCo<Map[Key], Key>]?: Map[Key] };
 
 function tryInit(map: CoMap) {
     if (
         map[InitValues] &&
         (map._schema[ItemsSym] ||
             Object.keys(map[InitValues].init).every(
-                (key) => (map._schema as any)[key]
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (key) => (map._schema as any)[key],
             ))
     ) {
         const raw = map.rawFromInit(
             map[InitValues].init,
-            map[InitValues].owner
+            map[InitValues].owner,
         );
         Object.defineProperties(map, {
             id: {
@@ -354,7 +360,7 @@ const CoMapProxyHandler: ProxyHandler<CoMap> = {
                         : new Ref(
                               raw as unknown as ID<CoValue>,
                               target._loadedAs,
-                              descriptor
+                              descriptor,
                           ).accessFrom(receiver, key);
                 }
             } else {

package/src/coValues/coStream.ts

@@ -15,7 +15,6 @@ import type {
     SchemaFor,
     Group,
     ID,
-    Me,
     IfCo,
     ClassOf,
     UnCo,
@@ -46,6 +45,7 @@ export type SingleCoStreamEntry<Item> = {
 };
 
 /** @category CoValues */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class CoStream<Item = any>
     extends CoValueBase
     implements CoValue<"CoStream", RawCoStream>
@@ -65,6 +65,7 @@ export class CoStream<Item = any>
 
     /** @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>;
@@ -81,15 +82,16 @@ export class CoStream<Item = any>
         [key: SessionID]: CoStreamEntry<Item>;
     };
     get inCurrentSession(): CoStreamEntry<Item> | undefined {
-        return this.perSession[this._loadedAs.sessionID];
+        return this.perSession[this._loadedAs.sessionID!];
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [InitValues]?: any;
 
     constructor(
         options:
             | { init: Item[]; owner: Account | Group }
-            | { fromRaw: RawCoStream }
+            | { fromRaw: RawCoStream },
     ) {
         super();
 
@@ -114,7 +116,7 @@ export class CoStream<Item = any>
     static create<S extends CoStream>(
         this: ClassOf<S>,
         init: S extends CoStream<infer Item> ? UnCo<Item>[] : never,
-        options: { owner: Account | Group }
+        options: { owner: Account | Group },
     ) {
         return new this({ init, owner: options.owner });
     }
@@ -153,13 +155,13 @@ export class CoStream<Item = any>
                 Object.entries(this).map(([account, entry]) => [
                     account,
                     mapper(entry.value),
-                ])
+                ]),
             ),
             in: Object.fromEntries(
                 Object.entries(this.perSession).map(([session, entry]) => [
                     session,
                     mapper(entry.value),
-                ])
+                ]),
             ),
         };
     }
@@ -169,8 +171,9 @@ export class CoStream<Item = any>
     }
 
     static schema<V extends CoStream>(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this: { new (...args: any): V } & typeof CoStream,
-        def: { [ItemsSym]: V["_schema"][ItemsSym] }
+        def: { [ItemsSym]: V["_schema"][ItemsSym] },
     ) {
         this._schema ||= {};
         Object.assign(this._schema, def);
@@ -185,9 +188,9 @@ function entryFromRawEntry<Item>(
         at: Date;
         value: JsonValue;
     },
-    loadedAs: Account & Me,
+    loadedAs: Account,
     accountID: ID<Account> | undefined,
-    itemField: Schema
+    itemField: Schema,
 ): Omit<CoStreamEntry<Item>, "all"> {
     return {
         get value(): NonNullable<Item> extends CoValue
@@ -201,7 +204,11 @@ function entryFromRawEntry<Item>(
                 return decodeSync(itemField.encoded)(rawEntry.value);
             } else if (isRefEncoded(itemField)) {
                 return this.ref?.accessFrom(
-                    accessFrom, rawEntry.by + rawEntry.tx.sessionID + rawEntry.tx.txIndex + ".value"
+                    accessFrom,
+                    rawEntry.by +
+                        rawEntry.tx.sessionID +
+                        rawEntry.tx.txIndex +
+                        ".value",
                 ) as NonNullable<Item> extends CoValue
                     ? (CoValue & Item) | null
                     : Item;
@@ -217,7 +224,7 @@ function entryFromRawEntry<Item>(
                 return new Ref(
                     rawId as unknown as ID<CoValue>,
                     loadedAs,
-                    itemField
+                    itemField,
                 ) as NonNullable<Item> extends CoValue
                     ? Ref<NonNullable<Item>>
                     : never;
@@ -231,8 +238,14 @@ function entryFromRawEntry<Item>(
                 new Ref<Account>(
                     accountID as unknown as ID<Account>,
                     loadedAs,
-                    Account
-                )?.accessFrom(accessFrom, rawEntry.by + rawEntry.tx.sessionID + rawEntry.tx.txIndex + ".by")
+                    Account,
+                )?.accessFrom(
+                    accessFrom,
+                    rawEntry.by +
+                        rawEntry.tx.sessionID +
+                        rawEntry.tx.txIndex +
+                        ".by",
+                )
             );
         },
         madeAt: rawEntry.at,
@@ -272,7 +285,7 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
                 rawEntry,
                 target._loadedAs,
                 key as unknown as ID<Account>,
-                target._schema[ItemsSym]
+                target._schema[ItemsSym],
             );
 
             Object.defineProperty(entry, "all", {
@@ -287,9 +300,10 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
                                 rawEntry.value,
                                 target._loadedAs,
                                 key as unknown as ID<Account>,
-                                target._schema[ItemsSym]
+                                target._schema[ItemsSym],
                             );
                         }
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
                 },
             });
@@ -298,7 +312,7 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
         } else if (key === "perSession") {
             return new Proxy(
                 {},
-                CoStreamPerSessionProxyHandler(target, receiver)
+                CoStreamPerSessionProxyHandler(target, receiver),
             );
         } else {
             return Reflect.get(target, key, receiver);
@@ -359,7 +373,7 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
 
 const CoStreamPerSessionProxyHandler = (
     innerTarget: CoStream,
-    accessFrom: CoStream
+    accessFrom: CoStream,
 ): ProxyHandler<Record<string, never>> => ({
     get(_target, key, receiver) {
         if (typeof key === "string" && key.includes("session")) {
@@ -376,7 +390,7 @@ const CoStreamPerSessionProxyHandler = (
                 cojsonInternals.isAccountID(by)
                     ? (by as unknown as ID<Account>)
                     : undefined,
-                innerTarget._schema[ItemsSym]
+                innerTarget._schema[ItemsSym],
             );
 
             Object.defineProperty(entry, "all", {
@@ -393,9 +407,10 @@ const CoStreamPerSessionProxyHandler = (
                                 cojsonInternals.isAccountID(by)
                                     ? (by as unknown as ID<Account>)
                                     : undefined,
-                                innerTarget._schema[ItemsSym]
+                                innerTarget._schema[ItemsSym],
                             );
                         }
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
                 },
             });
@@ -437,7 +452,7 @@ export class BinaryCoStream
               }
             | {
                   fromRaw: RawBinaryCoStream;
-              }
+              },
     ) {
         super();
 
@@ -455,13 +470,14 @@ export class BinaryCoStream
                 value: raw.id,
                 enumerable: false,
             },
+            _type: { value: "BinaryCoStream", enumerable: false },
             _raw: { value: raw, enumerable: false },
         });
     }
 
     static create<S extends BinaryCoStream>(
         this: ClassOf<S>,
-        options: { owner: Account | Group }
+        options: { owner: Account | Group },
     ) {
         return new this(options);
     }
@@ -500,19 +516,15 @@ export class BinaryCoStream
 
     static async loadAsBlob(
         id: ID<BinaryCoStream>,
-        options: {
-            as: Account & Me;
+        as: Account,
+        options?: {
             allowUnfinished?: boolean;
-            onProgress?: (progress: number) => void;
-        }
+        },
     ): Promise<Blob | undefined> {
-        const stream = await this.load(id, {
-            as: options.as,
-            onProgress: options.onProgress,
-        });
+        const stream = await this.load(id, as, []);
 
         return stream?.toBlob({
-            allowUnfinished: options.allowUnfinished,
+            allowUnfinished: options?.allowUnfinished,
         });
     }
 
@@ -521,7 +533,7 @@ export class BinaryCoStream
         options: {
             owner: Group | Account;
             onProgress?: (progress: number) => void;
-        }
+        },
     ): Promise<BinaryCoStream> {
         const stream = this.create({ owner: options.owner });
 
@@ -554,7 +566,7 @@ export class BinaryCoStream
             "Finished creating binary stream in",
             (end - start) / 1000,
             "s - Throughput in MB/s",
-            (1000 * (blob.size / (end - start))) / (1024 * 1024)
+            (1000 * (blob.size / (end - start))) / (1024 * 1024),
         );
         options.onProgress?.(1);