@y/y 14.0.0-rc.2 → 14.0.0-rc.21

package/src/utils/isParentOf.js

@@ -1,9 +1,7 @@
-import { Item } from '../internals.js' // eslint-disable-line
-
 /**
  * Check if `parent` is a parent of `child`.
  *
- * @param {import('../ytype.js').YType} parent
+ * @param {YType} parent
  * @param {Item|null} child
  * @return {Boolean} Whether `parent` is a parent of `child`.
  *
@@ -15,7 +13,7 @@ export const isParentOf = (parent, child) => {
     if (child.parent === parent) {
       return true
     }
-    child = /** @type {import('../ytype.js').YType} */ (child.parent)._item
+    child = /** @type {YType} */ (child.parent)._item
   }
   return false
 }

package/src/utils/logging.js

@@ -1,7 +1,3 @@
-import {
-  YType // eslint-disable-line
-} from '../internals.js'
-
 /**
  * Convenient helper to log type information.
  *

package/src/utils/meta.js

@@ -2,40 +2,50 @@
  * Meta API for describing Yjs documents
  */
 
-import * as idmap from './IdMap.js'
-import * as idset from './IdSet.js'
-import { IdSetEncoderV2 } from './UpdateEncoder.js'
-import { IdSetDecoderV2 } from './UpdateDecoder.js'
 import * as decoding from 'lib0/decoding'
 
-/**
- * @typedef {{ inserts: import('./IdSet.js').IdSet, deletes: import('./IdSet.js').IdSet }} ContentIds
- */
-
-/**
- * @typedef {{ inserts: import('./IdMap.js').IdMap<any>, deletes: import('./IdMap.js').IdMap<any> }} ContentMap
- */
+import {
+  createIdSetFromIdMap,
+  createDeleteSetFromStructStore,
+  createInsertSetFromStructStore,
+  diffIdMap,
+  mergeIdMaps,
+  createIdSet,
+  mergeIdSets,
+  diffIdSet,
+  createIdMapFromIdSet,
+  writeIdSet,
+  readIdSet,
+  writeIdMap,
+  readIdMap,
+  intersectMaps,
+  intersectSets,
+  filterIdMap
+} from './ids.js'
+import { IdSetEncoderV2 } from './UpdateEncoder.js'
+import { IdSetDecoderV2 } from './UpdateDecoder.js'
 
 /**
- * @param {import('./IdSet.js').IdSet} inserts
- * @param {import('./IdSet.js').IdSet} deletes
+ * @param {IdSet} inserts
+ * @param {IdSet} deletes
+ * @return {ContentIds}
  */
-export const createContentIds = (inserts = idset.createIdSet(), deletes = idset.createIdSet()) => ({ inserts, deletes })
+export const createContentIds = (inserts = createIdSet(), deletes = createIdSet()) => ({ inserts, deletes })
 
 /**
  * @param {ContentMap} contentMap
  */
 export const createContentIdsFromContentMap = contentMap => createContentIds(
-  idmap.createIdSetFromIdMap(contentMap.inserts),
-  idmap.createIdSetFromIdMap(contentMap.deletes)
+  createIdSetFromIdMap(contentMap.inserts),
+  createIdSetFromIdMap(contentMap.deletes)
 )
 
 /**
  * @param {import('./Doc.js').Doc} ydoc
  */
 export const createContentIdsFromDoc = ydoc => createContentIds(
-  idset.createInsertSetFromStructStore(ydoc.store, false),
-  idset.createDeleteSetFromStructStore(ydoc.store)
+  createInsertSetFromStructStore(ydoc.store, false),
+  createDeleteSetFromStructStore(ydoc.store)
 )
 
 /**
@@ -50,47 +60,48 @@ export const createContentIdsFromDocDiff = (ydocPrev, ydocNext) =>
  * @param {ContentIds} excludeContent
  */
 export const excludeContentIds = (content, excludeContent) =>
