@casual-simulation/aux-common 3.4.6-alpha.14668890889 → 3.5.0-alpha.15119114602

package/partitions/RemoteYjsPartition.js

@@ -1,24 +1,4 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { isTagEdit, preserve, del, insert, edit, ON_REMOTE_WHISPER_ACTION_NAME, ON_REMOTE_DATA_ACTION_NAME, } from '../bots';
+import { isTagEdit, preserve, del, insert, edit, ON_REMOTE_WHISPER_ACTION_NAME, ON_REMOTE_DATA_ACTION_NAME, getInstStateFromUpdates, } from '../bots';
 import { BehaviorSubject } from 'rxjs';
 import { breakIntoIndividualEvents, botAdded, createBot, botRemoved, hasValue, botUpdated, action, asyncResult, asyncError, convertToString, ON_SPACE_MAX_SIZE_REACHED, ON_SPACE_RATE_LIMIT_EXCEEDED_ACTION_NAME, } from '../bots';
 import { Text, Map, applyUpdate, YMapEvent, createAbsolutePositionFromRelativePosition, YTextEvent, } from 'yjs';
@@ -26,9 +6,10 @@ import { MemoryPartitionImpl } from './MemoryPartition';
 import { createRelativePositionFromStateVector, getClock, getStateVector, } from '../yjs/YjsHelpers';
 import { fromByteArray, toByteArray } from 'base64-js';
 import { YjsPartitionImpl } from './YjsPartition';
-import { ensureTagIsSerializable, supportsRemoteEvent } from './PartitionUtils';
+import { ensureTagIsSerializable, getStateFromUpdates, supportsRemoteEvent, } from './PartitionUtils';
 import { device } from '../common';
 import { RemoteYjsSharedDocument } from '../documents/RemoteYjsSharedDocument';
