@y/y 14.0.0-16 → 14.0.0-18

package/src/types/YArray.js

@@ -1,270 +0,0 @@
-/**
- * @module YArray
- */
-
-import {
-  AbstractType,
-  typeListGet,
-  typeListToArray,
-  typeListForEach,
-  typeListCreateIterator,
-  typeListInsertGenerics,
-  typeListPushGenerics,
-  typeListDelete,
-  typeListMap,
-  YArrayRefID,
-  transact,
-  warnPrematureAccess,
-  typeListSlice,
-  noAttributionsManager,
-  AbstractAttributionManager, ArraySearchMarker, UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Doc, Transaction, Item // eslint-disable-line
-} from '../internals.js'
-
-import * as delta from 'lib0/delta' // eslint-disable-line
-
-/**
- * A shared Array implementation.
- * @template {import('../utils/types.js').YValue} T
- * @extends {AbstractType<delta.ArrayDelta<T>,YArray<T>>}
- * @implements {Iterable<T>}
- */
-// @todo remove this
-// @ts-ignore
-export class YArray extends AbstractType {
-  constructor () {
-    super()
-    /**
-     * @type {Array<any>?}
-     * @private
-     */
-    this._prelimContent = []
-    /**
-     * @type {Array<ArraySearchMarker>}
-     */
-    this._searchMarker = []
-  }
-
-  /**
-   * Construct a new YArray containing the specified items.
-   * @template {import('../utils/types.js').YValue} T
-   * @param {Array<T>} items
-   * @return {YArray<T>}
-   */
-  static from (items) {
-    /**
-     * @type {YArray<T>}
-     */
-    const a = new YArray()
-    a.push(items)
-    return a
-  }
-
-  /**
-   * Integrate this type into the Yjs instance.
-   *
-   * * Save this struct in the os
-   * * This type is sent to other client
-   * * Observer functions are fired
-   *
-   * @param {Doc} y The Yjs instance
-   * @param {Item?} item
-   */
-  _integrate (y, item) {
-    super._integrate(y, item)
-    this.insert(0, /** @type {Array<any>} */ (this._prelimContent))
-    this._prelimContent = null
-  }
-
-  /**
-   * Makes a copy of this data type that can be included somewhere else.
-   *
-   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
-   *
-   * @return {YArray<T>}
-   */
-  clone () {
-    /**
-     * @type {this}
-     */
-    const arr = /** @type {this} */ (new YArray())
-    arr.insert(0, this.toArray().map(el =>
-      // @ts-ignore
-      el instanceof AbstractType ? /** @type {any} */ (el.clone()) : el
-    ))
-    return arr
-  }
-
-  get length () {
-    this.doc ?? warnPrematureAccess()
-    return this._length
-  }
-
-  /**
-   * Inserts new content at an index.
-   *
-   * Important: This function expects an array of content. Not just a content
-   * object. The reason for this "weirdness" is that inserting several elements
-   * is very efficient when it is done as a single operation.
-   *
-   * @example
-   *  // Insert character 'a' at position 0
-   *  yarray.insert(0, ['a'])
-   *  // Insert numbers 1, 2 at position 1
-   *  yarray.insert(1, [1, 2])
-   *
-   * @param {number} index The index to insert content at.
-   * @param {Array<T>} content The array of content
-   */
-  insert (index, content) {
-    if (this.doc !== null) {
-      transact(this.doc, transaction => {
-        typeListInsertGenerics(transaction, this, index, /** @type {any} */ (content))
-      })
-    } else {
-      /** @type {Array<any>} */ (this._prelimContent).splice(index, 0, ...content)
-    }
-  }
-
-  /**
-   * Appends content to this YArray.
-   *
-   * @param {Array<T>} content Array of content to append.
-   *
-   * @todo Use the following implementation in all types.
-   */
-  push (content) {
-    if (this.doc !== null) {
-      transact(this.doc, transaction => {
-        typeListPushGenerics(transaction, this, /** @type {any} */ (content))
-      })
-    } else {
-      /** @type {Array<any>} */ (this._prelimContent).push(...content)
-    }
-  }
-
-  /**
-   * Prepends content to this YArray.
-   *
-   * @param {Array<T>} content Array of content to prepend.
-   */
-  unshift (content) {
-    this.insert(0, content)
-  }
-
-  /**
-   * Deletes elements starting from an index.
-   *
-   * @param {number} index Index at which to start deleting elements
-   * @param {number} length The number of elements to remove. Defaults to 1.
-   */
-  delete (index, length = 1) {
-    if (this.doc !== null) {
-      transact(this.doc, transaction => {
-        typeListDelete(transaction, this, index, length)
-      })
-    } else {
-      /** @type {Array<any>} */ (this._prelimContent).splice(index, length)
-    }
-  }
-
-  /**
-   * Returns the i-th element from a YArray.
-   *
-   * @param {number} index The index of the element to return from the YArray
-   * @return {T}
-   */
-  get (index) {
-    return typeListGet(this, index)
-  }
-
-  /**
-   * Transforms this YArray to a JavaScript Array.
-   *
-   * @return {Array<T>}
-   */
-  toArray () {
-    return typeListToArray(this)
-  }
-
-  /**
-   * Render the difference to another ydoc (which can be empty) and highlight the differences with
-   * attributions.
-   *
-   * Note that deleted content that was not deleted in prevYdoc is rendered as an insertion with the
-   * attribution `{ isDeleted: true, .. }`.
-   *
-   * @param {AbstractAttributionManager} am
-   * @return {delta.ArrayDelta<import('./AbstractType.js').TypeToDelta<T>>} The Delta representation of this type.
-   *
-   * @public
-   */
-  getContentDeep (am = noAttributionsManager) {
-    return super.getContentDeep(am)
-  }
-
-  /**
-   * Returns a portion of this YArray into a JavaScript Array selected
-   * from start to end (end not included).
-   *
-   * @param {number} [start]
-   * @param {number} [end]
-   * @return {Array<T>}
-   */
-  slice (start = 0, end = this.length) {
-    return typeListSlice(this, start, end)
-  }
-
-  /**
-   * Transforms this Shared Type to a JSON object.
-   *
-   * @return {Array<any>}
-   */
-  toJSON () {
-    return this.map(c => c instanceof AbstractType ? c.toJSON() : c)
-  }
-
-  /**
-   * Returns an Array with the result of calling a provided function on every
-   * element of this YArray.
-   *
-   * @template M
-   * @param {function(T,number,YArray<T>):M} f Function that produces an element of the new Array
-   * @return {Array<M>} A new array with each element being the result of the
-   *                 callback function
-   */
-  map (f) {
-    return typeListMap(this, /** @type {any} */ (f))
-  }
-
-  /**
-   * Executes a provided function once on every element of this YArray.
-   *
-   * @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.
-   */
-  forEach (f) {
-    typeListForEach(this, f)
-  }
-
-  /**
-   * @return {IterableIterator<T>}
-   */
-  [Symbol.iterator] () {
-    return typeListCreateIterator(this)
-  }
-
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YArrayRefID)
-  }
-}
-
-/**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder
- * @return {import('../utils/types.js').YType}
- *
- * @private
- * @function
- */
-export const readYArray = _decoder => new YArray()

