@y/y 14.0.0-16

package/dist/src/utils/Transaction.d.ts

@@ -0,0 +1,136 @@
+/**
+ * A transaction is created for every change on the Yjs model. It is possible
+ * to bundle changes on the Yjs model in a single transaction to
+ * minimize the number on messages sent and the number of observer calls.
+ * If possible the user of this library should bundle as many changes as
+ * possible. Here is an example to illustrate the advantages of bundling:
+ *
+ * @example
+ * const ydoc = new Y.Doc()
+ * const map = ydoc.getMap('map')
+ * // Log content when change is triggered
+ * map.observe(() => {
+ *   console.log('change triggered')
+ * })
+ * // Each change on the map type triggers a log message:
+ * map.set('a', 0) // => "change triggered"
+ * map.set('b', 0) // => "change triggered"
+ * // When put in a transaction, it will trigger the log after the transaction:
+ * ydoc.transact(() => {
+ *   map.set('a', 1)
+ *   map.set('b', 1)
+ * }) // => "change triggered"
+ *
+ * @public
+ */
+export class Transaction {
+    /**
+     * @param {Doc} doc
+     * @param {any} origin
+     * @param {boolean} local
+     */
+    constructor(doc: Doc, origin: any, local: boolean);
+    /**
+     * The Yjs instance.
+     * @type {Doc}
+     */
+    doc: Doc;
+    /**
+     * Describes the set of deleted items by ids
+     */
+    deleteSet: IdSet;
+    /**
+     * Describes the set of items that are cleaned up / deleted by ids. It is a subset of
+     * this.deleteSet
+     */
+    cleanUps: IdSet;
+    /**
+     * Describes the set of inserted items by ids
+     */
+    insertSet: IdSet;
+    /**
+     * Holds the state before the transaction started.
+     * @type {Map<Number,Number>?}
+     */
+    _beforeState: Map<number, number> | null;
+    /**
+     * Holds the state after the transaction.
+     * @type {Map<Number,Number>?}
+     */
+    _afterState: Map<number, number> | null;
+    /**
+     * All types that were directly modified (property added or child
+     * inserted/deleted). New types are not included in this Set.
+     * Maps from type to parentSubs (`item.parentSub = null` for YArray)
+     * @type {Map<import('../utils/types.js').YType,Set<String|null>>}
+     */
+    changed: Map<import("../utils/types.js").YType, Set<string | null>>;
+    /**
+     * Stores the events for the types that observe also child elements.
+     * It is mainly used by `observeDeep`.
+     * @type {Map<import('../utils/types.js').YType,Array<YEvent<any>>>}
+     */
+    changedParentTypes: Map<import("../utils/types.js").YType, Array<YEvent<any>>>;
+    /**
+     * @type {Array<AbstractStruct>}
+     */
+    _mergeStructs: Array<AbstractStruct>;
+    /**
+     * @type {any}
+     */
+    origin: any;
+    /**
+     * Stores meta information on the transaction
+     * @type {Map<any,any>}
+     */
+    meta: Map<any, any>;
+    /**
+     * Whether this change originates from this doc.
+     * @type {boolean}
+     */
+    local: boolean;
+    /**
+     * @type {Set<Doc>}
+     */
+    subdocsAdded: Set<Doc>;
+    /**
+     * @type {Set<Doc>}
+     */
+    subdocsRemoved: Set<Doc>;
+    /**
+     * @type {Set<Doc>}
+     */
+    subdocsLoaded: Set<Doc>;
+    /**
+     * @type {boolean}
+     */
+    _needFormattingCleanup: boolean;
+    _done: boolean;
+    /**
+     * Holds the state before the transaction started.
+     *
+     * @deprecated
+     * @type {Map<Number,Number>}
+     */
+    get beforeState(): Map<number, number>;
+    /**
+     * Holds the state after the transaction.
+     *
+     * @deprecated
+     * @type {Map<Number,Number>}
+     */
+    get afterState(): Map<number, number>;
+}
+export function writeUpdateMessageFromTransaction(encoder: UpdateEncoderV1 | UpdateEncoderV2, transaction: Transaction): boolean;
+export function nextID(transaction: Transaction): import("./ID.js").ID;
+export function addChangedTypeToTransaction(transaction: Transaction, type: import("../utils/types.js").YType, parentSub: string | null): void;
+export function tryGc(tr: Transaction, idset: IdSet, gcFilter: (arg0: Item) => boolean): void;
+export function transact<T>(doc: Doc, f: (arg0: Transaction) => T, origin?: any, local?: boolean): T;
+import { Doc } from '../internals.js';
+import { IdSet } from '../internals.js';
+import { YEvent } from '../internals.js';
+import { AbstractStruct } from '../internals.js';
+import { UpdateEncoderV1 } from '../internals.js';
+import { UpdateEncoderV2 } from '../internals.js';
+import { Item } from '../internals.js';
+//# sourceMappingURL=Transaction.d.ts.map