-  createContentIds(idset.diffIdSet(content.inserts, excludeContent.inserts), idset.diffIdSet(content.deletes, excludeContent.deletes))
+  createContentIds(diffIdSet(content.inserts, excludeContent.inserts), diffIdSet(content.deletes, excludeContent.deletes))
 
 /**
  * @param {ContentMap} content
  * @param {ContentIds | ContentMap} excludeContent
  */
 export const excludeContentMap = (content, excludeContent) => createContentMap(
-  idmap.diffIdMap(content.inserts, excludeContent.inserts),
-  idmap.diffIdMap(content.deletes, excludeContent.deletes)
+  diffIdMap(content.inserts, excludeContent.inserts),
+  diffIdMap(content.deletes, excludeContent.deletes)
 )
 
 /**
  * @param {Array<ContentMap>} contents
  */
 export const mergeContentMaps = contents => createContentMap(
-  idmap.mergeIdMaps(contents.map(c => c.inserts)),
-  idmap.mergeIdMaps(contents.map(c => c.deletes))
+  mergeIdMaps(contents.map(c => c.inserts)),
+  mergeIdMaps(contents.map(c => c.deletes))
 )
 
 /**
  * @param {Array<ContentIds>} contents
  */
 export const mergeContentIds = contents => createContentIds(
-  idset.mergeIdSets(contents.map(c => c.inserts)),
-  idset.mergeIdSets(contents.map(c => c.deletes))
+  mergeIdSets(contents.map(c => c.inserts)),
+  mergeIdSets(contents.map(c => c.deletes))
 )
 
 /**
- * @param {import('./IdMap.js').IdMap<any>} inserts
- * @param {import('./IdMap.js').IdMap<any>} deletes
+ * @param {IdMap<any>} inserts
+ * @param {IdMap<any>} deletes
+ * @return {ContentMap}
  */
 export const createContentMap = (inserts, deletes) => ({ inserts, deletes })
 
 /**
  * @param {ContentIds} contentIds
- * @param {Array<idmap.ContentAttribute<any>>} insertAttrs
- * @param {Array<idmap.ContentAttribute<any>>} [deleteAttrs]
+ * @param {Array<ContentAttribute<any>>} insertAttrs
+ * @param {Array<ContentAttribute<any>>} [deleteAttrs]
  */
 export const createContentMapFromContentIds = (contentIds, insertAttrs, deleteAttrs = insertAttrs) => createContentMap(
-  idmap.createIdMapFromIdSet(contentIds.inserts, insertAttrs),
-  idmap.createIdMapFromIdSet(contentIds.deletes, deleteAttrs)
+  createIdMapFromIdSet(contentIds.inserts, insertAttrs),
+  createIdMapFromIdSet(contentIds.deletes, deleteAttrs)
 )
 
 /**
@@ -98,8 +109,8 @@ export const createContentMapFromContentIds = (contentIds, insertAttrs, deleteAt
  * @param {ContentIds} contentIds
  */
 export const writeContentIds = (encoder, contentIds) => {
-  idset.writeIdSet(encoder, contentIds.inserts)
-  idset.writeIdSet(encoder, contentIds.deletes)
+  writeIdSet(encoder, contentIds.inserts)
+  writeIdSet(encoder, contentIds.deletes)
 }
 
 /**
@@ -118,8 +129,8 @@ export const encodeContentIds = contentIds => {
  * @return {ContentIds}
  */
 export const readContentIds = decoder => createContentIds(
-  idset.readIdSet(decoder),
-  idset.readIdSet(decoder)
+  readIdSet(decoder),
+  readIdSet(decoder)
 )
 
 /**
@@ -134,8 +145,8 @@ export const decodeContentIds = buf => readContentIds(new IdSetDecoderV2(decodin
  * @param {ContentMap} contentMap
  */
 export const writeContentMap = (encoder, contentMap) => {
-  idmap.writeIdMap(encoder, contentMap.inserts)
-  idmap.writeIdMap(encoder, contentMap.deletes)
+  writeIdMap(encoder, contentMap.inserts)
+  writeIdMap(encoder, contentMap.deletes)
 }
 
 /**
@@ -145,8 +156,8 @@ export const writeContentMap = (encoder, contentMap) => {
  * @return {ContentMap} contentMap
  */
 export const readContentMap = (decoder) => createContentMap(
-  idmap.readIdMap(decoder),
-  idmap.readIdMap(decoder)
+  readIdMap(decoder),
+  readIdMap(decoder)
 )
 
 /**
@@ -163,8 +174,8 @@ export const encodeContentMap = contentMap => {
  * @param {ContentMap|ContentIds} mapB
  */
 export const intersectContentMap = (mapA, mapB) => createContentMap(
-  idmap.intersectMaps(mapA.inserts, mapB.inserts),
-  idmap.intersectMaps(mapA.deletes, mapB.deletes)
+  intersectMaps(mapA.inserts, mapB.inserts),
+  intersectMaps(mapA.deletes, mapB.deletes)
 )
 
 /**
@@ -172,8 +183,8 @@ export const intersectContentMap = (mapA, mapB) => createContentMap(
  * @param {ContentIds|ContentMap} setB
  */
 export const intersectContentIds = (setA, setB) => createContentIds(
-  idset.intersectSets(setA.inserts, setB.inserts),
-  idset.intersectSets(setA.deletes, setB.deletes)
+  intersectSets(setA.inserts, setB.inserts),
+  intersectSets(setA.deletes, setB.deletes)
 )
 
 /**
@@ -184,7 +195,7 @@ export const decodeContentMap = buf => readContentMap(new IdSetDecoderV2(decodin
 /**
  * @todo filter by array of content instead
  * @param {ContentMap} contentMap
- * @param {(c:Array<idmap.ContentAttribute<any>>)=>boolean} insertPredicate
- * @param {(c:Array<idmap.ContentAttribute<any>>)=>boolean} deletePredicate
+ * @param {(c:Array<ContentAttribute<any>>)=>boolean} insertPredicate
+ * @param {(c:Array<ContentAttribute<any>>)=>boolean} deletePredicate
  */
