@yorkie-js/sdk 0.7.3 → 0.7.5

package/dist/counter.html

@@ -58,7 +58,7 @@
           // 03. initialize document properties
           doc.update((root) => {
             if (!root.counter) {
-              root.counter = new yorkie.Counter(yorkie.IntType, 0);
+              root.counter = new yorkie.Counter(0);
             }
           }, 'create counter if not exists');
 

package/dist/multi.html

@@ -115,7 +115,7 @@
 
           doc.update((root) => {
             if (!root.counter) {
-              root.counter = new yorkie.Counter(yorkie.IntType, 0);
+              root.counter = new yorkie.Counter(0);
               root.todos = [];
               root.content = new yorkie.Text();
               root.content.edit(0, 0, '\n');

package/dist/yorkie-js-sdk.d.ts

@@ -1,5 +1,3 @@
-import { default as default_2 } from 'long';
-import { default as Long_2 } from 'long';
 import { Message } from '@bufbuild/protobuf';
 import { Rule } from '@yorkie-js/schema';
 import { Timestamp } from '@bufbuild/protobuf/wkt';
@@ -166,6 +164,38 @@ declare interface AuthErrorEvent_3 {
 
 declare type BaseArray<T> = JSONArray<T> | Array<T>;
 
+/**
+ * `BaseCounter` is an internal base that holds the shared state and
+ * initialization logic for Counter and DedupCounter. Not exported.
+ */
+declare class BaseCounter {
+    protected valueType: CounterType;
+    protected value: number | bigint;
+    protected context?: ChangeContext;
+    protected counter?: CRDTCounter;
+    constructor(valueType: CounterType, value: number | bigint);
+    /**
+     * `initialize` links this proxy to a ChangeContext and CRDTCounter.
+     */
+    initialize(context: ChangeContext, counter: CRDTCounter): void;
+    /**
+     * `getID` returns the ID of this counter.
+     */
+    getID(): TimeTicket;
+    /**
+     * `getValueType` returns the value type of this counter.
+     */
+    getValueType(): CounterType;
+    /**
+     * `toJSForTest` returns value with meta data for testing.
+     */
+    toJSForTest(): Devtools.JSONElement;
+    /**
+     * `ensureInitialized` throws if this counter has not been initialized.
+     */
+    protected ensureInitialized(): void;
+}
+
 declare interface BaseDocEvent {
     type: DocEventType_2;
 }
@@ -1183,6 +1213,12 @@ export declare interface ClientOptions {
      * client.
      */
     userAgent?: string;
+    /**
+     * `useGrpcWebTransport` determines the transport protocol.
+     * If true, uses gRPC-Web transport for backward compatibility.
+     * If false (default), uses Connect Protocol transport.
+     */
+    useGrpcWebTransport?: boolean;
 }
 
 /**
@@ -1261,38 +1297,25 @@ export declare const converter: {
 };
 
 /**
- * `Counter` is a custom data type that is used to counter.
+ * `Counter` is a numeric counter that supports `increase()`.
+ * For counting unique actors, use `DedupCounter` instead.
+ *
+ * ```typescript
+ * // Type is inferred from value:
+ * root.count = new Counter(0);           // Int
+ * root.count = new Counter(0n);           // Long
+ * ```
  */
-export declare class Counter {
-    private valueType;
-    private value;
-    private context?;
-    private counter?;
-    constructor(valueType: CounterType, value: number | default_2);
-    /**
-     * `initialize` initialize this text with context and internal text.
-     */
-    initialize(context: ChangeContext, counter: CRDTCounter): void;
-    /**
-     * `getID` returns the ID of this text.
-     */
-    getID(): TimeTicket;
+export declare class Counter extends BaseCounter {
+    constructor(value: number | bigint);
     /**
-     * `getValue` returns the value of this counter;
+     * `getValue` returns the value of this counter.
      */
-    getValue(): number | default_2;
-    /**
-     * `getValueType` returns the value type of this counter.
-     */
-    getValueType(): CounterType;
+    getValue(): number | bigint;
     /**
      * `increase` increases numeric data.
      */
-    increase(v: number | default_2): Counter;
-    /**
-     * `toJSForTest` returns value with meta data for testing.
-     */
-    toJSForTest(): Devtools.JSONElement;
+    increase(v: number | bigint): Counter;
 }
 
 /**
@@ -1307,12 +1330,13 @@ declare type CounterOpInfo_2 = IncreaseOpInfo_2;
 
 export declare enum CounterType {
     Int = 0,
-    Long = 1
+    Long = 1,
+    IntDedup = 2
 }
 
-export declare type CounterValue = number | default_2;
+export declare type CounterValue = number | bigint;
 
-declare type CounterValue_2 = number | Long_2;
+declare type CounterValue_2 = number | bigint;
 
 /**
  *
@@ -1347,6 +1371,7 @@ declare abstract class CRDTContainer extends CRDTElement {
 declare class CRDTCounter extends CRDTElement {
     private valueType;
     private value;
+    private hll?;
     constructor(valueType: CounterType, value: CounterValue, createdAt: TimeTicket);
     /**
      * `of` creates a new instance of Counter.
@@ -1408,8 +1433,30 @@ declare class CRDTCounter extends CRDTElement {
      * `toBytes` creates an array representing the value.
      */
     toBytes(): Uint8Array;
+    /**
+     * `isDedup` returns whether dedup mode is enabled (derived from ValueType).
+     */
+    isDedup(): boolean;
+    /**
+     * `increaseDedup` increases the counter using HLL-based dedup.
+     * Only updates the value if the actor is new (not seen before).
+     */
+    increaseDedup(v: Primitive, actor: string): CRDTCounter;
+    /**
+     * `hllBytes` returns the HLL register bytes, or undefined if not in dedup mode.
+     */
+    hllBytes(): Uint8Array | undefined;
+    /**
+     * `restoreHLL` restores the HLL state from serialized bytes.
+     */
+    restoreHLL(data: Uint8Array): void;
+    /**
+     * `recomputeValue` updates the counter value from the HLL cardinality estimate.
+     */
+    private recomputeValue;
     /**
      * `increase` increases numeric data.
+     * Dedup counters must use increaseDedup() instead.
      */
     increase(v: Primitive): CRDTCounter;
 }
@@ -1882,6 +1929,16 @@ declare class CRDTTree extends CRDTElement implements GCParent {
     private indexTree;
     private nodeMapByID;
     constructor(root: CRDTTreeNode, createdAt: TimeTicket);
+    /**
+     * `rebuildMergeState` reconstructs the `mergedInto` cache on source
+     * parents from the persisted `mergedFrom` field on moved children.
+     * For snapshots written before `mergedAt` was added to the proto,
+     * it also falls back to the source's `removedAt` — an approximation
+     * that may be wrong if the source was later overwritten by a
+     * concurrent delete, but this is the best we can do without the
+     * persisted merge ticket.
+     */
+    private rebuildMergeState;
     /**
      * `create` creates a new instance of `CRDTTree`.
      */
@@ -1890,6 +1947,19 @@ declare class CRDTTree extends CRDTElement implements GCParent {
      * `findFloorNode` finds node of given id.
      */
     findFloorNode(id: CRDTTreeNodeID): CRDTTreeNode | undefined;
+    /**
+     * `advancePastUnknownSplitSiblings` follows the insNextID chain of the
+     * given node, advancing past element-type split siblings that the editing
+     * client did not know about (not in versionVector).
+     */
+    private advancePastUnknownSplitSiblings;
+    /**
+     * `hasUnknownSplitSibling` checks whether the given element node has a
+     * split sibling (via insNextID) whose creation the editor did not know
+     * about. Used to prevent styling via End tokens when a concurrent split
+     * extended the range into the split sibling.
+     */
+    private hasUnknownSplitSibling;
     /**
      * `registerNode` registers the given node to the tree.
      */
@@ -1911,11 +1981,17 @@ declare class CRDTTree extends CRDTElement implements GCParent {
      */
     style(range: [CRDTTreePos, CRDTTreePos], attributes: {
         [key: string]: string;
-    } | undefined, editedAt: TimeTicket, versionVector?: VersionVector): [Array<GCPair>, Array<TreeChange>, DataSize];
+    } | undefined, editedAt: TimeTicket, versionVector?: VersionVector): [
+    Array<GCPair>,
+    Array<TreeChange>,
+    DataSize,
+    Map<string, string>,
+    Array<string>
+    ];
     /**
      * `removeStyle` removes the given attributes of the given range.
      */
-    removeStyle(range: [CRDTTreePos, CRDTTreePos], attributesToRemove: Array<string>, editedAt: TimeTicket, versionVector?: VersionVector): [Array<GCPair>, Array<TreeChange>, DataSize];
+    removeStyle(range: [CRDTTreePos, CRDTTreePos], attributesToRemove: Array<string>, editedAt: TimeTicket, versionVector?: VersionVector): [Array<GCPair>, Array<TreeChange>, DataSize, Map<string, string>];
     /**
      * `edit` edits the tree with the given range and content.
      * If the content is undefined, the range will be removed.
@@ -2079,6 +2155,29 @@ declare class CRDTTreeNode extends IndexTreeNode<CRDTTreeNode> implements GCPare
      * `insNextID` is the previous node id of this node after the node is split.
      */
     insNextID?: CRDTTreeNodeID;
+    /**
+     * `mergedFrom` records the source parent's ID when this node was moved
+     * by a concurrent merge. Persisted in the snapshot encoding as the
+     * witness of the merge relationship.
+     */
+    mergedFrom?: CRDTTreeNodeID;
+    /**
+     * `mergedAt` records the immutable ticket of the merge operation.
+     * Persisted alongside `mergedFrom` because the source parent's
+     * `removedAt` may be overwritten by later LWW tombstones and thus
+     * cannot serve as the merge-time causal boundary for splitElement's
+     * Fix 8 version-vector check.
+     */
+    mergedAt?: TimeTicket;
+    /**
+     * `mergedInto` is a runtime cache set on the source parent pointing
+     * at the merge target. Set locally during merge execution and rebuilt
+     * from `mergedFrom` on snapshot load. Used for the fast
+     * "is this tombstoned parent a merge source?" check in
+     * `FindTreeNodesWithSplitText`; the alternative (scanning
+     * `nodeMapByID` on every position resolution) would be too expensive.
+     */
+    mergedInto?: CRDTTreeNodeID;
     _value: string;
     constructor(id: CRDTTreeNodeID, type: string, opts?: string | Array<CRDTTreeNode>, attributes?: RHT, removedAt?: TimeTicket);
     /**
@@ -2124,7 +2223,7 @@ declare class CRDTTreeNode extends IndexTreeNode<CRDTTreeNode> implements GCPare
     /**
      * `split` splits the given offset of this node.
      */
-    split(tree: CRDTTree, offset: number, issueTimeTicket?: () => TimeTicket): [CRDTTreeNode | undefined, DataSize];
+    split(tree: CRDTTree, offset: number, issueTimeTicket?: () => TimeTicket, versionVector?: VersionVector): [CRDTTreeNode | undefined, DataSize];
     /**
      * `getCreatedAt` returns the creation time of this element.
      */
@@ -2342,6 +2441,32 @@ declare interface DeactivateOptions {
  */
 declare type DecreasedDepthOf<Depth extends number> = Depth extends 10 ? 9 : Depth extends 9 ? 8 : Depth extends 8 ? 7 : Depth extends 7 ? 6 : Depth extends 6 ? 5 : Depth extends 5 ? 4 : Depth extends 4 ? 3 : Depth extends 3 ? 2 : Depth extends 2 ? 1 : Depth extends 1 ? 0 : -1;
 
+/**
+ * `DedupCounter` is a Counter that uses HyperLogLog to count unique actors.
+ * Use `add(actor)` to record a unique visitor. Provides approximate counts
+ * with ~2% error rate.
+ *
+ * ```typescript
+ * doc.update((root) => {
+ *   root.uv = new yorkie.DedupCounter();
+ *   root.uv.add(userId);
+ * });
+ * ```
+ */
+export declare class DedupCounter extends BaseCounter {
+    constructor();
+    /**
+     * `getValue` returns the value of this counter. Always a number since
+     * DedupCounter only supports IntDedup.
+     */
+    getValue(): number;
+    /**
+     * `add` records a unique actor in the dedup counter. If the actor has
+     * already been counted, the call is ignored.
+     */
+    add(actor: string): DedupCounter;
+}
+
 /**
  * The top-level yorkie namespace with additional properties.
  *
@@ -2356,6 +2481,7 @@ declare const _default: {
     Primitive: typeof Primitive;
     Text: typeof Text_2;
     Counter: typeof Counter;
+    DedupCounter: typeof DedupCounter;
     Tree: typeof Tree;
     Devtools: typeof Devtools;
     Channel: typeof Channel;
@@ -2363,8 +2489,6 @@ declare const _default: {
     YSON: typeof YSON;
     LogLevel: typeof LogLevel;
     setLogLevel: typeof setLogLevel;
-    IntType: CounterType;
-    LongType: CounterType;
 };
 export default _default;
 
@@ -3493,10 +3617,17 @@ declare abstract class IndexTreeNode<T extends IndexTreeNode<T>> {
      * In this method, the child is physically removed from the tree.
      */
     removeChild(child: T): void;
+    /**
+     * `detachChild` removes the given child from this node's children list
+     * and updates both visibleSize and totalSize. Unlike `removeChild` which
+     * is used for GC purge of tombstoned nodes, `detachChild` is used for
+     * moving alive nodes between parents.
+     */
+    detachChild(child: T): void;
     /**
      * `splitElement` splits the given element at the given offset.
      */
-    splitElement(offset: number, issueTimeTicket: () => TimeTicket): [T | undefined, DataSize];
+    splitElement(offset: number, issueTimeTicket: () => TimeTicket, versionVector?: VersionVector): [T | undefined, DataSize];
     /**
      * `insertAfterInternal` inserts the given node after the given child.
      * This method does not update the size of the ancestors.
@@ -3765,7 +3896,7 @@ declare type JsonArray_2 = Array<Json_2>;
  * `JSONElement` is a wrapper for `CRDTElement` that provides users with an
  * easy-to-use interface for manipulating `Document`s.
  */
-export declare type JSONElement<T = unknown, A extends Indexable = Indexable> = PrimitiveValue | JSONObject<T> | JSONArray<T> | Text_2<A> | Counter | Tree;
+export declare type JSONElement<T = unknown, A extends Indexable = Indexable> = PrimitiveValue | JSONObject<T> | JSONArray<T> | Text_2<A> | Counter | DedupCounter | Tree;
 
 /**
  * `JSONElement` represents the result of `Element.toJSForTest()`.
@@ -4297,6 +4428,10 @@ declare type Operation_Increase = Message<"yorkie.v1.Operation.Increase"> & {
      * @generated from field: yorkie.v1.TimeTicket executed_at = 3;
      */
     executedAt?: TimeTicket_2;
+    /**
+     * @generated from field: string actor = 4;
+     */
+    actor: string;
 };
 
 /**
@@ -4840,7 +4975,7 @@ declare enum PrimitiveType {
  * `PrimitiveValue` represents a value of primitive type. Only values of type
  * included in `PrimitiveValue` can be set to the document.
  */
-export declare type PrimitiveValue = null | boolean | number | default_2 | string | Uint8Array | Date;
+export declare type PrimitiveValue = null | boolean | number | bigint | string | Uint8Array | Date;
 
 /**
  * `PrimitiveValue` represents a value of primitive type. Only values of type
@@ -4848,7 +4983,7 @@ export declare type PrimitiveValue = null | boolean | number | default_2 | strin
  */
 declare type PrimitiveValue_2 =
 // eslint-disable-next-line @typescript-eslint/no-restricted-types
-null | boolean | number | Long_2 | string | Uint8Array | Date;
+null | boolean | number | bigint | string | Uint8Array | Date;
 
 /**
  * `RemoteChangeEvent` is an event that occurs when the document is changed
@@ -6473,6 +6608,22 @@ declare type TreeNode_3 = Message<"yorkie.v1.TreeNode"> & {
     attributes: {
         [key: string]: NodeAttr;
     };
+    /**
+     * merged_from is set when this node was moved to a new parent by a
+     * concurrent merge. It points to the source parent's ID.
+     *
+     * @generated from field: yorkie.v1.TreeNodeID merged_from = 9;
+     */
+    mergedFrom?: TreeNodeID;
+    /**
+     * merged_at records the immutable ticket of the merge operation.
+     * Stored alongside merged_from because the source parent's removed_at
+     * may be overwritten by later LWW tombstones and thus cannot serve as
+     * the merge-time causal boundary for SplitElement.
+     *
+     * @generated from field: yorkie.v1.TimeTicket merged_at = 10;
+     */
+    mergedAt?: TimeTicket_2;
 };
 
 /**
@@ -6745,7 +6896,11 @@ declare enum ValueType {
     /**
      * @generated from enum value: VALUE_TYPE_TREE = 13;
      */
-    TREE = 13
+    TREE = 13,
+    /**
+     * @generated from enum value: VALUE_TYPE_INTEGER_DEDUP_CNT = 14;
+     */
+    INTEGER_DEDUP_CNT = 14
 }
 
 /**
@@ -6835,7 +6990,7 @@ declare interface WatchedEvent_2<P extends Indexable_2> extends BaseDocEvent {
 /**
  * `WrappedElement` is a wrapper of JSONElement that provides `getID()`.
  */
-export declare type WrappedElement<T = unknown, A extends Indexable = Indexable> = Primitive | JSONObject<T> | JSONArray<T> | Text_2<A> | Counter | Tree;
+export declare type WrappedElement<T = unknown, A extends Indexable = Indexable> = Primitive | JSONObject<T> | JSONArray<T> | Text_2<A> | Counter | DedupCounter | Tree;
 
 declare namespace YSON {
     export {