@y/y 14.0.0-16

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

@@ -0,0 +1,224 @@
+export const attributionJsonSchema: s.Schema<{
+    insert?: string[] | undefined;
+    insertedAt?: number | undefined;
+    delete?: string[] | undefined;
+    deletedAt?: number | undefined;
+    format?: {
+        [x: string]: string[];
+    } | undefined;
+    formatAt?: number | undefined;
+}>;
+export function createAttributionFromAttributionItems(attrs: Array<import("./IdMap.js").AttributionItem<any>> | null, deleted: boolean): Attribution | null;
+/**
+ * @template T
+ */
+export class AttributedContent<T> {
+    /**
+     * @param {AbstractContent} content
+     * @param {number} clock
+     * @param {boolean} deleted
+     * @param {Array<import('./IdMap.js').AttributionItem<T>> | null} attrs
+     * @param {0|1|2} renderBehavior
+     */
+    constructor(content: AbstractContent, clock: number, deleted: boolean, attrs: Array<import("./IdMap.js").AttributionItem<T>> | null, renderBehavior: 0 | 1 | 2);
+    content: AbstractContent;
+    clock: number;
+    deleted: boolean;
+    attrs: import("./IdMap.js").AttributionItem<T>[] | null;
+    render: boolean;
+}
+/**
+ * Abstract class for associating Attributions to content / changes
+ *
+ * Should fire an event when the attributions changed _after_ the original change happens. This
+ * Event will be used to update the attribution on the current content.
+ *
+ * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
+ */
+export class AbstractAttributionManager extends ObservableV2<{
+    change: (idset: IdSet, origin: any, local: boolean) => void;
+}> {
+    constructor();
+    /**
+     * @param {Array<AttributedContent<any>>} _contents - where to write the result
+     * @param {number} _client
+     * @param {number} _clock
+     * @param {boolean} _deleted
+     * @param {AbstractContent} _content
+     * @param {0|1|2} _shouldRender - 0: if undeleted or attributed, render as a retain operation. 1: render only if undeleted or attributed. 2: render as insert operation (if unattributed and deleted, render as delete).
+     */
+    readContent(_contents: Array<AttributedContent<any>>, _client: number, _clock: number, _deleted: boolean, _content: AbstractContent, _shouldRender: 0 | 1 | 2): void;
+    /**
+     * Calculate the length of the attributed content. This is used by iterators that walk through the
+     * content.
+     *
+     * If the content is not countable, it should return 0.
+     *
+     * @param {Item} _item
+     * @return {number}
+     */
+    contentLength(_item: Item): number;
+}
+/**
+ * @implements AbstractAttributionManager
+ *
+ * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
+ */
+export class TwosetAttributionManager extends ObservableV2<{
+    change: (idset: IdSet, origin: any, local: boolean) => void;
+}> implements AbstractAttributionManager {
+    /**
+     * @param {IdMap<any>} inserts
+     * @param {IdMap<any>} deletes
+     */
+    constructor(inserts: IdMap<any>, deletes: IdMap<any>);
+    inserts: IdMap<any>;
+    deletes: IdMap<any>;
+    /**
+     * @param {Array<AttributedContent<any>>} contents - where to write the result
+     * @param {number} client
+     * @param {number} clock
+     * @param {boolean} deleted
+     * @param {AbstractContent} content
+     * @param {0|1|2} shouldRender - whether this should render or just result in a `retain` operation
+     */
+    readContent(contents: Array<AttributedContent<any>>, client: number, clock: number, deleted: boolean, content: AbstractContent, shouldRender: 0 | 1 | 2): void;
+    /**
+     * @param {Item} item
+     * @return {number}
+     */
+    contentLength(item: Item): number;
+}
+/**
+ * Abstract class for associating Attributions to content / changes
+ *
+ * @implements AbstractAttributionManager
+ *
+ * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
+ */
+export class NoAttributionsManager extends ObservableV2<{
+    change: (idset: IdSet, origin: any, local: boolean) => void;
+}> implements AbstractAttributionManager {
+    constructor();
+    /**
+     * @param {Array<AttributedContent<any>>} contents - where to write the result
+     * @param {number} _client
+     * @param {number} clock
+     * @param {boolean} deleted
+     * @param {AbstractContent} content
+     * @param {0|1|2} shouldRender - whether this should render or just result in a `retain` operation
+     */
+    readContent(contents: Array<AttributedContent<any>>, _client: number, clock: number, deleted: boolean, content: AbstractContent, shouldRender: 0 | 1 | 2): void;
+    /**
+     * @param {Item} item
+     * @return {number}
+     */
+    contentLength(item: Item): number;
+}
+export const noAttributionsManager: NoAttributionsManager;
+/**
+ * @implements AbstractAttributionManager
+ *
+ * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
+ */
+export class DiffAttributionManager extends ObservableV2<{
+    change: (idset: IdSet, origin: any, local: boolean) => void;
+}> implements AbstractAttributionManager {
+    /**
+     * @param {Doc} prevDoc
+     * @param {Doc} nextDoc
+     */
+    constructor(prevDoc: Doc, nextDoc: Doc);
+    inserts: IdMap<any>;
+    deletes: IdMap<any>;
+    _prevDoc: Doc;
+    _prevDocStore: StructStore;
+    _nextDoc: Doc;
+    _nextBOH: (arg0: Transaction, arg1: Doc) => void;
+    _prevBOH: (arg0: Transaction, arg1: Doc) => void;
+    _prevUpdateListener: (arg0: Uint8Array<ArrayBuffer>, arg1: any, arg2: Doc, arg3: Transaction) => void;
+    _ndUpdateListener: (arg0: Uint8Array<ArrayBuffer>, arg1: any, arg2: Doc, arg3: Transaction) => void;
+    _afterTrListener: (arg0: Transaction, arg1: Doc) => void;
+    suggestionMode: boolean;
+    /**
+     * Optionally limit origins that may sync changes to the main doc if suggestion-mode is
+     * disabled.
+     *
+     * @type {Array<any>?}
+     */
+    suggestionOrigins: Array<any> | null;
+    _destroyHandler: (arg0: Doc) => void;
+    /**
+     * @param {ID} start
+     * @param {ID} end
+     */
+    acceptChanges(start: ID, end?: ID): void;
+    /**
+     * @param {ID} start
+     * @param {ID} end
+     */
+    rejectChanges(start: ID, end?: ID): void;
+    /**
+     * @param {Array<AttributedContent<any>>} contents - where to write the result
+     * @param {number} client
+     * @param {number} clock
+     * @param {boolean} deleted
+     * @param {AbstractContent} _content
+     * @param {0|1|2} shouldRender - whether this should render or just result in a `retain` operation
+     */
+    readContent(contents: Array<AttributedContent<any>>, client: number, clock: number, deleted: boolean, _content: AbstractContent, shouldRender: 0 | 1 | 2): void;
+    /**
+     * @param {Item} item
+     * @return {number}
+     */
+    contentLength(item: Item): number;
+}
+export function createAttributionManagerFromDiff(prevDoc: Doc, nextDoc: Doc): DiffAttributionManager;
+/**
+ * Intended for projects that used the v13 snapshot feature. With this AttributionManager you can
+ * read content similar to the previous snapshot api. Requires that `ydoc.gc` is turned off.
+ *
+ * @implements AbstractAttributionManager
+ *
+ * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
+ */
+export class SnapshotAttributionManager extends ObservableV2<{
+    change: (idset: IdSet, origin: any, local: boolean) => void;
+}> implements AbstractAttributionManager {
+    /**
+     * @param {Snapshot} prevSnapshot
+     * @param {Snapshot} nextSnapshot
+     */
+    constructor(prevSnapshot: Snapshot, nextSnapshot: Snapshot);
+    prevSnapshot: Snapshot;
+    nextSnapshot: Snapshot;
+    attrs: IdMap<any>;
+    /**
+     * @param {Array<AttributedContent<any>>} contents - where to write the result
+     * @param {number} client
+     * @param {number} clock
+     * @param {boolean} _deleted
+     * @param {AbstractContent} content
+     * @param {0|1|2} shouldRender - whether this should render or just result in a `retain` operation
+     */
+    readContent(contents: Array<AttributedContent<any>>, client: number, clock: number, _deleted: boolean, content: AbstractContent, shouldRender: 0 | 1 | 2): void;
+    /**
+     * @param {Item} item
+     * @return {number}
+     */
+    contentLength(item: Item): number;
+}
+export function createAttributionManagerFromSnapshots(prevSnapshot: Snapshot, nextSnapshot?: Snapshot): SnapshotAttributionManager;
+export type Attribution = s.Unwrap<typeof attributionJsonSchema>;
+import * as s from 'lib0/schema';
+import { AbstractContent } from '../internals.js';
+import { IdSet } from '../internals.js';
+import { ObservableV2 } from 'lib0/observable';
+import { Item } from '../internals.js';
+import { IdMap } from '../internals.js';
+import { Doc } from '../internals.js';
+import { StructStore } from '../internals.js';
+import { Transaction } from '../internals.js';
+import { ID } from '../internals.js';
+import { Snapshot } from '../internals.js';
+//# sourceMappingURL=AttributionManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AttributionManager.d.ts","sourceRoot":"","sources":["../../../src/utils/AttributionManager.js"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,267 @@
+export const generateNewClientId: typeof random.uint32;
+/**
+ * @typedef {import('../utils/types.js').YTypeConstructors} YTypeConstructors
+ */
+/**
+ * @typedef {import('../utils/types.js').YType} YType
+ */
+/**
+ * @typedef {Object} DocOpts
+ * @property {boolean} [DocOpts.gc=true] Disable garbage collection (default: gc=true)
+ * @property {function(Item):boolean} [DocOpts.gcFilter] Will be called before an Item is garbage collected. Return false to keep the Item.
+ * @property {string} [DocOpts.guid] Define a globally unique identifier for this document
+ * @property {string | null} [DocOpts.collectionid] Associate this document with a collection. This only plays a role if your provider has a concept of collection.
+ * @property {any} [DocOpts.meta] Any kind of meta information you want to associate with this document. If this is a subdocument, remote peers will store the meta information as well.
+ * @property {boolean} [DocOpts.autoLoad] If a subdocument, automatically load document. If this is a subdocument, remote peers will load the document as well automatically.
+ * @property {boolean} [DocOpts.shouldLoad] Whether the document should be synced by the provider now. This is toggled to true when you call ydoc.load()
+ * @property {boolean} [DocOpts.isSuggestionDoc] Set to true if this document merely suggests
+ * changes. If this flag is not set in a suggestion document, automatic formatting changes will be
+ * displayed as suggestions, which might not be intended.
+ */
+/**
+ * @typedef {Object} DocEvents
+ * @property {function(Doc):void} DocEvents.destroy
+ * @property {function(Doc):void} DocEvents.load
+ * @property {function(boolean, Doc):void} DocEvents.sync
+ * @property {function(Uint8Array<ArrayBuffer>, any, Doc, Transaction):void} DocEvents.update
+ * @property {function(Uint8Array<ArrayBuffer>, any, Doc, Transaction):void} DocEvents.updateV2
+ * @property {function(Doc):void} DocEvents.beforeAllTransactions
+ * @property {function(Transaction, Doc):void} DocEvents.beforeTransaction
+ * @property {function(Transaction, Doc):void} DocEvents.beforeObserverCalls
+ * @property {function(Transaction, Doc):void} DocEvents.afterTransaction
+ * @property {function(Transaction, Doc):void} DocEvents.afterTransactionCleanup
+ * @property {function(Doc, Array<Transaction>):void} DocEvents.afterAllTransactions
+ * @property {function({ loaded: Set<Doc>, added: Set<Doc>, removed: Set<Doc> }, Doc, Transaction):void} DocEvents.subdocs
+ */
+/**
+ * A Yjs instance handles the state of shared data.
+ * @extends ObservableV2<DocEvents>
+ */
+export class Doc extends ObservableV2<DocEvents> {
+    /**
+     * @param {DocOpts} opts configuration
+     */
+    constructor({ guid, collectionid, gc, gcFilter, meta, autoLoad, shouldLoad, isSuggestionDoc }?: DocOpts);
+    gc: boolean;
+    gcFilter: (arg0: Item) => boolean;
+    clientID: number;
+    guid: string;
+    collectionid: string | null;
+    isSuggestionDoc: boolean;
+    cleanupFormatting: boolean;
+    /**
+     * @type {Map<string, YType>}
+     */
+    share: Map<string, YType>;
+    store: StructStore;
+    /**
+     * @type {Transaction | null}
+     */
+    _transaction: Transaction | null;
+    /**
+     * @type {Array<Transaction>}
+     */
+    _transactionCleanups: Array<Transaction>;
+    /**
+     * @type {Set<Doc>}
+     */
+    subdocs: Set<Doc>;
+    /**
+     * If this document is a subdocument - a document integrated into another document - then _item is defined.
+     * @type {Item?}
+     */
+    _item: Item | null;
+    shouldLoad: boolean;
+    autoLoad: boolean;
+    meta: any;
+    /**
+     * This is set to true when the persistence provider loaded the document from the database or when the `sync` event fires.
+     * Note that not all providers implement this feature. Provider authors are encouraged to fire the `load` event when the doc content is loaded from the database.
+     *
+     * @type {boolean}
+     */
+    isLoaded: boolean;
+    /**
+     * This is set to true when the connection provider has successfully synced with a backend.
+     * Note that when using peer-to-peer providers this event may not provide very useful.
+     * Also note that not all providers implement this feature. Provider authors are encouraged to fire
+     * the `sync` event when the doc has been synced (with `true` as a parameter) or if connection is
+     * lost (with false as a parameter).
+     */
+    isSynced: boolean;
+    isDestroyed: boolean;
+    /**
+     * Promise that resolves once the document has been loaded from a persistence provider.
+     */
+    whenLoaded: Promise<any>;
+    whenSynced: Promise<any>;
+    /**
+     * Notify the parent document that you request to load data into this subdocument (if it is a subdocument).
+     *
+     * `load()` might be used in the future to request any provider to load the most current data.
+     *
+     * It is safe to call `load()` multiple times.
+     */
+    load(): void;
+    getSubdocs(): Set<Doc>;
+    getSubdocGuids(): Set<string>;
+    /**
+     * Changes that happen inside of a transaction are bundled. This means that
+     * the observer fires _after_ the transaction is finished and that all changes
+     * that happened inside of the transaction are sent as one message to the
+     * other peers.
+     *
+     * @template T
+     * @param {function(Transaction):T} f The function that should be executed as a transaction
+     * @param {any} [origin] Origin of who started the transaction. Will be stored on transaction.origin
+     * @return T
+     *
+     * @public
+     */
+    public transact<T>(f: (arg0: Transaction) => T, origin?: any): T;
+    /**
+     * Define a shared data type.
+     *
+     * Multiple calls of `ydoc.get(name, TypeConstructor)` yield the same result
+     * and do not overwrite each other. I.e.
+     * `ydoc.get(name, Y.Array) === ydoc.get(name, Y.Array)`
+     *
+     * After this method is called, the type is also available on `ydoc.share.get(name)`.
+     *
+     * *Best Practices:*
+     * Define all types right after the Y.Doc instance is created and store them in a separate object.
+     * Also use the typed methods `getText(name)`, `getArray(name)`, ..
+     *
+     * @template {YTypeConstructors} [TypeC=typeof AbstractType]
+     * @example
+     *   const ydoc = new Y.Doc(..)
+     *   const appState = {
+     *     document: ydoc.getText('document')
+     *     comments: ydoc.getArray('comments')
+     *   }
+     *
+     * @param {string} name
+     * @param {TypeC} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...
+     * @return {AbstractType} The created type. Constructed with TypeConstructor
+     *
+     * @public
+     */
+    public get<TypeC extends YTypeConstructors = typeof AbstractType>(name: string, TypeConstructor?: TypeC): AbstractType;
+    /**
+     * @template T
+     * @param {string} [name]
+     * @return {YArray<T>}
+     *
+     * @public
+     */
+    public getArray<T>(name?: string): YArray<T>;
+    /**
+     * @param {string} [name]
+     * @return {YText}
+     *
+     * @public
+     */
+    public getText(name?: string): YText;
+    /**
+     * @template T
+     * @param {string} [name]
+     * @return {YMap<T>}
+     *
+     * @public
+     */
+    public getMap<T>(name?: string): YMap<T>;
+    /**
+     * @param {string} [name]
+     * @return {YXmlElement}
+     *
+     * @public
+     */
+    public getXmlElement(name?: string): YXmlElement;
+    /**
+     * @param {string} [name]
+     * @return {YXmlFragment}
+     *
+     * @public
+     */
+    public getXmlFragment(name?: string): YXmlFragment;
+    /**
+     * Converts the entire document into a js object, recursively traversing each yjs type
+     * Doesn't log types that have not been defined (using ydoc.getType(..)).
+     *
+     * @deprecated Do not use this method and rather call toJSON directly on the shared types.
+     *
+     * @return {Object<string, any>}
+     */
+    toJSON(): {
+        [x: string]: any;
+    };
+}
+export function cloneDoc(ydoc: Doc, opts?: DocOpts): Doc;
+export type YTypeConstructors = import("../utils/types.js").YTypeConstructors;
+export type YType = import("../utils/types.js").YType;
+export type DocOpts = {
+    /**
+     * Disable garbage collection (default: gc=true)
+     */
+    gc?: boolean | undefined;
+    /**
+     * Will be called before an Item is garbage collected. Return false to keep the Item.
+     */
+    gcFilter?: ((arg0: Item) => boolean) | undefined;
+    /**
+     * Define a globally unique identifier for this document
+     */
+    guid?: string | undefined;
+    /**
+     * Associate this document with a collection. This only plays a role if your provider has a concept of collection.
+     */
+    collectionid?: string | null | undefined;
+    /**
+     * Any kind of meta information you want to associate with this document. If this is a subdocument, remote peers will store the meta information as well.
+     */
+    meta?: any;
+    /**
+     * If a subdocument, automatically load document. If this is a subdocument, remote peers will load the document as well automatically.
+     */
+    autoLoad?: boolean | undefined;
+    /**
+     * Whether the document should be synced by the provider now. This is toggled to true when you call ydoc.load()
+     */
+    shouldLoad?: boolean | undefined;
+    /**
+     * Set to true if this document merely suggests
+     * changes. If this flag is not set in a suggestion document, automatic formatting changes will be
+     * displayed as suggestions, which might not be intended.
+     */
+    isSuggestionDoc?: boolean | undefined;
+};
+export type DocEvents = {
+    destroy: (arg0: Doc) => void;
+    load: (arg0: Doc) => void;
+    sync: (arg0: boolean, arg1: Doc) => void;
+    update: (arg0: Uint8Array<ArrayBuffer>, arg1: any, arg2: Doc, arg3: Transaction) => void;
+    updateV2: (arg0: Uint8Array<ArrayBuffer>, arg1: any, arg2: Doc, arg3: Transaction) => void;
+    beforeAllTransactions: (arg0: Doc) => void;
+    beforeTransaction: (arg0: Transaction, arg1: Doc) => void;
+    beforeObserverCalls: (arg0: Transaction, arg1: Doc) => void;
+    afterTransaction: (arg0: Transaction, arg1: Doc) => void;
+    afterTransactionCleanup: (arg0: Transaction, arg1: Doc) => void;
+    afterAllTransactions: (arg0: Doc, arg1: Array<Transaction>) => void;
+    subdocs: (arg0: {
+        loaded: Set<Doc>;
+        added: Set<Doc>;
+        removed: Set<Doc>;
+    }, arg1: Doc, arg2: Transaction) => void;
+};
+import * as random from 'lib0/random';
+import { ObservableV2 } from 'lib0/observable';
+import { Item } from '../internals.js';
+import { StructStore } from '../internals.js';
+import { Transaction } from '../internals.js';
+import { AbstractType } from '../internals.js';
+import { YArray } from '../internals.js';
+import { YText } from '../internals.js';
+import { YMap } from '../internals.js';
+import { YXmlElement } from '../internals.js';
+import { YXmlFragment } from '../internals.js';
+//# sourceMappingURL=Doc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Doc.d.ts","sourceRoot":"","sources":["../../../src/utils/Doc.js"],"names":[],"mappings":"AAwBA,uDAAgD;AAEhD;;GAEG;AACH;;GAEG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH;IACE;;OAEG;IACH,gGAFW,OAAO,EAwFjB;IApFC,YAAY;IACZ,iBAtCmB,IAAI,KAAE,OAAO,CAsCR;IACxB,iBAAqC;IACrC,aAAgB;IAChB,4BAAgC;IAChC,yBAAsC;IACtC,2BAAyC;IACzC;;OAEG;IACH,OAFU,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAEN;IACtB,mBAA8B;IAC9B;;OAEG;IACH,cAFU,WAAW,GAAG,IAAI,CAEJ;IACxB;;OAEG;IACH,sBAFU,KAAK,CAAC,WAAW,CAAC,CAEE;IAC9B;;OAEG;IACH,SAFU,GAAG,CAAC,GAAG,CAAC,CAEM;IACxB;;;OAGG;IACH,OAFU,IAAI,OAAC,CAEE;IACjB,oBAA4B;IAC5B,kBAAwB;IACxB,UAAgB;IAChB;;;;;OAKG;IACH,UAFU,OAAO,CAEI;IACrB;;;;;;OAMG;IACH,kBAAqB;IACrB,qBAAwB;IACxB;;OAEG;IACH,yBAKE;IAeE,yBAAwC;IAe9C;;;;;;OAMG;IACH,aAQC;IAED,uBAEC;IAED,8BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gBAPa,CAAC,KACH,CAAS,IAAW,EAAX,WAAW,KAAE,CAAC,WACvB,GAAG,KAOb;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,WAdkC,KAAK,SAAzB,iBAAkB,8BAQrB,MAAM,oBACN,KAAK,GACJ,YAAY,CAqCvB;IAED;;;;;;OAMG;IACH,gBANa,CAAC,SACH,MAAM,GACL,MAAM,CAAC,CAAC,CAAC,CAMpB;IAED;;;;;OAKG;IACH,sBALW,MAAM,GACL,KAAK,CAMhB;IAED;;;;;;OAMG;IACH,cANa,CAAC,SACH,MAAM,GACL,IAAI,CAAC,CAAC,CAAC,CAMlB;IAED;;;;;OAKG;IACH,4BALW,MAAM,GACL,WAAW,CAMtB;IAED;;;;;OAKG;IACH,6BALW,MAAM,GACL,YAAY,CAMvB;IAED;;;;;;;OAOG;IACH;;MAWC;CA2BF;AAMM,+BAHI,GAAG,SACH,OAAO,OAMjB;gCAxVY,OAAO,mBAAmB,EAAE,iBAAiB;oBAG7C,OAAO,mBAAmB,EAAE,KAAK;;;;;;;;;uBAMvB,IAAI,KAAE,OAAO;;;;;;;;;;;;WAGtB,GAAG;;;;;;;;;;;;;;;;;aAUH,CAAS,IAAG,EAAH,GAAG,KAAE,IAAI;UAClB,CAAS,IAAG,EAAH,GAAG,KAAE,IAAI;UAClB,CAAS,IAAO,EAAP,OAAO,EAAE,IAAG,EAAH,GAAG,KAAE,IAAI;YAC3B,CAAS,IAAuB,EAAvB,UAAU,CAAC,WAAW,CAAC,EAAE,IAAG,EAAH,GAAG,EAAE,IAAG,EAAH,GAAG,EAAE,IAAW,EAAX,WAAW,KAAE,IAAI;cAC7D,CAAS,IAAuB,EAAvB,UAAU,CAAC,WAAW,CAAC,EAAE,IAAG,EAAH,GAAG,EAAE,IAAG,EAAH,GAAG,EAAE,IAAW,EAAX,WAAW,KAAE,IAAI;2BAC7D,CAAS,IAAG,EAAH,GAAG,KAAE,IAAI;uBAClB,CAAS,IAAW,EAAX,WAAW,EAAE,IAAG,EAAH,GAAG,KAAE,IAAI;yBAC/B,CAAS,IAAW,EAAX,WAAW,EAAE,IAAG,EAAH,GAAG,KAAE,IAAI;sBAC/B,CAAS,IAAW,EAAX,WAAW,EAAE,IAAG,EAAH,GAAG,KAAE,IAAI;6BAC/B,CAAS,IAAW,EAAX,WAAW,EAAE,IAAG,EAAH,GAAG,KAAE,IAAI;0BAC/B,CAAS,IAAG,EAAH,GAAG,EAAE,IAAkB,EAAlB,KAAK,CAAC,WAAW,CAAC,KAAE,IAAI;aACtC,CAAS,IAAwD,EAAxD;QAAE,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;QAAC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;KAAE,EAAE,IAAG,EAAH,GAAG,EAAE,IAAW,EAAX,WAAW,KAAE,IAAI;;wBAzC/E,aAAa;6BADR,iBAAiB;qBAFvC,iBAAiB;4BAAjB,iBAAiB;4BAAjB,iBAAiB;6BAAjB,iBAAiB;uBAAjB,iBAAiB;sBAAjB,iBAAiB;qBAAjB,iBAAiB;4BAAjB,iBAAiB;6BAAjB,iBAAiB"}

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

