edytor 1.0.0-rc.2 → 1.0.0

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

@@ -1,80 +0,0 @@
-/**
- * A relative position is based on the Yjs model and is not affected by document changes.
- * E.g. If you place a relative position before a certain character, it will always point to this character.
- * If you place a relative position at the end of a type, it will always point to the end of the type.
- *
- * A numeric position is often unsuited for user selections, because it does not change when content is inserted
- * before or after.
- *
- * ```Insert(0, 'x')('a|bc') = 'xa|bc'``` Where | is the relative position.
- *
- * One of the properties must be defined.
- *
- * @example
- *   // Current cursor position is at position 10
- *   const relativePosition = createRelativePositionFromIndex(yText, 10)
- *   // modify yText
- *   yText.insert(0, 'abc')
- *   yText.delete(3, 10)
- *   // Compute the cursor position
- *   const absolutePosition = createAbsolutePositionFromRelativePosition(y, relativePosition)
- *   absolutePosition.type === yText // => true
- *   console.log('cursor location is ' + absolutePosition.index) // => cursor location is 3
- *
- */
-export class RelativePosition {
-    /**
-     * @param {ID|null} type
-     * @param {string|null} tname
-     * @param {ID|null} item
-     * @param {number} assoc
-     */
-    constructor(type: ID | null, tname: string | null, item: ID | null, assoc?: number);
-    /**
-     * @type {ID|null}
-     */
-    type: ID | null;
-    /**
-     * @type {string|null}
-     */
-    tname: string | null;
-    /**
-     * @type {ID | null}
-     */
-    item: ID | null;
-    /**
-     * A relative position is associated to a specific character. By default
-     * assoc >= 0, the relative position is associated to the character
-     * after the meant position.
-     * I.e. position 1 in 'ab' is associated to character 'b'.
-     *
-     * If assoc < 0, then the relative position is associated to the character
-     * before the meant position.
-     *
-     * @type {number}
-     */
-    assoc: number;
-}
-export function relativePositionToJSON(rpos: RelativePosition): any;
-export function createRelativePositionFromJSON(json: any): RelativePosition;
-export class AbsolutePosition {
-    /**
-     * @param {YNode<any>} type
-     * @param {number} index
-     * @param {number} [assoc]
-     */
-    constructor(type: YNode<any>, index: number, assoc?: number);
-    /**
-     * @type {YNode<any>}
-     */
-    type: YNode<any>;
-    /**
-     * @type {number}
-     */
-    index: number;
-    assoc: number;
-}
-export function createAbsolutePosition(type: YNode<any>, index: number, assoc?: number): AbsolutePosition;
-export function createRelativePosition(type: YNode<any>, item: ID | null, assoc?: number): RelativePosition;
-export function createRelativePositionFromTypeIndex(type: YNode, index: number, assoc?: number, renderer?: import("./renderer-helpers.js").AbstractRenderer | null): RelativePosition;
-export function createAbsolutePositionFromRelativePosition(rpos: RelativePosition, doc: Doc, followUndoneDeletions?: boolean, renderer?: import("./renderer-helpers.js").AbstractRenderer | null): AbsolutePosition | null;

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