package/dist/src/utils/Transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transaction.d.ts","sourceRoot":"","sources":["../../../src/utils/Transaction.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACE;;;;OAIG;IACH,iBAJW,GAAG,UACH,GAAG,SACH,OAAO,EA+EjB;IA5EC;;;OAGG;IACH,KAFU,GAAG,CAEC;IACd;;OAEG;IACH,iBAA8B;IAC9B;;;OAGG;IACH,gBAA6B;IAC7B;;OAEG;IACH,iBAA8B;IAC9B;;;OAGG;IACH,cAFU,GAAG,gBAAe,OAAC,CAEL;IACxB;;;OAGG;IACH,aAFU,GAAG,gBAAe,OAAC,CAEN;IACvB;;;;;OAKG;IACH,SAFU,GAAG,CAAC,OAAO,mBAAmB,EAAE,KAAK,EAAC,GAAG,CAAC,SAAO,IAAI,CAAC,CAAC,CAEzC;IACxB;;;;OAIG;IACH,oBAFU,GAAG,CAAC,OAAO,mBAAmB,EAAE,KAAK,EAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAEhC;IACnC;;OAEG;IACH,eAFU,KAAK,CAAC,cAAc,CAAC,CAER;IACvB;;OAEG;IACH,QAFU,GAAG,CAEO;IACpB;;;OAGG;IACH,MAFU,GAAG,CAAC,GAAG,EAAC,GAAG,CAAC,CAED;IACrB;;;OAGG;IACH,OAFU,OAAO,CAEC;IAClB;;OAEG;IACH,cAFU,GAAG,CAAC,GAAG,CAAC,CAEW;IAC7B;;OAEG;IACH,gBAFU,GAAG,CAAC,GAAG,CAAC,CAEa;IAC/B;;OAEG;IACH,eAFU,GAAG,CAAC,GAAG,CAAC,CAEY;IAC9B;;OAEG;IACH,wBAFU,OAAO,CAEkB;IACnC,eAAkB;IAGpB;;;;;OAKG;IACH,mBAFU,GAAG,gBAAe,CAW3B;IAED;;;;;OAKG;IACH,kBAFU,GAAG,gBAAe,CAc3B;CACF;AAOM,2DAJI,eAAe,GAAG,eAAe,eACjC,WAAW,GACV,OAAO,CASlB;AAQM,oCALI,WAAW,wBAQrB;AAUM,yDAJI,WAAW,QACX,OAAO,mBAAmB,EAAE,KAAK,aACjC,MAAM,GAAC,IAAI,QAOrB;AAyFM,0BAJI,WAAW,SACX,KAAK,YACL,CAAS,IAAI,EAAJ,IAAI,KAAE,OAAO,QAKhC;AAwJM,yBARM,CAAC,OACH,GAAG,KACH,CAAS,IAAW,EAAX,WAAW,KAAE,CAAC,WACvB,GAAG,oBACF,CAAC,CAwCZ;oBA3dM,iBAAiB;sBAAjB,iBAAiB;uBAAjB,iBAAiB;+BAAjB,iBAAiB;gCAAjB,iBAAiB;gCAAjB,iBAAiB;qBAAjB,iBAAiB"}

package/dist/src/utils/UndoManager.d.ts

