edytor 1.0.0-rc.2 → 1.0.0

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

@@ -1,9 +1,6 @@
 /**
  * @typedef {{ inserts: IdSet, deletes: IdSet }} ContentIds
  */
-/**
- * @typedef {{ inserts: IdMap<any>, deletes: IdMap<any> }} ContentMap
- */
 export class IdRange {
     /**
      * @param {number} clock
@@ -23,12 +20,6 @@ export class IdRange {
      * @param {number} len
      */
     copyWith(clock: number, len: number): IdRange;
-    /**
-     * Helper method making this compatible with IdMap.
-     *
-     * @return {Array<ContentAttribute<any>>}
-     */
-    get attrs(): Array<ContentAttribute<any>>;
 }
 export class MaybeIdRange {
     /**
@@ -77,21 +68,6 @@ export class IdRanges {
      * Return the list of immutable id ranges, sorted and merged.
      */
     getIds(): IdRange[];
-    /**
-     * Test a predicate against every attribute held by these ranges. Does not mutate - see
-     * {@link AttrRanges#everyAttr}.
-     *
-     * This exists because an `IdMap` may hold `IdRanges`: {@link insertIntoIdMap}'s `src` may be an
-     * `IdSet`, and `_insertIntoIdSet` picks the container class from whichever `src` reaches a client
-     * first. For a pure `IdRanges` the loop is vacuous ({@link IdRange#attrs} is always `[]`), but it
-     * must *not* shortcut to `true`: the append branch of `_insertIntoIdSet` copies elements without
-     * checking their class, so an `IdRanges` reached by an `IdSet` first and an `IdMap` second holds
-     * real `AttrRange`s - which {@link $idMap} must still validate.
-     *
-     * @param {(attr:ContentAttribute<any>) => boolean} f
-     * @return {boolean}
-     */
-    everyAttr(f: (attr: ContentAttribute<any>) => boolean): boolean;
 }
 /**
  * @implements {traits.EqualityTrait}
@@ -169,239 +145,38 @@ export class IdSet implements traits.EqualityTrait {
      * @param {number} len
      */
     delete(client: number, clock: number, len: number): void;
-    $type: s.Schema<IdSet>;
     /**
      * @param {any} other
      */
     [traits.EqualityTraitSymbol](other: any): boolean;
 }
-export function equalIdSets(ds1: IdSet, ds2: IdSet): boolean;
-export function _deleteRangeFromIdSet(set: IdSet | IdMap<any>, client: number, clock: number, len: number): void;
+export function _deleteRangeFromIdSet(set: IdSet, client: number, clock: number, len: number): void;
 export function iterateStructsByIdSet(transaction: Transaction, ds: IdSet, f: (arg0: GC | Item) => void): void;
-export function iterateStructsByIdSetWithoutSplits(store: StructStore, ds: IdSet, f: (struct: GC | Item | Skip, offset: number, len: number) => void): void;
 export function findIndexInIdRanges(dis: Array<IdRange>, clock: number): number | null;
 export function findRangeStartInIdRanges(dis: Array<IdRange>, clock: number): number | null;
 export function mergeIdSets(idSets: Array<IdSet>): IdSet;
 /**
- * @template {IdSet | IdMap<any>} S
- * @param {S} dest
- * @param {S} src
+ * @param {IdSet} dest
+ * @param {IdSet} src
  */
-export function insertIntoIdSet<S extends IdSet | IdMap<any>>(dest: S, src: S): void;
-/**
- * Note that `src` may be an `IdSet`, in which case `dest` ends up holding `IdRanges` - which carry
- * no attributes ({@link IdRange#attrs} is `[]`). This is by design; {@link $idMap} tolerates it.
- *
- * @type {(dest: IdMap<any>, src: IdMap<any>|IdSet) => void}
- */
-export const insertIntoIdMap: (dest: IdMap<any>, src: IdMap<any> | IdSet) => void;
-export function _diffSet<Set extends IdSet | IdMap<any>>(set: Set, exclude: IdSet | IdMap<any>): Set;
+export function insertIntoIdSet(dest: IdSet, src: IdSet): void;
+export function _diffSet(set: IdSet, exclude: IdSet): IdSet;
 /**
  * Remove all ranges from `exclude` from `idSet`. The result is a fresh IdSet containing all ranges from `idSet` that are not
  * in `exclude`.
  *
- * @type {(idSet: IdSet, exclude: IdSet|IdMap<any>) => IdSet}
+ * @type {(idSet: IdSet, exclude: IdSet) => IdSet}
  */
