edytor 1.0.0-rc.3 → 2.0.0

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

@@ -1,158 +0,0 @@
-import * as map from 'lib0-v14/map'
-import * as set from 'lib0-v14/set'
-
-import { diffIdSet, intersectSets, mergeIdSets } from './ids.js'
-
-/**
- * @template {DeltaConf} DConf
- * YEvent describes the changes on a YNode.
- */
-export class YEvent {
-  /**
-   * @param {YNode<DConf>} target The changed type.
-   * @param {import('./Transaction.js').Transaction} transaction
-   * @param {Set<any>?} subs The keys that changed
-   */
-  constructor (target, transaction, subs) {
-    /**
-     * The type on which this event was created on.
-     * @type {import('../ynode.js').YNode<DConf>}
-     */
-    this.target = target
-    /**
-     * The current target on which the observe callback is called.
-     * @type {YNode<any>}
-     */
-    this.currentTarget = target
-    /**
-     * The transaction that triggered this event.
-     * @type {import('./Transaction.js').Transaction}
-     */
-    this.transaction = transaction
-    /**
-     * @type {Delta<import('../ynode.js').DeltaConfDeltaToYNode<DConf>>|null}
-     */
-    this._delta = null
-    /**
-     * @type {Delta<DConf>|null}
-     */
-    this._deltaDeep = null
-    /**
-     * Whether the children changed.
-     * @type {Boolean}
-     * @private
-     */
-    this.childListChanged = false
-    /**
-     * Set of all changed attributes.
-     * @type {Set<string>}
-     */
-    this.keysChanged = new Set()
-    subs?.forEach((sub) => {
-      if (sub === null) {
-        this.childListChanged = true
-      } else {
-        this.keysChanged.add(sub)
-      }
-    })
-  }
-
-  /**
-   * 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) {
-    return this.transaction.deleteSet.hasId(struct.id)
-  }
-
-  /**
-   * 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) {
-    return this.transaction.insertSet.hasId(struct.id)
-  }
-
-  /**
-   * @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
-   */
-  getDelta ({ renderer = this.target._renderer, deep } = {}) {
-    const insertSet = this.transaction.insertSet
-    const deleteSet = this.transaction.deleteSet
-    // content that was both inserted AND deleted by this transaction is normally invisible — but a
-    // renderer may still render it (e.g. remote content integrated under a suggestion-deleted
-    // parent is auto-deleted yet rendered with a delete attribution). Render
-    // `(I ∪ D) − ((I ∩ D) − renderer.attributed)`: the symmetric difference plus the attributed
-    // part of the intersection.
-    const both = intersectSets(insertSet, deleteSet)
-    const itemsToRender = mergeIdSets(
-      (both.isEmpty() || renderer === null)
-        ? [diffIdSet(insertSet, deleteSet), diffIdSet(deleteSet, insertSet)]
-        : [diffIdSet(insertSet, deleteSet), diffIdSet(deleteSet, insertSet), intersectSets(both, renderer.attributed)]
-    )
-    /**
-     * @todo this should be done only one in the transaction step
-     *
-     * @type {Map<YNode,Set<string|null>>|null}
-     */
-    let modified = this.transaction.changed
-    if (deep) {
-      // need to add deep changes to copy of modified
-      const dchanged = new Map()
-      modified.forEach((attrs, type) => {
-        dchanged.set(type, new Set(attrs))
-      })
-      for (let m of modified.keys()) {
-        while (m._item != null) {
-          const item = m._item
-          const ms = map.setIfUndefined(dchanged, item?.parent, set.create)
-          if (item && !ms.has(item.parentSub)) {
-            ms.add(item.parentSub)
-            m = /** @type {any} */ (item.parent)
-          } else {
-            break
-          }
-        }
-      }
-      modified = dchanged
-    }
-    return /** @type {any} */ (this.target.toDelta({ renderer, itemsToRender, retainDeletes: true, insertedItems: insertSet, deep: !!deep, modified }))
-  }
-
-  /**
-   * 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
-   */
-  get delta () {
-    return /** @type {any} */ (this._delta ?? (this._delta = this.getDelta().done()))
-  }
-
-  /**
-   * 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
-   */
-  get deltaDeep () {
-    return /** @type {any} */ (this._deltaDeep ?? (this._deltaDeep = /** @type {any} */ (this.getDelta({ deep: true }))))
-  }
-}
-

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