@@ -0,0 +1,188 @@
+export class StackItem {
+    /**
+     * @param {IdSet} deletions
+     * @param {IdSet} insertions
+     */
+    constructor(deletions: IdSet, insertions: IdSet);
+    insertions: IdSet;
+    deletions: IdSet;
+    /**
+     * Use this to save and restore metadata like selection range
+     */
+    meta: Map<any, any>;
+}
+/**
+ * @typedef {Object} UndoManagerOptions
+ * @property {number} [UndoManagerOptions.captureTimeout=500]
+ * @property {function(Transaction):boolean} [UndoManagerOptions.captureTransaction] Do not capture changes of a Transaction if result false.
+ * @property {function(Item):boolean} [UndoManagerOptions.deleteFilter=()=>true] Sometimes
+ * it is necessary to filter what an Undo/Redo operation can delete. If this
+ * filter returns false, the type/item won't be deleted even it is in the
+ * undo/redo scope.
+ * @property {Set<any>} [UndoManagerOptions.trackedOrigins=new Set([null])]
+ * @property {boolean} [ignoreRemoteMapChanges] Experimental. By default, the UndoManager will never overwrite remote changes. Enable this property to enable overwriting remote changes on key-value changes (Y.Map, properties on Y.Xml, etc..).
+ * @property {Doc} [doc] The document that this UndoManager operates on. Only needed if typeScope is empty.
+ */
+/**
+ * @typedef {Object} StackItemEvent
+ * @property {StackItem} StackItemEvent.stackItem
+ * @property {any} StackItemEvent.origin
+ * @property {'undo'|'redo'} StackItemEvent.type
+ * @property {Map<import('../utils/types.js').YType,Array<YEvent<any>>>} StackItemEvent.changedParentTypes
+ */
+/**
+ * Fires 'stack-item-added' event when a stack item was added to either the undo- or
+ * the redo-stack. You may store additional stack information via the
+ * metadata property on `event.stackItem.meta` (it is a `Map` of metadata properties).
+ * Fires 'stack-item-popped' event when a stack item was popped from either the
+ * undo- or the redo-stack. You may restore the saved stack information from `event.stackItem.meta`.
+ *
+ * @extends {ObservableV2<{'stack-item-added':function(StackItemEvent, UndoManager):void, 'stack-item-popped': function(StackItemEvent, UndoManager):void, 'stack-cleared': function({ undoStackCleared: boolean, redoStackCleared: boolean }):void, 'stack-item-updated': function(StackItemEvent, UndoManager):void }>}
+ */
+export class UndoManager extends ObservableV2<{
+    'stack-item-added': (arg0: StackItemEvent, arg1: UndoManager) => void;
+    'stack-item-popped': (arg0: StackItemEvent, arg1: UndoManager) => void;
+    'stack-cleared': (arg0: {
+        undoStackCleared: boolean;
+        redoStackCleared: boolean;
+    }) => void;
+    'stack-item-updated': (arg0: StackItemEvent, arg1: UndoManager) => void;
+}> {
+    /**
+     * @param {Doc|import('../utils/types.js').YType|Array<import('../utils/types.js').YType>} typeScope Limits the scope of the UndoManager. If this is set to a ydoc instance, all changes on that ydoc will be undone. If set to a specific type, only changes on that type or its children will be undone. Also accepts an array of types.
+     * @param {UndoManagerOptions} options
+     */
+    constructor(typeScope: Doc | import("../utils/types.js").YType | Array<import("../utils/types.js").YType>, { captureTimeout, captureTransaction, deleteFilter, trackedOrigins, ignoreRemoteMapChanges, doc }?: UndoManagerOptions);
+    /**
+     * @type {Array<import('../utils/types.js').YType | Doc>}
+     */
+    scope: Array<import("../utils/types.js").YType | Doc>;
+    doc: Doc;
+    deleteFilter: (arg0: Item) => boolean;
+    trackedOrigins: Set<any>;
+    captureTransaction: (arg0: Transaction) => boolean;
+    /**
+     * @type {Array<StackItem>}
+     */
+    undoStack: Array<StackItem>;
+    /**
+     * @type {Array<StackItem>}
+     */
+    redoStack: Array<StackItem>;
+    /**
+     * Whether the client is currently undoing (calling UndoManager.undo)
+     *
+     * @type {boolean}
+     */
+    undoing: boolean;
+    redoing: boolean;
+    /**
+     * The currently popped stack item if UndoManager.undoing or UndoManager.redoing
+     *
+     * @type {StackItem|null}
+     */
+    currStackItem: StackItem | null;
+    lastChange: number;
+    ignoreRemoteMapChanges: boolean;
+    captureTimeout: number;
+    /**
+     * @param {Transaction} transaction
+     */
+    afterTransactionHandler: (transaction: Transaction) => void;
+    /**
+     * Extend the scope.
+     *
+     * @param {Array<import('../utils/types.js').YType | Doc> | import('../utils/types.js').YType | Doc} ytypes
+     */
+    addToScope(ytypes: Array<import("../utils/types.js").YType | Doc> | import("../utils/types.js").YType | Doc): void;
+    /**
+     * @param {any} origin
+     */
+    addTrackedOrigin(origin: any): void;
+    /**
+     * @param {any} origin
+     */
+    removeTrackedOrigin(origin: any): void;
+    clear(clearUndoStack?: boolean, clearRedoStack?: boolean): void;
+    /**
+     * UndoManager merges Undo-StackItem if they are created within time-gap
+     * smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
+     * StackItem won't be merged.
+     *
+     *
+     * @example
+     *     // without stopCapturing
+     *     ytext.insert(0, 'a')
+     *     ytext.insert(1, 'b')
+     *     um.undo()
+     *     ytext.toString() // => '' (note that 'ab' was removed)
+     *     // with stopCapturing
+     *     ytext.insert(0, 'a')
+     *     um.stopCapturing()
+     *     ytext.insert(0, 'b')
+     *     um.undo()
+     *     ytext.toString() // => 'a' (note that only 'b' was removed)
+     *
+     */
+    stopCapturing(): void;
+    /**
+     * Undo last changes on type.
+     *
+     * @return {StackItem?} Returns StackItem if a change was applied
+     */
+    undo(): StackItem | null;
+    /**
+     * Redo last undo operation.
+     *
+     * @return {StackItem?} Returns StackItem if a change was applied
+     */
+    redo(): StackItem | null;
+    /**
+     * Are undo steps available?
+     *
+     * @return {boolean} `true` if undo is possible
+     */
+    canUndo(): boolean;
+    /**
+     * Are redo steps available?
+     *
+     * @return {boolean} `true` if redo is possible
+     */
+    canRedo(): boolean;
+}
+export type UndoManagerOptions = {
+    captureTimeout?: number | undefined;
+    /**
+     * Do not capture changes of a Transaction if result false.
+     */
+    captureTransaction?: ((arg0: Transaction) => boolean) | undefined;
+    /**
+     * Sometimes
+     * it is necessary to filter what an Undo/Redo operation can delete. If this
+     * filter returns false, the type/item won't be deleted even it is in the
+     * undo/redo scope.
+     */
+    deleteFilter?: ((arg0: Item) => boolean) | undefined;
+    trackedOrigins?: Set<any> | undefined;
+    /**
+     * Experimental. By default, the UndoManager will never overwrite remote changes. Enable this property to enable overwriting remote changes on key-value changes (Y.Map, properties on Y.Xml, etc..).
+     */
+    ignoreRemoteMapChanges?: boolean | undefined;
+    /**
+     * The document that this UndoManager operates on. Only needed if typeScope is empty.
+     */
+    doc?: Doc | undefined;
+};
+export type StackItemEvent = {
+    stackItem: StackItem;
+    origin: any;
+    type: "undo" | "redo";
+    changedParentTypes: Map<import("../utils/types.js").YType, Array<YEvent<any>>>;
+};
+import { IdSet } from '../internals.js';
+import { ObservableV2 } from 'lib0/observable';
+import { Doc } from '../internals.js';
+import { Item } from '../internals.js';
+import { Transaction } from '../internals.js';
+import { YEvent } from '../internals.js';
+//# sourceMappingURL=UndoManager.d.ts.map

