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

package/dist/cjs/collections.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableSortedKeys = stableSortedKeys;
+exports.stableEntries = stableEntries;
+exports.createStableIndexedMap = createStableIndexedMap;
+exports.deterministicShuffle = deterministicShuffle;
+function stableSortedKeys(record) {
+    return Object.keys(record).sort(compareStrings);
+}
+function stableEntries(record) {
+    return stableSortedKeys(record).map((id) => ({ id, value: record[id] }));
+}
+function createStableIndexedMap(entries) {
+    const sorted = [...entries].sort((left, right) => compareStrings(left.id, right.id));
+    const result = new Map();
+    for (const entry of sorted) {
+        if (result.has(entry.id)) {
+            throw new Error(`Duplicate stable id ${entry.id}`);
+        }
+        result.set(entry.id, entry.value);
+    }
+    return result;
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function deterministicShuffle(values, random) {
+    const result = values.slice();
+    for (let index = result.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(0, index);
+        const value = result[index];
+        result[index] = result[swapIndex];
+        result[swapIndex] = value;
+    }
+    return result;
+}

package/dist/cjs/collision.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixedVec2 = fixedVec2;
+exports.fixedAabb = fixedAabb;
+exports.fixedCircle = fixedCircle;
+exports.aabbIntersects = aabbIntersects;
+exports.aabbContainsPoint = aabbContainsPoint;
+exports.circleIntersects = circleIntersects;
+exports.circleIntersectsAabb = circleIntersectsAabb;
+exports.translateAabb = translateAabb;
+exports.sortAabbsByStableId = sortAabbsByStableId;
+function fixedVec2(x, y) {
+    assertInteger(x, 'x');
+    assertInteger(y, 'y');
+    return { x, y };
+}
+function fixedAabb(center, halfWidth, halfHeight) {
+    assertInteger(halfWidth, 'halfWidth');
+    assertInteger(halfHeight, 'halfHeight');
+    if (halfWidth < 0 || halfHeight < 0) {
+        throw new Error('AABB half extents must be non-negative');
+    }
+    return {
+        minX: center.x - halfWidth,
+        minY: center.y - halfHeight,
+        maxX: center.x + halfWidth,
+        maxY: center.y + halfHeight,
+    };
+}
+function fixedCircle(center, radius) {
+    assertInteger(radius, 'radius');
+    if (radius < 0) {
+        throw new Error('Circle radius must be non-negative');
+    }
+    return { center, radius };
+}
+function aabbIntersects(left, right) {
+    return left.minX < right.maxX && left.maxX > right.minX && left.minY < right.maxY && left.maxY > right.minY;
+}
+function aabbContainsPoint(aabb, point) {
+    return point.x >= aabb.minX && point.x <= aabb.maxX && point.y >= aabb.minY && point.y <= aabb.maxY;
+}
+function circleIntersects(left, right) {
+    const dx = left.center.x - right.center.x;
+    const dy = left.center.y - right.center.y;
+    const radius = left.radius + right.radius;
+    return dx * dx + dy * dy < radius * radius;
+}
+function circleIntersectsAabb(circle, aabb) {
+    const center = circle.center;
+    const closestPoint = closestPointOnAabb(center, aabb);
+    const delta = {
+        x: center.x - closestPoint.x,
+        y: center.y - closestPoint.y,
+    };
+    return delta.x * delta.x + delta.y * delta.y < circle.radius * circle.radius;
+}
+function translateAabb(aabb, delta) {
+    return {
+        minX: aabb.minX + delta.x,
+        minY: aabb.minY + delta.y,
+        maxX: aabb.maxX + delta.x,
+        maxY: aabb.maxY + delta.y,
+    };
+}
+function sortAabbsByStableId(items) {
+    return [...items].sort((left, right) => {
+        if (left.id < right.id) {
+            return -1;
+        }
+        if (left.id > right.id) {
+            return 1;
+        }
+        return 0;
+    });
+}
+function clampToRange(value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+}
+function closestPointOnAabb(point, aabb) {
+    return {
+        x: clampToRange(point.x, aabb.minX, aabb.maxX),
+        y: clampToRange(point.y, aabb.minY, aabb.maxY),
+    };
+}
+function assertInteger(value, name) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer fixed-point value`);
+    }
+}