@apollohg/react-native-rich-text-editor 2.0.0

package/dist/NativeEditorResultNormalization.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REJECTED_V2_RECORD_PREVIEW_CHARS = exports.RENDER_ELEMENT_TYPES = exports.V2_DOCUMENT_ORIGINS = exports.V2_RENDER_STATES = exports.V2_TRANSPORT_STATES = exports.V2_DOCUMENT_STATES = void 0;
+exports.isPlainRecord = isPlainRecord;
+exports.normalizeNativeEditorV2Result = normalizeNativeEditorV2Result;
+exports.parseNativeEditorV2JsonValue = parseNativeEditorV2JsonValue;
+exports.normalizeNativeEditorV2Bytes = normalizeNativeEditorV2Bytes;
+exports.normalizeNativeEditorV2Unit = normalizeNativeEditorV2Unit;
+exports.normalizeNativeEditorV2DecimalId = normalizeNativeEditorV2DecimalId;
+exports.normalizeRevisionField = normalizeRevisionField;
+exports.nativeEditorV2U32 = nativeEditorV2U32;
+exports.requireNativeEditorV2U32 = requireNativeEditorV2U32;
+exports.optionalBoolean = optionalBoolean;
+exports.whitelisted = whitelisted;
+exports.normalizeNativeEditorV2StateValue = normalizeNativeEditorV2StateValue;
+exports.normalizeNativeEditorV2MutationOutcomeValue = normalizeNativeEditorV2MutationOutcomeValue;
+exports.normalizeNativeEditorV2CommitValue = normalizeNativeEditorV2CommitValue;
+exports.normalizeNativeEditorV2ChangedValue = normalizeNativeEditorV2ChangedValue;
+exports.normalizeNativeEditorV2HtmlValue = normalizeNativeEditorV2HtmlValue;
+exports.hasExactOwnKeys = hasExactOwnKeys;
+exports.hasOnlyOwnKeys = hasOnlyOwnKeys;
+exports.booleanRecord = booleanRecord;
+exports.stringArray = stringArray;
+exports.validJsonValue = validJsonValue;
+exports.validRenderMark = validRenderMark;
+exports.normalizeNativeEditorV2PeersValue = normalizeNativeEditorV2PeersValue;
+exports.describeRejectedV2Record = describeRejectedV2Record;
+exports.invalidV2ResultError = invalidV2ResultError;
+exports.destroyedHandleError = destroyedHandleError;
+exports.invalidV2RequestError = invalidV2RequestError;
+exports.unwrapNativeEditorV2Result = unwrapNativeEditorV2Result;
+exports.requireV2DecimalId = requireV2DecimalId;
+exports.requireV2Bytes = requireV2Bytes;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+const NativeEditorV2Decimal_1 = require("./NativeEditorV2Decimal");
+const NativeEditorNativeModule_1 = require("./NativeEditorNativeModule");
+function isPlainRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Validate a raw v2 result record: exactly one of value/error, every error
+ * field type, every domain/code string, and the caller-supplied value
+ * normalizer. Returns null for any contract violation; the imperative layer
+ * turns that into the non-retryable FFI_RESULT_INVALID error.
+ */
+function normalizeNativeEditorV2Result(raw, normalizeValue) {
+    if (!isPlainRecord(raw))
+        return null;
+    const hasValue = raw.value !== null && raw.value !== undefined;
+    const hasError = raw.error !== null && raw.error !== undefined;
+    if (hasValue === hasError)
+        return null;
+    if (hasError) {
+        const error = (0, NativeEditorBoundaryError_1.normalizeNativeEditorV2Error)({ error: raw.error });
+        return error == null ? null : { ok: false, error };
+    }
+    const value = normalizeValue(raw.value);
+    return value == null ? null : { ok: true, value };
+}
+/** Parse a JSON-string result value; anything else is a contract violation. */
+function parseNativeEditorV2JsonValue(value) {
+    if (typeof value !== 'string' || value === '')
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validate a direct binary result value. JSON number arrays are rejected on
+ * purpose: the frozen v2 contract moves bytes as bytes.
+ */
+function normalizeNativeEditorV2Bytes(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    return null;
+}
+/** FfiUnitResult successes are exactly `true`; anything else is invalid. */
+function normalizeNativeEditorV2Unit(value) {
+    return value === true ? true : null;
+}
+/**
+ * Normalize a request/revision identifier to its canonical decimal string.
+ * V2 never accepts numeric compatibility values: JavaScript numbers cannot
+ * represent the complete Rust u64 domain.
+ */
+function normalizeNativeEditorV2DecimalId(value) {
+    return (0, NativeEditorV2Decimal_1.normalizeNativeEditorV2U64)(value);
+}
+function normalizeRevisionField(record, field) {
+    return normalizeNativeEditorV2DecimalId(record[field]);
+}
+function nativeEditorV2U32(value) {
+    return typeof value === 'number' &&
+        Number.isFinite(value) &&
+        Number.isInteger(value) &&
+        value >= 0 &&
+        value <= 4294967295
+        ? value
+        : null;
+}
+/** Require one exact JavaScript/platform u32 value at the v2 boundary. */
+function requireNativeEditorV2U32(value, field) {
+    const normalized = nativeEditorV2U32(value);
+    if (normalized == null) {
+        throw invalidV2RequestError(`NativeEditorBridge: invalid u32 ${field}`);
+    }
+    return normalized;
+}
+function optionalBoolean(value) {
+    return typeof value === 'boolean' ? value : null;
+}
+exports.V2_DOCUMENT_STATES = ['LocalReady', 'AwaitRemote', 'RoomReady'];
+exports.V2_TRANSPORT_STATES = [
+    'Detached',
+    'Disconnected',
+    'Connecting',
+    'Handshaking',
+    'Synchronized',
+    'Incompatible',
+    'Destroying',
+    'Destroyed',
+];
+exports.V2_RENDER_STATES = ['Loading', 'Ready'];
+exports.V2_DOCUMENT_ORIGINS = [
+    'nativeView',
+    'jsApi',
+    'remoteCollaboration',
+    'history',
+    'restore',
+    'import',
+];
+function whitelisted(value, allowed) {
+    return typeof value === 'string' && allowed.includes(value)
+        ? value
+        : null;
+}
+function normalizeNativeEditorV2StateValue(value) {
+    const parsed = typeof value === 'string' ? parseNativeEditorV2JsonValue(value) : value;
+    if (!isPlainRecord(parsed))
+        return null;
+    const documentState = whitelisted(parsed.documentState, exports.V2_DOCUMENT_STATES);
+    const transportState = whitelisted(parsed.transportState, exports.V2_TRANSPORT_STATES);
+    const renderState = whitelisted(parsed.renderState, exports.V2_RENDER_STATES);
+    const documentRevision = normalizeRevisionField(parsed, 'documentRevision');
+    const documentOrigin = whitelisted(parsed.documentOrigin, exports.V2_DOCUMENT_ORIGINS);
+    const stateRevision = normalizeRevisionField(parsed, 'stateRevision');
+    const canUndo = optionalBoolean(parsed.canUndo);
+    const canRedo = optionalBoolean(parsed.canRedo);
+    if (documentState == null ||
+        transportState == null ||
+        renderState == null ||
+        documentRevision == null ||
+        documentOrigin == null ||
+        stateRevision == null ||
+        canUndo == null ||
+        canRedo == null) {
+        return null;
+    }
+    return {
+        documentState,
+        transportState,
+        renderState,
+        documentRevision,
+        documentOrigin,
+        stateRevision,
+        canUndo,
+        canRedo,
+    };
+}
+function normalizeNativeEditorV2MutationOutcomeValue(value) {
+    const parsed = parseNativeEditorV2JsonValue(value);
+    if (!isPlainRecord(parsed))
+        return null;
+    if (parsed.type === 'notApplicable') {
+        return { type: 'notApplicable' };
+    }
+    if (parsed.type === 'replacement') {
+        const changed = optionalBoolean(parsed.changed);
+        const documentRevision = normalizeRevisionField(parsed, 'documentRevision');
+        if (changed == null || documentRevision == null)
+            return null;
+        return { type: 'replacement', changed, documentRevision };
+    }
+    if (parsed.type === 'transaction') {
+        const changed = optionalBoolean(parsed.changed);
+        const documentRevision = normalizeRevisionField(parsed, 'documentRevision');
+        const stateRevision = normalizeRevisionField(parsed, 'stateRevision');
+        const canUndo = optionalBoolean(parsed.canUndo);
+        const canRedo = optionalBoolean(parsed.canRedo);
+        if (changed == null ||
+            documentRevision == null ||
+            stateRevision == null ||
+            canUndo == null ||
+            canRedo == null) {
+            return null;
+        }
+        return {
+            type: 'transaction',
+            changed,
+            documentRevision,
+            stateRevision,
+            canUndo,
+            canRedo,
+        };
+    }
+    return null;
+}
+function normalizeNativeEditorV2CommitValue(value) {
+    const parsed = parseNativeEditorV2JsonValue(value);
+    if (!isPlainRecord(parsed))
+        return null;
+    const changed = optionalBoolean(parsed.changed);
+    const documentRevision = normalizeRevisionField(parsed, 'documentRevision');
+    if (changed == null || documentRevision == null)
+        return null;
+    return { changed, documentRevision };
+}
+function normalizeNativeEditorV2ChangedValue(value) {
+    const parsed = parseNativeEditorV2JsonValue(value);
+    if (!isPlainRecord(parsed))
+        return null;
+    return optionalBoolean(parsed.changed);
+}
+function normalizeNativeEditorV2HtmlValue(value) {
+    const parsed = parseNativeEditorV2JsonValue(value);
+    if (!isPlainRecord(parsed) || typeof parsed.html !== 'string')
+        return null;
+    return parsed.html;
+}
+exports.RENDER_ELEMENT_TYPES = new Set([
+    'textRun',
+    'blockStart',
+    'blockEnd',
+    'voidInline',
+    'voidBlock',
+    'opaqueInlineAtom',
+    'opaqueBlockAtom',
+]);
+function hasExactOwnKeys(record, expected) {
+    const actual = Object.keys(record).sort();
+    const sortedExpected = [...expected].sort();
+    return (actual.length === sortedExpected.length &&
+        actual.every((key, index) => key === sortedExpected[index]));
+}
+function hasOnlyOwnKeys(record, allowed) {
+    const allowedKeys = new Set(allowed);
+    return Object.keys(record).every((key) => allowedKeys.has(key));
+}
+function booleanRecord(value) {
+    return (isPlainRecord(value) && Object.values(value).every((entry) => typeof entry === 'boolean'));
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+function validJsonValue(value) {
+    if (value === null)
+        return true;
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(validJsonValue);
+    return isPlainRecord(value) && Object.values(value).every(validJsonValue);
+}
+function validRenderMark(value) {
+    return (typeof value === 'string' ||
+        (isPlainRecord(value) &&
+            typeof value.type === 'string' &&
+            Object.values(value).every(validJsonValue)));
+}
+function normalizeNativeEditorV2PeersValue(value) {
+    const parsed = typeof value === 'string' ? parseNativeEditorV2JsonValue(value) : value;
+    if (!isPlainRecord(parsed) || !Array.isArray(parsed.peers))
+        return null;
+    const peers = [];
+    for (const rawPeer of parsed.peers) {
+        if (!isPlainRecord(rawPeer))
+            return null;
+        const clientId = normalizeNativeEditorV2DecimalId(rawPeer.clientId);
+        const clock = nativeEditorV2U32(rawPeer.clock);
+        const isLocal = optionalBoolean(rawPeer.isLocal);
+        if (clientId == null || clock == null || isLocal == null)
+            return null;
+        if (rawPeer.state !== null && !isPlainRecord(rawPeer.state))
+            return null;
+        let cursor = null;
+        if (rawPeer.cursor !== null && rawPeer.cursor !== undefined) {
+            if (!isPlainRecord(rawPeer.cursor))
+                return null;
+            const anchor = nativeEditorV2U32(rawPeer.cursor.anchor);
+            const head = nativeEditorV2U32(rawPeer.cursor.head);
+            if (anchor == null || head == null)
+                return null;
+            cursor = { anchor, head };
+        }
+        peers.push({
+            clientId,
+            clock,
+            isLocal,
+            state: rawPeer.state ?? null,
+            cursor,
+        });
+    }
+    return peers;
+}
+exports.REJECTED_V2_RECORD_PREVIEW_CHARS = 4000;
+/** Dev-only preview of a rejected boundary record, bounded so a large document never floods the log. */
+function describeRejectedV2Record(raw) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(raw);
+    }
+    catch {
+        return `<unserializable ${typeof raw}>`;
+    }
+    if (serialized === undefined)
+        return `<${typeof raw}>`;
+    return serialized.length > exports.REJECTED_V2_RECORD_PREVIEW_CHARS
+        ? `${serialized.slice(0, exports.REJECTED_V2_RECORD_PREVIEW_CHARS)}… (${serialized.length} chars)`
+        : serialized;
+}
+function invalidV2ResultError() {
+    return new NativeEditorBoundaryError_1.NativeEditorNonRetryableError({
+        domain: 'boundary',
+        code: 'FFI_RESULT_INVALID',
+        message: NativeEditorNativeModule_1.ERR_V2_NATIVE_RESPONSE,
+        requestId: null,
+        operationIndex: null,
+        limit: null,
+        actual: null,
+        details: null,
+    });
+}
+function destroyedHandleError() {
+    return new NativeEditorBoundaryError_1.NativeEditorNonRetryableError({
+        domain: 'lifecycle',
+        code: 'ENGINE_DESTROYED',
+        message: NativeEditorNativeModule_1.ERR_V2_DESTROYED,
+        requestId: null,
+        operationIndex: null,
+        limit: null,
+        actual: null,
+        details: null,
+    });
+}
+function invalidV2RequestError(message) {
+    return new NativeEditorBoundaryError_1.NativeEditorEngineBoundaryError({
+        domain: 'boundary',
+        code: 'CONFIG_INVALID',
+        message,
+        requestId: null,
+        operationIndex: null,
+        limit: null,
+        actual: null,
+        details: null,
+    });
+}
+/**
+ * Unwrap a raw v2 result record on the imperative path: typed per-domain
+ * throws for recoverable engine errors, the distinct non-retryable class for
+ * ENGINE_INVARIANT_FAILED / lifecycle-destroyed states and for malformed
+ * records (a bridge contract violation can never succeed on retry).
+ */
+function unwrapNativeEditorV2Result(raw, normalizeValue) {
+    const result = normalizeNativeEditorV2Result(raw, normalizeValue);
+    if (result == null) {
+        // The thrown error cannot carry the payload, so name the rejected
+        // record here — otherwise the failure is unattributable in the app.
+        if (__DEV__) {
+            console.error('NativeEditorBridge: native module returned a record this boundary rejected', describeRejectedV2Record(raw));
+        }
+        throw invalidV2ResultError();
+    }
+    if (!result.ok)
+        throw (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(result.error);
+    return result.value;
+}
+function requireV2DecimalId(value, field) {
+    const normalized = normalizeNativeEditorV2DecimalId(value);
+    if (normalized == null) {
+        throw invalidV2RequestError(`NativeEditorBridge: invalid ${field} for v2 request`);
+    }
+    return normalized;
+}
+function requireV2Bytes(value, field) {
+    const normalized = normalizeNativeEditorV2Bytes(value);
+    if (normalized == null) {
+        throw invalidV2RequestError(`NativeEditorBridge: invalid ${field} for v2 request`);
+    }
+    return normalized;
+}