@@ -0,0 +1,19 @@
+/**
+ * General event handler implementation.
+ *
+ * @template ARG0, ARG1
+ *
+ * @private
+ */
+export class EventHandler<ARG0, ARG1> {
+    /**
+     * @type {Array<function(ARG0, ARG1):void>}
+     */
+    l: Array<(arg0: ARG0, arg1: ARG1) => void>;
+}
+export function createEventHandler<ARG0, ARG1>(): EventHandler<ARG0, ARG1>;
+export function addEventHandlerListener<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>, f: (arg0: ARG0, arg1: ARG1) => void): number;
+export function removeEventHandlerListener<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>, f: (arg0: ARG0, arg1: ARG1) => void): void;
+export function removeAllEventHandlerListeners<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>): void;
+export function callEventHandlerListeners<ARG0, ARG1>(eventHandler: EventHandler<ARG0, ARG1>, arg0: ARG0, arg1: ARG1): void;
+//# sourceMappingURL=EventHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EventHandler.d.ts","sourceRoot":"","sources":["../../../src/utils/EventHandler.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,0BAJa,IAAI,EAAE,IAAI;IAMnB;;OAEG;IACH,GAFU,KAAK,CAAC,CAAS,IAAI,EAAJ,IAAI,EAAE,IAAI,EAAJ,IAAI,KAAE,IAAI,CAAC,CAE/B;CAEd;AASM,mCANM,IAAI,EAAC,IAAI,KACT,YAAY,CAAC,IAAI,EAAC,IAAI,CAAC,CAKsB;AAanD,wCAPM,IAAI,EAAC,IAAI,gBACX,YAAY,CAAC,IAAI,EAAC,IAAI,CAAC,KACvB,CAAS,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,KAAE,IAAI,UAMX;AAajB,2CARM,IAAI,EAAC,IAAI,gBACX,YAAY,CAAC,IAAI,EAAC,IAAI,CAAC,KACvB,CAAS,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,KAAE,IAAI,QAalC;AAUM,+CANM,IAAI,EAAC,IAAI,gBACX,YAAY,CAAC,IAAI,EAAC,IAAI,CAAC,QAOjC;AAcM,0CARM,IAAI,EAAC,IAAI,gBACX,YAAY,CAAC,IAAI,EAAC,IAAI,CAAC,QACvB,IAAI,QACJ,IAAI,QAM0B"}

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

