@y/y 14.0.0-rc.18 → 14.0.0-rc.19

package/src/utils/RelativePosition.js

@@ -4,7 +4,7 @@ import * as error from 'lib0/error'
 
 import { Item, followRedone, ContentType } from '../structs/Item.js'
 import { writeID, readID, compareIDs, findRootTypeKey, createID } from './ID.js'
-import { noAttributionsManager } from './attribution-manager-helpers.js'
+import { baseRenderer } from './renderer-helpers.js'
 
 /**
  * A relative position is based on the Yjs model and is not affected by document changes.
@@ -146,12 +146,12 @@ export const createRelativePosition = (type, item, assoc) => {
  * @param {YType} type The base type (e.g. YText or YArray).
  * @param {number} index The absolute position.
  * @param {number} [assoc]
- * @param {import('../utils/AttributionManager.js').AbstractAttributionManager} attributionManager
+ * @param {import('../utils/Renderer.js').AbstractRenderer} renderer
  * @return {RelativePosition}
  *
  * @function
  */
-export const createRelativePositionFromTypeIndex = (type, index, assoc = 0, attributionManager = noAttributionsManager) => {
+export const createRelativePositionFromTypeIndex = (type, index, assoc = 0, renderer = baseRenderer) => {
   let t = type._start
   if (assoc < 0) {
     // associated to the left character or the beginning of a type, increment index if possible.
@@ -161,7 +161,7 @@ export const createRelativePositionFromTypeIndex = (type, index, assoc = 0, attr
     index--
   }
   while (t !== null) {
-    const len = attributionManager.contentLength(t)
+    const len = renderer.contentLength(t)
     if (len > index) {
       // case 1: found position somewhere in the linked list
       return createRelativePosition(type, createID(t.id.client, t.id.clock + index), assoc)
@@ -272,12 +272,12 @@ const getItemWithOffset = (store, id) => {
  * @param {RelativePosition} rpos
  * @param {Doc} doc
  * @param {boolean} followUndoneDeletions - whether to follow undone deletions - see https://github.com/yjs/yjs/issues/638
- * @param {import('../utils/AttributionManager.js').AbstractAttributionManager} attributionManager
+ * @param {import('../utils/Renderer.js').AbstractRenderer} renderer
  * @return {AbsolutePosition|null}
  *
  * @function
  */
-export const createAbsolutePositionFromRelativePosition = (rpos, doc, followUndoneDeletions = true, attributionManager = noAttributionsManager) => {
+export const createAbsolutePositionFromRelativePosition = (rpos, doc, followUndoneDeletions = true, renderer = baseRenderer) => {
   const store = doc.store
   const rightID = rpos.item
   const typeID = rpos.type
@@ -296,10 +296,10 @@ export const createAbsolutePositionFromRelativePosition = (rpos, doc, followUndo
     }
     type = /** @type {YType<any>} */ (right.parent)
     if (type._item === null || !type._item.deleted) {
-      index = attributionManager.contentLength(right) === 0 ? 0 : (res.diff + (assoc >= 0 ? 0 : 1)) // adjust position based on left association if necessary
+      index = renderer.contentLength(right) === 0 ? 0 : (res.diff + (assoc >= 0 ? 0 : 1)) // adjust position based on left association if necessary
       let n = right.left
       while (n !== null) {
-        index += attributionManager.contentLength(n)
+        index += renderer.contentLength(n)
         n = n.left
       }
     }

package/src/utils/{AttributionManager.js → Renderer.js}

@@ -11,16 +11,16 @@ import { UpdateEncoderV1 } from './UpdateEncoder.js'
 import { transact } from './Transaction.js'
 import { UndoManager, StackItem } from './UndoManager.js'
 
-import { $attributionManager, AttributedContent } from './attribution-manager-helpers.js'
+import { $renderer, AttributedContent } from './renderer-helpers.js'
 
-export { noAttributionsManager, NoAttributionsManager, AbstractAttributionManager, $attributionManager } from './attribution-manager-helpers.js'
+export { baseRenderer, BaseRenderer, AbstractRenderer, $renderer } from './renderer-helpers.js'
 
 /**
- * @implements AbstractAttributionManager
+ * @implements AbstractRenderer
  *
  * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
  */
-export class TwosetAttributionManager extends ObservableV2 {
+export class TwosetRenderer extends ObservableV2 {
   /**
    * @param {IdMap<any>} inserts
    * @param {IdMap<any>} deletes
@@ -31,7 +31,7 @@ export class TwosetAttributionManager extends ObservableV2 {
     this.deletes = deletes
   }
 
-  get $type () { return $attributionManager }
+  get $type () { return $renderer }
 
   /**
    * @param {Array<AttributedContent<any>>} contents - where to write the result
@@ -93,15 +93,15 @@ const getItemContent = (store, client, clock, len) => {
 
 /**
  * @param {Transaction?} tr - only specify this if you want to fill the content of deleted content
- * @param {DiffAttributionManager} am
+ * @param {DiffRenderer} renderer
  * @param {ID} start
  * @param {ID} end
  * @param {boolean} collectAll - collect as many items as possible. Accept adding redundant changes.
  */
-const collectSuggestedChanges = (tr, am, start, end, collectAll) => {
+const collectSuggestedChanges = (tr, renderer, start, end, collectAll) => {
   const inserts = createIdSet()
   const deletes = createIdSet()
-  const store = am._nextDoc.store
+  const store = renderer._nextDoc.store
   /**
    * make sure to collect suggestions until all formats are closed
    * @type {Set<string>}
@@ -121,7 +121,7 @@ const collectSuggestedChanges = (tr, am, start, end, collectAll) => {
       break
     }
     if (!item.deleted) {
-      const slice = am.inserts.slice(item.id.client, item.id.clock, item.length)
+      const slice = renderer.inserts.slice(item.id.client, item.id.clock, item.length)
       if (slice.some(s => s.attrs === null)) {
         for (let i = slice.length - 1; i >= 0; i--) {
           const s = slice[i]
@@ -137,7 +137,7 @@ const collectSuggestedChanges = (tr, am, start, end, collectAll) => {
   // eslint-disable-next-line
   itemLoop: while (item != null) {
     const itemClient = item.id.client
-    const slice = (item.deleted ? am.deletes : am.inserts).slice(itemClient, item.id.clock, item.length)
+    const slice = (item.deleted ? renderer.deletes : renderer.inserts).slice(itemClient, item.id.clock, item.length)
     foundEndItem ||= item === endItem
     if (item.deleted) {
       // item probably gc'd content. Need to split item and fill with content again
@@ -154,7 +154,7 @@ const collectSuggestedChanges = (tr, am, start, end, collectAll) => {
         if (tr != null) {
           const splicedItem = getItemCleanStart(tr, createID(itemClient, s.clock))
           if (s.attrs != null) {
-            splicedItem.content = getItemContent(am._prevDocStore, itemClient, s.clock, s.len)
+            splicedItem.content = getItemContent(renderer._prevDocStore, itemClient, s.clock, s.len)
           }
         }
       }
@@ -197,15 +197,15 @@ export class Attributions {
 const extractAttributions = (attrs, slice) => attrs == null ? createIdMapFromIdSet(slice, []) : mergeIdMaps([intersectMaps(attrs, slice), createIdMapFromIdSet(slice, [])])
 
 /**
- * @implements AbstractAttributionManager
+ * @implements AbstractRenderer
  *
  * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
  */
-export class DiffAttributionManager extends ObservableV2 {
+export class DiffRenderer extends ObservableV2 {
   /**
    * @param {Doc} prevDoc
    * @param {Doc} nextDoc
-   * @param {Object} [options] - options for the attribution manager
+   * @param {Object} [options] - options for the renderer
    * @param {Attributions?} [options.attrs] - the attributes to apply to the diff
    */
   constructor (prevDoc, nextDoc, { attrs = null } = {}) {
@@ -264,7 +264,7 @@ export class DiffAttributionManager extends ObservableV2 {
     })
     this._afterTrListener = nextDoc.on('afterTransaction', (tr) => {
       // apply deletes on attributed deletes (content that is already deleted, but is rendered by
-      // the attribution manager)
+      // the renderer)
       if (!this.suggestionMode && tr.local && (this.suggestionOrigins == null || this.suggestionOrigins.some(o => o === tr.origin))) {
         const attributedDeletes = tr.meta.get('attributedDeletes')
         if (attributedDeletes != null) {
@@ -290,7 +290,7 @@ export class DiffAttributionManager extends ObservableV2 {
     prevDoc.on('destroy', this._destroyHandler)
   }
 
-  get $type () { return $attributionManager }
+  get $type () { return $renderer }
 
   destroy () {
     super.destroy()
@@ -411,24 +411,24 @@ export class DiffAttributionManager extends ObservableV2 {
  *
  * @param {Doc} prevDoc
  * @param {Doc} nextDoc
- * @param {Object} [options] - options for the attribution manager
+ * @param {Object} [options] - options for the renderer
  * @param {ContentMap?} [options.attrs] - the attributes to apply to the diff
  */
-export const createAttributionManagerFromDiff = (prevDoc, nextDoc, options) => new DiffAttributionManager(prevDoc, nextDoc, options)
+export const createDiffRenderer = (prevDoc, nextDoc, options) => new DiffRenderer(prevDoc, nextDoc, options)
 
 /**
- * Intended for projects that used the v13 snapshot feature. With this AttributionManager you can
+ * Intended for projects that used the v13 snapshot feature. With this renderer you can
  * read content similar to the previous snapshot api. Requires that `ydoc.gc` is turned off.
  *
- * @implements AbstractAttributionManager
+ * @implements AbstractRenderer
  *
  * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
  */
-export class SnapshotAttributionManager extends ObservableV2 {
+export class SnapshotRenderer extends ObservableV2 {
   /**
    * @param {Snapshot} prevSnapshot
    * @param {Snapshot} nextSnapshot
-   * @param {Object} [options] - options for the attribution manager
+   * @param {Object} [options] - options for the renderer
    * @param {Array<ContentAttribute>} [options.attrs] - the attributes to apply to the diff
    */
   constructor (prevSnapshot, nextSnapshot) {
@@ -445,7 +445,7 @@ export class SnapshotAttributionManager extends ObservableV2 {
     this.attrs = mergeIdMaps([diffIdMap(inserts, prevSnapshot.ds), deletes])
   }
 
-  get $type () { return $attributionManager }
+  get $type () { return $renderer }
 
   /**
    * @param {Array<AttributedContent<any>>} contents - where to write the result
@@ -495,4 +495,4 @@ export class SnapshotAttributionManager extends ObservableV2 {
  * @param {Snapshot} prevSnapshot
  * @param {Snapshot} nextSnapshot
  */
-export const createAttributionManagerFromSnapshots = (prevSnapshot, nextSnapshot = prevSnapshot) => new SnapshotAttributionManager(prevSnapshot, nextSnapshot)
+export const createSnapshotRenderer = (prevSnapshot, nextSnapshot = prevSnapshot) => new SnapshotRenderer(prevSnapshot, nextSnapshot)

package/src/utils/Snapshot.js

@@ -119,11 +119,11 @@ export const splitSnapshotAffectedStructs = (transaction, snapshot) => {
 /**
  * @example
  *  const ydoc = new Y.Doc({ gc: false })
- *  ydoc.getText().insert(0, 'world!')
+ *  ydoc.get().insert(0, 'world!')
  *  const snapshot = Y.snapshot(ydoc)
- *  ydoc.getText().insert(0, 'hello ')
+ *  ydoc.get().insert(0, 'hello ')
  *  const restored = Y.createDocFromSnapshot(ydoc, snapshot)
- *  assert(restored.getText().toString() === 'world!')
+ *  assert(restored.get().toString() === 'world!')
  *
  * @param {Doc} originDoc
  * @param {Snapshot} snapshot

package/src/utils/Transaction.js

@@ -26,18 +26,18 @@ export const generateNewClientId = random.uint53
  *
  * @example
  * const ydoc = new Y.Doc()
- * const map = ydoc.getMap('map')
+ * 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.set('a', 0) // => "change triggered"
- * map.set('b', 0) // => "change triggered"
+ * 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.set('a', 1)
- *   map.set('b', 1)
+ *   map.setAttr('a', 1)
+ *   map.setAttr('b', 1)
  * }) // => "change triggered"
  *
  * @public

package/src/utils/YEvent.js

@@ -2,7 +2,7 @@ import * as map from 'lib0/map'
 import * as set from 'lib0/set'
 
 import { diffIdSet, mergeIdSets } from './ids.js'
-import { noAttributionsManager } from './attribution-manager-helpers.js'
+import { baseRenderer } from './renderer-helpers.js'
 import { createAbsolutePositionFromRelativePosition, createRelativePosition } from './RelativePosition.js'
 
 /**
@@ -85,14 +85,14 @@ export class YEvent {
 
   /**
    * @template {boolean} [Deep=false]
-   * @param {AbstractAttributionManager} am
    * @param {object} [opts]
+   * @param {AbstractRenderer} [opts.renderer] - renders the content (with attributions); defaults to `baseRenderer`
    * @param {Deep} [opts.deep]
    * @return {Deep extends true ? Delta<DConf> : Delta<import('../ytype.js').DeltaConfDeltaToYType<DConf>>} The Delta representation of this type.
    *
    * @public
    */
-  getDelta (am = noAttributionsManager, { deep } = {}) {
+  getDelta ({ renderer = baseRenderer, deep } = {}) {
     const itemsToRender = mergeIdSets([diffIdSet(this.transaction.insertSet, this.transaction.deleteSet), diffIdSet(this.transaction.deleteSet, this.transaction.insertSet)])
     /**
      * @todo this should be done only one in the transaction step
@@ -120,7 +120,7 @@ export class YEvent {
       }
       modified = dchanged
     }
-    return /** @type {any} */ (this.target.toDelta(am, { itemsToRender, retainDeletes: true, deletedItems: this.transaction.deleteSet, deep: !!deep, modified }))
+    return /** @type {any} */ (this.target.toDelta({ renderer, itemsToRender, retainDeletes: true, deletedItems: this.transaction.deleteSet, deep: !!deep, modified }))
   }
 
   /**
@@ -142,7 +142,7 @@ export class YEvent {
    * @public
    */
   get deltaDeep () {
-    return /** @type {any} */ (this._deltaDeep ?? (this._deltaDeep = /** @type {any} */ (this.getDelta(noAttributionsManager, { deep: true }))))
+    return /** @type {any} */ (this._deltaDeep ?? (this._deltaDeep = /** @type {any} */ (this.getDelta({ deep: true }))))
   }
 }
 
@@ -158,13 +158,13 @@ export class YEvent {
  *
  * @param {YType} parent
  * @param {YType} child target
- * @param {AbstractAttributionManager} am
+ * @param {AbstractRenderer} renderer
  * @return {Array<string|number>} Path to the target
  *
  * @private
  * @function
  */
-export const getPathTo = (parent, child, am = noAttributionsManager) => {
+export const getPathTo = (parent, child, renderer = baseRenderer) => {
   const path = []
   const doc = /** @type {Doc} */ (parent.doc)
   while (child._item !== null && child !== parent) {
@@ -174,7 +174,7 @@ export const getPathTo = (parent, child, am = noAttributionsManager) => {
     } else {
       const parent = /** @type {import('../ytype.js').YType} */ (child._item.parent)
       // parent is array-ish
-      const apos = /** @type {import('../utils/RelativePosition.js').AbsolutePosition} */ (createAbsolutePositionFromRelativePosition(createRelativePosition(parent, child._item.id), doc, false, am))
+      const apos = /** @type {import('../utils/RelativePosition.js').AbsolutePosition} */ (createAbsolutePositionFromRelativePosition(createRelativePosition(parent, child._item.id), doc, false, renderer))
       path.unshift(apos.index)
     }
     child = /** @type {YType} */ (child._item.parent)

package/src/utils/delta-helpers.js

@@ -1,6 +1,6 @@
 import * as delta from 'lib0/delta'
 import { createInsertSetFromStructStore, createDeleteSetFromStructStore, diffIdSet, mergeIdSets } from './ids.js'
-import { createAttributionManagerFromDiff } from './AttributionManager.js'
+import { createDiffRenderer } from './Renderer.js'
 import { computeModifiedFromItems } from '../ytype.js'
 
 /**
@@ -8,7 +8,7 @@ import { computeModifiedFromItems } from '../ytype.js'
  * @param {Doc} v2
  * @return {delta.DeltaBuilderAny}
  */
-export const diffDocsToDelta = (v1, v2, { am = createAttributionManagerFromDiff(v1, v2) } = {}) => {
+export const diffDocsToDelta = (v1, v2, { renderer = createDiffRenderer(v1, v2) } = {}) => {
   const insertDiff = diffIdSet(createInsertSetFromStructStore(v2.store, false), createInsertSetFromStructStore(v1.store, false))
   const deleteDiff = diffIdSet(createDeleteSetFromStructStore(v2.store), createDeleteSetFromStructStore(v1.store))
   // don't render items that have been inserted and then deleted
@@ -23,8 +23,8 @@ export const diffDocsToDelta = (v1, v2, { am = createAttributionManagerFromDiff(
   v2.share.forEach((type, typename) => {
     const typeConf = changedTypes.get(type)
     if (typeConf) {
-      const shareDelta = type.toDelta(am, {
-        itemsToRender, retainDeletes: true, deletedItems: deletesOnly, modified: changedTypes, deep: true
+      const shareDelta = type.toDelta({
+        renderer, itemsToRender, retainDeletes: true, deletedItems: deletesOnly, modified: changedTypes, deep: true
       })
       d.modifyAttr(typename, shareDelta)
     }

package/src/utils/ids.js

@@ -7,7 +7,7 @@ import * as rabin from 'lib0/hash/rabin'
 import * as array from 'lib0/array'
 import * as map from 'lib0/map'
 
-import { iterateStructs, findIndexSS, iterateStructsWithoutSplits } from './transaction-helpers.js'
+import { iterateStructs, findIndexSS, iterateStructsWithoutSplits, tryGc } from './transaction-helpers.js'
 import { UpdateEncoderV2, IdSetEncoderV2 } from './UpdateEncoder.js'
 import { IdSetDecoderV2 } from './UpdateDecoder.js'
 
@@ -369,6 +369,27 @@ export const iterateStructsByIdSet = (transaction, ds, f) =>
     }
   })
 
+/**
+ * Garbage-collect the deleted content referenced by `ids` on `doc`.
+ *
+ * This is useful to retroactively reclaim memory on a document created with `gc: false`
+ * (e.g. once a snapshot, or an UndoManager StackItem, that referenced this content is no
+ * longer needed) - without enabling gc for the whole document. Ids that reference live
+ * (non-deleted) content, already-collected structs, items flagged with `keep`, or items
+ * rejected by `gcFilter` are skipped.
+ *
+ * @param {Doc} doc
+ * @param {IdSet} ids
+ * @param {function(Item):boolean} [gcFilter]
+ */
+export const gcIdSet = (doc, ids, gcFilter = doc.gcFilter) =>
+  doc.transact(tr => {
+    // Split structs exactly at the IdSet boundaries so that only the referenced content is
+    // collected - an arbitrary IdSet need not align with struct boundaries.
+    iterateStructsByIdSet(tr, ids, () => {})
+    tryGc(tr, ids, gcFilter)
+  })
+
 /**
  * Iterate over all structs that are mentioned by the IdSet, without spliting the items.
  *

package/src/utils/{attribution-manager-helpers.js → renderer-helpers.js}

@@ -38,14 +38,14 @@ export class AttributedContent {
 }
 
 /**
- * Abstract class for associating Attributions to content / changes
+ * 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.
  *
  * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
  */
-export class AbstractAttributionManager extends ObservableV2 {
+export class AbstractRenderer extends ObservableV2 {
   /**
    * @param {Array<AttributedContent<any>>} _contents - where to write the result
    * @param {number} _client
@@ -72,17 +72,17 @@ export class AbstractAttributionManager extends ObservableV2 {
   }
 }
 
-export const $attributionManager = AbstractAttributionManager.prototype.$type = s.$type('y:am', AbstractAttributionManager)
+export const $renderer = AbstractRenderer.prototype.$type = s.$type('y:r', AbstractRenderer)
 
 /**
- * Abstract class for associating Attributions to content / changes
+ * The default renderer. Renders content as-is, without looking up any attributions.
  *
- * @implements AbstractAttributionManager
+ * @implements AbstractRenderer
  *
  * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
  */
-export class NoAttributionsManager extends ObservableV2 {
-  get $type () { return $attributionManager }
+export class BaseRenderer extends ObservableV2 {
+  get $type () { return $renderer }
 
   /**
    * @param {Array<AttributedContent<any>>} contents - where to write the result
@@ -107,4 +107,4 @@ export class NoAttributionsManager extends ObservableV2 {
   }
 }
 
-export const noAttributionsManager = new NoAttributionsManager()
+export const baseRenderer = new BaseRenderer()