-export const diffIdSet: (idSet: IdSet, exclude: IdSet | IdMap<any>) => IdSet;
-export function _intersectSets<SetA extends IdSet | IdMap<any>, SetB extends IdSet | IdMap<any>>(setA: SetA, setB: SetB): SetA extends IdMap<infer A> ? (SetB extends IdMap<infer B> ? IdMap<A | B> : IdMap<A>) : IdSet;
-export function intersectSets<SetA extends IdSet | IdMap<any>, SetB extends IdSet | IdMap<any>>(setA: SetA, setB: SetB): SetA extends IdMap<infer A> ? (SetB extends IdMap<infer B> ? IdMap<A | B> : IdMap<A>) : IdSet;
+export const diffIdSet: (idSet: IdSet, exclude: IdSet) => IdSet;
+export function _intersectSets(setA: IdSet, setB: IdSet): IdSet;
+export function intersectSets(setA: IdSet, setB: IdSet): IdSet;
 export function createIdSet(): IdSet;
 export function createDeleteSetFromStructStore(ss: StructStore): IdSet;
-export function writeIdSet(encoder: IdSetEncoderV1 | IdSetEncoderV2, idSet: IdSet): void;
-export function readIdSet(decoder: IdSetDecoderV1 | IdSetDecoderV2): IdSet;
-export function readAndApplyDeleteSet(decoder: IdSetDecoderV1 | IdSetDecoderV2, transaction: Transaction, store: StructStore): Uint8Array<ArrayBuffer> | null;
-/**
- * @template Attrs
- */
-export class AttrRange<Attrs> {
-    /**
-     * @param {number} clock
-     * @param {number} len
-     * @param {Array<ContentAttribute<Attrs>>} attrs
-     */
-    constructor(clock: number, len: number, attrs: Array<ContentAttribute<Attrs>>);
-    /**
-     * @readonly
-     */
-    readonly clock: number;
-    /**
-     * @readonly
-     */
-    readonly len: number;
-    /**
-     * @readonly
-     */
-    readonly attrs: ContentAttribute<Attrs>[];
-    /**
-     * @param {number} clock
-     * @param {number} len
-     */
-    copyWith(clock: number, len: number): AttrRange<Attrs>;
-}
-/**
- * @todo rename this to `Attribute`
- * @template V
- */
-export class ContentAttribute<V> {
-    /**
-     * @param {string} name
-     * @param {V} val
-     */
-    constructor(name: string, val: V);
-    name: string;
-    val: V;
-    hash(): string;
-}
-export function createContentAttribute<V>(name: string, val: V): ContentAttribute<V>;
-export function createMaybeAttrRange<Attrs>(clock: number, len: number, attrs: Array<ContentAttribute<Attrs>> | null): MaybeAttrRange<Attrs>;
-/**
- * Whenever this is instantiated, it must receive a fresh array of ops, not something copied.
- *
- * @template Attrs
- */
-export class AttrRanges<Attrs> {
-    /**
-     * @param {Array<AttrRange<Attrs>>} ids
-     */
-    constructor(ids: Array<AttrRange<Attrs>>);
-    sorted: boolean;
-    /**
-     * @private
-     */
-    private _ids;
-    copy(): AttrRanges<Attrs>;
-    /**
-     * @param {number} clock
-     * @param {number} length
-     * @param {Array<ContentAttribute<Attrs>>} attrs
-     */
-    add(clock: number, length: number, attrs: Array<ContentAttribute<Attrs>>): void;
-    /**
-     * Return the list of id ranges, sorted and merged.
-     */
-    getIds(): AttrRange<Attrs>[];
-    /**
-     * Test a predicate against every attribute held by these ranges.
-     *
-     * Unlike {@link AttrRanges#getIds} this does **not** sort/merge - i.e. it does not mutate its
-     * receiver, which matters because it backs {@link $idMap}`.check`. The *set* of attributes is
-     * invariant under sorting/merging (merging only ever concatenates existing attr arrays), so this
-     * observes exactly the attributes that `getIds()` would expose.
-     *
-     * @param {(attr:ContentAttribute<Attrs>) => boolean} f
-     * @return {boolean}
-     */
-    everyAttr(f: (attr: ContentAttribute<Attrs>) => boolean): boolean;
-}
-/**
- * @template Attrs
- */
-export class IdMap<Attrs> {
-    /**
-     * @type {Map<number,AttrRanges<Attrs>>}
-     */
-    clients: Map<number, AttrRanges<Attrs>>;
-    /**
-     * @type {Map<string, ContentAttribute<Attrs>>}
-     */
-    attrsH: Map<string, ContentAttribute<Attrs>>;
-    /**
-     * @type {Set<ContentAttribute<Attrs>>}
-     */
-    attrs: Set<ContentAttribute<Attrs>>;
-    /**
-     * @param {(attrRange:AttrRange<Attrs>, client:number) => void} f
-     */
-    forEach(f: (attrRange: AttrRange<Attrs>, client: number) => void): void;
-    isEmpty(): boolean;
-    /**
-     * @param {ID} id
-     * @return {boolean}
-     */
-    hasId(id: ID): boolean;
-    /**
-     * @param {number} client
-     * @param {number} clock
-     * @return {boolean}
-     */
-    has(client: number, clock: number): boolean;
-    /**
-     * Total number of ids in `[clock, clock+len)` of `client` contained in this map (i.e. carrying
-     * an attribution, incl. an empty `[]`). Allocation-free (binary search + linear scan).
-     * Equivalent to `slice(client, clock, len).reduce((s, r) => r.attrs != null ? s + r.len : s, 0)`
-     * without allocating.
-     *
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     * @return {number}
-     */
-    coveredLength(client: number, clock: number, len: number): number;
-    /**
-     * Return attributions for a slice of ids.
-     *
-     * @param {ID} id
-     * @param {number} len
-     * @return {Array<MaybeAttrRange<Attrs>>}
-     */
-    sliceId(id: ID, len: number): Array<MaybeAttrRange<Attrs>>;
-    /**
-     * Return attributions for a slice of ids.
-     *
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     * @return {Array<MaybeAttrRange<Attrs>>}
-     */
-    slice(client: number, clock: number, len: number): Array<MaybeAttrRange<Attrs>>;
-    /**
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     * @param {Array<ContentAttribute<Attrs>>} attrs
-     */
-    add(client: number, clock: number, len: number, attrs: Array<ContentAttribute<Attrs>>): void;
-    /**
-     * @param {number} client
-     * @param {number} clock
-     * @param {number} len
-     */
-    delete(client: number, clock: number, len: number): void;
-    $type: s.Schema<IdMap<any>>;
-}
-export function idmapAttrsEqual<T>(a: Array<T>, b: Array<T>): boolean;
-export function writeIdMap<Attr>(encoder: IdSetEncoderV1 | IdSetEncoderV2, idmap: IdMap<Attr>): void;
-export function encodeIdMap(idmap: IdMap<any>): Uint8Array<ArrayBuffer>;
-export function readIdMap(decoder: IdSetDecoderV1 | IdSetDecoderV2): IdMap<any>;
-export function decodeIdMap(data: Uint8Array): IdMap<any>;
-export function createIdMap(): IdMap<any>;
-/**
- * Schema of an {@link IdSet}.
- *
- * Nominal: `check` is a single identity compare against the globally interned `y:idSet` tag, so it
- * stays sound across duplicate yjs installations (unlike `instanceof`) - the same reason
- * {@link $renderer} uses `$type`.
- */
-export const $idSet: s.Schema<IdSet>;
-/**
- * Schema of an {@link IdMap} with any mapped-value type. This is where the nominal `y:idMap` tag
- * lives - {@link $idMap} builds on it. Mirrors lib0's `$deltaAny` / `$delta` split.
- */
-export const $idMapAny: s.Schema<IdMap<any>>;
+export function writeIdSet(encoder: IdSetEncoder, idSet: IdSet): void;
+export function readIdSet(decoder: IdSetDecoder): IdSet;
+export function readAndApplyDeleteSet(decoder: IdSetDecoder, transaction: Transaction, store: StructStore): Uint8Array<ArrayBuffer> | null;
 export type ContentIds = {
     inserts: IdSet;
     deletes: IdSet;
 };
