edytor 1.0.0-rc.2 → 1.0.0

package/dist/crdt/vendor/yjs/dts/utils/RangeCursor.d.ts

@@ -1,28 +1,24 @@
 /**
  * One element of the bounded read stream produced by {@link RangeCursor#read}
- * — the read-side analogue of a delta op's content payload, carrying the same
- * attribution inputs `YNode#toDelta` consumes (mode `1` semantics).
+ * — one live piece of content overlapping the range, with the formats folded
+ * at it.
  *
  * @typedef {Object} RangePiece
  * @property {AbstractContent} content - the piece's content object. BORROWED
- *   from the item (never mutated, never copied) or produced by the renderer.
+ *   from the item (never mutated, never copied).
  *   Emit `[offset, offset + len)` of it: slice `content.str` for
- *   `ContentString` (UTF-16 units — identical to clipping a `toDelta` insert
- *   op's string) and index `content.getContent()` for element content.
+ *   `ContentString` (UTF-16 units) and index `content.getContent()` for
+ *   element content.
  * @property {ID} id - replicated id of the first emitted element.
  * @property {number} index - rendered position the emitted range starts at.
  * @property {number} offset - start of the emitted range inside `content`.
- * @property {number} len - rendered length of the emitted range. `0` for
- *   `ContentFormat` markers and for pieces occupying no rendered position
- *   (renderer-hidden or unattributed tombstones).
- * @property {boolean} deleted - effective tombstone flag (renderer-aware: a
- *   restored piece clears it, an attributed tombstone keeps it).
- * @property {Array<ContentAttribute<any>>?} attrs - native attribution
- *   inputs (`createAttributionFromAttributionItems` computes the delta-level
- *   `Attribution` from them); `null` when unattributed.
+ * @property {number} len - rendered length of the emitted range (`0` for a
+ *   live piece occupying no position).
+ * @property {boolean} deleted - always `false`: a read emits live content only.
+ * @property {null} attrs - always `null` (no attribution layer).
  * @property {Object<string,any>|undefined} formats - folded format state at
- *   the piece (the `toDelta` `format` object equivalent). SHARED between
- *   adjacent pieces of one fold state — treat as read-only.
+ *   the piece. SHARED between adjacent pieces of one fold state — treat as
+ *   read-only.
  */
 /**
  * A forward-only, read-only cursor over one `YNode` list. Fields mirror
@@ -32,20 +28,13 @@
  */
 export class RangeCursor {
     /**
-     * @param {YNode<any>} parent - the list node to read.
-     * @param {AbstractRenderer?} [renderer] - defaults to the node's active
-     *   renderer (`this._renderer`), the `toDelta`/`applyDelta` convention.
-     *   Pass `null` to force the generic interpretation.
+     * @param {YNode} parent - the list node to read.
      */
-    constructor(parent: YNode<any>, renderer?: AbstractRenderer | null);
+    constructor(parent: YNode);
     /**
-     * @type {YNode<any>}
+     * @type {YNode}
      */
-    parent: YNode<any>;
-    /**
-     * @type {AbstractRenderer?}
-     */
-    renderer: AbstractRenderer | null;
+    parent: YNode;
     /**
      * The next unprocessed sequence item — a parked cursor keeps `index` at
      * its left edge.
@@ -55,7 +44,7 @@ export class RangeCursor {
     /**
      * Rendered units strictly before `p` — the
      * `ItemTextListPosition#index`/`ArraySearchMarker#index` space
-     * (countable, non-deleted units while `renderer === null`).
+     * (countable, non-deleted units).
      * @type {number}
      */
     index: number;
@@ -83,30 +72,25 @@ export class RangeCursor {
      * from the best engine-owned checkpoint — an `ArraySearchMarker`
      * carrying a `formats` snapshot.
      *
-     * Read-seed eligibility is deliberately WEAKER than `applyDelta`'s
-     * mutation seed (UPSTREAM.md YP5): a read may resume on ANY item at-or-left
+     * Read-seed eligibility is deliberately WEAKER than the write cursor's
+     * seed (UPSTREAM.md YP5): a read may resume on ANY item at-or-left
      * of the target — the forward fold reproduces format state from the
      * snapshot — while the mutation cursor must anchor on the FIRST item at
      * the index (its `p.left` must be countable-or-null). Both consume the
      * same marker records and snapshots.
      *
-     * Restricted to `renderer === null` for the same reason the mutation seed
-     * is: `marker.index` records the raw countable space, which a renderer's
-     * `contentLength` can reinterpret.
-     *
      * @param {number} index
      */
     seek(index: number): void;
     /**
-     * Fold one `ContentFormat` piece into the cursor's format state — the
-     * `!deleted` gate mirrors `ItemTextListPosition#forward`/`toDelta`: a
-     * tombstoned marker (or a piece the renderer renders as deleted) applies
-     * nothing.
+     * Fold one `ContentFormat` item into the cursor's format state — the
+     * `!deleted` gate mirrors `ItemTextListPosition#forward`: a tombstoned
+     * marker applies nothing.
      *
-     * @param {AttributedContent<any>} c
+     * @param {import('../structs/Item.js').Item} item
      * @param {{ markers: number }?} stats
      */
-    _foldPiece(c: AttributedContent<any>, stats: {
+    _foldItem(item: import("../structs/Item.js").Item, stats: {
         markers: number;
     } | null): void;
     /**
@@ -122,9 +106,8 @@ export class RangeCursor {
     } | undefined;
     /**
      * Emit the {@link RangePiece}s of `[i0, i1)` — a bounded, read-only walk
-     * of the item list producing the same pieces `toDelta`'s current-state
-     * render consumes (`readItemPieces`), clipped to the range and carrying
-     * folded format state + native attribution inputs.
+     * of the item list producing its live content, clipped to the range and
+     * carrying the folded format state.
      *
      * The cursor is left positioned to serve the NEXT forward read cheaply:
      * items fully consumed advance `p`/`index`; a range ending inside an
@@ -146,16 +129,16 @@ export class RangeCursor {
 }
 /**
  * One element of the bounded read stream produced by {@link RangeCursor#read}
- * — the read-side analogue of a delta op's content payload, carrying the same
- * attribution inputs `YNode#toDelta` consumes (mode `1` semantics).
+ * — one live piece of content overlapping the range, with the formats folded
+ * at it.
  */
 export type RangePiece = {
     /**
      * - the piece's content object. BORROWED
-     * from the item (never mutated, never copied) or produced by the renderer.
+     * from the item (never mutated, never copied).
      * Emit `[offset, offset + len)` of it: slice `content.str` for
-     * `ContentString` (UTF-16 units — identical to clipping a `toDelta` insert
-     * op's string) and index `content.getContent()` for element content.
+     * `ContentString` (UTF-16 units) and index `content.getContent()` for
+     * element content.
      */
     content: AbstractContent;
     /**
@@ -171,26 +154,22 @@ export type RangePiece = {
      */
     offset: number;
     /**
-     * - rendered length of the emitted range. `0` for
-     * `ContentFormat` markers and for pieces occupying no rendered position
-     * (renderer-hidden or unattributed tombstones).
+     * - rendered length of the emitted range (`0` for a
+     * live piece occupying no position).
      */
     len: number;
     /**
-     * - effective tombstone flag (renderer-aware: a
-     * restored piece clears it, an attributed tombstone keeps it).
+     * - always `false`: a read emits live content only.
      */
     deleted: boolean;
     /**
-     * - native attribution
-     * inputs (`createAttributionFromAttributionItems` computes the delta-level
-     * `Attribution` from them); `null` when unattributed.
+     * - always `null` (no attribution layer).
      */
-    attrs: Array<ContentAttribute<any>> | null;
+    attrs: null;
     /**
      * - folded format state at
-     * the piece (the `toDelta` `format` object equivalent). SHARED between
-     * adjacent pieces of one fold state — treat as read-only.
+     * the piece. SHARED between adjacent pieces of one fold state — treat as
+     * read-only.
      */
     formats: {
         [x: string]: any;

package/dist/crdt/vendor/yjs/dts/utils/Transaction.d.ts

@@ -2,25 +2,10 @@ export const generateNewClientId: typeof random.uint53;
 /**
  * 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:
+ * minimize the number of messages sent.
  *
- * @example
- * const ydoc = new Y.Doc()
- * const map = ydoc.get('map')
- * // Log content when change is triggered
- * map.observe(() => {
- *   console.log('change triggered')
- * })
- * // Each change on the map type triggers a log message:
- * map.setAttr('a', 0) // => "change triggered"
- * map.setAttr('b', 0) // => "change triggered"
- * // When put in a transaction, it will trigger the log after the transaction:
- * ydoc.transact(() => {
- *   map.setAttr('a', 1)
- *   map.setAttr('b', 1)
- * }) // => "change triggered"
+ * YP19: a commit is told through the document's events (`commit`, then
+ * `afterTransaction`); nodes have no observers.
  *
  * @public
  */
@@ -40,25 +25,10 @@ export class Transaction {
      * Describes the set of deleted items by ids
      */
     deleteSet: import("./ids.js").IdSet;
-    /**
-     * Describes the set of items that are cleaned up / deleted by ids. It is a subset of
-     * this.deleteSet
-     */
-    cleanUps: import("./ids.js").IdSet;
     /**
      * Describes the set of inserted items by ids
      */
     insertSet: import("./ids.js").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.
@@ -66,12 +36,6 @@ export class Transaction {
      * @type {Map<YNode,Set<String|null>>}
      */
     changed: Map<YNode, Set<string | null>>;
-    /**
-     * Stores the events for the types that observe also child elements.
-     * It is mainly used by `observeDeep`.
-     * @type {Map<YNode,Array<YEvent<any>>>}
-     */
-    changedParentTypes: Map<YNode, Array<YEvent<any>>>;
     /**
      * @type {Array<AbstractStruct>}
      */
@@ -80,50 +44,11 @@ export class Transaction {
      * @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 cleanupYTextFormatting(type: YNode): number;
-export function cleanupYTextAfterTransaction(transaction: Transaction): void;
 export function transact<T>(doc: Doc, f: (arg0: Transaction) => T, origin?: any, local?: boolean): T;
 import * as random from 'lib0-v14/random';
-import { YEvent } from './YEvent.js';

package/dist/crdt/vendor/yjs/dts/utils/UpdateDecoder.d.ts

@@ -1,78 +1,4 @@
-/**
- * @typedef {IdSetDecoderV1 | IdSetDecoderV2} IdSetDecoder
- */
-export class IdSetDecoderV1 {
-    /**
-     * @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 IdSetDecoderV1 {
-    /**
-     * @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 IdSetDecoderV2 {
+export class IdSetDecoder {
     /**
      * @param {decoding.Decoder} decoder
      */
@@ -92,7 +18,7 @@ export class IdSetDecoderV2 {
      */
     readDsLen(): number;
 }
-export class UpdateDecoderV2 extends IdSetDecoderV2 {
+export class UpdateDecoder extends IdSetDecoder {
     /**
      * List of cached keys. If the keys[id] does not exist, we read a new key
      * from stringEncoder and push it to keys.
@@ -153,10 +79,6 @@ export class UpdateDecoderV2 extends IdSetDecoderV2 {
      */
     readBuf(): Uint8Array;
     /**
-     * This is mainly here for legacy purposes.
-     *
-     * Initial we incoded objects using JSON. Now we use the much faster lib0-v14/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
-     *
      * @return {any}
      */
     readJSON(): any;
@@ -165,6 +87,5 @@ export class UpdateDecoderV2 extends IdSetDecoderV2 {
      */
     readKey(): string;
 }
-export type IdSetDecoder = IdSetDecoderV1 | IdSetDecoderV2;
 import * as decoding from 'lib0-v14/decoding';
 import { ID } from './ID.js';

package/dist/crdt/vendor/yjs/dts/utils/UpdateEncoder.d.ts

@@ -1,70 +1,4 @@
-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 {
+export class IdSetEncoder {
     restEncoder: encoding.Encoder;
     dsCurrVal: number;
     toUint8Array(): Uint8Array<ArrayBuffer>;
@@ -78,7 +12,7 @@ export class IdSetEncoderV2 {
      */
     writeIdSetLen(len: number): void;
 }
-export class UpdateEncoderV2 extends IdSetEncoderV2 {
+export class UpdateEncoder extends IdSetEncoder {
     /**
      * @type {Map<string,number>}
      */
@@ -142,10 +76,6 @@ export class UpdateEncoderV2 extends IdSetEncoderV2 {
      */
     writeBuf(buf: Uint8Array): void;
     /**
-     * This is mainly here for legacy purposes.
-     *
-     * Initial we incoded objects using JSON. Now we use the much faster lib0-v14/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
-     *
      * @param {any} embed
      */
     writeJSON(embed: any): void;
@@ -159,6 +89,4 @@ export class UpdateEncoderV2 extends IdSetEncoderV2 {
      */
     writeKey(key: string): void;
 }
-export type IdSetEncoder = IdSetEncoderV1 | IdSetEncoderV2;
-export type UpdateEncoder = UpdateEncoderV1 | UpdateEncoderV2;
 import * as encoding from 'lib0-v14/encoding';

package/dist/crdt/vendor/yjs/dts/utils/encoding-helpers.d.ts

@@ -1,5 +1,5 @@
-export function writeStructs(encoder: UpdateEncoderV1 | UpdateEncoderV2, structs: Array<GC | Item | Skip>, client: number, idranges: Array<IdRange>): void;
-export function writeStructsFromIdSet(encoder: UpdateEncoderV1 | UpdateEncoderV2, store: StructStore, idset: IdSet): void;
-export function writeStructsFromTransaction(encoder: UpdateEncoderV1 | UpdateEncoderV2, transaction: Transaction): void;
-export function writeUpdateMessageFromTransaction(encoder: UpdateEncoderV1 | UpdateEncoderV2, transaction: Transaction): boolean;
+export function writeStructs(encoder: UpdateEncoder, structs: Array<GC | Item | Skip>, client: number, idranges: Array<IdRange>): void;
+export function writeStructsFromIdSet(encoder: UpdateEncoder, store: StructStore, idset: IdSet): void;
+export function writeStructsFromTransaction(encoder: UpdateEncoder, transaction: Transaction): void;
+export function writeUpdateMessageFromTransaction(encoder: UpdateEncoder, transaction: Transaction): boolean;
 import { Skip } from '../structs/Skip.js';

package/dist/crdt/vendor/yjs/dts/utils/encoding.d.ts

@@ -1,26 +1,14 @@
-export function writeClientsStructs(encoder: UpdateEncoderV1 | UpdateEncoderV2, store: StructStore, _sm: Map<number, number>): void;
-export function readUpdateV2(decoder: decoding.Decoder, ydoc: Doc, transactionOrigin?: any, structDecoder?: UpdateDecoderV1 | UpdateDecoderV2): void;
-export function applyUpdateV2(ydoc: Doc, update: Uint8Array, transactionOrigin?: any, YDecoder?: typeof UpdateDecoderV1 | typeof UpdateDecoderV2): void;
+export function writeClientsStructs(encoder: UpdateEncoder, store: StructStore, _sm: Map<number, number>): void;
+export function readUpdate(decoder: decoding.Decoder, ydoc: Doc, transactionOrigin?: any, structDecoder?: UpdateDecoder): void;
 export function applyUpdate(ydoc: Doc, update: Uint8Array, transactionOrigin?: any): void;
-export function writeStateAsUpdate(encoder: UpdateEncoderV1 | UpdateEncoderV2, doc: Doc, targetStateVector?: Map<number, number>): void;
-export function encodeStateAsUpdateV2(doc: Doc, encodedTargetStateVector?: Uint8Array, encoder?: UpdateEncoderV1 | UpdateEncoderV2): Uint8Array<ArrayBuffer>;
+export function writeStateAsUpdate(encoder: UpdateEncoder, doc: Doc, targetStateVector?: Map<number, number>): void;
 export function encodeStateAsUpdate(doc: Doc, encodedTargetStateVector?: Uint8Array): Uint8Array<ArrayBuffer>;
-export function readStateVector(decoder: IdSetDecoderV1 | IdSetDecoderV2): Map<number, number>;
-export function mergeUpdatesV2(updates: Array<Uint8Array<ArrayBuffer>>, YDecoder?: typeof UpdateDecoderV1 | typeof UpdateDecoderV2, YEncoder?: typeof UpdateEncoderV1 | typeof UpdateEncoderV2): Uint8Array<ArrayBuffer>;
 export function mergeUpdates(updates: Array<Uint8Array<ArrayBuffer>>): Uint8Array<ArrayBuffer>;
-export function diffUpdateV2(update: Uint8Array, sv: Uint8Array, YDecoder?: typeof UpdateDecoderV1 | typeof UpdateDecoderV2, YEncoder?: typeof UpdateEncoderV1 | typeof UpdateEncoderV2): Uint8Array<ArrayBuffer>;
+export function diffUpdate(update: Uint8Array, sv: Uint8Array): Uint8Array<ArrayBuffer>;
 export function decodeStateVector(decodedState: Uint8Array): Map<number, number>;
-export function writeStateVector(encoder: IdSetEncoderV1 | IdSetEncoderV2, sv: Map<number, number>): IdSetEncoderV1 | IdSetEncoderV2;
-export function writeDocumentStateVector(encoder: IdSetEncoderV1 | IdSetEncoderV2, doc: Doc): IdSetEncoderV1 | IdSetEncoderV2;
-export function encodeStateVectorV2(doc: Doc | Map<number, number>, encoder?: IdSetEncoderV1 | IdSetEncoderV2): Uint8Array<ArrayBuffer>;
 export function encodeStateVector(doc: Doc | Map<number, number>): Uint8Array<ArrayBuffer>;
-import { UpdateEncoderV1 } from './UpdateEncoder.js';
-import { UpdateEncoderV2 } from './UpdateEncoder.js';
+import { UpdateEncoder } from './UpdateEncoder.js';
 import { StructStore } from './StructStore.js';
 import * as decoding from 'lib0-v14/decoding';
 import { Doc } from './Doc.js';
-import { UpdateDecoderV1 } from './UpdateDecoder.js';
-import { UpdateDecoderV2 } from './UpdateDecoder.js';
-import { IdSetDecoderV1 } from './UpdateDecoder.js';
-import { IdSetEncoderV1 } from './UpdateEncoder.js';
-import { IdSetEncoderV2 } from './UpdateEncoder.js';
+import { UpdateDecoder } from './UpdateDecoder.js';