@liveblocks/client 0.12.1 → 0.13.0

package/README.md

@@ -1,17 +1,45 @@
 <p align="center">
   <a href="https://liveblocks.io">
-    <img src="https://liveblocks.io/icon-192x192.png" height="96">
+    <img src="https://liveblocks.io/images/blog/introducing-liveblocks.png">
   </a>
 </p>
 
-# [Liveblocks](https://liveblocks.io) · [![Twitter Follow](https://shields.io/twitter/follow/liveblocks?label=Follow)](https://twitter.com/liveblocks)
+# Liveblocks · [![Twitter Follow](https://shields.io/twitter/follow/liveblocks?label=Follow)](https://twitter.com/liveblocks)
 
-Liveblocks helps you create performant and reliable collaborative experiences.
+**At [Liveblocks](https://liveblocks.io), we’re building tools to help companies create world-class collaborative products that attract, engage and retain users.** This repository is a set of open-source packages for building performant and reliable multiplayer experiences.
 
-## [Documentation](https://liveblocks.io/docs)
+## Installation
+
+```
+npm install @liveblocks/client
+```
 
 ## Examples
 
-Try it live on [liveblocks.io](https://liveblocks.io/examples).
+- Browse our gallery of collaborative UI patterns. [View examples gallery](https://liveblocks.io/examples)
+- Explore and clone any of our open-source examples. [View code examples](https://github.com/liveblocks/liveblocks/tree/main/examples)
+
+## Documentation
+
+[Read the documentation](https://liveblocks.io/docs) to start using Liveblocks.
+
+## Releases
+
+For changelog, visit [https://github.com/liveblocks/liveblocks/releases](https://github.com/liveblocks/liveblocks/releases).
+
+## Authors
+
+- Guillaume Salles ([@guillaume_slls](https://twitter.com/guillaume_slls)) - [Liveblocks](https://liveblocks.io)
+- Olivier Foucherot ([@ofoucherot](https://twitter.com/ofoucherot)) - [Liveblocks](https://liveblocks.io)
+- Steven Fabre ([@stevenfabre](https://twitter.com/stevenfabre)) - [Liveblocks](https://liveblocks.io)
+
+## Community
+
+- [Discord](https://discord.gg/X4YWJuH9VY) - To get involved with the Liveblocks community, ask questions and share tips.
+- [Twitter](https://twitter.com/liveblocks) - To receive updates, announcements, blog posts, and general Liveblocks tips.
+
+## License
+
+Licensed under the Apache License 2.0, Copyright © 2021-present [Liveblocks](https://liveblocks.io).
 
-Clone one of our [examples](https://github.com/liveblocks/liveblocks/tree/main/examples).
+See [LICENSE](../../LICENSE) for more information.

package/lib/cjs/AbstractCrdt.d.ts

@@ -0,0 +1,61 @@
+import { Op } from "./live";
+export declare type ApplyResult = {
+    reverse: Op[];
+    modified: AbstractCrdt;
+} | {
+    modified: false;
+};
+export interface Doc {
+    generateId: () => string;
+    generateOpId: () => string;
+    addItem: (id: string, item: AbstractCrdt) => void;
+    deleteItem: (id: string) => void;
+    dispatch: (ops: Op[], reverseOps: Op[], modified: AbstractCrdt[]) => void;
+}
+export declare abstract class AbstractCrdt {
+    #private;
+    /**
+     * INTERNAL
+     */
+    protected get _doc(): Doc | undefined;
+    /**
+     * INTERNAL
+     */
+    get _id(): string | undefined;
+    /**
+     * INTERNAL
+     */
+    get _parent(): AbstractCrdt | undefined;
+    /**
+     * INTERNAL
+     */
+    get _parentKey(): string | undefined;
+    /**
+     * INTERNAL
+     */
+    _apply(op: Op): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _setParentLink(parent: AbstractCrdt, key: string): void;
+    /**
+     * INTERNAL
+     */
+    _attach(id: string, doc: Doc): void;
+    /**
+     * INTERNAL
+     */
+    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detach(): void;
+    /**
+     * INTERNAL
+     */
+    abstract _detachChild(crdt: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    abstract _serialize(parentId: string, parentKey: string): Op[];
+}

package/lib/cjs/AbstractCrdt.js

@@ -0,0 +1,98 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _AbstractCrdt_parent, _AbstractCrdt_doc, _AbstractCrdt_id, _AbstractCrdt_parentKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCrdt = void 0;
+const live_1 = require("./live");
+class AbstractCrdt {
+    constructor() {
+        _AbstractCrdt_parent.set(this, void 0);
+        _AbstractCrdt_doc.set(this, void 0);
+        _AbstractCrdt_id.set(this, void 0);
+        _AbstractCrdt_parentKey.set(this, void 0);
+    }
+    /**
+     * INTERNAL
+     */
+    get _doc() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_doc, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    get _id() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_id, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    get _parent() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_parent, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    get _parentKey() {
+        return __classPrivateFieldGet(this, _AbstractCrdt_parentKey, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _apply(op) {
+        switch (op.type) {
+            case live_1.OpType.DeleteCrdt: {
+                if (this._parent != null && this._parentKey != null) {
+                    const parent = this._parent;
+                    const reverse = this._serialize(this._parent._id, this._parentKey);
+                    this._parent._detachChild(this);
+                    return { modified: parent, reverse };
+                }
+                return { modified: false };
+            }
+        }
+        return { modified: false };
+    }
+    /**
+     * INTERNAL
+     */
+    _setParentLink(parent, key) {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_parent, "f") != null && __classPrivateFieldGet(this, _AbstractCrdt_parent, "f") !== parent) {
+            throw new Error("Cannot attach parent if it already exist");
+        }
+        __classPrivateFieldSet(this, _AbstractCrdt_parentKey, key, "f");
+        __classPrivateFieldSet(this, _AbstractCrdt_parent, parent, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _attach(id, doc) {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_id, "f") || __classPrivateFieldGet(this, _AbstractCrdt_doc, "f")) {
+            throw new Error("Cannot attach if CRDT is already attached");
+        }
+        doc.addItem(id, this);
+        __classPrivateFieldSet(this, _AbstractCrdt_id, id, "f");
+        __classPrivateFieldSet(this, _AbstractCrdt_doc, doc, "f");
+    }
+    /**
+     * INTERNAL
+     */
+    _detach() {
+        if (__classPrivateFieldGet(this, _AbstractCrdt_doc, "f") && __classPrivateFieldGet(this, _AbstractCrdt_id, "f")) {
+            __classPrivateFieldGet(this, _AbstractCrdt_doc, "f").deleteItem(__classPrivateFieldGet(this, _AbstractCrdt_id, "f"));
+        }
+        __classPrivateFieldSet(this, _AbstractCrdt_parent, undefined, "f");
+        __classPrivateFieldSet(this, _AbstractCrdt_doc, undefined, "f");
+    }
+}
+exports.AbstractCrdt = AbstractCrdt;
+_AbstractCrdt_parent = new WeakMap(), _AbstractCrdt_doc = new WeakMap(), _AbstractCrdt_id = new WeakMap(), _AbstractCrdt_parentKey = new WeakMap();

package/lib/cjs/LiveList.d.ts

@@ -0,0 +1,133 @@
+import { AbstractCrdt, Doc, ApplyResult } from "./AbstractCrdt";
+import { SerializedList, SerializedCrdtWithId, Op } from "./live";
+/**
+ * The LiveList class represents an ordered collection of items that is synchorinized across clients.
+ */
+export declare class LiveList<T> extends AbstractCrdt {
+    #private;
+    constructor(items?: T[]);
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item]: [id: string, item: SerializedList], parentToChildren: Map<string, SerializedCrdtWithId[]>, doc: Doc): LiveList<never>;
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId?: string, parentKey?: string): Op[];
+    /**
+     * INTERNAL
+     */
+    _attach(id: string, doc: Doc): void;
+    /**
+     * INTERNAL
+     */
+    _detach(): void;
+    /**
+     * INTERNAL
+     */
+    _attachChild(id: string, key: string, child: AbstractCrdt): ApplyResult;
+    /**
+     * INTERNAL
+     */
+    _detachChild(child: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    _setChildKey(key: string, child: AbstractCrdt): void;
+    /**
+     * INTERNAL
+     */
+    _apply(op: Op): ApplyResult;
+    /**
+     * Returns the number of elements.
+     */
+    get length(): number;
+    /**
+     * Adds one element to the end of the LiveList.
+     * @param element The element to add to the end of the LiveList.
+     */
+    push(element: T): void;
+    /**
+     * Inserts one element at a specified index.
+     * @param element The element to insert.
+     * @param index The index at which you want to insert the element.
+     */
+    insert(element: T, index: number): void;
+    /**
+     * Move one element from one index to another.
+     * @param index The index of the element to move
+     * @param targetIndex The index where the element should be after moving.
+     */
+    move(index: number, targetIndex: number): void;
+    /**
+     * Deletes an element at the specified index
+     * @param index The index of the element to delete
+     */
+    delete(index: number): void;
+    /**
+     * Returns an Array of all the elements in the LiveList.
+     */
+    toArray(): T[];
+    /**
+     * Tests whether all elements pass the test implemented by the provided function.
+     * @param predicate Function to test for each element, taking two arguments (the element and its index).
+     * @returns true if the predicate function returns a truthy value for every element. Otherwise, false.
+     */
+    every(predicate: (value: T, index: number) => unknown): boolean;
+    /**
+     * Creates an array with all elements that pass the test implemented by the provided function.
+     * @param predicate Function to test each element of the LiveList. Return a value that coerces to true to keep the element, or to false otherwise.
+     * @returns An array with the elements that pass the test.
+     */
+    filter(predicate: (value: T, index: number) => unknown): T[];
+    /**
+     * Returns the first element that satisfies the provided testing function.
+     * @param predicate Function to execute on each value.
+     * @returns The value of the first element in the LiveList that satisfies the provided testing function. Otherwise, undefined is returned.
+     */
+    find(predicate: (value: T, index: number) => unknown): T | undefined;
+    /**
+     * Returns the index of the first element in the LiveList that satisfies the provided testing function.
+     * @param predicate Function to execute on each value until the function returns true, indicating that the satisfying element was found.
+     * @returns The index of the first element in the LiveList that passes the test. Otherwise, -1.
+     */
+    findIndex(predicate: (value: T, index: number) => unknown): number;
+    /**
+     * Executes a provided function once for each element.
+     * @param callbackfn Function to execute on each element.
+     */
+    forEach(callbackfn: (value: T, index: number) => void): void;
+    /**
+     * Get the element at the specified index.
+     * @param index The index on the element to get.
+     * @returns The element at the specified index or undefined.
+     */
+    get(index: number): T | undefined;
+    /**
+     * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index to start the search at.
+     * @returns The first index of the element in the LiveList; -1 if not found.
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns the last index at which a given element can be found in the LiveList, or -1 if it is not present. The LiveLsit is searched backwards, starting at fromIndex.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index at which to start searching backwards.
+     * @returns
+     */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Creates an array populated with the results of calling a provided function on every element.
+     * @param callback Function that is called for every element.
+     * @returns An array with each element being the result of the callback function.
+     */
+    map<U>(callback: (value: T, index: number) => U): U[];
+    /**
+     * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
+     * @param predicate Function to test for each element.
+     * @returns true if the callback function returns a truthy value for at least one element. Otherwise, false.
+     */
+    some(predicate: (value: T, index: number) => unknown): boolean;
+    [Symbol.iterator](): IterableIterator<T>;
+}