@liveblocks/client 0.12.0-beta.8 → 0.12.2

package/lib/cjs/live.d.ts

@@ -114,6 +114,7 @@ export declare enum OpType {
 }
 export declare type Op = CreateObjectOp | UpdateObjectOp | DeleteCrdtOp | CreateListOp | SetParentKeyOp | DeleteObjectKeyOp | CreateMapOp | CreateRegisterOp;
 export declare type UpdateObjectOp = {
+    opId?: string;
     id: string;
     type: OpType.UpdateObject;
     data: {

package/lib/cjs/position.d.ts

@@ -3,8 +3,4 @@ export declare const max = 126;
 export declare function makePosition(before?: string, after?: string): string;
 export declare function posCodes(str: string): number[];
 export declare function pos(codes: number[]): string;
-export declare function compare(itemA: {
-    position: string;
-}, itemB: {
-    position: string;
-}): number;
+export declare function compare(posA: string, posB: string): number;

package/lib/cjs/position.js

@@ -94,9 +94,9 @@ function pos(codes) {
     return String.fromCharCode(...codes);
 }
 exports.pos = pos;
-function compare(itemA, itemB) {
-    const aCodes = posCodes(itemA.position);
-    const bCodes = posCodes(itemB.position);
+function compare(posA, posB) {
+    const aCodes = posCodes(posA);
+    const bCodes = posCodes(posB);
     const maxLength = Math.max(aCodes.length, bCodes.length);
     for (let i = 0; i < maxLength; i++) {
         const a = aCodes[i] == null ? exports.min : aCodes[i];
@@ -108,6 +108,6 @@ function compare(itemA, itemB) {
             return a - b;
         }
     }
-    throw new Error(`Impossible to compare similar position "${itemA.position}" and "${itemB.position}"`);
+    throw new Error(`Impossible to compare similar position "${posA}" and "${posB}"`);
 }
 exports.compare = compare;

package/lib/cjs/room.d.ts

@@ -49,6 +49,7 @@ declare type Context = {
     authEndpoint: AuthEndpoint;
     liveblocksServer: string;
     throttleDelay: number;
+    publicApiKey?: string;
 };
 export declare function makeStateMachine(state: State, context: Context, mockedEffects?: Effects): {
     onOpen: () => void;
@@ -80,6 +81,8 @@ export declare function makeStateMachine(state: State, context: Context, mockedE
     };
     updatePresence: <T_4 extends Presence>(overrides: Partial<T_4>) => void;
     broadcastEvent: (event: any) => void;
+    undo: () => void;
+    redo: () => void;
     getStorage: <TRoot>() => Promise<{
         root: import("./doc").LiveObject<TRoot>;
     }>;

package/lib/cjs/room.js

@@ -74,7 +74,7 @@ function makeStateMachine(state, context, mockedEffects) {
         authenticate() {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const token = yield (0, authentication_1.default)(context.authEndpoint, context.room);
+                    const token = yield (0, authentication_1.default)(context.authEndpoint, context.room, context.publicApiKey);
                     const parsedToken = (0, authentication_1.parseToken)(token);
                     const socket = new WebSocket(`${context.liveblocksServer}/?token=${token}`);
                     socket.addEventListener("message", onMessage);
@@ -500,6 +500,12 @@ function makeStateMachine(state, context, mockedEffects) {
             };
         });
     }
+    function undo() {
+        storage.undo();
+    }
+    function redo() {
+        storage.redo();
+    }
     return {
         // Internal
         onOpen,
@@ -518,6 +524,8 @@ function makeStateMachine(state, context, mockedEffects) {
         // Presence
         updatePresence,
         broadcastEvent,
+        undo,
+        redo,
         getStorage,
         selectors: {
             // Core
@@ -566,14 +574,23 @@ function defaultState(me, defaultStorageRoot) {
 exports.defaultState = defaultState;
 function createRoom(name, options) {
     const throttleDelay = options.throttle || 100;
-    const liveblocksServer = options.liveblocksServer || "wss://liveblocks.net/v2";
-    const authEndpoint = options.authEndpoint;
+    const liveblocksServer = options.liveblocksServer || "wss://liveblocks.net/v4";
+    let authEndpoint;
+    if (options.authEndpoint) {
+        authEndpoint = options.authEndpoint;
+    }
+    else {
+        const publicAuthorizeEndpoint = options.publicAuthorizeEndpoint ||
+            "https://liveblocks.io/api/public/authorize";
+        authEndpoint = publicAuthorizeEndpoint;
+    }
     const state = defaultState(options.defaultPresence, options.defaultStorageRoot);
     const machine = makeStateMachine(state, {
         throttleDelay,
         liveblocksServer,
         authEndpoint,
         room: name,
+        publicApiKey: options.publicApiKey,
     });
     const room = {
         /////////////
@@ -591,6 +608,8 @@ function createRoom(name, options) {
         getOthers: machine.selectors.getOthers,
         broadcastEvent: machine.broadcastEvent,
         getStorage: machine.getStorage,
+        undo: machine.undo,
+        redo: machine.redo,
     };
     return {
         connect: machine.connect,

package/lib/cjs/storage.d.ts

@@ -16,4 +16,6 @@ export default class Storage {
     private createDocFromMessage;
     getDocument<TRoot>(): Promise<Doc<TRoot>>;
     onMessage(message: ServerMessage): Promise<void>;
+    undo(): void;
+    redo(): void;
 }

package/lib/cjs/storage.js

@@ -20,11 +20,11 @@ class Storage {
         this._getInitialStateResolver = null;
     }
     createDocFromMessage(message) {
-        if (message.items.length === 0) {
-            this._doc = doc_1.Doc.from(this.options.defaultRoot, this.options.getConnectionId(), this.options.dispatch);
-        }
-        else {
-            this._doc = doc_1.Doc.load(message.items, this.options.getConnectionId(), this.options.dispatch);
+        this._doc = doc_1.Doc.load(message.items, this.options.getConnectionId(), this.options.dispatch);
+        for (const key in this.options.defaultRoot) {
+            if (this._doc.root.get(key) == null) {
+                this._doc.root.set(key, this.options.defaultRoot[key]);
+            }
         }
     }
     getDocument() {
@@ -50,13 +50,19 @@ class Storage {
                     break;
                 }
                 case live_1.ServerMessageType.UpdateStorage: {
-                    for (const op of message.ops) {
-                        (_b = this._doc) === null || _b === void 0 ? void 0 : _b.apply(op);
-                    }
+                    (_b = this._doc) === null || _b === void 0 ? void 0 : _b.apply(message.ops);
                     break;
                 }
             }
         });
     }
+    undo() {
+        var _a;
+        (_a = this._doc) === null || _a === void 0 ? void 0 : _a.undo();
+    }
+    redo() {
+        var _a;
+        (_a = this._doc) === null || _a === void 0 ? void 0 : _a.redo();
+    }
 }
 exports.default = Storage;

package/lib/cjs/types.d.ts

@@ -87,14 +87,19 @@ declare type AuthEndpointCallback = (room: string) => Promise<{
     token: string;
 }>;
 export declare type AuthEndpoint = string | AuthEndpointCallback;
+/**
+ * The authentication endpoint that is called to ensure that the current user has access to a room.
+ * Can be an url or a callback if you need to add additional headers.
+ */
 export declare type ClientOptions = {
-    /**
-     * The authentication endpoint that is called to ensure that the current user has access to a room.
-     * Can be an url or a callback if you need to add additional headers.
-     */
-    authEndpoint: AuthEndpoint;
     throttle?: number;
-};
+} & ({
+    publicApiKey: string;
+    authEndpoint?: never;
+} | {
+    publicApiKey?: never;
+    authEndpoint: AuthEndpoint;
+});
 export declare type AuthorizeResponse = {
     token: string;
 };
@@ -261,5 +266,7 @@ export declare type Room = {
     getStorage: <TRoot>() => Promise<{
         root: LiveObject<TRoot>;
     }>;
+    undo: () => void;
+    redo: () => void;
 };
 export {};

package/lib/esm/authentication.d.ts

@@ -1,3 +1,3 @@
 import { AuthEndpoint, AuthenticationToken } from "./types";
-export default function auth(endpoint: AuthEndpoint, room: string): Promise<string>;
+export default function auth(endpoint: AuthEndpoint, room: string, publicApiKey?: string): Promise<string>;
 export declare function parseToken(token: string): AuthenticationToken;

package/lib/esm/authentication.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-function fetchAuthorize(endpoint, room) {
+function fetchAuthorize(endpoint, room, publicApiKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const res = yield fetch(endpoint, {
             method: "POST",
@@ -16,6 +16,7 @@ function fetchAuthorize(endpoint, room) {
             },
             body: JSON.stringify({
                 room,
+                publicApiKey,
             }),
         });
         if (!res.ok) {
@@ -34,10 +35,10 @@ function fetchAuthorize(endpoint, room) {
         return authResponse.token;
     });
 }
-export default function auth(endpoint, room) {
+export default function auth(endpoint, room, publicApiKey) {
     return __awaiter(this, void 0, void 0, function* () {
         if (typeof endpoint === "string") {
-            return fetchAuthorize(endpoint, room);
+            return fetchAuthorize(endpoint, room, publicApiKey);
         }
         if (typeof endpoint === "function") {
             const { token } = yield endpoint(room);

package/lib/esm/doc.d.ts

@@ -9,10 +9,14 @@ export declare class Doc<T extends Record<string, any> = Record<string, any>> {
     addItem(id: string, item: AbstractCrdt): void;
     deleteItem(id: string): void;
     getItem(id: string): AbstractCrdt | undefined;
-    apply(op: Op): void;
+    apply(ops: Op[]): Op[];
     get root(): LiveObject<T>;
+    addToUndoStack(ops: Op[]): void;
+    undo(): void;
+    redo(): void;
     count(): number;
     generateId(): string;
+    generateOpId(): string;
 }
 declare abstract class AbstractCrdt {
     #private;
@@ -31,24 +35,49 @@ declare abstract class AbstractCrdt {
     /**
      * INTERNAL
      */
-    _setParent(parent: AbstractCrdt): void;
+    get _parentKey(): string | undefined;
+    _apply(op: Op): Op[];
+    /**
+     * INTERNAL
+     */
+    _setParentLink(parent: AbstractCrdt, key: string): void;
     /**
      * INTERNAL
      */
     _attach(id: string, doc: Doc): void;
-    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt): void;
+    abstract _attachChild(id: string, key: string, crdt: AbstractCrdt): Op[];
     /**
      * INTERNAL
      */
     _detach(): void;
     abstract _detachChild(crdt: AbstractCrdt): void;
+    /**
+     * Subscribes to updates.
+     */
     subscribe(listener: () => void): void;
+    /**
+     * Subscribes to updates and children updates.
+     */
     subscribeDeep(listener: () => void): void;
+    /**
+     * Unsubscribes to updates.
+     */
     unsubscribe(listener: () => void): void;
+    /**
+     * Unsubscribes to updates and children updates.
+     */
     unsubscribeDeep(listener: () => void): void;
-    notify(onlyDeep?: boolean): void;
+    /**
+     * INTERNAL
+     */
+    _notify(onlyDeep?: boolean): void;
     abstract _serialize(parentId: string, parentKey: string): Op[];
 }
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
 export declare class LiveObject<T extends Record<string, any> = Record<string, any>> extends AbstractCrdt {
     #private;
     constructor(object?: T);
@@ -69,7 +98,7 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: keyof T, child: AbstractCrdt): void;
+    _attachChild(id: string, key: keyof T, child: AbstractCrdt): Op[];
     /**
      * INTERNAL
      */
@@ -81,12 +110,33 @@ export declare class LiveObject<T extends Record<string, any> = Record<string, a
     /**
      * INTERNAL
      */
-    _apply(op: Op): void;
+    _apply(op: Op): Op[];
+    /**
+     * Transform the LiveObject into a javascript object
+     */
     toObject(): T;
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
     set<TKey extends keyof T>(key: TKey, value: T[TKey]): void;
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
     get<TKey extends keyof T>(key: TKey): T[TKey];
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param overrides The object used to overrides properties
+     */
     update(overrides: Partial<T>): void;
 }
+/**
+ * The LiveMap class is similar to a JavaScript Map that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
 export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     #private;
     constructor(entries?: readonly (readonly [TKey, TValue])[] | null | undefined);
@@ -105,7 +155,7 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: TKey, child: AbstractCrdt): void;
+    _attachChild(id: string, key: TKey, child: AbstractCrdt): Op[];
     /**
      * INTERNAL
      */
@@ -114,17 +164,58 @@ export declare class LiveMap<TKey extends string, TValue> extends AbstractCrdt {
      * INTERNAL
      */
     _detachChild(child: AbstractCrdt): void;
+    /**
+     * Returns a specified element from the LiveMap.
+     * @param key The key of the element to return.
+     * @returns The element associated with the specified key, or undefined if the key can't be found in the LiveMap.
+     */
     get(key: TKey): TValue | undefined;
+    /**
+     * Adds or updates an element with a specified key and a value.
+     * @param key The key of the element to add. Should be a string.
+     * @param value The value of the element to add. Should be serializable to JSON.
+     */
     set(key: TKey, value: TValue): void;
+    /**
+     * Returns the number of elements in the LiveMap.
+     */
     get size(): number;
+    /**
+     * Returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key The key of the element to test for presence.
+     */
     has(key: TKey): boolean;
+    /**
+     * Removes the specified element by key.
+     * @param key The key of the element to remove.
+     * @returns true if an element existed and has been removed, or false if the element does not exist.
+     */
     delete(key: TKey): boolean;
+    /**
+     * Returns a new Iterator object that contains the [key, value] pairs for each element.
+     */
     entries(): IterableIterator<[string, TValue]>;
+    /**
+     * Same function object as the initial value of the entries method.
+     */
     [Symbol.iterator](): IterableIterator<[string, TValue]>;
+    /**
+     * Returns a new Iterator object that contains the keys for each element.
+     */
     keys(): IterableIterator<TKey>;
+    /**
+     * Returns a new Iterator object that contains the values for each element.
+     */
     values(): IterableIterator<TValue>;
+    /**
+     * Executes a provided function once per each key/value pair in the Map object, in insertion order.
+     * @param callback Function to execute for each entry in the map.
+     */
     forEach(callback: (value: TValue, key: TKey, map: LiveMap<TKey, TValue>) => void): void;
 }
+/**
+ * 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[]);
@@ -147,7 +238,7 @@ export declare class LiveList<T> extends AbstractCrdt {
     /**
      * INTERNAL
      */
-    _attachChild(id: string, key: string, child: AbstractCrdt): void;
+    _attachChild(id: string, key: string, child: AbstractCrdt): Op[];
     /**
      * INTERNAL
      */
@@ -156,20 +247,100 @@ export declare class LiveList<T> extends AbstractCrdt {
      * INTERNAL
      */
     _setChildKey(key: string, child: AbstractCrdt): void;
-    push(item: T): void;
-    insert(item: T, index: number): void;
+    /**
+     * INTERNAL
+     */
+    _apply(op: Op): Op[];
+    /**
+     * 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(index: number): T;
+    /**
+     * 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>;
 }