@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/cjs/ecs-lite.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEcsLiteWorld = createEcsLiteWorld;
+const canonical_js_1 = require("./canonical.js");
+function createEcsLiteWorld(snapshot) {
+    const world = snapshot === undefined
+        ? { nextEntityId: 1, entities: [], components: new Map(), singletons: new Map() }
+        : mutableFromSnapshot(snapshot);
+    return {
+        createEntity() {
+            const entityId = world.nextEntityId;
+            world.nextEntityId += 1;
+            world.entities.push(entityId);
+            world.entities.sort((left, right) => left - right);
+            return entityId;
+        },
+        destroyEntity(entityId) {
+            requireEntity(world, entityId);
+            world.entities = world.entities.filter((candidate) => candidate !== entityId);
+            for (const componentName of Array.from(world.components.keys()).sort(compareStrings)) {
+                world.components.get(componentName)?.delete(String(entityId));
+            }
+        },
+        addComponent(entityId, componentName, value) {
+            requireEntity(world, entityId);
+            const entityKey = String(entityId);
+            const componentValues = world.components.get(componentName) ?? new Map();
+            componentValues.set(entityKey, (0, canonical_js_1.cloneCanonical)(value));
+            world.components.set(componentName, componentValues);
+        },
+        removeComponent(entityId, componentName) {
+            requireEntity(world, entityId);
+            world.components.get(componentName)?.delete(String(entityId));
+        },
+        getComponent(entityId, componentName) {
+            requireEntity(world, entityId);
+            const value = world.components.get(componentName)?.get(String(entityId));
+            return value === undefined ? undefined : (0, canonical_js_1.cloneCanonical)(value);
+        },
+        setSingleton(name, value) {
+            world.singletons.set(name, (0, canonical_js_1.cloneCanonical)(value));
+        },
+        getSingleton(name) {
+            const value = world.singletons.get(name);
+            return value === undefined ? undefined : (0, canonical_js_1.cloneCanonical)(value);
+        },
+        query(componentNames) {
+            const sortedNames = componentNames.slice().sort(compareStrings);
+            return world.entities.flatMap((entityId) => {
+                const components = {};
+                for (const componentName of sortedNames) {
+                    const component = world.components.get(componentName)?.get(String(entityId));
+                    if (component === undefined) {
+                        return [];
+                    }
+                    components[componentName] = (0, canonical_js_1.cloneCanonical)(component);
+                }
+                return [{ entityId, components }];
+            });
+        },
+        snapshot() {
+            return snapshotFromMutable(world);
+        },
+        restore(snapshotToRestore) {
+            const restored = mutableFromSnapshot(snapshotToRestore);
+            world.nextEntityId = restored.nextEntityId;
+            world.entities = restored.entities;
+            world.components = restored.components;
+            world.singletons = restored.singletons;
+        },
+        checksum() {
+            return (0, canonical_js_1.defaultChecksum)(snapshotFromMutable(world));
+        },
+    };
+}
+function requireEntity(world, entityId) {
+    if (!world.entities.includes(entityId)) {
+        throw new Error(`Unknown ECS entity ${entityId}`);
+    }
+}
+function mutableFromSnapshot(snapshot) {
+    validateSnapshot(snapshot);
+    return {
+        nextEntityId: snapshot.nextEntityId,
+        entities: snapshot.entities.slice().sort((left, right) => left - right),
+        components: componentsMapFromSnapshot(snapshot.components),
+        singletons: new Map(Object.keys(snapshot.singletons)
+            .sort(compareStrings)
+            .map((key) => [key, (0, canonical_js_1.cloneCanonical)(snapshot.singletons[key])])),
+    };
+}
+function validateSnapshot(snapshot) {
+    validateEntityId(snapshot.nextEntityId, 'nextEntityId');
+    const entityIds = new Set();
+    let maxEntityId = 0;
+    for (const entityId of snapshot.entities) {
+        validateEntityId(entityId, 'entity');
+        if (entityIds.has(entityId)) {
+            throw new Error(`Duplicate ECS entity ${entityId}`);
+        }
+        entityIds.add(entityId);
+        maxEntityId = Math.max(maxEntityId, entityId);
+    }
+    if (snapshot.nextEntityId <= maxEntityId) {
+        throw new Error(`Invalid ECS nextEntityId ${snapshot.nextEntityId}`);
+    }
+    for (const componentName of Object.keys(snapshot.components).sort(compareStrings)) {
+        for (const entityKey of Object.keys(snapshot.components[componentName]).sort(compareStrings)) {
+            const entityId = Number(entityKey);
+            validateEntityId(entityId, `component ${componentName}`);
+            if (entityKey !== String(entityId)) {
+                throw new Error(`Invalid ECS component ${componentName} key ${entityKey}`);
+            }
+            if (!entityIds.has(entityId)) {
+                throw new Error(`Unknown ECS entity ${entityId} in component ${componentName}`);
+            }
+        }
+    }
+}
+function validateEntityId(entityId, label) {
+    if (!Number.isSafeInteger(entityId) || entityId < 1) {
+        throw new Error(`Invalid ECS ${label} ${entityId}`);
+    }
+}
+function snapshotFromMutable(world) {
+    const components = Object.fromEntries(Array.from(world.components.keys()).sort(compareStrings).map((componentName) => {
+        const values = world.components.get(componentName);
+        return [
+            componentName,
+            Object.fromEntries(Array.from(values.keys())
+                .sort((left, right) => Number(left) - Number(right))
+                .map((entityId) => [entityId, (0, canonical_js_1.cloneCanonical)(values.get(entityId))])),
+        ];
+    }));
+    const singletons = Object.fromEntries(Array.from(world.singletons.keys())
+        .sort(compareStrings)
+        .map((key) => [key, (0, canonical_js_1.cloneCanonical)(world.singletons.get(key))]));
+    return {
+        nextEntityId: world.nextEntityId,
+        entities: world.entities.slice().sort((left, right) => left - right),
+        components,
+        singletons,
+    };
+}
+function componentsMapFromSnapshot(components) {
+    return new Map(Object.keys(components).sort(compareStrings).map((componentName) => [
+        componentName,
+        new Map(Object.keys(components[componentName])
+            .sort((left, right) => Number(left) - Number(right))
+            .map((entityId) => [entityId, (0, canonical_js_1.cloneCanonical)(components[componentName][entityId])])),
+    ]));
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/cjs/effects-adapter.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicEventEffectsAdapter = createDeterministicEventEffectsAdapter;
+const canonical_js_1 = require("./canonical.js");
+const collections_js_1 = require("./collections.js");
+const errors_js_1 = require("./errors.js");
+function createDeterministicEventEffectsAdapter(config) {
+    validateTarget(config.target);
+    const dispatched = [];
+    const seen = new Set();
+    const listeners = new Set();
+    return {
+        dispatch(records) {
+            const nextDispatches = [];
+            for (const record of records) {
+                const dedupeKey = `${record.sequence}:${record.predictionState}`;
+                if (seen.has(dedupeKey)) {
+                    continue;
+                }
+                const effect = config.mapEvent(cloneEventRecord(record));
+                seen.add(dedupeKey);
+                if (effect === undefined) {
+                    continue;
+                }
+                const dispatch = freezeEffectDispatch({
+                    target: config.target,
+                    record: cloneEventRecord(record),
+                    effect: freezeEffectValue((0, canonical_js_1.cloneCanonical)(effect)),
+                });
+                dispatched.push(dispatch);
+                nextDispatches.push(dispatch);
+                for (const listener of listeners) {
+                    listener(dispatch);
+                }
+            }
+            return nextDispatches;
+        },
+        getDispatched() {
+            return dispatched.map((dispatch) => freezeEffectDispatch({
+                target: dispatch.target,
+                record: cloneEventRecord(dispatch.record),
+                effect: freezeEffectValue((0, canonical_js_1.cloneCanonical)(dispatch.effect)),
+            }));
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        reset() {
+            dispatched.length = 0;
+            seen.clear();
+        },
+    };
+}
+function cloneEventRecord(record) {
+    return freezeEffectValue({
+        eventId: record.eventId,
+        frame: record.frame,
+        sequence: record.sequence,
+        payload: (0, canonical_js_1.cloneCanonical)(record.payload),
+        predictionState: record.predictionState,
+        dedupeKey: record.dedupeKey,
+        notHashedKeys: [...record.notHashedKeys],
+        deliveryScope: record.deliveryScope,
+        playerSlot: record.playerSlot,
+    });
+}
+function freezeEffectDispatch(dispatch) {
+    freezeEffectValue(dispatch.record);
+    freezeEffectValue(dispatch.effect);
+    return Object.freeze(dispatch);
+}
+function freezeEffectValue(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            freezeEffectValue(item);
+        }
+        return Object.freeze(value);
+    }
+    const record = value;
+    for (const key of (0, collections_js_1.stableSortedKeys)(record)) {
+        freezeEffectValue(record[key]);
+    }
+    return Object.freeze(value);
+}
+function validateTarget(target) {
+    if (target !== 'r3f' && target !== 'audio' && target !== 'ui' && target !== 'custom') {
+        throw new errors_js_1.SyncplayError(`Unsupported deterministic effect target ${target}`, {
+            code: 'effects.target',
+        });
+    }
+}