-export type ContentMap = {
-    inserts: IdMap<any>;
-    deletes: IdMap<any>;
-};
-export type MaybeAttrRange<Attrs> = {
-    clock: number;
-    len: number;
-    attrs: Array<ContentAttribute<Attrs>> | null;
-};
 import * as traits from 'lib0-v14/traits';
-import * as s from 'lib0-v14/schema';
-import { IdSetEncoderV2 } from './UpdateEncoder.js';
-import { IdSetDecoderV2 } from './UpdateDecoder.js';

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

@@ -0,0 +1,5 @@
+export function idAtIndex(type: YNode, index: number, assoc?: number): ID | null;
+export function indexOfId(doc: Doc, id: ID, assoc?: number): {
+    type: YNode;
+    index: number;
+} | null;

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

@@ -0,0 +1,3 @@
+export function redoItem(transaction: Transaction, item: Item, redoitems: Set<Item>, itemsToDelete: IdSet, deletedByHistory?: (arg0: ID) => boolean): Item | null;
+export function keepItem(item: Item | null, keep: boolean): void;
+import { Item } from '../structs/Item.js';

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

@@ -5,12 +5,10 @@ export function getItemCleanStart(transaction: Transaction, id: ID): Item;
 export function getItemCleanEnd(transaction: Transaction, store: StructStore, id: ID): Item;
 export function replaceStruct(tr: Transaction, struct: GC | Item, newStruct: GC | Item): void;
 export function iterateStructs(transaction: Transaction, structs: Array<Item | GC>, clockStart: number, len: number, f: (arg0: GC | Item) => void): void;