@@ -0,0 +1,26 @@
+export class ID {
+    /**
+     * @param {number} client client id
+     * @param {number} clock unique per client id, continuous number
+     */
+    constructor(client: number, clock: number);
+    /**
+     * Client id
+     * @type {number}
+     */
+    client: number;
+    /**
+     * unique per client id, continuous number
+     * @type {number}
+     */
+    clock: number;
+}
+export function compareIDs(a: ID | null, b: ID | null): boolean;
+export function createID(client: number, clock: number): ID;
+export function writeID(encoder: encoding.Encoder, id: ID): void;
+export function readID(decoder: decoding.Decoder): ID;
+export function findRootTypeKey(type: AbstractType<any>): string;
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+import { AbstractType } from '../internals.js';
+//# sourceMappingURL=ID.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ID.d.ts","sourceRoot":"","sources":["../../../src/utils/ID.js"],"names":[],"mappings":"AAMA;IACE;;;OAGG;IACH,oBAHW,MAAM,SACN,MAAM,EAahB;IAVC;;;OAGG;IACH,QAFU,MAAM,CAEI;IACpB;;;OAGG;IACH,OAFU,MAAM,CAEE;CAErB;AASM,8BANI,EAAE,GAAG,IAAI,KACT,EAAE,GAAG,IAAI,GACR,OAAO,CAIsG;AASlH,iCANI,MAAM,SACN,MAAM,MAK+C;AASzD,iCANI,QAAQ,CAAC,OAAO,MAChB,EAAE,QAQZ;AAaM,gCANI,QAAQ,CAAC,OAAO,GACf,EAAE,CAM0D;AAajE,sCANI,YAAY,CAAC,GAAG,CAAC,GAChB,MAAM,CAajB;0BArFyB,eAAe;0BADf,eAAe;6BAFZ,iBAAiB"}