package/src/types/YMap.js

@@ -1,244 +0,0 @@
-/**
- * @module YMap
- */
-
-import {
-  AbstractType,
-  typeMapDelete,
-  typeMapSet,
-  typeMapGet,
-  typeMapHas,
-  createMapIterator,
-  YMapRefID,
-  transact,
-  warnPrematureAccess,
-  UpdateDecoderV1, UpdateDecoderV2, UpdateEncoderV1, UpdateEncoderV2, Doc, Item // eslint-disable-line
-} from '../internals.js'
-
-import * as iterator from 'lib0/iterator'
-import * as delta from 'lib0/delta' // eslint-disable-line
-
-/**
- * @template MapType
- * A shared Map implementation.
- *
- * @extends AbstractType<delta.MapDelta<{[K in string]:MapType}>>
- * @implements {Iterable<[string, MapType]>}
- */
-export class YMap extends AbstractType {
-  /**
-   *
-   * @param {Iterable<readonly [string, any]>=} entries - an optional iterable to initialize the YMap
-   */
-  constructor (entries) {
-    super()
-    /**
-     * @type {Map<string,any>?}
-     * @private
-     */
-    this._prelimContent = null
-
-    if (entries === undefined) {
-      this._prelimContent = new Map()
-    } else {
-      this._prelimContent = new Map(entries)
-    }
-  }
-
-  /**
-   * Integrate this type into the Yjs instance.
-   *
-   * * Save this struct in the os
-   * * This type is sent to other client
-   * * Observer functions are fired
-   *
-   * @param {Doc} y The Yjs instance
-   * @param {Item?} item
-   */
-  _integrate (y, item) {
-    super._integrate(y, item)
-    ;/** @type {Map<string, any>} */ (this._prelimContent).forEach((value, key) => {
-      this.set(key, value)
-    })
-    this._prelimContent = null
-  }
-
-  /**
-   * Makes a copy of this data type that can be included somewhere else.
-   *
-   * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
-   *
-   * @return {this}
-   */
-  clone () {
-    const map = this._copy()
-    this.forEach((value, key) => {
-      map.set(key, value instanceof AbstractType ? /** @type {typeof value} */ (value.clone()) : value)
-    })
-    return map
-  }
-
-  /**
-   * Transforms this Shared Type to a JSON object.
-   *
-   * @return {Object<string,any>}
-   */
-  toJSON () {
-    this.doc ?? warnPrematureAccess()
-    /**
-     * @type {Object<string,MapType>}
-     */
-    const map = {}
-    this._map.forEach((item, key) => {
-      if (!item.deleted) {
-        const v = item.content.getContent()[item.length - 1]
-        map[key] = v instanceof AbstractType ? v.toJSON() : v
-      }
-    })
-    return map
-  }
-
-  /**
-   * Returns the size of the YMap (count of key/value pairs)
-   *
-   * @return {number}
-   */
-  get size () {
-    return [...createMapIterator(this)].length
-  }
-
-  /**
-   * Returns the keys for each element in the YMap Type.
-   *
-   * @return {IterableIterator<string>}
-   */
-  keys () {
-    return iterator.iteratorMap(createMapIterator(this), /** @param {any} v */ v => v[0])
-  }
-
-  /**
-   * Returns the values for each element in the YMap Type.
-   *
-   * @return {IterableIterator<MapType>}
-   */
-  values () {
-    return iterator.iteratorMap(createMapIterator(this), /** @param {any} v */ v => v[1].content.getContent()[v[1].length - 1])
-  }
-
-  /**
-   * Returns an Iterator of [key, value] pairs
-   *
-   * @return {IterableIterator<[string, MapType]>}
-   */
-  entries () {
-    return iterator.iteratorMap(createMapIterator(this), /** @param {any} v */ v => /** @type {any} */ ([v[0], v[1].content.getContent()[v[1].length - 1]]))
-  }
-
-  /**
-   * Executes a provided function on once on every key-value pair.
-   *
-   * @param {function(MapType,string,YMap<MapType>):void} f A function to execute on every element of this YArray.
-   */
-  forEach (f) {
-    this.doc ?? warnPrematureAccess()
-    this._map.forEach((item, key) => {
-      if (!item.deleted) {
-        f(item.content.getContent()[item.length - 1], key, this)
-      }
-    })
-  }
-
-  /**
-   * Returns an Iterator of [key, value] pairs
-   *
-   * @return {IterableIterator<[string, MapType]>}
-   */
-  [Symbol.iterator] () {
-    return this.entries()
-  }
-
-  /**
-   * Remove a specified element from this YMap.
-   *
-   * @param {string} key The key of the element to remove.
-   */
-  delete (key) {
-    if (this.doc !== null) {
-      transact(this.doc, transaction => {
-        typeMapDelete(transaction, this, key)
-      })
-    } else {
-      /** @type {Map<string, any>} */ (this._prelimContent).delete(key)
-    }
-  }
-
-  /**
-   * Adds or updates an element with a specified key and value.
-   * @template {MapType} VAL
-   *
-   * @param {string} key The key of the element to add to this YMap
-   * @param {VAL} value The value of the element to add
-   * @return {VAL}
-   */
-  set (key, value) {
-    if (this.doc !== null) {
-      transact(this.doc, transaction => {
-        typeMapSet(transaction, this, key, /** @type {any} */ (value))
-      })
-    } else {
-      /** @type {Map<string, any>} */ (this._prelimContent).set(key, value)
-    }
-    return value
-  }
-
-  /**
-   * Returns a specified element from this YMap.
-   *
-   * @param {string} key
-   * @return {MapType|undefined}
-   */
-  get (key) {
-    return /** @type {any} */ (typeMapGet(this, key))
-  }
-
-  /**
-   * Returns a boolean indicating whether the specified key exists or not.
-   *
-   * @param {string} key The key to test.
-   * @return {boolean}
-   */
-  has (key) {
-    return typeMapHas(this, key)
-  }
-
-  /**
-   * Removes all elements from this YMap.
-   */
-  clear () {
-    if (this.doc !== null) {
-      transact(this.doc, transaction => {
-        this.forEach(function (_value, key, map) {
-          typeMapDelete(transaction, map, key)
-        })
-      })
-    } else {
-      /** @type {Map<string, any>} */ (this._prelimContent).clear()
-    }
-  }
-
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   */
-  _write (encoder) {
-    encoder.writeTypeRef(YMapRefID)
-  }
-}
-
-/**
- * @param {UpdateDecoderV1 | UpdateDecoderV2} _decoder
- * @return {import('../utils/types.js').YType}
- *
- * @private
- * @function
- */
-export const readYMap = _decoder => new YMap()