-export const filterContentMap = (contentMap, insertPredicate, deletePredicate) => createContentMap(idmap.filterIdMap(contentMap.inserts, insertPredicate), idmap.filterIdMap(contentMap.deletes, deletePredicate))
+export const filterContentMap = (contentMap, insertPredicate, deletePredicate) => createContentMap(filterIdMap(contentMap.inserts, insertPredicate), filterIdMap(contentMap.deletes, deletePredicate))

package/src/utils/renderer-helpers.js

@@ -0,0 +1,110 @@
+import * as s from 'lib0/schema'
+import * as error from 'lib0/error'
+import { ObservableV2 } from 'lib0/observable'
+
+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} 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)
+  }
+}
+
+/**
+ * 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 AbstractRenderer extends ObservableV2 {
+  /**
+   * @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} _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).
+   */
+  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:r', AbstractRenderer)
+
+/**
+ * The default renderer. Renders content as-is, without looking up any attributions.
+ *
+ * @implements AbstractRenderer
+ *
+ * @extends {ObservableV2<{change:(idset:IdSet,origin:any,local:boolean)=>void}>}
+ */
+export class BaseRenderer extends ObservableV2 {
+  get $type () { return $renderer }
+
+  /**
+   * @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} shouldRender - whether this should render or just result in a `retain` operation
+   */
+  readContent (contents, _client, clock, deleted, content, shouldRender) {
+    if (!deleted || shouldRender) {
+      contents.push(new AttributedContent(content, clock, deleted, null, shouldRender))
+    }
+  }
+
+  /**
+   * @param {Item} item
+   * @return {number}
+   */
+  contentLength (item) {
+    return (item.deleted || !item.content.isCountable()) ? 0 : item.length
+  }
+}
+
+export const baseRenderer = new BaseRenderer()

package/src/utils/schemas.js

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