edytor 1.0.0-rc.2 → 1.0.0

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

@@ -3,48 +3,33 @@
  */
 
 import { ObservableV2 } from 'lib0-v14/observable'
-import * as random from 'lib0-v14/random'
 import * as map from 'lib0-v14/map'
-import * as array from 'lib0-v14/array'
-import * as promise from 'lib0-v14/promise'
 
 import { StructStore } from './StructStore.js'
 import { transact, generateNewClientId } from './Transaction.js'
 import { YNode } from '../ynode.js'
-import { $doc } from './schemas.js'
 
 /**
  * @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.commit
  * @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.
+ * A Yjs instance handles the state of shared data. YP19: no subdocuments,
+ * no load/sync state, no guid — a document is its store, its root nodes and
+ * its transaction events.
  * @extends ObservableV2<DocEvents>
  */
 export class Doc extends ObservableV2 {
@@ -58,7 +43,7 @@ export class Doc extends ObservableV2 {
   /**
    * @param {DocOpts} opts configuration
    */
-  constructor ({ guid = random.uuidv4(), collectionid = null, gc = true, gcFilter = () => true, meta = null, autoLoad = false, shouldLoad = true, isSuggestionDoc = false } = {}) {
+  constructor ({ gc = true, gcFilter = () => true } = {}) {
     super()
     this.gc = gc
     this.gcFilter = gcFilter
@@ -70,10 +55,6 @@ export class Doc extends ObservableV2 {
      */
     this.keepReplaced = null
     this.clientID = generateNewClientId()
-    this.guid = guid
-    this.collectionid = collectionid
-    this.isSuggestionDoc = isSuggestionDoc
-    this.cleanupFormatting = !isSuggestionDoc
     /**
      * YP13: the greatest Lamport timestamp of a paired mark this document
      * integrated (see `utils/marks.js`).
@@ -93,95 +74,7 @@ export class Doc extends ObservableV2 {
      * @type {Array<Transaction>}
      */
     this._transactionCleanups = []
-    /**
-     * @type {Set<Doc>}
-     */
-    this.subdocs = new Set()
-    /**
-     * If this document is a subdocument - a document integrated into another document - then _item is defined.
-     * @type {Item?}
-     */
-    this._item = null
-    this.shouldLoad = shouldLoad
-    this.autoLoad = autoLoad
-    this.meta = meta
-    /**
-     * 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}
-     */
-    this.isLoaded = false
-    /**
-     * 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).
-     */
-    this.isSynced = false
     this.isDestroyed = false
-    /**
-     * Promise that resolves once the document has been loaded from a persistence provider.
-     */
-    this.whenLoaded = promise.create(resolve => {
-      this.on('load', () => {
-        this.isLoaded = true
-        resolve(this)
-      })
-    })
-    const provideSyncedPromise = () => promise.create(resolve => {
-      /**
-       * @param {boolean} isSynced
-       */
-      const eventHandler = (isSynced) => {
-        if (isSynced === undefined || isSynced === true) {
-          this.off('sync', eventHandler)
-          resolve()
-        }
-      }
-      this.on('sync', eventHandler)
-    })
-    this.on('sync', isSynced => {
-      if (isSynced === false && this.isSynced) {
-        this.whenSynced = provideSyncedPromise()
-      }
-      this.isSynced = isSynced === undefined || isSynced === true
-      if (this.isSynced && !this.isLoaded) {
-        this.emit('load', [this])
-      }
-    })
-    /**
-     * Promise that resolves once the document has been synced with a backend.
-     * This promise is recreated when the connection is lost.
-     * Note the documentation about the `isSynced` property.
-     */
-    this.whenSynced = provideSyncedPromise()
-  }
-
-  /**
-   * 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 () {
-    const item = this._item
-    if (item !== null && !this.shouldLoad) {
-      transact(/** @type {any} */ (item.parent).doc, transaction => {
-        transaction.subdocsLoaded.add(this)
-      }, null, true)
-    }
-    this.shouldLoad = true
-  }
-
-  getSubdocs () {
-    return this.subdocs
-  }
-
-  getSubdocGuids () {
-    return new Set(array.from(this.subdocs).map(doc => doc.guid))
   }
 
   /**
@@ -193,83 +86,34 @@ export class Doc extends ObservableV2 {
    * @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
-   * @param {boolean} [local]
    * @return T
+   *
+   * @public
    */
-  transact (f, origin = null, local = true) {
-    return transact(this, f, origin, local)
+  transact (f, origin = null) {
+    return transact(this, f, origin)
   }
 
   /**
-   * Define a shared data type.
-   *
-   * Multiple calls of `ydoc.get(name)` yield the same result
-   * and do not overwrite each other. I.e.
-   * `ydoc.get(name) === ydoc.get(name)`
-   *
-   * After this method is called, the type is also available on `ydoc.share.get(name)`.
-   *
-   * @param {string} key
-   * @param {string?} name Type-name
+   * The root node named `key`, created on first access.
    *
+   * @param {string} [key]
    * @return {YNode}
    */
-  get (key = '', name = null) {
+  get (key = '') {
     return map.setIfUndefined(this.share, key, () => {
-      const t = new YNode(name)
+      const t = new YNode(null)
       t._integrate(this, null)
       return t
     })
   }
 
   /**
-   * 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 () {
-    /**
-     * @type {Object<string, any>}
-     */
-    const doc = {}
-    this.share.forEach((value, key) => {
-      doc[key] = value.toJSON()
-    })
-    return doc
-  }
-
-  /**
-   * Emit `destroy` event and unregister all event handlers.
+   * Emit `destroy` to the document's listeners and drop them.
    */
   destroy () {
     this.isDestroyed = true
-    // Tear down the top-level shared types as RDTs (emits their `'destroy'` event so any bindings
-    // unsubscribe). Only top-level types are destroyed here; nested child types are not recursed.
-    this.share.forEach(type => type.destroy())
-    array.from(this.subdocs).forEach(subdoc => subdoc.destroy())
-    const item = this._item
-    if (item !== null) {
-      this._item = null
-      const content = /** @type {ContentDoc} */ (item.content)
-      /**
-       * new content doc which replaces the new one
-       */
-      const contentDoc = new Doc({ guid: this.guid, ...content.opts, shouldLoad: false })
-      content.doc = contentDoc
-      contentDoc._item = item
-      transact(/** @type {any} */ (item).parent.doc, transaction => {
-        if (!item.deleted) {
-          transaction.subdocsAdded.add(contentDoc)
-        }
-        transaction.subdocsRemoved.add(this)
-      }, null, true)
-    }
     this.emit('destroy', [this])
     super.destroy()
   }
 }
-
-Doc.prototype.$type = $doc

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

@@ -42,7 +42,7 @@ export const createID = (client, clock) => new ID(client, clock)
  * `type` does not store any information about the `keyname`.
  * This function finds the correct `keyname` for `type` and throws otherwise.
  *
- * @param {YNode<any>} type
+ * @param {YNode} type
  * @return {string}
  *
  * @private

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

@@ -7,9 +7,9 @@
  * search-marker checkpoints (the `formats` snapshots YP4 added for
  * `applyDelta`'s mutation-cursor seeding are exactly the checkpoints a
  * format-aware range read needs) and emits one {@link RangePiece} per
- * visible piece overlapping the range — the SAME physical-sequence
- * interpretation `YNode#toDelta` renders with (`readItemPieces`), folded
- * by `updateCurrentFormats`, measured by `rendererContentLength`.
+ * visible piece overlapping the range — the live content, folded by
+ * `updateCurrentFormats`, measured by `liveLength` (the same interpretation
+ * the write cursor, `ItemTextListPosition`, walks with).
  *
  * Cold reads leave sparse format-aware checkpoints behind their walk at
  * `READ_PLANT_GAP`-item cadence (`plantSearchMarker`) — `findMarker`'s
@@ -19,7 +19,7 @@
  *
  * Reads are pure with respect to replicated state: they never open a
  * transaction — no updates are produced, no items are split, no undo
- * state changes, no renderer is installed or mutated. The only writes
+ * state changes. The only writes
  * are to the node's local `_searchMarker` pool — the same adaptive
  * checkpoint maintenance upstream's own read-path lookups perform via
  * `findMarker` (`typeListGet`, position resolution) — non-replicated,
@@ -32,8 +32,7 @@ import { ContentFormat } from '../structs/Item.js'
 import { plantSearchMarker } from '../ynode.js'
 
 import { createID } from './ID.js'
-import { rendererContentLength, readItemPieces } from './renderer-helpers.js'
-import { updateCurrentFormats } from './transaction-helpers.js'
+import { updateCurrentFormats, liveLength } from './transaction-helpers.js'
 import { formatValue } from './marks.js' // YP13
 
 /**
@@ -46,29 +45,25 @@ const READ_PLANT_GAP = 64
 
 /**
  * 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.
  */
 
 /**
@@ -79,20 +74,13 @@ const READ_PLANT_GAP = 64
  */
 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, renderer = parent._renderer) {
+  constructor (parent) {
     /**
-     * @type {YNode<any>}
+     * @type {YNode}
      */
     this.parent = parent
-    /**
-     * @type {AbstractRenderer?}
-     */
-    this.renderer = renderer
     /**
      * The next unprocessed sequence item — a parked cursor keeps `index` at
      * its left edge.
@@ -102,7 +90,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}
      */
     this.index = 0
@@ -136,23 +124,19 @@ 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) {
     const parent = this.parent
     const ms = parent._searchMarker
-    if (ms === null || this.renderer !== null) return
+    if (ms === null) return
     /**
      * @type {import('../structs/Item.js').Item?}
      */
@@ -202,18 +186,16 @@ export class RangeCursor {
   }
 
   /**
-   * 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, stats) {
-    if (c.content.constructor !== ContentFormat) return
-    if (!c.deleted) {
-      updateCurrentFormats(this.currentFormats, /** @type {ContentFormat} */ (c.content))
+  _foldItem (item, stats) {
+    if (!item.deleted) {
+      updateCurrentFormats(this.currentFormats, /** @type {ContentFormat} */ (item.content))
       this._formatsObj = null
     }
     if (stats !== null) stats.markers++
@@ -242,9 +224,8 @@ export class RangeCursor {
 
   /**
    * 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
@@ -272,30 +253,19 @@ export class RangeCursor {
     if (i0 > this.index) {
       this.seek(i0)
     }
-    /**
-     * Per-item attributed pieces buffer (reused across items), plus the
-     * trivial-piece scratch `readItemPieces` reuses — `cs` is drained
-     * before the next item, so one allocation serves the whole read.
-     * @type {Array<AttributedContent<any>>}
-     */
-    const cs = []
-    /**
-     * @type {AttributedContent<any>?}
-     */
-    let csScratch = null
     // Items stepped since the cursor passed the last checkpoint — a sparse
     // marker is recorded at every `READ_PLANT_GAP` boundary during a cold
     // walk (the checkpoint pool only fills where work actually happens —
     // `findMarker`'s merge-left rule cannot anchor mid-run in
     // same-client-contiguous lists, so read-driven planting is what makes
-    // read-only workloads bounded). Index space is the raw countable one,
-    // hence the `renderer === null` gate — same space markers record.
+    // read-only workloads bounded). Index space is the raw countable one —
+    // the same space markers record.
     let stepsSincePlant = 0
-    const planting = this.renderer === null && parent._searchMarker !== null
+    const planting = parent._searchMarker !== null
     while (this.p !== null) {
       const item = this.p
       const start = this.index
-      const end = start + rendererContentLength(this.renderer, item)
+      const end = start + liveLength(item)
       if (stats !== null) stats.items++
       if (end <= i0) {
         // Boundary checkpoint — BEFORE folding the item (the snapshot is
@@ -304,16 +274,9 @@ export class RangeCursor {
           plantSearchMarker(parent, item, start, this.currentFormats)
           stepsSincePlant = 0
         }
-        // Prefix item — only format state can matter. `readItemPieces`
-        // gives marker pieces their effective `deleted` flag (renderer-
-        // aware), identical to `toDelta`'s fold.
+        // Prefix item — only format state can matter.
         if (item.content.constructor === ContentFormat) {
-          cs.length = 0
-          readItemPieces(cs, this.renderer, item, csScratch)
-          if (csScratch === null) csScratch = cs[0] ?? null
-          for (let k = 0; k < cs.length; k++) {
-            this._foldPiece(cs[k], stats)
-          }
+          this._foldItem(item, stats)
         }
         this.index = end
         this.p = item.right
@@ -325,72 +288,42 @@ export class RangeCursor {
         plantSearchMarker(parent, item, start, this.currentFormats)
         stepsSincePlant = 0
       }
-      // Overlapping item — produce its attributed pieces (the shared
-      // physical-sequence interpretation).
-      cs.length = 0
-      readItemPieces(cs, this.renderer, item, csScratch)
-      if (csScratch === null) csScratch = cs[0] ?? null
-      /**
-       * Rendered position of the piece currently being processed.
-       * @type {number}
-       */
-      let pix = start
-      for (let k = 0; k < cs.length; k++) {
-        const c = cs[k]
-        const content = c.content
-        if (content.constructor === ContentFormat) {
-          this._foldPiece(c, stats)
-          // Marker pieces reach the stream only when attributed — they
-          // occupy no rendered position.
-          if (c.attrs != null) {
+      // Overlapping item: a format marker folds (it occupies no position),
+      // a tombstone shows nothing, live content emits its part of the range.
+      const content = item.content
+      if (content.constructor === ContentFormat) {
+        this._foldItem(item, stats)
+      } else if (!item.deleted) {
+        const plen = content.isCountable() ? content.getLength() : 0
+        if (plen === 0) {
+          if (start >= i0 && start < i1) {
             out.push({
               content,
-              id: createID(item.id.client, c.clock),
-              index: pix,
+              id: item.id,
+              index: start,
               offset: 0,
               len: 0,
-              deleted: c.deleted,
-              attrs: c.attrs,
+              deleted: false,
+              attrs: null,
               formats: this._emitFormats()
             })
           }
-          continue
-        }
-        // Rendered length of this piece: `render` is the mode-1 flag
-        // (`!deleted || attrs != null`) — deleted unattributed pieces
-        // occupy no rendered position, attributed tombstones do (they
-        // render as deletes).
-        const plen = c.render && content.isCountable() ? content.getLength() : 0
-        if (plen === 0) {
-          if (pix >= i0 && pix < i1) {
+        } else {
+          const lo = math.max(i0, start)
+          const hi = math.min(i1, start + plen)
+          if (lo < hi) {
             out.push({
               content,
-              id: createID(item.id.client, c.clock),
-              index: pix,
-              offset: 0,
-              len: 0,
-              deleted: c.deleted,
-              attrs: c.attrs,
+              id: createID(item.id.client, item.id.clock + (lo - start)),
+              index: lo,
+              offset: lo - start,
+              len: hi - lo,
+              deleted: false,
+              attrs: null,
               formats: this._emitFormats()
             })
           }
-          continue
-        }
-        const lo = math.max(i0, pix)
-        const hi = math.min(i1, pix + plen)
-        if (lo < hi) {
-          out.push({
-            content,
-            id: createID(item.id.client, c.clock + (lo - pix)),
-            index: lo,
-            offset: lo - pix,
-            len: hi - lo,
-            deleted: c.deleted,
-            attrs: c.attrs,
-            formats: this._emitFormats()
-          })
         }
-        pix += plen
       }
       if (end > i1) return out // range ends inside this item — stay parked at its left edge
       // Item fully consumed — the boundary at `end` is the next item's left

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

@@ -56,16 +56,6 @@ export class StructStore {
     structs.push(struct)
   }
 
-  /**
-   * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
-   *
-   * @param {ID} id
-   * @return {GC|Item}
-   */
-  get (id) {
-    const structs = /** @type {Array<GC|Item>} */ (this.clients.get(id.client))
-    return structs[findIndexSS(structs, id.clock)]
-  }
 
   /**
    * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
@@ -96,18 +86,6 @@ export class StructStore {
     return lastStruct.id.clock + lastStruct.length
   }
 
-  /**
-   * Perform a binary search on a sorted array
-   * @param {ID} id
-   * @return {{ structs: Array<GC|Item|Skip>, index: number }}
-   *
-   * @function
-   */
-  getIndex (id) {
-    const structs = this.clients.get(id.client) || []
-    const index = findIndexSS(structs, id.clock)
-    return { structs, index }
-  }
 }
 
 /**