@@ -1,205 +0,0 @@
-export class StackItem {
-    /**
-     * @param {IdSet} insertions
-     * @param {IdSet} deletions
-     */
-    constructor(insertions: IdSet, deletions: IdSet);
-    inserts: import("./ids.js").IdSet;
-    deletes: import("./ids.js").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} [ignoreRemoteAttributeChanges] By default, the UndoManager will never overwrite remote changes. In some cases this might be the expected behavior. This property enables overwriting remote changes on attribute changes. (previously named `ignoreRemoteMapChanges`)
- * @property {Doc} [doc] The document that this UndoManager operates on. Only needed if typeScope is empty.
- * @property {function(Item,StackItem):boolean} [restoreFilter] Whether popping the stack item may re-create the deleted item (default: always). // YP11
- * @property {function(Transaction,StackItem):void} [onApply] Called inside the undo/redo transaction once the stack item is applied; its writes join the step. // YP11
- * @property {function(Item,StackItem,Transaction):boolean} [withdraw] Asked for every item a popped stack item would delete; `true` keeps it (the hook may write in its place, in the transaction) and counts as a change (default: never). // YP12
- */
-/**
- * @typedef {Object} StackItemEvent
- * @property {StackItem} StackItemEvent.stackItem
- * @property {any} StackItemEvent.origin
- * @property {'undo'|'redo'} StackItemEvent.type
- * @property {Map<YNode,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|YNode|Array<YNode>} 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 | YNode | Array<YNode>, { captureTimeout, captureTransaction, deleteFilter, trackedOrigins, ignoreRemoteAttributeChanges, restoreFilter, onApply, withdraw, doc }?: UndoManagerOptions);
-    /**
-     * @type {Array<YNode | Doc>}
-     */
-    scope: Array<YNode | Doc>;
-    doc: Doc;
-    deleteFilter: (arg0: Item) => boolean;
-    restoreFilter: (arg0: Item, arg1: StackItem) => boolean;
-    onApply: (arg0: Transaction, arg1: StackItem) => void;
-    withdraw: (arg0: Item, arg1: StackItem, arg2: Transaction) => 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;
-    ignoreRemoteAttributeChanges: boolean;
-    captureTimeout: number;
-    /**
-     * @param {Transaction} transaction
-     */
-    afterTransactionHandler: (transaction: Transaction) => void;
-    /**
-     * Extend the scope.
-     *
-     * @param {Array<YNode | Doc> | YNode | Doc} ynodes
-     */
-    addToScope(ynodes: Array<YNode | Doc> | YNode | 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 function redoItem(transaction: Transaction, item: Item, redoitems: Set<Item>, itemsToDelete: IdSet, ignoreRemoteAttributeChanges: boolean, um: import("../utils/UndoManager.js").UndoManager): Item | null;
-export function keepItem(item: Item | null, keep: boolean): void;
-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;
-    /**
-     * By default, the UndoManager will never overwrite remote changes. In some cases this might be the expected behavior. This property enables overwriting remote changes on attribute changes. (previously named `ignoreRemoteMapChanges`)
-     */
-    ignoreRemoteAttributeChanges?: boolean | undefined;
-    /**
-     * The document that this UndoManager operates on. Only needed if typeScope is empty.
-     */
-    doc?: Doc | undefined;
-    /**
-     * Whether popping the stack item may re-create the deleted item (default: always). // YP11
-     */
-    restoreFilter?: ((arg0: Item, arg1: StackItem) => boolean) | undefined;
-    /**
-     * Called inside the undo/redo transaction once the stack item is applied; its writes join the step. // YP11
-     */
-    onApply?: ((arg0: Transaction, arg1: StackItem) => void) | undefined;
-    /**
-     * Asked for every item a popped stack item would delete; `true` keeps it (the hook may write in its place, in the transaction) and counts as a change (default: never). // YP12
-     */
-    withdraw?: ((arg0: Item, arg1: StackItem, arg2: Transaction) => boolean) | undefined;
-};
-export type StackItemEvent = {
-    stackItem: StackItem;
-    origin: any;
-    type: "undo" | "redo";
-    changedParentTypes: Map<YNode, Array<YEvent<any>>>;
-};
-import { ObservableV2 } from 'lib0-v14/observable';
-import { YNode } from '../ynode.js';
-import { Doc } from './Doc.js';
-import { Item } from '../structs/Item.js';

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

@@ -1,93 +0,0 @@
-/**
- * @template {DeltaConf} DConf
- * YEvent describes the changes on a YNode.
- */
-export class YEvent<DConf extends DeltaConf> {
-    /**
-     * @param {YNode<DConf>} target The changed type.
-     * @param {import('./Transaction.js').Transaction} transaction
-     * @param {Set<any>?} subs The keys that changed
-     */
-    constructor(target: YNode<DConf>, transaction: import("./Transaction.js").Transaction, subs: Set<any> | null);
-    /**
-     * The type on which this event was created on.
-     * @type {import('../ynode.js').YNode<DConf>}
-     */
-    target: import("../ynode.js").YNode<DConf>;
-    /**
-     * The current target on which the observe callback is called.
-     * @type {YNode<any>}
-     */
-    currentTarget: YNode<any>;
-    /**
-     * The transaction that triggered this event.
-     * @type {import('./Transaction.js').Transaction}
-     */
-    transaction: import("./Transaction.js").Transaction;
-    /**
-     * @type {Delta<import('../ynode.js').DeltaConfDeltaToYNode<DConf>>|null}
-     */
-    _delta: Delta<import("../ynode.js").DeltaConfDeltaToYNode<DConf>> | null;
-    /**
-     * @type {Delta<DConf>|null}
-     */
-    _deltaDeep: Delta<DConf> | null;
-    /**
-     * Whether the children changed.
-     * @type {Boolean}
-     * @private
-     */
-    private childListChanged;
-    /**
-     * Set of all changed attributes.
-     * @type {Set<string>}
-     */
-    keysChanged: Set<string>;
-    /**
-     * Check if a struct is deleted by this event.
-     *
-     * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
-     *
-     * @param {AbstractStruct} struct
-     * @return {boolean}
-     */
-    deletes(struct: AbstractStruct): boolean;
-    /**
-     * Check if a struct is added by this event.
-     *
-     * In contrast to change.deleted, this method also returns true if the struct was added and then deleted.
-     *
-     * @param {AbstractStruct} struct
-     * @return {boolean}
-     */
-    adds(struct: AbstractStruct): boolean;
-    /**
-     * @template {boolean} [Deep=false]
-     * @param {object} [opts]
-     * @param {AbstractRenderer?} [opts.renderer] - renders the content (with attributions); defaults to the target type's active renderer (see {@link YNode#useRenderer}), i.e. `null` (render as-is) unless changed
-     * @param {Deep} [opts.deep]
-     * @return {Deep extends true ? Delta<DConf> : Delta<import('../ynode.js').DeltaConfDeltaToYNode<DConf>>} The Delta representation of this type.
-     *
-     * @public
-     */
-    public getDelta<Deep extends boolean = false>({ renderer, deep }?: {
-        renderer?: import("./renderer-helpers.js").AbstractRenderer | null | undefined;
-        deep?: Deep | undefined;
-    }): Deep extends true ? Delta<DConf> : Delta<import("../ynode.js").DeltaConfDeltaToYNode<DConf>>;
-    /**
-     * Compute the changes in the delta format.
-     * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
-     *
-     * @type {Delta<import('../ynode.js').DeltaConfDeltaToYNode<DConf>>} The Delta representation of this type.
-     * @public
-     */
-    public get delta(): Delta<import("../ynode.js").DeltaConfDeltaToYNode<DConf>>;
-    /**
-     * Compute the changes in the delta format.
-     * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
-     *
-     * @type {Delta<DConf>} The Delta representation of this type.
-     * @public
-     */
-    public get deltaDeep(): Delta<DConf>;
-}

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