@@ -1,74 +0,0 @@
-/**
- * Meta API for describing Yjs documents
- */
-
-import * as decoding from 'lib0-v14/decoding'
-import * as s from 'lib0-v14/schema'
-
-import { $idSet, $idMapAny, createIdMap, writeIdMap, readIdMap } from './ids.js'
-import { IdSetEncoderV2 } from './UpdateEncoder.js'
-import { IdSetDecoderV2 } from './UpdateDecoder.js'
-
-/**
- * @param {IdMap<any>} [inserts]
- * @param {IdMap<any>} [deletes]
- * @return {ContentMap}
- */
-export const createContentMap = (inserts = createIdMap(), deletes = createIdMap()) => ({ inserts, deletes })
-
-/**
- * @todo this encoding needs to be heavily optimized for production
- *
- * @param {import('./UpdateEncoder.js').IdSetEncoder} encoder
- * @param {ContentMap} contentMap
- */
-export const writeContentMap = (encoder, contentMap) => {
-  writeIdMap(encoder, contentMap.inserts)
-  writeIdMap(encoder, contentMap.deletes)
-}
-
-/**
- * @todo this encoding needs to be heavily optimized for production
- *
- * @param {import('./UpdateDecoder.js').IdSetDecoder} decoder
- * @return {ContentMap} contentMap
- */
-export const readContentMap = (decoder) => createContentMap(
-  readIdMap(decoder),
-  readIdMap(decoder)
-)
-
-/**
- * @param {ContentMap} contentMap
- */
-export const encodeContentMap = contentMap => {
-  const encoder = new IdSetEncoderV2()
-  writeContentMap(encoder, contentMap)
-  return encoder.toUint8Array()
-}
-
-/**
- * @param {Uint8Array<any>} buf
- */
-export const decodeContentMap = buf => readContentMap(new IdSetDecoderV2(decoding.createDecoder(buf)))
-
-/**
- * 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.$object({ inserts: $idSet, deletes: $idSet })
-
-/**
- * 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.$object({ inserts: $idMapAny, deletes: $idMapAny })

package/dist/crdt/vendor/yjs/src/utils/renderer-helpers.js

@@ -1,186 +0,0 @@
-import * as s from 'lib0-v14/schema'
-import * as error from 'lib0-v14/error'
-import { ObservableV2 } from 'lib0-v14/observable'
-
-import { ContentFormat } from '../structs/Item.js'
-
-import { createIdSet } from './ids.js'
-
-export const attributionJsonSchema = s.$object({
-  insert: s.$array(s.$string).optional,
-  insertAt: s.$number.optional,
-  delete: s.$array(s.$string).optional,
-  deleteAt: s.$number.optional,
-  format: s.$record(s.$string, s.$array(s.$string)).optional,
-  formatAt: s.$number.optional
-})
-
-/**
- * @todo rename this to `insertBy`, `insertAt`, ..
- *
- * @typedef {s.Unwrap<typeof attributionJsonSchema>} Attribution
- */
-
-/**
- * @template T
- */
-export class AttributedContent {
-  /**
-   * @param {AbstractContent} content
-   * @param {number} clock
-   * @param {boolean} deleted
-   * @param {Array<ContentAttribute<T>> | null} attrs
-   * @param {0|1|2|3} renderBehavior
-   */
-  constructor (content, clock, deleted, attrs, renderBehavior) {
-    this.content = content
-    this.clock = clock
-    this.deleted = deleted
-    this.attrs = attrs
-    this.render = renderBehavior === 0 ? false : (renderBehavior === 1 ? (!deleted || attrs != null) : true)
-    /**
-     * 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.
-     */
-    this.fresh = renderBehavior === 3
-  }
-}
-
-/**
- * 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 {
-  constructor () {
-    super()
-    /**
-     * 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}
-     */
-    this.attributed = createIdSet()
-  }
-
-  /**
-   * 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) {
-    return this.attributed.intersects(item.id.client, item.id.clock, item.length)
-  }
-
-  /**
-   * @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, _client, _clock, _deleted, _content, _shouldRender) {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * 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) {
-    error.methodUnimplemented()
-  }
-}
-
-export const $renderer = AbstractRenderer.prototype.$type = s.$type('y:renderer', AbstractRenderer)
-
-/**
- * Rendered length of `item` under `renderer`: the generic rule — alive countable content renders
- * at full length, everything else at length `0` — unless the renderer claims the item.
- *
- * @param {AbstractRenderer?} renderer
- * @param {Item} item
- * @return {number}
- */
-export const rendererContentLength = (renderer, item) =>
-  renderer !== null && renderer.hasItem(item)
-    ? renderer.contentLength(item)
-    : ((item.deleted || !item.content.isCountable()) ? 0 : item.length)
-
-/**
- * The `AttributedContent` pieces `item` contributes to a *current-state*
- * render — the single physical-sequence interpretation shared by
- * `YNode#toDelta` (full render, `itemsToRender == null && !retainInserts`)
- * and `RangeCursor`'s bounded reads (UPSTREAM.md YP5):
- *
- * - a renderer-claimed item expands through `renderer.readContent` in mode
- *   `1` — the renderer's own attribution/restore/hide semantics;
- * - a `ContentFormat` marker contributes one piece carrying its `{key,
- *   value}` — consumers fold it into format state (by the piece's effective
- *   `deleted` flag) and it occupies no rendered length;
- * - a tombstoned item contributes nothing — invisible in the current state;
- * - any other item contributes itself whole.
- *
- * The pieces' `render`/`fresh` flags follow mode-`1` semantics
- * (`render = !deleted || attrs != null`).
- *
- * `scratch` is an optional caller-owned `AttributedContent` reused for the
- * single trivial piece — both consumers drain `out` before the next call,
- * so reusing it keeps the common live-content path allocation-free
- * (renderer-claimed items always allocate their own pieces).
- *
- * @param {Array<AttributedContent<any>>} out
- * @param {AbstractRenderer?} renderer
- * @param {import('../structs/Item.js').Item} item
- * @param {AttributedContent<any>?} [scratch]
- */
-export const readItemPieces = (out, renderer, item, scratch = null) => {
-  const content = item.content
-  if (renderer !== null && renderer.hasItem(item)) {
-    renderer.readContent(out, item.id.client, item.id.clock, item.deleted, content, 1)
-    return
-  }
-  let piece = scratch
-  if (content.constructor === ContentFormat) {
-    if (piece === null) {
-      piece = new AttributedContent(content, item.id.clock, item.deleted, null, 1)
-    } else {
-      piece.content = content
-      piece.clock = item.id.clock
-      piece.deleted = item.deleted
-      piece.attrs = null
-      piece.render = !item.deleted
-      piece.fresh = false
-    }
-    out.push(piece)
-  } else if (!item.deleted) {
-    if (piece === null) {
-      piece = new AttributedContent(content, item.id.clock, false, null, 1)
-    } else {
-      piece.content = content
-      piece.clock = item.id.clock
-      piece.deleted = false
-      piece.attrs = null
-      piece.render = true
-      piece.fresh = false
-    }
-    out.push(piece)
-  }
-}

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