package/dist/src/utils/UndoManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UndoManager.d.ts","sourceRoot":"","sources":["../../../src/utils/UndoManager.js"],"names":[],"mappings":"AAkBA;IACE;;;OAGG;IACH,uBAHW,KAAK,cACL,KAAK,EASf;IANC,kBAA4B;IAC5B,iBAA0B;IAC1B;;OAEG;IACH,oBAAqB;CAExB;AAgGD;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH;wBAF8C,CAAS,IAAc,EAAd,cAAc,EAAE,IAAW,EAAX,WAAW,KAAE,IAAI;yBAAuB,CAAS,IAAc,EAAd,cAAc,EAAE,IAAW,EAAX,WAAW,KAAE,IAAI;qBAAmB,CAAS,IAAwD,EAAxD;QAAE,gBAAgB,EAAE,OAAO,CAAC;QAAC,gBAAgB,EAAE,OAAO,CAAA;KAAE,KAAE,IAAI;0BAAwB,CAAS,IAAc,EAAd,cAAc,EAAE,IAAW,EAAX,WAAW,KAAE,IAAI;;IAGnT;;;OAGG;IACH,uBAHW,GAAG,GAAC,OAAO,mBAAmB,EAAE,KAAK,GAAC,KAAK,CAAC,OAAO,mBAAmB,EAAE,KAAK,CAAC,sGAC9E,kBAAkB,EAsG5B;IA3FC;;OAEG;IACH,OAFU,KAAK,CAAC,OAAO,mBAAmB,EAAE,KAAK,GAAG,GAAG,CAAC,CAEzC;IACf,SAAc;IAEd,qBA9CmB,IAAI,KAAE,OAAO,CA8CA;IAEhC,yBAAoC;IACpC,2BAlDmB,WAAW,KAAE,OAAO,CAkDK;IAC5C;;OAEG;IACH,WAFU,KAAK,CAAC,SAAS,CAAC,CAEP;IACnB;;OAEG;IACH,WAFU,KAAK,CAAC,SAAS,CAAC,CAEP;IACnB;;;;OAIG;IACH,SAFU,OAAO,CAEG;IACpB,iBAAoB;IACpB;;;;OAIG;IACH,eAFU,SAAS,GAAC,IAAI,CAEC;IACzB,mBAAmB;IACnB,gCAAoD;IACpD,uBAAoC;IACpC;;OAEG;IACH,uCAFW,WAAW,UAmDrB;IAOH;;;;OAIG;IACH,mBAFW,KAAK,CAAC,OAAO,mBAAmB,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,OAAO,mBAAmB,EAAE,KAAK,GAAG,GAAG,QAYlG;IAED;;OAEG;IACH,yBAFW,GAAG,QAIb;IAED;;OAEG;IACH,4BAFW,GAAG,QAIb;IAED,gEAcC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,sBAEC;IAED;;;;OAIG;IACH,QAFY,SAAS,OAAC,CAWrB;IAED;;;;OAIG;IACH,QAFY,SAAS,OAAC,CAWrB;IAED;;;;OAIG;IACH,WAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,WAFY,OAAO,CAIlB;CAOF;;;;;;iCApQsB,WAAW,KAAE,OAAO;;;;;;;2BACpB,IAAI,KAAE,OAAO;;;;;;;;;;;;eAWtB,SAAS;YACT,GAAG;UACH,MAAM,GAAC,MAAM;wBACb,GAAG,CAAC,OAAO,mBAAmB,EAAE,KAAK,EAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;;sBAtIhE,iBAAiB;6BAKK,iBAAiB;oBALvC,iBAAiB;qBAAjB,iBAAiB;4BAAjB,iBAAiB;uBAAjB,iBAAiB"}