@@ -1,25 +0,0 @@
-export function createContentMap(inserts?: IdMap<any>, deletes?: IdMap<any>): ContentMap;
-export function writeContentMap(encoder: import("./UpdateEncoder.js").IdSetEncoder, contentMap: ContentMap): void;
-export function readContentMap(decoder: import("./UpdateDecoder.js").IdSetDecoder): ContentMap;
-export function encodeContentMap(contentMap: ContentMap): Uint8Array<ArrayBuffer>;
-export function decodeContentMap(buf: Uint8Array<any>): import("./ids.js").ContentMap;
-/**
- * Schema of {@link ContentIds} - the shape produced by {@link createContentIds}.
- *
- * Structural: a `ContentIds` is a plain object literal, so there is no prototype to tag. The
- * *nominal* {@link $idSet} checks on the two fields are what discriminate it from a
- * {@link ContentMap} in both directions.
- *
- * @type {s.Schema<ContentIds>}
- */
-export const $contentIds: s.Schema<ContentIds>;
-/**
- * Schema of {@link ContentMap} - the shape produced by {@link createContentMap}.
- *
- * See {@link $contentIds}. Use {@link $idMap} on the individual fields to additionally constrain
- * the mapped-value type; `ContentMap` itself hardcodes `IdMap<any>`.
- *
- * @type {s.Schema<ContentMap>}
- */
-export const $contentMap: s.Schema<ContentMap>;
-import * as s from 'lib0-v14/schema';

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