+import { v4 as uuid } from 'uuid';
 /**
  * Attempts to create a YjsPartition from the given config.
  * @param config The config.
@@ -100,7 +81,7 @@ export class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument {
             var _a;
             const version = getStateVector(this._doc);
             if (this._isRemoteUpdate) {
-                const _b = version, _c = this._currentSite, currentVersion = _b[_c], otherVersions = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
+                const { [this._currentSite]: currentVersion, ...otherVersions } = version;
                 return {
                     currentSite: this._currentSite,
                     remoteSite: this._remoteSite,
@@ -121,152 +102,180 @@ export class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument {
             }
         };
     }
-    applyEvents(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._static) {
-                return [];
+    async applyEvents(events) {
+        if (this._static) {
+            return [];
+        }
+        let finalEvents = [];
+        for (let e of events) {
+            if (e.type === 'apply_state') {
+                finalEvents.push(...breakIntoIndividualEvents(this.state, e));
             }
-            let finalEvents = [];
-            for (let e of events) {
-                if (e.type === 'apply_state') {
-                    finalEvents.push(...breakIntoIndividualEvents(this.state, e));
-                }
-                else if (e.type === 'add_bot' ||
-                    e.type === 'remove_bot' ||
-                    e.type === 'update_bot') {
-                    finalEvents.push(e);
-                }
+            else if (e.type === 'add_bot' ||
+                e.type === 'remove_bot' ||
+                e.type === 'update_bot') {
+                finalEvents.push(e);
             }
-            this._applyEvents(finalEvents);
-            return [];
-        });
+        }
+        this._applyEvents(finalEvents);
+        return [];
     }
-    sendRemoteEvents(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._readOnly || !this._remoteEvents) {
-                return;
+    async sendRemoteEvents(events) {
+        if (this._readOnly || !this._remoteEvents) {
+            return;
+        }
+        for (let event of events) {
+            if (!supportsRemoteEvent(this._remoteEvents, event)) {
+                continue;
             }
-            for (let event of events) {
-                if (!supportsRemoteEvent(this._remoteEvents, event)) {
-                    continue;
+            if (event.type === 'remote') {
+                if (event.event.type === 'get_remotes') {
+                    // Do nothing for get_remotes since it will be handled by the OtherPlayersPartition.
+                    // TODO: Make this mechanism more extensible so that we don't have to hardcode for each time
+                    //       we do this type of logic.
                 }
-                if (event.type === 'remote') {
-                    if (event.event.type === 'get_remotes') {
-                        // Do nothing for get_remotes since it will be handled by the OtherPlayersPartition.
-                        // TODO: Make this mechanism more extensible so that we don't have to hardcode for each time
-                        //       we do this type of logic.
-                    }
-                    else if (event.event.type === 'get_remote_count') {
-                        const action = event.event;
-                        this._client
-                            .connectionCount(action.recordName, action.inst, action.branch)
-                            .subscribe({
-                            next: (count) => {
-                                this._onEvents.next([
-                                    asyncResult(event.taskId, count),
-                                ]);
-                            },
-                            error: (err) => {
-                                this._onEvents.next([
-                                    asyncError(event.taskId, err),
-                                ]);
-                            },
-                        });
-                    }
-                    else if (event.event.type === 'list_inst_updates') {
-                        const action = event.event;
-                        this._client
-                            .getBranchUpdates(this._recordName, this._inst, this._branch)
-                            .subscribe({
-                            next: ({ updates, timestamps }) => {
-                                this._onEvents.next([
-                                    asyncResult(event.taskId, updates.map((u, i) => ({
-                                        id: i,
-                                        update: u,
-                                        timestamp: timestamps === null || timestamps === void 0 ? void 0 : timestamps[i],
-                                    }))),
-                                ]);
-                            },
-                            error: (err) => {
-                                this._onEvents.next([
-                                    asyncError(event.taskId, err),
-                                ]);
-                            },
-                        });
-                    }
-                    else if (event.event.type === 'get_inst_state_from_updates') {
-                        const action = event.event;
-                        try {
-                            let partition = new YjsPartitionImpl({
-                                type: 'yjs',
-                            });
-                            for (let { update } of action.updates) {
-                                const updateBytes = toByteArray(update);
-                                applyUpdate(partition.doc, updateBytes);
-                            }
+                else if (event.event.type === 'get_remote_count') {
+                    const action = event.event;
+                    this._client
+                        .connectionCount(action.recordName, action.inst, action.branch)
+                        .subscribe({
+                        next: (count) => {
                             this._onEvents.next([
-                                asyncResult(event.taskId, partition.state, false),
+                                asyncResult(event.taskId, count),
                             ]);
-                        }
-                        catch (err) {
-                            this._onEvents.next([asyncError(event.taskId, err)]);
-                        }
-                    }
-                    else if (event.event.type === 'create_initialization_update') {
-                        const action = (event.event);
-                        try {
-                            let partition = new YjsPartitionImpl({
-                                type: 'yjs',
-                            });
-                            partition.doc.on('update', (update) => {
-                                let instUpdate = {
-                                    id: 0,
-                                    timestamp: Date.now(),
-                                    update: fromByteArray(update),
-                                };
-                                this._onEvents.next([
-                                    asyncResult(event.taskId, instUpdate, false),
-                                ]);
-                            });
-                            yield partition.applyEvents(action.bots.map((b) => botAdded(createBot(b.id, b.tags))));
-                        }
-                        catch (err) {
-                            this._onEvents.next([asyncError(event.taskId, err)]);
-                        }
-                    }
-                    else if (event.event.type === 'apply_updates_to_inst') {
-                        const action = event.event;
-                        try {
-                            this.applyStateUpdates(action.updates);
+                        },
+                        error: (err) => {
                             this._onEvents.next([
-                                asyncResult(event.taskId, null, false),
+                                asyncError(event.taskId, err),
                             ]);
+                        },
+                    });
+                }
+                else if (event.event.type === 'list_inst_updates') {
+                    const action = event.event;
+                    this._client
+                        .getBranchUpdates(this._recordName, this._inst, this._branch)
+                        .subscribe({
+                        next: ({ updates, timestamps }) => {
+                            this._onEvents.next([
+                                asyncResult(event.taskId, updates.map((u, i) => ({
+                                    id: i,
+                                    update: u,
+                                    timestamp: timestamps === null || timestamps === void 0 ? void 0 : timestamps[i],
+                                }))),
+                            ]);
+                        },
+                        error: (err) => {
+                            this._onEvents.next([
+                                asyncError(event.taskId, err),
+                            ]);
+                        },
+                    });
+                }
+                else if (event.event.type === 'get_inst_state_from_updates') {
+                    const action = event.event;
+                    try {
+                        let partition = new YjsPartitionImpl({
+                            type: 'yjs',
+                        });
+                        for (let { update } of action.updates) {
+                            const updateBytes = toByteArray(update);
+                            applyUpdate(partition.doc, updateBytes);
                         }
-                        catch (err) {
-                            this._onEvents.next([asyncError(event.taskId, err)]);
-                        }
+                        this._onEvents.next([
+                            asyncResult(event.taskId, partition.state, false),
+                        ]);
                     }
-                    else if (event.event.type === 'get_current_inst_update') {
-                        const action = event.event;
-                        try {
-                            const update = this.getStateUpdate();
+                    catch (err) {
+                        this._onEvents.next([asyncError(event.taskId, err)]);
+                    }
+                }
+                else if (event.event.type === 'create_initialization_update') {
+                    const action = (event.event);
+                    try {
+                        let partition = new YjsPartitionImpl({
+                            type: 'yjs',
+                        });
+                        partition.doc.on('update', (update) => {
+                            let instUpdate = {
+                                id: 0,
+                                timestamp: Date.now(),
+                                update: fromByteArray(update),
+                            };
                             this._onEvents.next([
-                                asyncResult(event.taskId, update, false),
+                                asyncResult(event.taskId, instUpdate, false),
                             ]);
+                        });
+                        await partition.applyEvents(action.bots.map((b) => botAdded(createBot(b.id, b.tags))));
+                    }
+                    catch (err) {
+                        this._onEvents.next([asyncError(event.taskId, err)]);
+                    }
+                }
+                else if (event.event.type === 'apply_updates_to_inst') {
+                    const action = event.event;
+                    try {
+                        this.applyStateUpdates(action.updates);
+                        this._onEvents.next([
+                            asyncResult(event.taskId, null, false),
+                        ]);
+                    }
+                    catch (err) {
+                        this._onEvents.next([asyncError(event.taskId, err)]);
+                    }
+                }
+                else if (event.event.type === 'get_current_inst_update') {
+                    const action = event.event;
+                    try {
+                        const update = this.getStateUpdate();
+                        this._onEvents.next([
+                            asyncResult(event.taskId, update, false),
+                        ]);
+                    }
+                    catch (err) {
+                        this._onEvents.next([asyncError(event.taskId, err)]);
+                    }
+                }
+                else if (event.event.type === 'install_aux_file') {
+                    const action = event.event;
+                    try {
+                        if (action.mode === 'copy') {
+                            let bots;
+                            if (action.aux.version === 2) {
+                                const state = getStateFromUpdates(getInstStateFromUpdates(action.aux.updates));
+                                bots = Object.values(state);
+                            }
+                            else {
+                                bots = Object.values(action.aux.state);
+                            }
+                            if (bots && bots.length > 0) {
+                                this._applyEvents(bots.map((b) => botAdded(createBot(uuid(), b.tags))));
+                            }
                         }
-                        catch (err) {
-                            this._onEvents.next([asyncError(event.taskId, err)]);
+                        else {
+                            if (action.aux.version === 2) {
+                                this.applyStateUpdates(action.aux.updates);
+                            }
+                            else if (action.aux.version === 1) {
+                                this._applyEvents(Object.values(action.aux.state).map((b) => botAdded(createBot(b.id, b.tags))));
+                            }
                         }
+                        this._onEvents.next([
+                            asyncResult(event.taskId, null, false),
+                        ]);
                     }
-                    else {
-                        this._client.sendAction(this._recordName, this._inst, this._branch, event);
+                    catch (err) {
+                        this._onEvents.next([asyncError(event.taskId, err)]);
                     }
                 }
                 else {
                     this._client.sendAction(this._recordName, this._inst, this._branch, event);
                 }
             }
-        });
+            else {
+                this._client.sendAction(this._recordName, this._inst, this._branch, event);
+            }
+        }
     }
     _handleClientEvent(event) {
         if (event.action.type === 'device') {
@@ -286,7 +295,11 @@ export class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument {
                 ]);
             }
             else if (hasValue(event.action.taskId)) {
-                const newEvent = device(event.action.connection, Object.assign(Object.assign({}, event.action.event), { taskId: event.action.taskId, playerId: event.action.connection.connectionId }), event.action.taskId);
+                const newEvent = device(event.action.connection, {
+                    ...event.action.event,
+                    taskId: event.action.taskId,
+                    playerId: event.action.connection.connectionId,
+                }, event.action.taskId);
                 this._onEvents.next([newEvent]);
             }
             else {
@@ -402,88 +415,86 @@ export class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument {
     //         this._isRemoteUpdate = false;
     //     }
     // }
-    _processTransaction(transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let memoryEvents = [];
-            const version = getStateVector(this._doc);
-            for (let [type, events] of transaction.changedParentTypes) {
-                if (type === this._bots) {
-                    for (let event of events) {
-                        // Update the current target so that the event
-                        // path is calculated from the bots map.
-                        // see https://github.com/yjs/yjs/blob/5244755879daaa7b5a1ca64e6af617cdbb110462/src/utils/YEvent.js#L63
-                        event.currentTarget = this._bots;
-                        const target = event.target;
-                        if (target === type) {
-                            // Bot was added or removed
-                            if (event instanceof YMapEvent) {
-                                for (let [key, change] of event.changes.keys) {
-                                    if (change.action === 'add') {
-                                        // bot added
-                                        const value = this._bots.get(key);
-                                        const bot = this._mapToBot(key, value);
-                                        memoryEvents.push(botAdded(bot));
-                                    }
-                                    else if (change.action === 'delete') {
-                                        // bot deleted
-                                        memoryEvents.push(botRemoved(key));
-                                    }
-                                    else if (change.action === 'update') {
-                                        // bot updated in a way that we can't track
-                                        // in this scenario, we just remove the bot and re-add it
-                                        memoryEvents.push(botRemoved(key));
-                                        const value = this._bots.get(key);
-                                        const bot = this._mapToBot(key, value);
-                                        memoryEvents.push(botAdded(bot));
-                                    }
+    async _processTransaction(transaction) {
+        let memoryEvents = [];
+        const version = getStateVector(this._doc);
+        for (let [type, events] of transaction.changedParentTypes) {
+            if (type === this._bots) {
+                for (let event of events) {
+                    // Update the current target so that the event
+                    // path is calculated from the bots map.
+                    // see https://github.com/yjs/yjs/blob/5244755879daaa7b5a1ca64e6af617cdbb110462/src/utils/YEvent.js#L63
+                    event.currentTarget = this._bots;
+                    const target = event.target;
+                    if (target === type) {
+                        // Bot was added or removed
+                        if (event instanceof YMapEvent) {
+                            for (let [key, change] of event.changes.keys) {
+                                if (change.action === 'add') {
+                                    // bot added
+                                    const value = this._bots.get(key);
+                                    const bot = this._mapToBot(key, value);
+                                    memoryEvents.push(botAdded(bot));
+                                }
+                                else if (change.action === 'delete') {
+                                    // bot deleted
+                                    memoryEvents.push(botRemoved(key));
+                                }
+                                else if (change.action === 'update') {
+                                    // bot updated in a way that we can't track
+                                    // in this scenario, we just remove the bot and re-add it
+                                    memoryEvents.push(botRemoved(key));
+                                    const value = this._bots.get(key);
+                                    const bot = this._mapToBot(key, value);
+                                    memoryEvents.push(botAdded(bot));
                                 }
                             }
                         }
-                        else {
-                            this._handleValueUpdates(target, event, memoryEvents, version, (event) => event.path[event.path.length - 1], (event, key) => {
-                                throw new Error('should not happen');
-                            }, (event) => ({
-                                id: event.path[event.path.length - 2],
-                                tag: event.path[event.path.length - 1],
-                            }), (id, tags) => botUpdated(id, {
-                                tags,
-                            }), (id, tag, val) => botUpdated(id, {
-                                tags: {
-                                    [tag]: val,
-                                },
-                            }));
-                        }
                     }
-                }
-                else if (type === this._masks) {
-                    for (let event of events) {
-                        // Update the current target so that the event
-                        // path is calculated from the bots map.
-                        // see https://github.com/yjs/yjs/blob/5244755879daaa7b5a1ca64e6af617cdbb110462/src/utils/YEvent.js#L63
-                        event.currentTarget = this._masks;
-                        const target = event.target;
-                        this._handleValueUpdates(target, event, memoryEvents, version, (event) => event.path[event.path.length - 1], (event, key) => parseTagMaskId(key), (event) => parseTagMaskId(event.path[event.path.length - 1]), (id, tags) => botUpdated(id, {
-                            masks: {
-                                [this.space]: tags,
-                            },
+                    else {
+                        this._handleValueUpdates(target, event, memoryEvents, version, (event) => event.path[event.path.length - 1], (event, key) => {
+                            throw new Error('should not happen');
+                        }, (event) => ({
+                            id: event.path[event.path.length - 2],
+                            tag: event.path[event.path.length - 1],
+                        }), (id, tags) => botUpdated(id, {
+                            tags,
                         }), (id, tag, val) => botUpdated(id, {
-                            masks: {
-                                [this.space]: {
-                                    [tag]: val,
-                                },
+                            tags: {
+                                [tag]: val,
                             },
                         }));
                     }
                 }
             }
-            this._currentVersion = {
-                currentSite: this._currentSite,
-                remoteSite: this._remoteSite,
-                vector: version,
-            };
-            yield this._internalPartition.applyEvents(memoryEvents);
-            this._onVersionUpdated.next(this._currentVersion);
-        });
+            else if (type === this._masks) {
+                for (let event of events) {
+                    // Update the current target so that the event
+                    // path is calculated from the bots map.
+                    // see https://github.com/yjs/yjs/blob/5244755879daaa7b5a1ca64e6af617cdbb110462/src/utils/YEvent.js#L63
+                    event.currentTarget = this._masks;
+                    const target = event.target;
+                    this._handleValueUpdates(target, event, memoryEvents, version, (event) => event.path[event.path.length - 1], (event, key) => parseTagMaskId(key), (event) => parseTagMaskId(event.path[event.path.length - 1]), (id, tags) => botUpdated(id, {
+                        masks: {
+                            [this.space]: tags,
+                        },
+                    }), (id, tag, val) => botUpdated(id, {
+                        masks: {
+                            [this.space]: {
+                                [tag]: val,
+                            },
+                        },
+                    }));
+                }
+            }
+        }
+        this._currentVersion = {
+            currentSite: this._currentSite,
+            remoteSite: this._remoteSite,
+            vector: version,
+        };
+        await this._internalPartition.applyEvents(memoryEvents);
+        this._onVersionUpdated.next(this._currentVersion);
     }
     _mapToBot(id, map) {
         let tags = {};
@@ -527,7 +538,10 @@ export class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument {
                     text = new Text(convertToString(val));
                     map.set(valueId, text);
                 }
-                const version = Object.assign(Object.assign({}, newVal.version), { [this._currentSite]: getClock(doc, this._localId) });
+                const version = {
+                    ...newVal.version,
+                    [this._currentSite]: getClock(doc, this._localId),
+                };
                 if (text instanceof Text) {
                     for (let ops of newVal.operations) {
                         let index = 0;