package/dist/src/utils/UpdateDecoder.d.ts

@@ -0,0 +1,167 @@
+export class DSDecoderV1 {
+    /**
+     * @param {decoding.Decoder} decoder
+     */
+    constructor(decoder: decoding.Decoder);
+    restDecoder: decoding.Decoder<ArrayBufferLike>;
+    resetDsCurVal(): void;
+    /**
+     * @return {number}
+     */
+    readDsClock(): number;
+    /**
+     * @return {number}
+     */
+    readDsLen(): number;
+}
+export class UpdateDecoderV1 extends DSDecoderV1 {
+    /**
+     * @return {ID}
+     */
+    readLeftID(): ID;
+    /**
+     * @return {ID}
+     */
+    readRightID(): ID;
+    /**
+     * Read the next client id.
+     * Use this in favor of readID whenever possible to reduce the number of objects created.
+     */
+    readClient(): number;
+    /**
+     * @return {number} info An unsigned 8-bit integer
+     */
+    readInfo(): number;
+    /**
+     * @return {string}
+     */
+    readString(): string;
+    /**
+     * @return {boolean} isKey
+     */
+    readParentInfo(): boolean;
+    /**
+     * @return {number} info An unsigned 8-bit integer
+     */
+    readTypeRef(): number;
+    /**
+     * Write len of a struct - well suited for Opt RLE encoder.
+     *
+     * @return {number} len
+     */
+    readLen(): number;
+    /**
+     * @return {any}
+     */
+    readAny(): any;
+    /**
+     * @return {Uint8Array}
+     */
+    readBuf(): Uint8Array;
+    /**
+     * Legacy implementation uses JSON parse. We use any-decoding in v2.
+     *
+     * @return {any}
+     */
+    readJSON(): any;
+    /**
+     * @return {string}
+     */
+    readKey(): string;
+}
+export class DSDecoderV2 {
+    /**
+     * @param {decoding.Decoder} decoder
+     */
+    constructor(decoder: decoding.Decoder);
+    /**
+     * @private
+     */
+    private dsCurrVal;
+    restDecoder: decoding.Decoder<ArrayBufferLike>;
+    resetDsCurVal(): void;
+    /**
+     * @return {number}
+     */
+    readDsClock(): number;
+    /**
+     * @return {number}
+     */
+    readDsLen(): number;
+}
+export class UpdateDecoderV2 extends DSDecoderV2 {
+    /**
+     * List of cached keys. If the keys[id] does not exist, we read a new key
+     * from stringEncoder and push it to keys.
+     *
+     * @type {Array<string>}
+     */
+    keys: Array<string>;
+    keyClockDecoder: decoding.IntDiffOptRleDecoder;
+    clientDecoder: decoding.UintOptRleDecoder;
+    leftClockDecoder: decoding.IntDiffOptRleDecoder;
+    rightClockDecoder: decoding.IntDiffOptRleDecoder;
+    infoDecoder: decoding.RleDecoder<number>;
+    stringDecoder: decoding.StringDecoder;
+    parentInfoDecoder: decoding.RleDecoder<number>;
+    typeRefDecoder: decoding.UintOptRleDecoder;
+    lenDecoder: decoding.UintOptRleDecoder;
+    /**
+     * @return {ID}
+     */
+    readLeftID(): ID;
+    /**
+     * @return {ID}
+     */
+    readRightID(): ID;
+    /**
+     * Read the next client id.
+     * Use this in favor of readID whenever possible to reduce the number of objects created.
+     */
+    readClient(): number;
+    /**
+     * @return {number} info An unsigned 8-bit integer
+     */
+    readInfo(): number;
+    /**
+     * @return {string}
+     */
+    readString(): string;
+    /**
+     * @return {boolean}
+     */
+    readParentInfo(): boolean;
+    /**
+     * @return {number} An unsigned 8-bit integer
+     */
+    readTypeRef(): number;
+    /**
+     * Write len of a struct - well suited for Opt RLE encoder.
+     *
+     * @return {number}
+     */
+    readLen(): number;
+    /**
+     * @return {any}
+     */
+    readAny(): any;
+    /**
+     * @return {Uint8Array}
+     */
+    readBuf(): Uint8Array;
+    /**
+     * This is mainly here for legacy purposes.
+     *
+     * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
+     *
+     * @return {any}
+     */
+    readJSON(): any;
+    /**
+     * @return {string}
+     */
+    readKey(): string;
+}
+import * as decoding from 'lib0/decoding';
+import { ID } from '../internals.js';
+//# sourceMappingURL=UpdateDecoder.d.ts.map

