cojson 0.2.2 → 0.2.3

package/src/coValues/coMap.ts

@@ -1,48 +1,49 @@
-import { JsonObject, JsonValue } from '../jsonValue.js';
-import { TransactionID } from '../ids.js';
-import { CoID, ReadableCoValue, WriteableCoValue } from '../coValue.js';
-import { CoValueCore, accountOrAgentIDfromSessionID } from '../coValueCore.js';
-import { AccountID, isAccountID } from '../account.js';
-import { Group } from '../group.js';
-import { parseJSON } from '../jsonStringify.js';
-
-type MapOp<K extends string, V extends JsonValue | undefined> = {
+import { JsonObject, JsonValue } from "../jsonValue.js";
+import { TransactionID } from "../ids.js";
+import { CoID, CoValue, isCoValue } from "../coValue.js";
+import { CoValueCore, accountOrAgentIDfromSessionID } from "../coValueCore.js";
+import { AccountID, isAccountID } from "../account.js";
+import { Group } from "../group.js";
+import { parseJSON } from "../jsonStringify.js";
+
+type MapOp<K extends string, V extends JsonValue | CoValue | undefined> = {
     txID: TransactionID;
     madeAt: number;
     changeIdx: number;
 } & MapOpPayload<K, V>;
 // TODO: add after TransactionID[] for conflicts/ordering
 
-export type MapOpPayload<K extends string, V extends JsonValue | undefined> = {
-    op: "set";
-    key: K;
-    value: V;
-} |
-{
-    op: "del";
-    key: K;
-};
-
-export type MapK<M extends { [key: string]: JsonValue | undefined; }> = keyof M & string;
-export type MapV<M extends { [key: string]: JsonValue | undefined; }> = M[MapK<M>];
-
+export type MapOpPayload<
+    K extends string,
+    V extends JsonValue | CoValue | undefined
+> =
+    | {
+          op: "set";
+          key: K;
+          value: V extends CoValue ? CoID<V> : Exclude<V, CoValue>;
+      }
+    | {
+          op: "del";
+          key: K;
+      };
 
 /** A collaborative map with precise shape `M` and optional static metadata `Meta` */
 export class CoMap<
-    M extends { [key: string]: JsonValue | undefined; },
-    Meta extends JsonObject | null = null,
-> implements ReadableCoValue {
-    id: CoID<CoMap<M, Meta>>;
+    M extends { [key: string]: JsonValue | CoValue | undefined },
+    Meta extends JsonObject | null = null
+> implements CoValue
+{
+    id: CoID<this>;
     type = "comap" as const;
     core: CoValueCore;
     /** @internal */
     ops: {
-        [KK in MapK<M>]?: MapOp<KK, M[KK]>[];
+        [Key in keyof M & string]?: MapOp<Key, M[Key]>[];
     };
 
     /** @internal */
     constructor(core: CoValueCore) {
-        this.id = core.id as CoID<CoMap<M, Meta>>;
+        this.id = core.id as CoID<this>;
         this.core = core;
         this.ops = {};
 
@@ -61,11 +62,18 @@ export class CoMap<
     protected fillOpsFromCoValue() {
         this.ops = {};
 
-        for (const { txID, changes, madeAt } of this.core.getValidSortedTransactions()) {
-            for (const [changeIdx, changeUntyped] of (
-                parseJSON(changes)
+        for (const {
+            txID,
+            changes,
+            madeAt,
+        } of this.core.getValidSortedTransactions()) {
+            for (const [changeIdx, changeUntyped] of parseJSON(
+                changes
             ).entries()) {
-                const change = changeUntyped as MapOpPayload<MapK<M>, MapV<M>>;
+                const change = changeUntyped as MapOpPayload<
+                    keyof M & string,
+                    M[keyof M & string]
+                >;
                 let entries = this.ops[change.key];
                 if (!entries) {
                     entries = [];
@@ -75,18 +83,25 @@ export class CoMap<
                     txID,
                     madeAt,
                     changeIdx,
-                    ...(change as MapOpPayload<MapK<M>, MapV<M>>),
+                    ...(change as MapOpPayload<
+                        keyof M & string,
+                        M[keyof M & string]
+                    >),
                 });
             }
         }
     }
 
-    keys(): MapK<M>[] {
-        return Object.keys(this.ops) as MapK<M>[];
+    keys(): (keyof M & string)[] {
+        return Object.keys(this.ops) as (keyof M & string)[];
     }
 
     /** Returns the current value for the given key. */
-    get<K extends MapK<M>>(key: K): M[K] | undefined {
+    get<K extends keyof M & string>(
+        key: K
+    ):
+        | (M[K] extends CoValue ? CoID<M[K]> : Exclude<M[K], CoValue>)
+        | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -101,7 +116,12 @@ export class CoMap<
         }
     }
 
-    getAtTime<K extends MapK<M>>(key: K, time: number): M[K] | undefined {
+    getAtTime<K extends keyof M & string>(
+        key: K,
+        time: number
+    ):
+        | (M[K] extends CoValue ? CoID<M[K]> : Exclude<M[K], CoValue>)
+        | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -121,8 +141,8 @@ export class CoMap<
     }
 
     /** Returns the accountID of the last account to modify the value for the given key. */
-    whoEdited<K extends MapK<M>>(key: K): AccountID | undefined {
-        const tx  = this.getLastTxID(key);
+    whoEdited<K extends keyof M & string>(key: K): AccountID | undefined {
+        const tx = this.getLastTxID(key);
         if (!tx) {
             return undefined;
         }
@@ -134,7 +154,7 @@ export class CoMap<
         }
     }
 
-    getLastTxID<K extends MapK<M>>(key: K): TransactionID | undefined {
+    getLastTxID<K extends keyof M & string>(key: K): TransactionID | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -145,7 +165,15 @@ export class CoMap<
         return lastEntry.txID;
     }
 
-    getLastEntry<K extends MapK<M>>(key: K): { at: number; txID: TransactionID; value: M[K]; } | undefined {
+    getLastEntry<K extends keyof M & string>(
+        key: K
+    ):
+        | {
+              at: number;
+              txID: TransactionID;
+              value: M[K] extends CoValue ? CoID<M[K]> : Exclude<M[K], CoValue>;
+          }
+        | undefined {
         const ops = this.ops[key];
         if (!ops) {
             return undefined;
@@ -156,21 +184,43 @@ export class CoMap<
         if (lastEntry.op === "del") {
             return undefined;
         } else {
-            return { at: lastEntry.madeAt, txID: lastEntry.txID, value: lastEntry.value };
+            return {
+                at: lastEntry.madeAt,
+                txID: lastEntry.txID,
+                value: lastEntry.value,
+            };
         }
     }
 
-    getHistory<K extends MapK<M>>(key: K): { at: number; txID: TransactionID; value: M[K] | undefined; }[] {
+    getHistory<K extends keyof M & string>(
+        key: K
+    ): {
+        at: number;
+        txID: TransactionID;
+        value:
+            | (M[K] extends CoValue ? CoID<M[K]> : Exclude<M[K], CoValue>)
+            | undefined;
+    }[] {
         const ops = this.ops[key];
         if (!ops) {
             return [];
         }
 
-        const history: { at: number; txID: TransactionID; value: M[K] | undefined; }[] = [];
+        const history: {
+            at: number;
+            txID: TransactionID;
+            value:
+                | (M[K] extends CoValue ? CoID<M[K]> : Exclude<M[K], CoValue>)
+                | undefined;
+        }[] = [];
 
         for (const op of ops) {
             if (op.op === "del") {
-                history.push({ at: op.madeAt, txID: op.txID, value: undefined });
+                history.push({
+                    at: op.madeAt,
+                    txID: op.txID,
+                    value: undefined,
+                });
             } else {
                 history.push({ at: op.madeAt, txID: op.txID, value: op.value });
             }
@@ -192,25 +242,28 @@ export class CoMap<
         return json;
     }
 
-    subscribe(listener: (coMap: CoMap<M, Meta>) => void): () => void {
+    subscribe(listener: (coMap: this) => void): () => void {
         return this.core.subscribe((content) => {
-            listener(content as CoMap<M, Meta>);
+            listener(content as this);
         });
     }
 
-    edit(changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta> {
+    edit(changer: (editable: WriteableCoMap<M, Meta>) => void): this {
         const editable = new WriteableCoMap<M, Meta>(this.core);
         changer(editable);
-        return new CoMap(this.core);
+        return new CoMap(this.core) as this;
     }
 }
 
 export class WriteableCoMap<
-    M extends { [key: string]: JsonValue | undefined; },
-    Meta extends JsonObject | null = null,
-> extends CoMap<M, Meta> implements WriteableCoValue {
+        M extends { [key: string]: JsonValue | CoValue | undefined },
+        Meta extends JsonObject | null = null
+    >
+    extends CoMap<M, Meta>
+    implements CoValue
+{
     /** @internal */
-    edit(_changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta> {
+    edit(_changer: (editable: WriteableCoMap<M, Meta>) => void): this {
         throw new Error("Already editing.");
     }
 
@@ -219,14 +272,21 @@ export class WriteableCoMap<
      * If `privacy` is `"private"` **(default)**, both `key` and `value` are encrypted in the transaction, only readable by other members of the group this `CoMap` belongs to. Not even sync servers can see the content in plaintext.
      *
      * If `privacy` is `"trusting"`, both `key` and `value` are stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
-    set<K extends MapK<M>>(key: K, value: M[K], privacy: "private" | "trusting" = "private"): void {
-        this.core.makeTransaction([
-            {
-                op: "set",
-                key,
-                value,
-            },
-        ], privacy);
+    set<K extends keyof M & string>(
+        key: K,
+        value: M[K] extends CoValue ? M[K] | CoID<M[K]> : M[K],
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        this.core.makeTransaction(
+            [
+                {
+                    op: "set",
+                    key,
+                    value: isCoValue(value) ? value.id : value,
+                },
+            ],
+            privacy
+        );
 
         this.fillOpsFromCoValue();
     }
@@ -236,13 +296,19 @@ export class WriteableCoMap<
      * If `privacy` is `"private"` **(default)**, `key` is encrypted in the transaction, only readable by other members of the group this `CoMap` belongs to. Not even sync servers can see the content in plaintext.
      *
      * If `privacy` is `"trusting"`, `key` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
-    delete(key: MapK<M>, privacy: "private" | "trusting" = "private"): void {
-        this.core.makeTransaction([
-            {
-                op: "del",
-                key,
-            },
-        ], privacy);
+    delete(
+        key: keyof M & string,
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        this.core.makeTransaction(
+            [
+                {
+                    op: "del",
+                    key,
+                },
+            ],
+            privacy
+        );
 
         this.fillOpsFromCoValue();
     }

package/src/coValues/coStream.ts

@@ -1,14 +1,13 @@
 import { JsonObject, JsonValue } from "../jsonValue.js";
-import { CoID, ReadableCoValue, WriteableCoValue } from "../coValue.js";
+import { CoValue, CoID, isCoValue } from "../coValue.js";
 import { CoValueCore, accountOrAgentIDfromSessionID } from "../coValueCore.js";
 import { Group } from "../group.js";
 import { SessionID } from "../ids.js";
 import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
-import { AccountID } from "../index.js";
-import { isAccountID } from "../account.js";
+import { AccountID, isAccountID } from "../account.js";
 import { parseJSON } from "../jsonStringify.js";
 
-export type BinaryChunkInfo = {
+export type BinaryStreamInfo = {
     mimeType: string;
     fileName?: string;
     totalSizeBytes?: number;
@@ -16,7 +15,7 @@ export type BinaryChunkInfo = {
 
 export type BinaryStreamStart = {
     type: "start";
-} & BinaryChunkInfo;
+} & BinaryStreamInfo;
 
 export type BinaryStreamChunk = {
     type: "chunk";
@@ -34,20 +33,25 @@ export type BinaryStreamItem =
     | BinaryStreamChunk
     | BinaryStreamEnd;
 
+export type CoStreamItem<T extends JsonValue | CoValue> = {
+    item: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+    madeAt: number;
+};
+
 export class CoStream<
-    T extends JsonValue,
+    T extends JsonValue | CoValue,
     Meta extends JsonObject | null = null
-> implements ReadableCoValue
+> implements CoValue
 {
-    id: CoID<CoStream<T, Meta>>;
+    id: CoID<this>;
     type = "costream" as const;
     core: CoValueCore;
     items: {
-        [key: SessionID]: {item: T, madeAt: number}[];
+        [key: SessionID]: CoStreamItem<T>[];
     };
 
     constructor(core: CoValueCore) {
-        this.id = core.id as CoID<CoStream<T, Meta>>;
+        this.id = core.id as CoID<this>;
         this.core = core;
         this.items = {};
         this.fillFromCoValue();
@@ -71,18 +75,22 @@ export class CoStream<
             changes,
         } of this.core.getValidSortedTransactions()) {
             for (const changeUntyped of parseJSON(changes)) {
-                const change = changeUntyped as T;
+                const change = changeUntyped as T extends CoValue
+                    ? CoID<T>
+                    : Exclude<T, CoValue>;
                 let entries = this.items[txID.sessionID];
                 if (!entries) {
                     entries = [];
                     this.items[txID.sessionID] = entries;
                 }
-                entries.push({item: change, madeAt});
+                entries.push({ item: change, madeAt });
             }
         }
     }
 
-    getSingleStream(): T[] | undefined {
+    getSingleStream():
+        | (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[]
+        | undefined {
         if (Object.keys(this.items).length === 0) {
             return undefined;
         } else if (Object.keys(this.items).length !== 1) {
@@ -91,36 +99,54 @@ export class CoStream<
             );
         }
 
-        return Object.values(this.items)[0]?.map(item => item.item);
+        return Object.values(this.items)[0]?.map((item) => item.item);
     }
 
-    getLastItemsPerAccount(): {[account: AccountID]: T | undefined} {
-        const result: {[account: AccountID]: {item: T, madeAt: number} | undefined} = {};
+    getLastItemsPerAccount(): {
+        [account: AccountID]:
+            | (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)
+            | undefined;
+    } {
+        const result: { [account: AccountID]: CoStreamItem<T> | undefined } =
+            {};
 
         for (const [sessionID, items] of Object.entries(this.items)) {
-            const account = accountOrAgentIDfromSessionID(sessionID as SessionID);
+            const account = accountOrAgentIDfromSessionID(
+                sessionID as SessionID
+            );
             if (!isAccountID(account)) continue;
             if (items.length > 0) {
                 const lastItemOfSession = items[items.length - 1]!;
-                if (!result[account] || lastItemOfSession.madeAt > result[account]!.madeAt) {
+                if (
+                    !result[account] ||
+                    lastItemOfSession.madeAt > result[account]!.madeAt
+                ) {
                     result[account] = lastItemOfSession;
                 }
             }
         }
 
-        return Object.fromEntries(Object.entries(result).map(([account, item]) =>
-            [account, item?.item]
-        ));
+        return Object.fromEntries(
+            Object.entries(result).map(([account, item]) => [
+                account,
+                item?.item,
+            ])
+        );
     }
 
-    getLastItemFrom(account: AccountID): T | undefined {
-        let lastItem: {item: T, madeAt: number} | undefined;
+    getLastItemFrom(
+        account: AccountID
+    ): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>) | undefined {
+        let lastItem: CoStreamItem<T> | undefined;
 
         for (const [sessionID, items] of Object.entries(this.items)) {
             if (sessionID.startsWith(account)) {
                 if (items.length > 0) {
                     const lastItemOfSession = items[items.length - 1]!;
-                    if (!lastItem || lastItemOfSession.madeAt > lastItem.madeAt) {
+                    if (
+                        !lastItem ||
+                        lastItemOfSession.madeAt > lastItem.madeAt
+                    ) {
                         lastItem = lastItemOfSession;
                     }
                 }
@@ -130,32 +156,35 @@ export class CoStream<
         return lastItem?.item;
     }
 
-    getLastItemFromMe(): T | undefined {
+    getLastItemFromMe():
+        | (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)
+        | undefined {
         const myAccountID = this.core.node.account.id;
         if (!isAccountID(myAccountID)) return undefined;
         return this.getLastItemFrom(myAccountID);
     }
 
     toJSON(): {
-        [key: SessionID]: T[];
+        [key: SessionID]: (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[];
     } {
-        return Object.fromEntries(Object.entries(this.items).map(([sessionID, items]) =>
-            [sessionID, items.map(item => item.item)]
-        ));
+        return Object.fromEntries(
+            Object.entries(this.items).map(([sessionID, items]) => [
+                sessionID,
+                items.map((item) => item.item),
+            ])
+        );
     }
 
-    subscribe(listener: (coMap: CoStream<T, Meta>) => void): () => void {
+    subscribe(listener: (coStream: this) => void): () => void {
         return this.core.subscribe((content) => {
-            listener(content as CoStream<T, Meta>);
+            listener(content as this);
         });
     }
 
-    edit(
-        changer: (editable: WriteableCoStream<T, Meta>) => void
-    ): CoStream<T, Meta> {
+    edit(changer: (editable: WriteableCoStream<T, Meta>) => void): this {
         const editable = new WriteableCoStream<T, Meta>(this.core);
         changer(editable);
-        return new CoStream(this.core);
+        return new CoStream(this.core) as this;
     }
 }
 
@@ -165,12 +194,14 @@ export class BinaryCoStream<
         Meta extends BinaryCoStreamMeta = { type: "binary" }
     >
     extends CoStream<BinaryStreamItem, Meta>
-    implements ReadableCoValue
+    implements CoValue
 {
-    id!: CoID<BinaryCoStream<Meta>>;
+    id!: CoID<this>;
 
-    getBinaryChunks(allowUnfinished?: boolean):
-        | (BinaryChunkInfo & { chunks: Uint8Array[]; finished: boolean })
+    getBinaryChunks(
+        allowUnfinished?: boolean
+    ):
+        | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
         | undefined {
         // const before = performance.now();
         const items = this.getSingleStream();
@@ -226,31 +257,33 @@ export class BinaryCoStream<
         };
     }
 
-    edit(
-        changer: (editable: WriteableBinaryCoStream<Meta>) => void
-    ): BinaryCoStream<Meta> {
+    edit(changer: (editable: WriteableBinaryCoStream<Meta>) => void): this {
         const editable = new WriteableBinaryCoStream<Meta>(this.core);
         changer(editable);
-        return new BinaryCoStream(this.core);
+        return new BinaryCoStream(this.core) as this;
     }
 }
 
 export class WriteableCoStream<
-        T extends JsonValue,
+        T extends JsonValue | CoValue,
         Meta extends JsonObject | null = null
     >
     extends CoStream<T, Meta>
-    implements WriteableCoValue
+    implements CoValue
 {
     /** @internal */
-    edit(
-        _changer: (editable: WriteableCoStream<T, Meta>) => void
-    ): CoStream<T, Meta> {
+    edit(_changer: (editable: WriteableCoStream<T, Meta>) => void): this {
         throw new Error("Already editing.");
     }
 
-    push(item: T, privacy: "private" | "trusting" = "private") {
-        this.core.makeTransaction([item], privacy);
+    push(
+        item: T extends CoValue ? T | CoID<T> : T,
+        privacy: "private" | "trusting" = "private"
+    ) {
+        this.core.makeTransaction(
+            [isCoValue(item) ? item.id : item],
+            privacy
+        );
         this.fillFromCoValue();
     }
 }
@@ -259,12 +292,10 @@ export class WriteableBinaryCoStream<
         Meta extends BinaryCoStreamMeta = { type: "binary" }
     >
     extends BinaryCoStream<Meta>
-    implements WriteableCoValue
+    implements CoValue
 {
     /** @internal */
-    edit(
-        _changer: (editable: WriteableBinaryCoStream<Meta>) => void
-    ): BinaryCoStream<Meta> {
+    edit(_changer: (editable: WriteableBinaryCoStream<Meta>) => void): this {
         throw new Error("Already editing.");
     }
 
@@ -274,7 +305,7 @@ export class WriteableBinaryCoStream<
     }
 
     startBinaryStream(
-        settings: BinaryChunkInfo,
+        settings: BinaryStreamInfo,
         privacy: "private" | "trusting" = "private"
     ) {
         this.push(

package/src/coValues/static.ts

@@ -1,15 +1,15 @@
 import { JsonObject } from '../jsonValue.js';
-import { CoID, ReadableCoValue } from '../coValue.js';
+import { CoID, CoValue } from '../coValue.js';
 import { CoValueCore } from '../coValueCore.js';
 import { Group } from '../index.js';
 
-export class Static<T extends JsonObject> implements ReadableCoValue{
-    id: CoID<Static<T>>;
+export class Static<T extends JsonObject> implements CoValue{
+    id: CoID<this>;
     type = "static" as const;
     core: CoValueCore;
 
     constructor(core: CoValueCore) {
-        this.id = core.id as CoID<Static<T>>;
+        this.id = core.id as CoID<this>;
         this.core = core;
     }
 
@@ -25,7 +25,7 @@ export class Static<T extends JsonObject> implements ReadableCoValue{
         throw new Error("Method not implemented.");
     }
 
-    subscribe(_listener: (coMap: Static<T>) => void): () => void {
+    subscribe(_listener: (st: this) => void): () => void {
         throw new Error("Method not implemented.");
     }
 }