@@ -1,3 +0,0 @@
-import * as s from 'lib0-v14/schema'
-
-export const $doc = /** @type {s.Schema<Doc>} */ (s.$type('y:doc', null))

package/dist/edytor.utils.d.ts

@@ -1,50 +0,0 @@
-import type { Text } from './text/text.svelte.js';
-import type { Block } from './block/block.svelte.js';
-import type { Edytor } from './edytor.svelte.js';
-import type { Flow, FlowTarget } from './crdt/flow.js';
-import type { Prepared } from './crdt/edytor-doc.js';
-/** The two endpoints of a range, as the selection holds them. */
-export type RangeEndpoints = {
-    startText: Text | null;
-    endText: Text | null;
-    yStart: number;
-    yEnd: number;
-};
-type At = {
-    block: string;
-    offset: number;
-};
-/**
- * Apply a prepared op and answer the caret it reports (`null` when it planned
- * none); the caret's block and its parent are normalized in its transaction.
- */
-export declare const applyAt: (edytor: Edytor, plan: Prepared) => At | null;
-/** The caret an op answered, as a text handle and offset. */
-export declare function caretOf(this: Edytor, at: At | null | undefined): readonly [Text | null, number];
-type RangeDelete = {
-    replace?: boolean;
-    selection?: RangeEndpoints;
-};
-/** The document's range deletion (`del.range.*`; `replace`: the deletion half of a replacement). */
-export declare function prepareDeleteContent(this: Edytor, { replace, selection }: RangeDelete): Prepared;
-/**
- * Delete the selected range (or `selection`) through the document's prepared
- * range deletion and answer the caret the op decided.
- */
-export declare function deleteContentWithinSelection(this: Edytor, payload: RangeDelete, plan?: Prepared): At | null;
-/** The range deletion's caret; refused at preparation: the range's start; vetoed: none. */
-export declare function rangeCaret(this: Edytor, at: At | null | undefined, payload: RangeDelete): readonly [Text | null, number] | undefined;
-type FlowInsert = {
-    flow: Flow;
-    target: FlowTarget;
-};
-export declare function prepareFlow(this: Edytor, { flow, target }: FlowInsert): Prepared;
-/** Place an admitted flow at `target` (`flow.*`) and answer the caret the op decided. */
-export declare function insertFlow(this: Edytor, payload: FlowInsert, plan?: Prepared): At | null;
-type BlocksDelete = {
-    blocks: Block[];
-};
-export declare function prepareDeleteBlocks(this: Edytor, { blocks }: BlocksDelete): Prepared;
-/** Delete a block selection (one document plan; nested members ride their ancestor). */
-export declare function deleteBlocks(this: Edytor, { blocks }: BlocksDelete, plan?: Prepared): boolean;
-export {};