package/dist/src/utils/UpdateDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateDecoder.d.ts","sourceRoot":"","sources":["../../../src/utils/UpdateDecoder.js"],"names":[],"mappings":"AAMA;IACE;;OAEG;IACH,qBAFW,QAAQ,CAAC,OAAO,EAI1B;IADC,+CAA0B;IAG5B,sBAEC;IAED;;OAEG;IACH,eAFY,MAAM,CAIjB;IAED;;OAEG;IACH,aAFY,MAAM,CAIjB;CACF;AAED;IACE;;OAEG;IACH,cAFY,EAAE,CAIb;IAED;;OAEG;IACH,eAFY,EAAE,CAIb;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,YAFY,MAAM,CAIjB;IAED;;OAEG;IACH,cAFY,MAAM,CAIjB;IAED;;OAEG;IACH,kBAFY,OAAO,CAIlB;IAED;;OAEG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAFY,MAAM,CAIjB;IAED;;OAEG;IACH,WAFY,GAAG,CAId;IAED;;OAEG;IACH,WAFY,UAAU,CAIrB;IAED;;;;OAIG;IACH,YAFY,GAAG,CAId;IAED;;OAEG;IACH,WAFY,MAAM,CAIjB;CACF;AAED;IACE;;OAEG;IACH,qBAFW,QAAQ,CAAC,OAAO,EAQ1B;IALC;;OAEG;IACH,kBAAkB;IAClB,+CAA0B;IAG5B,sBAEC;IAED;;OAEG;IACH,eAFY,MAAM,CAKjB;IAED;;OAEG;IACH,aAFY,MAAM,CAMjB;CACF;AAED;IAMI;;;;;OAKG;IACH,MAFU,KAAK,CAAC,MAAM,CAAC,CAET;IAEd,+CAA6F;IAC7F,0CAAwF;IACxF,gDAA8F;IAC9F,iDAA+F;IAC/F,yCAAmG;IACnG,sCAAoF;IACpF,+CAAyG;IACzG,2CAAyF;IACzF,uCAAqF;IAGvF;;OAEG;IACH,cAFY,EAAE,CAIb;IAED;;OAEG;IACH,eAFY,EAAE,CAIb;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,YAFY,MAAM,CAIjB;IAED;;OAEG;IACH,cAFY,MAAM,CAIjB;IAED;;OAEG;IACH,kBAFY,OAAO,CAIlB;IAED;;OAEG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAFY,MAAM,CAIjB;IAED;;OAEG;IACH,WAFY,GAAG,CAId;IAED;;OAEG;IACH,WAFY,UAAU,CAIrB;IAED;;;;;;OAMG;IACH,YAFY,GAAG,CAId;IAED;;OAEG;IACH,WAFY,MAAM,CAWjB;CACF;0BAvRyB,eAAe;mBAGlC,iBAAiB"}