-export function iterateStructsWithoutSplits(structs: Array<Item | GC>, clockStart: number, len: number, f: (struct: GC | Item | Skip, offset: number, len: number) => void): void;
 export function splitStruct(transaction: Transaction | null, leftStruct: Item | GC | Skip, diff: number): GC | Item | Skip;
 export function addChangedTypeToTransaction(transaction: Transaction, type: YNode, parentSub: string | null): void;
 export function tryToMergeWithLefts(structs: Array<GC | Item | Skip>, pos: number): number;
 export function tryGcDeleteSet(tr: Transaction, ds: IdSet, gcFilter: (arg0: Item) => boolean): void;
 export function tryMerge(ds: IdSet, store: StructStore): void;
-export function cleanupContextlessFormattingGap(transaction: Transaction, item: Item | null): 0 | undefined;
+export function liveLength(item: Item): number;
 export function updateCurrentFormats(currentFormats: Map<string, any>, format: ContentFormat): void;
-export function cleanupFormattingGap(transaction: Transaction, start: Item, curr: Item | null, startFormats: Map<string, any>, currFormats: Map<string, any>): number;

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

@@ -1,9 +1,9 @@
 export class LazyStructReader {
     /**
-     * @param {UpdateDecoderV1 | UpdateDecoderV2} decoder
+     * @param {UpdateDecoder} decoder
      * @param {boolean} filterSkips
      */
-    constructor(decoder: UpdateDecoderV1 | UpdateDecoderV2, filterSkips: boolean);
+    constructor(decoder: UpdateDecoder, filterSkips: boolean);
     gen: Generator<GC | Item | Skip, void, unknown>;
     /**
      * @type {null | Item | Skip | GC}
@@ -20,19 +20,15 @@ export function decodeUpdate(update: Uint8Array): {
     structs: (GC | Item | Skip)[];
     ds: import("./ids.js").IdSet;
 };
-export function decodeUpdateV2(update: Uint8Array, YDecoder?: typeof UpdateDecoderV2 | typeof UpdateDecoderV1): {
-    structs: (GC | Item | Skip)[];
-    ds: import("./ids.js").IdSet;
-};
 export class LazyStructWriter {
     /**
-     * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
+     * @param {import('./UpdateEncoder.js').UpdateEncoder} encoder
      */
-    constructor(encoder: UpdateEncoderV1 | UpdateEncoderV2);
+    constructor(encoder: import("./UpdateEncoder.js").UpdateEncoder);
     currClient: number;
     startClock: number;
     written: number;
-    encoder: UpdateEncoderV1 | UpdateEncoderV2;
+    encoder: import("./UpdateEncoder.js").UpdateEncoder;
     /**
      * We want to write operations lazily, but also we need to know beforehand how many operations we want to write for each client.
      *
@@ -51,20 +47,7 @@ export class LazyStructWriter {
 export function sliceStruct(left: Item | GC | Skip, diff: number): Item | GC | Skip;
 export function writeStructToLazyStructWriter(lazyWriter: LazyStructWriter, struct: Item | GC | Skip, offset: number, offsetEnd: number): void;
 export function finishLazyStructWriting(lazyWriter: LazyStructWriter): void;
-export function convertUpdateFormat(update: Uint8Array, blockTransformer: (arg0: Item | GC | Skip) => Item | GC | Skip, YDecoder: typeof UpdateDecoderV2 | typeof UpdateDecoderV1, YEncoder: typeof UpdateEncoderV2 | typeof UpdateEncoderV1): Uint8Array<ArrayBuffer>;
-export function convertUpdateFormatV2ToV1(update: Uint8Array): Uint8Array<ArrayBuffer>;
-export type ObfuscatorOptions = {
-    formatting?: boolean | undefined;
-    subdocs?: boolean | undefined;
-    /**
-     * Whether to obfuscate nodeName / hookName
-     */
-    name?: boolean | undefined;
-};
 import { GC } from '../structs/GC.js';
 import { Item } from '../structs/Item.js';
 import { Skip } from '../structs/Skip.js';
-import { UpdateDecoderV1 } from './UpdateDecoder.js';
-import { UpdateDecoderV2 } from './UpdateDecoder.js';
-import { UpdateEncoderV1 } from './UpdateEncoder.js';
-import { UpdateEncoderV2 } from './UpdateEncoder.js';
+import { UpdateDecoder } from './UpdateDecoder.js';