Function arrayImplementation

packages/core/src/array.ts:19–149

(arr: Y.Array<T>)

} & T[]; // TODO: should return ArrayImplementation<T> on getter

function arrayImplementation<T>(arr: Y.Array<T>) {
  const slice = function slice() {
    let ic = this[$reactiveproxy]?.implicitObserver;
    (arr as any)._implicitObserver = ic;

    const items = arr.slice.bind(arr).apply(arr, arguments);
    return items.map((item) => {
      const ret = parseYjsReturnValue(item, ic);
      if (ic && typeof ret === "object") {
        // when using Reactive, we should make sure the returned
        // object is made reactive with the implicit observer ic
        return reactive(ret, ic);
      } else {
        return ret;
      }
    });
  } as T[]["slice"];

  const wrapItems = function wrapItems(items) {
    return items.map((item) => {
      const wrapped = crdtValue(item as any); // TODO
      let valueToSet = getYjsValue(wrapped) || wrapped;
      if (valueToSet instanceof Box) {
        valueToSet = valueToSet.value;
      }
      if (valueToSet instanceof Y.AbstractType && valueToSet.parent) {
        throw new Error("Not supported: reassigning object that already occurs in the tree.");
      }
      return valueToSet;
    });
  };

  const findIndex = function findIndex() {
    return [].findIndex.apply(slice.apply(this), arguments);
  } as T[]["find"];

  const methods = {
    // get length() {
    //   return arr.length;
    // },
    // set length(val: number) {
    //   throw new Error("set length of yjs array is unsupported");
    // },
    slice,
    unshift: (...items: T[]) => {
      arr.unshift(wrapItems(items));
      return (arr as any).lengthUntracked;
    },

    push: (...items: T[]) => {
      arr.push(wrapItems(items));
      return (arr as any).lengthUntracked;
    },

    insert: arr.insert.bind(arr) as Y.Array<T>["insert"],
    toJSON: arr.toJSON.bind(arr) as Y.Array<T>["toJSON"],

    forEach: function () {