package/dist/src/utils/UpdateEncoder.d.ts

@@ -0,0 +1,164 @@
+export class IdSetEncoderV1 {
+    restEncoder: encoding.Encoder;
+    toUint8Array(): Uint8Array<ArrayBuffer>;
+    resetIdSetCurVal(): void;
+    /**
+     * @param {number} clock
+     */
+    writeIdSetClock(clock: number): void;
+    /**
+     * @param {number} len
+     */
+    writeIdSetLen(len: number): void;
+}
+export class UpdateEncoderV1 extends IdSetEncoderV1 {
+    /**
+     * @param {ID} id
+     */
+    writeLeftID(id: ID): void;
+    /**
+     * @param {ID} id
+     */
+    writeRightID(id: ID): void;
+    /**
+     * Use writeClient and writeClock instead of writeID if possible.
+     * @param {number} client
+     */
+    writeClient(client: number): void;
+    /**
+     * @param {number} info An unsigned 8-bit integer
+     */
+    writeInfo(info: number): void;
+    /**
+     * @param {string} s
+     */
+    writeString(s: string): void;
+    /**
+     * @param {boolean} isYKey
+     */
+    writeParentInfo(isYKey: boolean): void;
+    /**
+     * @param {number} info An unsigned 8-bit integer
+     */
+    writeTypeRef(info: number): void;
+    /**
+     * Write len of a struct - well suited for Opt RLE encoder.
+     *
+     * @param {number} len
+     */
+    writeLen(len: number): void;
+    /**
+     * @param {any} any
+     */
+    writeAny(any: any): void;
+    /**
+     * @param {Uint8Array} buf
+     */
+    writeBuf(buf: Uint8Array): void;
+    /**
+     * @param {any} embed
+     */
+    writeJSON(embed: any): void;
+    /**
+     * @param {string} key
+     */
+    writeKey(key: string): void;
+}
+export class IdSetEncoderV2 {
+    restEncoder: encoding.Encoder;
+    dsCurrVal: number;
+    toUint8Array(): Uint8Array<ArrayBuffer>;
+    resetIdSetCurVal(): void;
+    /**
+     * @param {number} clock
+     */
+    writeIdSetClock(clock: number): void;
+    /**
+     * @param {number} len
+     */
+    writeIdSetLen(len: number): void;
+}
+export class UpdateEncoderV2 extends IdSetEncoderV2 {
+    /**
+     * @type {Map<string,number>}
+     */
+    keyMap: Map<string, number>;
+    /**
+     * Refers to the next unique key-identifier to me used.
+     * See writeKey method for more information.
+     *
+     * @type {number}
+     */
+    keyClock: number;
+    keyClockEncoder: encoding.IntDiffOptRleEncoder;
+    clientEncoder: encoding.UintOptRleEncoder;
+    leftClockEncoder: encoding.IntDiffOptRleEncoder;
+    rightClockEncoder: encoding.IntDiffOptRleEncoder;
+    infoEncoder: encoding.RleEncoder<number>;
+    stringEncoder: encoding.StringEncoder;
+    parentInfoEncoder: encoding.RleEncoder<number>;
+    typeRefEncoder: encoding.UintOptRleEncoder;
+    lenEncoder: encoding.UintOptRleEncoder;
+    /**
+     * @param {ID} id
+     */
+    writeLeftID(id: ID): void;
+    /**
+     * @param {ID} id
+     */
+    writeRightID(id: ID): void;
+    /**
+     * @param {number} client
+     */
+    writeClient(client: number): void;
+    /**
+     * @param {number} info An unsigned 8-bit integer
+     */
+    writeInfo(info: number): void;
+    /**
+     * @param {string} s
+     */
+    writeString(s: string): void;
+    /**
+     * @param {boolean} isYKey
+     */
+    writeParentInfo(isYKey: boolean): void;
+    /**
+     * @param {number} info An unsigned 8-bit integer
+     */
+    writeTypeRef(info: number): void;
+    /**
+     * Write len of a struct - well suited for Opt RLE encoder.
+     *
+     * @param {number} len
+     */
+    writeLen(len: number): void;
+    /**
+     * @param {any} any
+     */
+    writeAny(any: any): void;
+    /**
+     * @param {Uint8Array} buf
+     */
+    writeBuf(buf: Uint8Array): void;
+    /**
+     * This is mainly here for legacy purposes.
+     *
+     * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
+     *
+     * @param {any} embed
+     */
+    writeJSON(embed: any): void;
+    /**
+     * Property keys are often reused. For example, in y-prosemirror the key `bold` might
+     * occur very often. For a 3d application, the key `position` might occur very often.
+     *
+     * We cache these keys in a Map and refer to them via a unique number.
+     *
+     * @param {string} key
+     */
+    writeKey(key: string): void;
+}
+import * as encoding from 'lib0/encoding';
+import { ID } from '../internals.js';
+//# sourceMappingURL=UpdateEncoder.d.ts.map

