cojson 0.2.1 → 0.2.3

package/src/coValue.ts

@@ -1,17 +1,32 @@
 import { JsonObject, JsonValue } from "./jsonValue.js";
 import { RawCoID } from "./ids.js";
 import { CoMap } from "./coValues/coMap.js";
-import { BinaryCoStream, BinaryCoStreamMeta, CoStream } from "./coValues/coStream.js";
+import {
+    BinaryCoStream,
+    BinaryCoStreamMeta,
+    CoStream,
+} from "./coValues/coStream.js";
 import { Static } from "./coValues/static.js";
 import { CoList } from "./coValues/coList.js";
 import { CoValueCore } from "./coValueCore.js";
 import { Group } from "./group.js";
 
-export type CoID<T extends CoValueImpl> = RawCoID & {
+export type CoID<T extends CoValue> = RawCoID & {
     readonly __type: T;
 };
 
-export interface ReadableCoValue extends CoValue {
+export interface CoValue {
+    /** The `CoValue`'s (precisely typed) `CoID` */
+    id: CoID<this>;
+    core: CoValueCore;
+    /** Specifies which kind of `CoValue` this is */
+    type: string;
+    /** The `CoValue`'s (precisely typed) static metadata */
+    meta: JsonObject | null;
+    /** The `Group` this `CoValue` belongs to (determining permissions) */
+    group: Group;
+    /** Returns an immutable JSON presentation of this `CoValue` */
+    toJSON(): JsonValue;
     /** Lets you subscribe to future updates to this CoValue (whether made locally or by other users).
      *
      * Takes a listener function that will be called with the current state for each update.
@@ -19,42 +34,37 @@ export interface ReadableCoValue extends CoValue {
      * Returns an unsubscribe function.
      *
      * Used internally by `useTelepathicData()` for reactive updates on changes to a `CoValue`. */
-    subscribe(listener: (coValue: CoValueImpl) => void): () => void;
+    subscribe(listener: (coValue: this) => void): () => void;
     /** Lets you apply edits to a `CoValue`, inside the changer callback, which receives a `WriteableCoValue`.
      *
      *  A `WritableCoValue` has all the same methods as a `CoValue`, but all edits made to it (with its additional mutator methods)
      *  are reflected in it immediately - so it behaves mutably, whereas a `CoValue` is always immutable
      *  (you need to use `subscribe` to receive new versions of it). */
-    edit?:
-        | ((changer: (editable: WriteableCoValue) => void) => CoValueImpl)
-        | undefined;
+    edit?: ((changer: (editable: CoValue) => void) => this) | undefined;
 }
 
-export interface CoValue {
-    /** The `CoValue`'s (precisely typed) `CoID` */
-    id: CoID<CoValueImpl>;
-    core: CoValueCore;
-    /** Specifies which kind of `CoValue` this is */
-    type: CoValueImpl["type"];
-    /** The `CoValue`'s (precisely typed) static metadata */
-    meta: JsonObject | null;
-    /** The `Group` this `CoValue` belongs to (determining permissions) */
-    group: Group;
-    /** Returns an immutable JSON presentation of this `CoValue` */
-    toJSON(): JsonValue;
-}
+export type AnyCoMap = CoMap<
+    { [key: string]: JsonValue | CoValue | undefined },
+    JsonObject | null
+>;
 
-export interface WriteableCoValue extends CoValue {}
+export type AnyCoList = CoList<JsonValue | CoValue, JsonObject | null>;
 
-export type CoValueImpl =
-    | CoMap<{ [key: string]: JsonValue | undefined; }, JsonObject | null>
-    | CoList<JsonValue, JsonObject | null>
-    | CoStream<JsonValue, JsonObject | null>
-    | BinaryCoStream<BinaryCoStreamMeta>
-    | Static<JsonObject>;
+export type AnyCoStream = CoStream<JsonValue | CoValue, JsonObject | null>;
+
+export type AnyBinaryCoStream = BinaryCoStream<BinaryCoStreamMeta>;
+
+export type AnyStatic = Static<JsonObject>;
+
+export type AnyCoValue =
+    | AnyCoMap
+    | AnyCoList
+    | AnyCoStream
+    | AnyBinaryCoStream
+    | AnyStatic;
 
 export function expectMap(
-    content: CoValueImpl
+    content: CoValue
 ): CoMap<{ [key: string]: string }, JsonObject | null> {
     if (content.type !== "comap") {
         throw new Error("Expected map");
@@ -62,3 +72,19 @@ export function expectMap(
 
     return content as CoMap<{ [key: string]: string }, JsonObject | null>;
 }
+
+export function isCoValueImpl(
+    value: JsonValue | AnyCoValue | undefined
+): value is AnyCoValue {
+    return (
+        value instanceof CoMap ||
+        value instanceof CoList ||
+        value instanceof CoStream ||
+        value instanceof BinaryCoStream ||
+        value instanceof Static
+    );
+}
+
+export function isCoValue(value: JsonValue | CoValue | undefined) : value is CoValue {
+    return isCoValueImpl(value as AnyCoValue);
+}

package/src/coValueCore.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from "@noble/hashes/utils";
-import { CoValueImpl } from "./coValue.js";
+import { AnyCoValue } from "./coValue.js";
 import { Static } from "./coValues/static.js";
 import { BinaryCoStream, CoStream } from "./coValues/coStream.js";
 import { CoMap } from "./coValues/coMap.js";
@@ -38,7 +38,7 @@ import { Stringified, stableStringify } from "./jsonStringify.js";
 export const MAX_RECOMMENDED_TX_SIZE = 100 * 1024;
 
 export type CoValueHeader = {
-    type: CoValueImpl["type"];
+    type: AnyCoValue["type"];
     ruleset: RulesetDef;
     meta: JsonObject | null;
     createdAt: `2${string}` | null;
@@ -99,8 +99,8 @@ export class CoValueCore {
     node: LocalNode;
     header: CoValueHeader;
     _sessions: { [key: SessionID]: SessionLog };
-    _cachedContent?: CoValueImpl;
-    listeners: Set<(content?: CoValueImpl) => void> = new Set();
+    _cachedContent?: AnyCoValue;
+    listeners: Set<(content?: AnyCoValue) => void> = new Set();
     _decryptionCache: {
         [key: Encrypted<JsonValue[], JsonValue>]:
             | Stringified<JsonValue[]>
@@ -376,7 +376,7 @@ export class CoValueCore {
         }
     }
 
-    subscribe(listener: (content?: CoValueImpl) => void): () => void {
+    subscribe(listener: (content?: AnyCoValue) => void): () => void {
         this.listeners.add(listener);
         listener(this.getCurrentContent());
 
@@ -493,7 +493,7 @@ export class CoValueCore {
         return success;
     }
 
-    getCurrentContent(): CoValueImpl {
+    getCurrentContent(): AnyCoValue {
         if (this._cachedContent) {
             return this._cachedContent;
         }

package/src/coValues/coList.ts

@@ -1,5 +1,5 @@
 import { JsonObject, JsonValue } from "../jsonValue.js";
-import { CoID, ReadableCoValue, WriteableCoValue } from "../coValue.js";
+import { CoID, CoValue, isCoValue } from "../coValue.js";
 import { CoValueCore, accountOrAgentIDfromSessionID } from "../coValueCore.js";
 import { SessionID, TransactionID } from "../ids.js";
 import { Group } from "../group.js";
@@ -8,15 +8,15 @@ import { parseJSON } from "../jsonStringify.js";
 
 type OpID = TransactionID & { changeIdx: number };
 
-type InsertionOpPayload<T extends JsonValue> =
+type InsertionOpPayload<T extends JsonValue | CoValue> =
     | {
           op: "pre";
-          value: T;
+          value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
           before: OpID | "end";
       }
     | {
           op: "app";
-          value: T;
+          value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
           after: OpID | "start";
       };
 
@@ -25,11 +25,11 @@ type DeletionOpPayload = {
     insertion: OpID;
 };
 
-export type ListOpPayload<T extends JsonValue> =
+export type ListOpPayload<T extends JsonValue | CoValue> =
     | InsertionOpPayload<T>
     | DeletionOpPayload;
 
-type InsertionEntry<T extends JsonValue> = {
+type InsertionEntry<T extends JsonValue | CoValue> = {
     madeAt: number;
     predecessors: OpID[];
     successors: OpID[];
@@ -40,10 +40,12 @@ type DeletionEntry = {
     deletionID: OpID;
 } & DeletionOpPayload;
 
-export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
-    implements ReadableCoValue
+export class CoList<
+    T extends JsonValue | CoValue,
+    Meta extends JsonObject | null = null
+> implements CoValue
 {
-    id: CoID<CoList<T, Meta>>;
+    id: CoID<this>;
     type = "colist" as const;
     core: CoValueCore;
     /** @internal */
@@ -69,7 +71,7 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
 
     /** @internal */
     constructor(core: CoValueCore) {
-        this.id = core.id as CoID<CoList<T, Meta>>;
+        this.id = core.id as CoID<this>;
         this.core = core;
         this.afterStart = [];
         this.beforeEnd = [];
@@ -99,7 +101,9 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
             changes,
             madeAt,
         } of this.core.getValidSortedTransactions()) {
-            for (const [changeIdx, changeUntyped] of parseJSON(changes).entries()) {
+            for (const [changeIdx, changeUntyped] of parseJSON(
+                changes
+            ).entries()) {
                 const change = changeUntyped as ListOpPayload<T>;
 
                 if (change.op === "pre" || change.op === "app") {
@@ -201,7 +205,9 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
     }
 
     /** Get the item currently at `idx`. */
-    get(idx: number): T | undefined {
+    get(
+        idx: number
+    ): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>) | undefined {
         const entry = this.entries()[idx];
         if (!entry) {
             return undefined;
@@ -210,12 +216,20 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
     }
 
     /** Returns the current items in the CoList as an array. */
-    asArray(): T[] {
+    asArray(): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[] {
         return this.entries().map((entry) => entry.value);
     }
 
-    entries(): { value: T; madeAt: number; opID: OpID }[] {
-        const arr: { value: T; madeAt: number; opID: OpID }[] = [];
+    entries(): {
+        value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+        madeAt: number;
+        opID: OpID;
+    }[] {
+        const arr: {
+            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+            madeAt: number;
+            opID: OpID;
+        }[] = [];
         for (const opID of this.afterStart) {
             this.fillArrayFromOpID(opID, arr);
         }
@@ -228,7 +242,11 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
     /** @internal */
     private fillArrayFromOpID(
         opID: OpID,
-        arr: { value: T; madeAt: number; opID: OpID }[]
+        arr: {
+            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+            madeAt: number;
+            opID: OpID;
+        }[]
     ) {
         const entry =
             this.insertions[opID.sessionID]?.[opID.txIndex]?.[opID.changeIdx];
@@ -269,23 +287,42 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
     }
 
     /** Returns the current items in the CoList as an array. (alias of `asArray`) */
-    toJSON(): T[] {
+    toJSON(): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[] {
         return this.asArray();
     }
 
-    map<U>(mapper: (value: T, idx: number) => U): U[] {
+    map<U>(
+        mapper: (
+            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
+            idx: number
+        ) => U
+    ): U[] {
         return this.entries().map((entry, idx) => mapper(entry.value, idx));
     }
 
-    filter<U extends T>(predicate: (value: T, idx: number) => value is U): U[];
-    filter(predicate: (value: T, idx: number) => boolean): T[] {
+    filter<U extends T extends CoValue ? CoID<T> : Exclude<T, CoValue>>(
+        predicate: (
+            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
+            idx: number
+        ) => value is U
+    ): U[];
+    filter(
+        predicate: (
+            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
+            idx: number
+        ) => boolean
+    ): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[] {
         return this.entries()
             .filter((entry, idx) => predicate(entry.value, idx))
             .map((entry) => entry.value);
     }
 
     reduce<U>(
-        reducer: (accumulator: U, value: T, idx: number) => U,
+        reducer: (
+            accumulator: U,
+            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
+            idx: number
+        ) => U,
         initialValue: U
     ): U {
         return this.entries().reduce(
@@ -294,32 +331,28 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
         );
     }
 
-    subscribe(listener: (coMap: CoList<T, Meta>) => void): () => void {
+    subscribe(listener: (coList: this) => void): () => void {
         return this.core.subscribe((content) => {
-            listener(content as CoList<T, Meta>);
+            listener(content as this);
         });
     }
 
-    edit(
-        changer: (editable: WriteableCoList<T, Meta>) => void
-    ): CoList<T, Meta> {
+    edit(changer: (editable: WriteableCoList<T, Meta>) => void): this {
         const editable = new WriteableCoList<T, Meta>(this.core);
         changer(editable);
-        return new CoList(this.core);
+        return new CoList(this.core) as this;
     }
 }
 
 export class WriteableCoList<
-        T extends JsonValue,
+        T extends JsonValue | CoValue,
         Meta extends JsonObject | null = null
     >
     extends CoList<T, Meta>
-    implements WriteableCoValue
+    implements CoValue
 {
     /** @internal */
-    edit(
-        _changer: (editable: WriteableCoList<T, Meta>) => void
-    ): CoList<T, Meta> {
+    edit(_changer: (editable: WriteableCoList<T, Meta>) => void): this {
         throw new Error("Already editing.");
     }
 
@@ -330,7 +363,7 @@ export class WriteableCoList<
      * If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
     append(
         after: number,
-        value: T,
+        value: T extends CoValue ? T | CoID<T> : T,
         privacy: "private" | "trusting" = "private"
     ): void {
         const entries = this.entries();
@@ -351,7 +384,7 @@ export class WriteableCoList<
             [
                 {
                     op: "app",
-                    value,
+                    value: isCoValue(value) ? value.id : value,
                     after: opIDBefore,
                 },
             ],
@@ -366,7 +399,10 @@ export class WriteableCoList<
      * If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
      *
      * If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
-    push(value: T, privacy: "private" | "trusting" = "private"): void {
+    push(
+        value: T extends CoValue ? T | CoID<T> : T,
+        privacy: "private" | "trusting" = "private"
+    ): void {
         // TODO: optimize
         const entries = this.entries();
         this.append(
@@ -385,7 +421,7 @@ export class WriteableCoList<
      */
     prepend(
         before: number,
-        value: T,
+        value: T extends CoValue ? T | CoID<T> : T,
         privacy: "private" | "trusting" = "private"
     ): void {
         const entries = this.entries();
@@ -410,7 +446,7 @@ export class WriteableCoList<
             [
                 {
                     op: "pre",
-                    value,
+                    value: isCoValue(value) ? value.id : value,
                     before: opIDAfter,
                 },
             ],