package/dist/edytor.utils.js

@@ -1,67 +0,0 @@
-import { normalizeChildren, normalizeContent } from './block/block.utils.js';
-import { viewOf } from './selection/visibility.js';
-const REFUSED = { status: 'refused', ids: [] };
-/**
- * Apply a prepared op and answer the caret it reports (`null` when it planned
- * none); the caret's block and its parent are normalized in its transaction.
- */
-export const applyAt = (edytor, plan) => {
-    if (!('writes' in plan) || !plan.at)
-        return null;
-    const { facade, dispatcher } = edytor;
-    facade.apply(plan);
-    dispatcher.request(plan.at.block, normalizeContent);
-    dispatcher.request(facade.parentOf(plan.at.block) ?? 'root', normalizeChildren);
-    return plan.at;
-};
-/** The caret an op answered, as a text handle and offset. */
-export function caretOf(at) {
-    const hit = at && this.idToBlock.get(at.block)?.textAtOffset(at.offset);
-    return hit ? [hit.text, hit.offset] : [null, 0];
-}
-/** The document's range deletion (`del.range.*`; `replace`: the deletion half of a replacement). */
-export function prepareDeleteContent({ replace = false, selection }) {
-    const { startText, endText, yStart, yEnd } = selection ?? this.selection.state;
-    if (!startText || !endText)
-        return REFUSED;
-    const at = (text, offset) => ({
-        block: text.parent.id,
-        offset: text.segStart + offset
-    });
-    const prepare = replace ? this.facade.prepare.replaceRange : this.facade.prepare.deleteRange;
-    return prepare(at(startText, yStart), at(endText, yEnd), viewOf(this));
-}
-/**
- * Delete the selected range (or `selection`) through the document's prepared
- * range deletion and answer the caret the op decided.
- */
-export function deleteContentWithinSelection(payload, plan = prepareDeleteContent.call(this, payload)) {
-    return applyAt(this, plan);
-}
-/** The range deletion's caret; refused at preparation: the range's start; vetoed: none. */
-export function rangeCaret(at, payload) {
-    if (at === undefined)
-        return undefined;
-    const { startText, yStart } = payload.selection ?? this.selection.state;
-    return at ? caretOf.call(this, at) : [startText, yStart];
-}
-export function prepareFlow({ flow, target }) {
-    return this.facade.prepare.insertFlow(target, flow, viewOf(this));
-}
-/** Place an admitted flow at `target` (`flow.*`) and answer the caret the op decided. */
-export function insertFlow(payload, plan = prepareFlow.call(this, payload)) {
-    return applyAt(this, plan);
-}
-export function prepareDeleteBlocks({ blocks }) {
-    return this.facade.prepare.deleteBlocks(blocks.map((block) => block.id));
-}
-/** Delete a block selection (one document plan; nested members ride their ancestor). */
-export function deleteBlocks({ blocks }, plan = prepareDeleteBlocks.call(this, { blocks })) {
-    if (!('writes' in plan))
-        return false;
-    const parents = new Set(blocks.map((block) => block.parent));
-    this.facade.apply(plan);
-    for (const parent of parents)
-        parent?.normalizeChildren();
-    return true;
-}