@@ -1,98 +0,0 @@
-export const attributionJsonSchema: s.Schema<{
-    insert?: string[] | undefined;
-    insertAt?: number | undefined;
-    delete?: string[] | undefined;
-    deleteAt?: number | undefined;
-    format?: {
-        [x: string]: string[];
-    } | undefined;
-    formatAt?: number | undefined;
-}>;
-/**
- * @todo rename this to `insertBy`, `insertAt`, ..
- *
- * @typedef {s.Unwrap<typeof attributionJsonSchema>} Attribution
- */
-/**
- * @template T
- */
-export class AttributedContent<T> {
-    /**
-     * @param {AbstractContent} content
-     * @param {number} clock
-     * @param {boolean} deleted
-     * @param {Array<ContentAttribute<T>> | null} attrs
-     * @param {0|1|2|3} renderBehavior
-     */
-    constructor(content: AbstractContent, clock: number, deleted: boolean, attrs: Array<ContentAttribute<T>> | null, renderBehavior: 0 | 1 | 2 | 3);
-    content: import("../structs/Item.js").AbstractContent;
-    clock: number;
-    deleted: boolean;
-    attrs: import("./ids.js").ContentAttribute<T>[] | null;
-    render: boolean;
-    /**
-     * Fresh content that was deleted in the same transaction (mode `3`): even in a
-     * `retainDeletes` render it must produce an *insert* — the consuming state (e.g. the
-     * maintained `delta` cache) has never seen this content, so there is nothing to retain.
-     */
-    fresh: boolean;
-}
-/**
- * Abstract base class for renderers. A renderer renders Content (with Attributions) to a delta.
- *
- * 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.
- *
- * Only items claimed via {@link AbstractRenderer#hasItem} reach the renderer — everything else is
- * rendered by the generic fast path (as-is, without attributions, deleted content invisible).
- *
- * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
- */
-export class AbstractRenderer extends ObservableV2<{
-    change: (idset: IdSet, origin: any, local: boolean) => void;
-}> {
-    constructor();
-    /**
-     * Ids of the content this renderer may render non-normally (attributed, restored, hidden, …).
-     * May over-approximate — {@link AbstractRenderer#readContent} remains authoritative for what
-     * is actually rendered. Content outside this set is rendered by the generic fast path without
-     * consulting the renderer.
-     *
-     * @type {IdSet}
-     */
-    attributed: IdSet;
-    /**
-     * Whether `item` (any part of its id range) must be rendered by this renderer. Items for which
-     * this returns `false` are rendered by the generic fast path.
-     *
-     * @param {Item} item
-     * @return {boolean}
-     */
-    hasItem(item: Item): boolean;
-    /**
-     * @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|3} _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). 3: fresh content deleted in the same transaction, marked {@link AttributedContent#fresh} — render as insert where attributed (it must insert even in a `retainDeletes` render: the consuming state has never seen it), as *nothing* where unattributed (invisible; a delete op would misapply).
-     */
-    readContent(_contents: Array<AttributedContent<any>>, _client: number, _clock: number, _deleted: boolean, _content: AbstractContent, _shouldRender: 0 | 1 | 2 | 3): 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;
-    $type: s.Schema<AbstractRenderer>;
-}
-export const $renderer: s.Schema<AbstractRenderer>;
-export function rendererContentLength(renderer: AbstractRenderer | null, item: Item): number;
-export function readItemPieces(out: Array<AttributedContent<any>>, renderer: AbstractRenderer | null, item: import("../structs/Item.js").Item, scratch?: AttributedContent<any> | null): void;
-export type Attribution = s.Unwrap<typeof attributionJsonSchema>;
-import * as s from 'lib0-v14/schema';
-import { ObservableV2 } from 'lib0-v14/observable';

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

@@ -1,2 +0,0 @@
-export const $doc: s.Schema<Doc>;
-import * as s from 'lib0-v14/schema';

package/dist/crdt/vendor/yjs/src/utils/EventHandler.js

@@ -1,75 +0,0 @@
-import * as f from 'lib0-v14/function'
-
-/**
- * General event handler implementation.
- *
- * @template ARG0, ARG1
- *
- * @private
- */
-export class EventHandler {
-  constructor () {
-    /**
-     * @type {Array<function(ARG0, ARG1):void>}
-     */
-    this.l = []
-  }
-}
-
-/**
- * @template ARG0,ARG1
- * @returns {EventHandler<ARG0,ARG1>}
- *
- * @private
- * @function
- */
-export const createEventHandler = () => new EventHandler()
-
-/**
- * Adds an event listener that is called when
- * {@link EventHandler#callEventListeners} is called.
- *
- * @template ARG0,ARG1
- * @param {EventHandler<ARG0,ARG1>} eventHandler
- * @param {function(ARG0,ARG1):void} f The event handler.
- *
- * @private
- * @function
- */
-export const addEventHandlerListener = (eventHandler, f) =>
-  eventHandler.l.push(f)
-
-/**
- * Removes an event listener.
- *
- * @template ARG0,ARG1
- * @param {EventHandler<ARG0,ARG1>} eventHandler
- * @param {function(ARG0,ARG1):void} f The event handler that was added with
- *                     {@link EventHandler#addEventListener}
- *
- * @private
- * @function
- */
-export const removeEventHandlerListener = (eventHandler, f) => {
-  const l = eventHandler.l
-  const len = l.length
-  eventHandler.l = l.filter(g => f !== g)
-  if (len === eventHandler.l.length) {
-    console.error('[yjs] Tried to remove event handler that doesn\'t exist.')
-  }
-}
-
-/**
- * Call all event listeners that were added via
- * {@link EventHandler#addEventListener}.
- *
- * @template ARG0,ARG1
- * @param {EventHandler<ARG0,ARG1>} eventHandler
- * @param {ARG0} arg0
- * @param {ARG1} arg1
- *
- * @private
- * @function
- */
-export const callEventHandlerListeners = (eventHandler, arg0, arg1) =>
-  f.callAll(eventHandler.l, [arg0, arg1])