jazz-tools 0.17.14 → 0.18.0

package/src/tools/coValues/coPlainText.ts

@@ -1,20 +1,15 @@
-import {
-  ControlledAccount,
-  type OpID,
-  RawAccount,
-  type RawCoPlainText,
-  stringifyOpID,
-} from "cojson";
+import { type OpID, type RawCoPlainText, stringifyOpID } from "cojson";
 import { calcPatch } from "fast-myers-diff";
 import {
   AnonymousJazzAgent,
   CoValue,
   CoValueClass,
+  CoValueJazzApi,
   ID,
   Resolved,
   SubscribeListenerOptions,
   SubscribeRestArgs,
-  coValueClassFromCoValueClassOrSchema,
+  TypeSym,
   parseCoValueCreateOptions,
 } from "../internal.js";
 import {
@@ -24,37 +19,15 @@ import {
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
-import { coValuesCache } from "../lib/cache.js";
 import { Account } from "./account.js";
-import { Group } from "./group.js";
-import { RegisteredSchemas } from "./registeredSchemas.js";
+import { getCoValueOwner, Group } from "./group.js";
 
 export type TextPos = OpID;
 
 export class CoPlainText extends String implements CoValue {
-  declare id: ID<this>;
-  declare _type: "CoPlainText";
-  declare _raw: RawCoPlainText;
-
-  get _owner(): Account | Group {
-    return this._raw.group instanceof RawAccount
-      ? Account.fromRaw(this._raw.group)
-      : Group.fromRaw(this._raw.group);
-  }
-
-  get _loadedAs() {
-    const agent = this._raw.core.node.getCurrentAgent();
+  declare [TypeSym]: "CoPlainText";
 
-    if (agent instanceof ControlledAccount) {
-      return coValuesCache.get(agent.account, () =>
-        coValueClassFromCoValueClassOrSchema(
-          RegisteredSchemas["Account"],
-        ).fromRaw(agent.account),
-      );
-    }
-
-    return new AnonymousJazzAgent(this._raw.core.node);
-  }
+  declare $jazz: CoTextJazzApi<this>;
 
   /** @internal */
   constructor(
@@ -72,20 +45,24 @@ export class CoPlainText extends String implements CoValue {
       super(options.fromRaw.toString());
       const raw = options.fromRaw;
       Object.defineProperties(this, {
-        id: { value: raw.id, enumerable: false },
-        _type: { value: "CoPlainText", enumerable: false },
-        _raw: { value: raw, enumerable: false },
+        [TypeSym]: { value: "CoPlainText", enumerable: false },
+        $jazz: {
+          value: new CoTextJazzApi(this, raw),
+          enumerable: false,
+        },
       });
       return;
     }
 
     if ("text" in options && "owner" in options) {
       super(options.text);
-      const raw = options.owner._raw.createPlainText(options.text);
+      const raw = options.owner.$jazz.raw.createPlainText(options.text);
       Object.defineProperties(this, {
-        id: { value: raw.id, enumerable: false },
-        _type: { value: "CoPlainText", enumerable: false },
-        _raw: { value: raw, enumerable: false },
+        [TypeSym]: { value: "CoPlainText", enumerable: false },
+        $jazz: {
+          value: new CoTextJazzApi(this, raw),
+          enumerable: false,
+        },
       });
       return;
     }
@@ -106,6 +83,7 @@ export class CoPlainText extends String implements CoValue {
    * ```
    *
    * @category Creation
+   * @deprecated Use `co.plainText(...).create` instead.
    */
   static create<T extends CoPlainText>(
     this: CoValueClass<T>,
@@ -117,19 +95,19 @@ export class CoPlainText extends String implements CoValue {
   }
 
   get length() {
-    return this._raw.toString().length;
+    return this.$jazz.raw.toString().length;
   }
 
   toString() {
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
   }
 
   valueOf() {
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
   }
 
   toJSON(): string {
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
   }
 
   [inspect]() {
@@ -137,33 +115,34 @@ export class CoPlainText extends String implements CoValue {
   }
 
   insertBefore(idx: number, text: string) {
-    this._raw.insertBefore(idx, text);
+    this.$jazz.raw.insertBefore(idx, text);
   }
 
   insertAfter(idx: number, text: string) {
-    this._raw.insertAfter(idx, text);
+    this.$jazz.raw.insertAfter(idx, text);
   }
 
   deleteRange(range: { from: number; to: number }) {
-    this._raw.deleteRange(range);
+    this.$jazz.raw.deleteRange(range);
   }
 
   posBefore(idx: number): TextPos | undefined {
-    return this._raw.mapping.opIDbeforeIdx[idx];
+    return this.$jazz.raw.mapping.opIDbeforeIdx[idx];
   }
 
   posAfter(idx: number): TextPos | undefined {
-    return this._raw.mapping.opIDafterIdx[idx];
+    return this.$jazz.raw.mapping.opIDafterIdx[idx];
   }
 
   idxBefore(pos: TextPos): number | undefined {
-    return this._raw.mapping.idxBeforeOpID[stringifyOpID(pos)];
+    return this.$jazz.raw.mapping.idxBeforeOpID[stringifyOpID(pos)];
   }
 
   idxAfter(pos: TextPos): number | undefined {
-    return this._raw.mapping.idxAfterOpID[stringifyOpID(pos)];
+    return this.$jazz.raw.mapping.idxAfterOpID[stringifyOpID(pos)];
   }
 
+  /** @category Internals */
   static fromRaw<V extends CoPlainText>(
     this: CoValueClass<V> & typeof CoPlainText,
     raw: RawCoPlainText,
@@ -171,37 +150,11 @@ export class CoPlainText extends String implements CoValue {
     return new this({ fromRaw: raw });
   }
 
-  /**
-   * Apply text, modifying the text in place. Calculates the diff and applies it to the CoValue.
-   *
-   * @category Mutation
-   */
-  applyDiff(other: string) {
-    const current = this._raw.toString();
-
-    // Split both strings into grapheme arrays for proper comparison
-    const currentGraphemes = this._raw.toGraphemes(current);
-    const otherGraphemes = this._raw.toGraphemes(other);
-
-    // Calculate the diff on grapheme arrays
-    const patches = [...calcPatch(currentGraphemes, otherGraphemes)];
-
-    // Apply patches in reverse order to avoid index shifting issues
-    for (const [from, to, insert] of patches.reverse()) {
-      if (to > from) {
-        this.deleteRange({ from, to });
-      }
-      if (insert.length > 0) {
-        // Join the graphemes back into a string for insertion
-        this.insertBefore(from, this._raw.fromGraphemes(insert));
-      }
-    }
-  }
-
   /**
    * Load a `CoPlainText` with a given ID, as a given account.
    *
    * @category Subscription & Loading
+   * @deprecated Use `co.plainText(...).load` instead.
    */
   static load<T extends CoPlainText>(
     this: CoValueClass<T>,
@@ -211,20 +164,6 @@ export class CoPlainText extends String implements CoValue {
     return loadCoValueWithoutMe(this, id, options);
   }
 
-  //   /**
-  //    * Effectful version of `CoMap.load()`.
-  //    *
-  //    * Needs to be run inside an `AccountCtx` context.
-  //    *
-  //    * @category Subscription & Loading
-  //    */
-  //   static loadEf<T extends CoPlainText>(
-  //     this: CoValueClass<T>,
-  //     id: ID<T>,
-  //   ): Effect.Effect<T, UnavailableError, AccountCtx> {
-  //     return loadCoValueEf(this, id, []);
-  //   }
-
   /**
    * Load and subscribe to a `CoPlainText` with a given ID, as a given account.
    *
@@ -237,6 +176,7 @@ export class CoPlainText extends String implements CoValue {
    * Also see the `useCoState` hook to reactively subscribe to a CoValue in a React component.
    *
    * @category Subscription & Loading
+   * @deprecated Use `co.plainText(...).subscribe` instead.
    */
   static subscribe<T extends CoPlainText>(
     this: CoValueClass<T>,
@@ -258,22 +198,6 @@ export class CoPlainText extends String implements CoValue {
     return subscribeToCoValueWithoutMe<T, true>(this, id, options, listener);
   }
 
-  /**
-   * Given an already loaded `CoPlainText`, subscribe to updates to the `CoPlainText` and ensure that the specified fields are loaded to the specified depth.
-   *
-   * Works like `CoPlainText.subscribe()`, but you don't need to pass the ID or the account to load as again.
-   *
-   * Returns an unsubscribe function that you should call when you no longer need updates.
-   *
-   * @category Subscription & Loading
-   **/
-  subscribe<T extends CoPlainText>(
-    this: T,
-    listener: (value: Resolved<T, true>, unsubscribe: () => void) => void,
-  ): () => void {
-    return subscribeToExistingCoValue(this, {}, listener);
-  }
-
   /**
    * Allow CoPlainText to behave like a primitive string in most contexts (e.g.,
    * string concatenation, template literals, React rendering, etc.) by implementing
@@ -287,9 +211,69 @@ export class CoPlainText extends String implements CoValue {
   [Symbol.toPrimitive](hint: string) {
     if (hint === "number") {
       // Not meaningful for text, but required for completeness
-      return Number(this._raw.toString());
+      return Number(this.$jazz.raw.toString());
     }
     // For 'string' and 'default', return the string representation
-    return this._raw.toString();
+    return this.$jazz.raw.toString();
+  }
+}
+
+export class CoTextJazzApi<T extends CoPlainText> extends CoValueJazzApi<T> {
+  constructor(
+    private coText: T,
+    public raw: RawCoPlainText,
+  ) {
+    super(coText);
+  }
+
+  get id(): ID<T> {
+    return this.raw.id;
+  }
+
+  get owner(): Group {
+    return getCoValueOwner(this.coText);
+  }
+
+  /**
+   * Apply text, modifying the text in place. Calculates the diff and applies it to the CoValue.
+   *
+   * @category Mutation
+   */
+  applyDiff(other: string) {
+    const current = this.raw.toString();
+
+    // Split both strings into grapheme arrays for proper comparison
+    const currentGraphemes = this.raw.toGraphemes(current);
+    const otherGraphemes = this.raw.toGraphemes(other);
+
+    // Calculate the diff on grapheme arrays
+    const patches = [...calcPatch(currentGraphemes, otherGraphemes)];
+
+    // Apply patches in reverse order to avoid index shifting issues
+    for (const [from, to, insert] of patches.reverse()) {
+      if (to > from) {
+        this.coText.deleteRange({ from, to });
+      }
+      if (insert.length > 0) {
+        // Join the graphemes back into a string for insertion
+        this.coText.insertBefore(from, this.raw.fromGraphemes(insert));
+      }
+    }
+  }
+
+  /**
+   * Given an already loaded `CoPlainText`, subscribe to updates to the `CoPlainText` and ensure that the specified fields are loaded to the specified depth.
+   *
+   * Works like `CoPlainText.subscribe()`, but you don't need to pass the ID or the account to load as again.
+   *
+   * Returns an unsubscribe function that you should call when you no longer need updates.
+   *
+   * @category Subscription & Loading
+   **/
+  subscribe<T extends CoPlainText>(
+    this: CoTextJazzApi<T>,
+    listener: (value: Resolved<T, true>, unsubscribe: () => void) => void,
+  ): () => void {
+    return subscribeToExistingCoValue(this.coText, {}, listener);
   }
 }

package/src/tools/coValues/deepLoading.ts

@@ -1,5 +1,5 @@
 import { SessionID } from "cojson";
-import { ItemsSym } from "../internal.js";
+import { ItemsSym, TypeSym } from "../internal.js";
 import { type Account } from "./account.js";
 import { CoFeedEntry } from "./coFeed.js";
 import { type CoKeys } from "./coMap.js";
@@ -34,7 +34,7 @@ export type RefsToResolve<
       : IsUnion<NonNullable<V>> extends true
         ? true
         : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
-          V extends Array<infer Item>
+          V extends ReadonlyArray<infer Item>
           ?
               | {
                   $each?: RefsToResolve<
@@ -46,7 +46,7 @@ export type RefsToResolve<
                 }
               | boolean
           : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
-            V extends { _type: "CoMap" | "Group" | "Account" }
+            V extends { [TypeSym]: "CoMap" | "Group" | "Account" }
             ?
                 | ({
                     [Key in CoKeys<V> as NonNullable<V[Key]> extends CoValue
@@ -69,7 +69,7 @@ export type RefsToResolve<
                     : never)
                 | boolean
             : V extends {
-                  _type: "CoStream";
+                  [TypeSym]: "CoStream";
                   byMe: CoFeedEntry<infer Item> | undefined;
                 }
               ?
@@ -103,7 +103,7 @@ type CoMapLikeLoaded<
   DepthLimit extends number,
   CurrentDepth extends number[],
 > = {
-  -readonly [Key in keyof Depth]-?: Key extends CoKeys<V>
+  readonly [Key in keyof Omit<Depth, "$onError">]-?: Key extends CoKeys<V>
     ? NonNullable<V[Key]> extends CoValue
       ?
           | DeeplyLoaded<
@@ -128,11 +128,11 @@ export type DeeplyLoaded<
   : Depth extends boolean | undefined // Checking against boolean instead of true because the inference from RefsToResolveStrict transforms true into boolean
     ? V
     : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
-      [V] extends [Array<infer Item>]
+      [V] extends [ReadonlyArray<infer Item>]
       ? NotNull<Item> extends CoValue
         ? Depth extends { $each: infer ItemDepth }
           ? // Deeply loaded CoList
-            (
+            ReadonlyArray<
               | (NotNull<Item> &
                   DeeplyLoaded<
                     NotNull<Item>,
@@ -141,12 +141,12 @@ export type DeeplyLoaded<
                     [0, ...CurrentDepth]
                   >)
               | onErrorNullEnabled<Depth["$each"]>
-            )[] &
+            > &
               V // the CoList base type needs to be intersected after so that built-in methods return the correct narrowed array type
           : never
         : V
       : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
-        [V] extends [{ _type: "CoMap" | "Group" | "Account" }]
+        [V] extends [{ [TypeSym]: "CoMap" | "Group" | "Account" }]
         ? // If Depth = {} return V in any case
           keyof Depth extends never
           ? V
@@ -155,7 +155,7 @@ export type DeeplyLoaded<
             ? // 1.1. Deeply loaded Record-like CoMap with { $each: true | {$onError: null} }
               Depth extends { $each: infer ItemDepth }
               ? {
-                  [key: string]:
+                  readonly [key: string]:
                     | DeeplyLoaded<
                         NonNullable<V[ItemsSym]>,
                         ItemDepth,
@@ -174,7 +174,7 @@ export type DeeplyLoaded<
               CoMapLikeLoaded<V, Depth, DepthLimit, CurrentDepth>
         : [V] extends [
               {
-                _type: "CoStream";
+                [TypeSym]: "CoStream";
                 byMe: CoFeedEntry<infer Item> | undefined;
               },
             ]
@@ -188,13 +188,13 @@ export type DeeplyLoaded<
             } & { [key: ID<Account>]: { value: NotNull<Item> } } & V // same reason as in CoList
           : [V] extends [
                 {
-                  _type: "BinaryCoStream";
+                  [TypeSym]: "BinaryCoStream";
                 },
               ]
             ? V
             : [V] extends [
                   {
-                    _type: "CoPlainText";
+                    [TypeSym]: "CoPlainText";
                   },
                 ]
               ? V