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

package/dist/cjs/canonical.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalize = canonicalize;
+exports.canonicalStringify = canonicalStringify;
+exports.cloneCanonical = cloneCanonical;
+exports.decodeCanonicalValue = decodeCanonicalValue;
+exports.defaultChecksum = defaultChecksum;
+exports.encodeCanonicalBytes = encodeCanonicalBytes;
+exports.decodeCanonicalBytes = decodeCanonicalBytes;
+exports.encodeUtf8 = encodeUtf8;
+exports.decodeUtf8 = decodeUtf8;
+const errors_js_1 = require("./errors.js");
+const reservedTag = '$rdm';
+function canonicalize(value) {
+    return canonicalizeValue(value, new WeakSet());
+}
+function canonicalStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function cloneCanonical(value) {
+    return decodeCanonical(JSON.parse(canonicalStringify(value)));
+}
+function decodeCanonicalValue(value) {
+    return decodeCanonical(value);
+}
+function defaultChecksum(value) {
+    return fnv1a64(canonicalStringify(value));
+}
+function encodeCanonicalBytes(value) {
+    return encodeUtf8(canonicalStringify(value));
+}
+function decodeCanonicalBytes(bytes) {
+    return decodeCanonical(JSON.parse(decodeUtf8(bytes)));
+}
+function encodeUtf8(source) {
+    if (typeof TextEncoder !== 'undefined') {
+        return new TextEncoder().encode(source);
+    }
+    if (typeof Buffer !== 'undefined') {
+        return Uint8Array.from(Buffer.from(source, 'utf8'));
+    }
+    throw new errors_js_1.SyncplayError('No UTF-8 encoder is available in this runtime', {
+        code: 'canonical.utf8-encoder',
+    });
+}
+function decodeUtf8(bytes) {
+    if (typeof TextDecoder !== 'undefined') {
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('utf8');
+    }
+    throw new errors_js_1.SyncplayError('No UTF-8 decoder is available in this runtime', {
+        code: 'canonical.utf8-decoder',
+    });
+}
+/**
+ * Recognize an already-canonical sentinel tag and return it (with container
+ * contents re-canonicalized), or undefined when the record is NOT a
+ * well-formed tag — the caller then rejects the reserved key as usual.
+ */
+function passThroughCanonicalTag(record, seen) {
+    const tag = record[reservedTag];
+    // rdm-ignore-next-line determinism/no-object-key-order: keys are used only for an order-independent count and membership check
+    const keys = Object.keys(record);
+    if ((tag === 'nan' || tag === 'infinity' || tag === 'negative-infinity' || tag === 'negative-zero' || tag === 'undefined')
+        && keys.length === 1) {
+        return { [reservedTag]: tag };
+    }
+    if (tag === 'bigint' && keys.length === 2 && typeof record.value === 'string') {
+        return { [reservedTag]: 'bigint', value: record.value };
+    }
+    if (tag === 'typed-array' && keys.length === 3 && typeof record.constructor === 'string' && Array.isArray(record.bytes)
+        && record.bytes.every((byte) => typeof byte === 'number' && Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+        return { [reservedTag]: 'typed-array', constructor: record.constructor, bytes: [...record.bytes] };
+    }
+    if (tag === 'map' && keys.length === 2 && Array.isArray(record.entries)
+        && record.entries.every((entry) => Array.isArray(entry) && entry.length === 2)) {
+        const entries = record.entries.map((entry) => {
+            const pair = entry;
+            return [canonicalizeValue(pair[0], seen), canonicalizeValue(pair[1], seen)];
+        });
+        return { [reservedTag]: 'map', entries };
+    }
+    if (tag === 'set' && keys.length === 2 && Array.isArray(record.values)) {
+        return { [reservedTag]: 'set', values: record.values.map((item) => canonicalizeValue(item, seen)) };
+    }
+    return undefined;
+}
+function canonicalizeValue(value, seen) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'boolean' || typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (Number.isNaN(value)) {
+            return { [reservedTag]: 'nan' };
+        }
+        if (value === Infinity) {
+            return { [reservedTag]: 'infinity' };
+        }
+        if (value === -Infinity) {
+            return { [reservedTag]: 'negative-infinity' };
+        }
+        if (Object.is(value, -0)) {
+            return { [reservedTag]: 'negative-zero' };
+        }
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        return { [reservedTag]: 'bigint', value: value.toString() };
+    }
+    if (value === undefined) {
+        return { [reservedTag]: 'undefined' };
+    }
+    if (typeof value === 'function' || typeof value === 'symbol') {
+        throw new errors_js_1.SyncplayError('Functions and symbols are not deterministic state values', {
+            code: 'canonical.unsupported-value',
+        });
+    }
+    if (seen.has(value)) {
+        throw new errors_js_1.SyncplayError('Cyclic deterministic state is not supported', {
+            code: 'canonical.cycle',
+        });
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const result = value.map((item) => canonicalizeValue(item, seen));
+        seen.delete(value);
+        return result;
+    }
+    if (ArrayBuffer.isView(value)) {
+        const typedArray = value;
+        const bytes = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+        const result = {
+            [reservedTag]: 'typed-array',
+            constructor: typedArray.constructor.name,
+            bytes: Array.from(bytes),
+        };
+        seen.delete(value);
+        return result;
+    }
+    if (value instanceof Map) {
+        const entries = Array.from(value.entries()).map(([entryKey, entryValue]) => {
+            const key = canonicalizeValue(entryKey, seen);
+            return [key, canonicalizeValue(entryValue, seen)];
+        });
+        entries.sort((a, b) => canonicalCompare(a[0], b[0]));
+        seen.delete(value);
+        return { [reservedTag]: 'map', entries };
+    }
+    if (value instanceof Set) {
+        const values = Array.from(value.values()).map((item) => canonicalizeValue(item, seen));
+        values.sort(canonicalCompare);
+        seen.delete(value);
+        return { [reservedTag]: 'set', values };
+    }
+    if (Object.getPrototypeOf(value) !== Object.prototype) {
+        seen.delete(value);
+        throw new errors_js_1.SyncplayError('Class instances and built-ins require explicit serializers', {
+            code: 'canonical.class-instance',
+        });
+    }
+    const record = value;
+    if (Object.prototype.hasOwnProperty.call(record, reservedTag)) {
+        // Idempotency: a WELL-FORMED sentinel tag is an already-canonical value
+        // (e.g. checksumming a canonicalizeState projection re-enters canonicalize
+        // with `{$rdm:'negative-zero'}` objects — a -0 state field must not make
+        // getChecksum throw every frame). Container tags re-canonicalize their
+        // contents (a no-op when truly canonical). Anything else with the reserved
+        // key is still rejected — user state cannot squat on `$rdm`.
+        const passedThrough = passThroughCanonicalTag(record, seen);
+        if (passedThrough !== undefined) {
+            seen.delete(value);
+            return passedThrough;
+        }
+        seen.delete(value);
+        throw new errors_js_1.SyncplayError(`State objects cannot use reserved key ${reservedTag}`, {
+            code: 'canonical.reserved-key',
+        });
+    }
+    const result = {};
+    for (const key of Object.keys(record).sort(compareUniqueStrings)) {
+        result[key] = canonicalizeValue(record[key], seen);
+    }
+    seen.delete(value);
+    return result;
+}
+function decodeCanonical(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string' || typeof value === 'number') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => decodeCanonical(item));
+    }
+    const record = value;
+    const tag = record[reservedTag];
+    if (typeof tag === 'string') {
+        if (tag === 'nan') {
+            return Number.NaN;
+        }
+        if (tag === 'infinity') {
+            return Infinity;
+        }
+        if (tag === 'negative-infinity') {
+            return -Infinity;
+        }
+        if (tag === 'negative-zero') {
+            return -0;
+        }
+        if (tag === 'undefined') {
+            return undefined;
+        }
+        if (tag === 'bigint') {
+            return BigInt(record.value);
+        }
+        if (tag === 'map') {
+            const entries = record.entries;
+            return new Map(entries.map(([entryKey, entryValue]) => [decodeCanonical(entryKey), decodeCanonical(entryValue)]));
+        }
+        if (tag === 'set') {
+            const values = record.values;
+            return new Set(values.map((item) => decodeCanonical(item)));
+        }
+        if (tag === 'typed-array') {
+            return decodeTypedArray(record);
+        }
+    }
+    const result = {};
+    for (const key of Object.keys(record).sort(compareUniqueStrings)) {
+        result[key] = decodeCanonical(record[key]);
+    }
+    return result;
+}
+function compareUniqueStrings(left, right) {
+    return left < right ? -1 : 1;
+}
+function decodeTypedArray(record) {
+    const constructorName = record.constructor;
+    if (typeof constructorName !== 'string') {
+        throw new errors_js_1.SyncplayError('Typed array canonical value is missing a constructor name', {
+            code: 'canonical.invalid-typed-array',
+        });
+    }
+    const bytes = Uint8Array.from(record.bytes);
+    const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    switch (constructorName) {
+        case 'Int8Array':
+            return new Int8Array(buffer);
+        case 'Uint8Array':
+            return new Uint8Array(buffer);
+        case 'Uint8ClampedArray':
+            return new Uint8ClampedArray(buffer);
+        case 'Int16Array':
+            return new Int16Array(buffer);
+        case 'Uint16Array':
+            return new Uint16Array(buffer);
+        case 'Int32Array':
+            return new Int32Array(buffer);
+        case 'Uint32Array':
+            return new Uint32Array(buffer);
+        case 'Float32Array':
+            return new Float32Array(buffer);
+        case 'Float64Array':
+            return new Float64Array(buffer);
+        case 'BigInt64Array':
+            return new BigInt64Array(buffer);
+        case 'BigUint64Array':
+            return new BigUint64Array(buffer);
+        case 'DataView':
+            return new DataView(buffer);
+        default:
+            throw new errors_js_1.SyncplayError(`Unsupported typed array constructor: ${constructorName}`, {
+                code: 'canonical.unsupported-typed-array',
+            });
+    }
+}
+function canonicalCompare(a, b) {
+    const aText = JSON.stringify(a);
+    const bText = JSON.stringify(b);
+    if (aText < bText) {
+        return -1;
+    }
+    if (aText > bText) {
+        return 1;
+    }
+    return 0;
+}
+function fnv1a64(value) {
+    let hash = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= BigInt(value.charCodeAt(index));
+        hash = BigInt.asUintN(64, hash * prime);
+    }
+    return hash.toString(16).padStart(16, '0');
+}