package/dist/src/utils/UpdateEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateEncoder.d.ts","sourceRoot":"","sources":["../../../src/utils/UpdateEncoder.js"],"names":[],"mappings":"AAOA;IAEI,8BAA2C;IAG7C,wCAEC;IAED,yBAEC;IAED;;OAEG;IACH,uBAFW,MAAM,QAIhB;IAED;;OAEG;IACH,mBAFW,MAAM,QAIhB;CACF;AAED;IACE;;OAEG;IACH,gBAFW,EAAE,QAKZ;IAED;;OAEG;IACH,iBAFW,EAAE,QAKZ;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;OAEG;IACH,gBAFW,MAAM,QAIhB;IAED;;OAEG;IACH,eAFW,MAAM,QAIhB;IAED;;OAEG;IACH,wBAFW,OAAO,QAIjB;IAED;;OAEG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAFW,MAAM,QAIhB;IAED;;OAEG;IACH,cAFW,GAAG,QAIb;IAED;;OAEG;IACH,cAFW,UAAU,QAIpB;IAED;;OAEG;IACH,iBAFW,GAAG,QAIb;IAED;;OAEG;IACH,cAFW,MAAM,QAIhB;CACF;AAED;IAEI,8BAA2C;IAC3C,kBAAkB;IAGpB,wCAEC;IAED,yBAEC;IAED;;OAEG;IACH,uBAFW,MAAM,QAMhB;IAED;;OAEG;IACH,mBAFW,MAAM,QAQhB;CACF;AAED;IAGI;;OAEG;IACH,QAFU,GAAG,CAAC,MAAM,EAAC,MAAM,CAAC,CAEL;IACvB;;;;;OAKG;IACH,UAFU,MAAM,CAEC;IACjB,+CAA0D;IAC1D,0CAAqD;IACrD,gDAA2D;IAC3D,iDAA4D;IAC5D,yCAA+D;IAC/D,sCAAiD;IACjD,+CAAqE;IACrE,2CAAsD;IACtD,uCAAkD;IAoBpD;;OAEG;IACH,gBAFW,EAAE,QAKZ;IAED;;OAEG;IACH,iBAFW,EAAE,QAKZ;IAED;;OAEG;IACH,oBAFW,MAAM,QAIhB;IAED;;OAEG;IACH,gBAFW,MAAM,QAIhB;IAED;;OAEG;IACH,eAFW,MAAM,QAIhB;IAED;;OAEG;IACH,wBAFW,OAAO,QAIjB;IAED;;OAEG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAFW,MAAM,QAIhB;IAED;;OAEG;IACH,cAFW,GAAG,QAIb;IAED;;OAEG;IACH,cAFW,UAAU,QAIpB;IAED;;;;;;OAMG;IACH,iBAFW,GAAG,QAIb;IAED;;;;;;;OAOG;IACH,cAFW,MAAM,QAwBhB;CACF;0BA9TyB,eAAe;mBAIlC,iBAAiB"}