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

package/dist/NativeEditorCollaborationTransport.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE64_ALPHABET = exports.MAX_COLLABORATION_ADAPTER_FRAME_BYTES = exports.MAX_COLLABORATION_ADAPTER_FRAMES = exports.MAX_COLLABORATION_ADAPTER_TIMEOUT_MILLIS = exports.MAX_COLLABORATION_PROTOCOL_BYTES = exports.MAX_COLLABORATION_PROTOCOLS = exports.COLLABORATION_PROTOCOL_TOKEN = void 0;
+exports.collaborationProtocolAdapterDescriptor = collaborationProtocolAdapterDescriptor;
+exports.collaborationTransportWireConfig = collaborationTransportWireConfig;
+exports.serializeCollaborationProtocolAdapterResult = serializeCollaborationProtocolAdapterResult;
+exports.normalizeNativeCollaborationTransportDiagnostics = normalizeNativeCollaborationTransportDiagnostics;
+exports.encodeNativeCollaborationProtocolBytes = encodeNativeCollaborationProtocolBytes;
+exports.decodeNativeCollaborationProtocolBytes = decodeNativeCollaborationProtocolBytes;
+exports.normalizeNativeCollaborationTransportEvent = normalizeNativeCollaborationTransportEvent;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+const NativeEditorResultNormalization_1 = require("./NativeEditorResultNormalization");
+const NativeEditorCreateJson_1 = require("./NativeEditorCreateJson");
+exports.COLLABORATION_PROTOCOL_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+exports.MAX_COLLABORATION_PROTOCOLS = 16;
+exports.MAX_COLLABORATION_PROTOCOL_BYTES = 128;
+exports.MAX_COLLABORATION_ADAPTER_TIMEOUT_MILLIS = 60000;
+exports.MAX_COLLABORATION_ADAPTER_FRAMES = 16;
+exports.MAX_COLLABORATION_ADAPTER_FRAME_BYTES = 64 * 1024;
+function collaborationProtocolAdapterDescriptor(value) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        !Array.isArray(value.protocols) ||
+        value.protocols.length < 1 ||
+        value.protocols.length > exports.MAX_COLLABORATION_PROTOCOLS ||
+        typeof value.onOpen !== 'function' ||
+        typeof value.onMessage !== 'function') {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration protocol adapter');
+    }
+    const protocols = value.protocols.map((protocol) => {
+        if (typeof protocol !== 'string' ||
+            protocol.length === 0 ||
+            (0, NativeEditorCreateJson_1.utf8V2JsonByteLength)(protocol) > exports.MAX_COLLABORATION_PROTOCOL_BYTES ||
+            !exports.COLLABORATION_PROTOCOL_TOKEN.test(protocol)) {
+            throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration WebSocket subprotocol');
+        }
+        return protocol;
+    });
+    if (new Set(protocols).size !== protocols.length) {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: duplicate collaboration WebSocket subprotocol');
+    }
+    const timeoutMillis = value.timeoutMillis;
+    if (timeoutMillis !== undefined &&
+        (!Number.isSafeInteger(timeoutMillis) ||
+            timeoutMillis < 1 ||
+            timeoutMillis > exports.MAX_COLLABORATION_ADAPTER_TIMEOUT_MILLIS)) {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration protocol adapter timeout');
+    }
+    const rawTerminalCloseCodes = value.terminalCloseCodes;
+    if (rawTerminalCloseCodes !== undefined &&
+        (!Array.isArray(rawTerminalCloseCodes) ||
+            rawTerminalCloseCodes.some((code) => !Number.isSafeInteger(code) || code < 1000 || code > 4999))) {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration terminal close code');
+    }
+    const terminalCloseCodes = rawTerminalCloseCodes === undefined ? undefined : [...rawTerminalCloseCodes];
+    if (terminalCloseCodes !== undefined &&
+        new Set(terminalCloseCodes).size !== terminalCloseCodes.length) {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: duplicate collaboration terminal close code');
+    }
+    return {
+        protocols,
+        ...(timeoutMillis === undefined ? {} : { timeoutMillis }),
+        ...(terminalCloseCodes === undefined ? {} : { terminalCloseCodes }),
+    };
+}
+function collaborationTransportWireConfig(config) {
+    if (config === null ||
+        typeof config !== 'object' ||
+        typeof config.url !== 'string' ||
+        typeof config.connect !== 'boolean') {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration transport configuration');
+    }
+    return {
+        url: config.url,
+        connect: config.connect,
+        ...(config.protocolAdapter === undefined
+            ? {}
+            : {
+                protocolAdapter: collaborationProtocolAdapterDescriptor(config.protocolAdapter),
+            }),
+    };
+}
+function serializeCollaborationProtocolAdapterResult(value) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        (value.action !== 'continue' && value.action !== 'ready' && value.action !== 'reject') ||
+        (value.frames !== undefined &&
+            (!Array.isArray(value.frames) ||
+                value.frames.length > exports.MAX_COLLABORATION_ADAPTER_FRAMES))) {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration protocol adapter result');
+    }
+    const frames = (value.frames ?? []).map((frame) => {
+        if (frame === null || typeof frame !== 'object') {
+            throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration protocol adapter frame');
+        }
+        if (frame.type === 'text' && typeof frame.data === 'string') {
+            if ((0, NativeEditorCreateJson_1.utf8V2JsonByteLength)(frame.data) > exports.MAX_COLLABORATION_ADAPTER_FRAME_BYTES) {
+                throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: collaboration protocol adapter frame is too large');
+            }
+            return { type: 'text', data: frame.data };
+        }
+        if (frame.type === 'binary' &&
+            frame.data instanceof Uint8Array &&
+            frame.data.byteLength <= exports.MAX_COLLABORATION_ADAPTER_FRAME_BYTES) {
+            return {
+                type: 'binary',
+                data: encodeNativeCollaborationProtocolBytes(frame.data),
+            };
+        }
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid collaboration protocol adapter frame');
+    });
+    return JSON.stringify({
+        action: value.action,
+        ...(frames.length === 0 ? {} : { frames }),
+    });
+}
+function normalizeNativeCollaborationTransportDiagnostics(value) {
+    if (!(0, NativeEditorResultNormalization_1.isPlainRecord)(value))
+        return null;
+    const transportState = (0, NativeEditorResultNormalization_1.whitelisted)(value.transportState, NativeEditorResultNormalization_1.V2_TRANSPORT_STATES);
+    const nextDeadlineMillis = value.nextDeadlineMillis === null
+        ? null
+        : (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2DecimalId)(value.nextDeadlineMillis);
+    const remoteCommitApplied = (0, NativeEditorResultNormalization_1.optionalBoolean)(value.remoteCommitApplied);
+    const peersChanged = (0, NativeEditorResultNormalization_1.optionalBoolean)(value.peersChanged);
+    const renewedLocal = (0, NativeEditorResultNormalization_1.optionalBoolean)(value.renewedLocal);
+    const expiredPeerCount = (0, NativeEditorResultNormalization_1.nativeEditorV2U32)(value.expiredPeerCount);
+    if (typeof value.wakeReason !== 'string' ||
+        transportState == null ||
+        (value.nextDeadlineMillis !== null && nextDeadlineMillis == null) ||
+        remoteCommitApplied == null ||
+        peersChanged == null ||
+        renewedLocal == null ||
+        expiredPeerCount == null) {
+        return null;
+    }
+    return {
+        wakeReason: value.wakeReason,
+        transportState,
+        nextDeadlineMillis,
+        remoteCommitApplied,
+        peersChanged,
+        renewedLocal,
+        expiredPeerCount,
+    };
+}
+exports.BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function encodeNativeCollaborationProtocolBytes(bytes) {
+    let encoded = '';
+    for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index];
+        const second = index + 1 < bytes.length ? bytes[index + 1] : 0;
+        const third = index + 2 < bytes.length ? bytes[index + 2] : 0;
+        const value = (first << 16) | (second << 8) | third;
+        encoded += exports.BASE64_ALPHABET[(value >>> 18) & 63];
+        encoded += exports.BASE64_ALPHABET[(value >>> 12) & 63];
+        encoded += index + 1 < bytes.length ? exports.BASE64_ALPHABET[(value >>> 6) & 63] : '=';
+        encoded += index + 2 < bytes.length ? exports.BASE64_ALPHABET[value & 63] : '=';
+    }
+    return encoded;
+}
+function decodeNativeCollaborationProtocolBytes(value) {
+    if (value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+        return null;
+    const firstPadding = value.indexOf('=');
+    if (firstPadding >= 0 && firstPadding < value.length - 2)
+        return null;
+    const outputLength = (value.length / 4) * 3 - (value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0);
+    const bytes = new Uint8Array(outputLength);
+    let outputIndex = 0;
+    for (let index = 0; index < value.length; index += 4) {
+        const first = exports.BASE64_ALPHABET.indexOf(value[index]);
+        const second = exports.BASE64_ALPHABET.indexOf(value[index + 1]);
+        const third = value[index + 2] === '=' ? 0 : exports.BASE64_ALPHABET.indexOf(value[index + 2]);
+        const fourth = value[index + 3] === '=' ? 0 : exports.BASE64_ALPHABET.indexOf(value[index + 3]);
+        if (first < 0 || second < 0 || third < 0 || fourth < 0)
+            return null;
+        const decoded = (first << 18) | (second << 12) | (third << 6) | fourth;
+        if (outputIndex < outputLength)
+            bytes[outputIndex++] = (decoded >>> 16) & 0xff;
+        if (outputIndex < outputLength)
+            bytes[outputIndex++] = (decoded >>> 8) & 0xff;
+        if (outputIndex < outputLength)
+            bytes[outputIndex++] = decoded & 0xff;
+    }
+    return bytes;
+}
+function normalizeNativeCollaborationTransportEvent(value) {
+    if (!(0, NativeEditorResultNormalization_1.isPlainRecord)(value))
+        return null;
+    const editorId = (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2DecimalId)(value.editorId);
+    const eventSequence = (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2DecimalId)(value.eventSequence);
+    const generation = value.generation === null ? null : (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2DecimalId)(value.generation);
+    if (editorId == null ||
+        editorId === '0' ||
+        eventSequence == null ||
+        eventSequence === '0' ||
+        (value.generation !== null && generation == null)) {
+        return null;
+    }
+    if (value.kind === 'state') {
+        const state = (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2StateValue)(value.state);
+        const peers = (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2PeersValue)({ peers: value.peers });
+        const diagnostics = normalizeNativeCollaborationTransportDiagnostics(value.diagnostics);
+        if (state == null || peers == null || diagnostics == null)
+            return null;
+        return {
+            editorId,
+            eventSequence,
+            generation,
+            kind: 'state',
+            state,
+            peers,
+            diagnostics,
+        };
+    }
+    if (value.kind === 'error') {
+        const error = (0, NativeEditorBoundaryError_1.normalizeNativeEditorV2Error)({ error: value.error });
+        if (error == null)
+            return null;
+        return {
+            editorId,
+            eventSequence,
+            generation,
+            kind: 'error',
+            error: (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(error),
+        };
+    }
+    if (value.kind === 'protocolAdapter') {
+        const eventId = (0, NativeEditorResultNormalization_1.normalizeNativeEditorV2DecimalId)(value.eventId);
+        if (generation == null ||
+            typeof value.attemptId !== 'string' ||
+            value.attemptId.length === 0 ||
+            eventId == null ||
+            eventId === '0' ||
+            (value.negotiatedProtocol !== null && typeof value.negotiatedProtocol !== 'string') ||
+            (value.phase !== 'open' && value.phase !== 'message')) {
+            return null;
+        }
+        const base = {
+            editorId,
+            eventSequence,
+            generation,
+            kind: 'protocolAdapter',
+            attemptId: value.attemptId,
+            eventId,
+            negotiatedProtocol: value.negotiatedProtocol,
+        };
+        if (value.phase === 'open') {
+            if (value.frame !== undefined)
+                return null;
+            return { ...base, phase: 'open' };
+        }
+        if (!(0, NativeEditorResultNormalization_1.isPlainRecord)(value.frame) || typeof value.frame.data !== 'string')
+            return null;
+        if (value.frame.type === 'text') {
+            return {
+                ...base,
+                phase: 'message',
+                frame: { type: 'text', data: value.frame.data },
+            };
+        }
+        if (value.frame.type === 'binary') {
+            const data = decodeNativeCollaborationProtocolBytes(value.frame.data);
+            if (data == null)
+                return null;
+            return {
+                ...base,
+                phase: 'message',
+                frame: { type: 'binary', data },
+            };
+        }
+    }
+    return null;
+}

package/dist/NativeEditorCreateConfig.d.ts

@@ -0,0 +1,16 @@
+import { type ResolvedDocumentSchema } from './schemas';
+import { type NativeEditorCreateConfig } from './NativeEditorTypes';
+export declare function normalizeV2CreatePolicy(value: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeV2SnapshotMetadata(value: unknown): Record<string, unknown>;
+export declare function buildV2CreateRequestUnchecked(config: NativeEditorCreateConfig): {
+    envelope: Record<string, unknown>;
+    limits: NativeEditorCreateConfig['limits'];
+    snapshotState: Uint8Array | null;
+};
+export declare function cloneAndFreezeDescriptorValue<T>(value: T): T;
+export declare function cloneAndFreezeDocumentDescriptor(descriptor: ResolvedDocumentSchema): ResolvedDocumentSchema;
+export declare function buildV2CreateRequest(config: NativeEditorCreateConfig): {
+    configJson: string;
+    snapshotState: Uint8Array | null;
+    documentDescriptor: ResolvedDocumentSchema;
+};

package/dist/NativeEditorCreateConfig.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeV2CreatePolicy = normalizeV2CreatePolicy;
+exports.normalizeV2SnapshotMetadata = normalizeV2SnapshotMetadata;
+exports.buildV2CreateRequestUnchecked = buildV2CreateRequestUnchecked;
+exports.cloneAndFreezeDescriptorValue = cloneAndFreezeDescriptorValue;
+exports.cloneAndFreezeDocumentDescriptor = cloneAndFreezeDocumentDescriptor;
+exports.buildV2CreateRequest = buildV2CreateRequest;
+const schemas_1 = require("./schemas");
+const NativeEditorCreateValidation_1 = require("./NativeEditorCreateValidation");
+const NativeEditorCreateJson_1 = require("./NativeEditorCreateJson");
+const NativeEditorResultNormalization_1 = require("./NativeEditorResultNormalization");
+function normalizeV2CreatePolicy(value) {
+    const policy = (0, NativeEditorCreateValidation_1.normalizeV2CreateRecord)(value, NativeEditorCreateValidation_1.V2_CREATE_POLICY_KEYS, 'policy');
+    const maxLength = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(policy, 'maxLength');
+    if (maxLength !== undefined &&
+        (typeof maxLength !== 'number' ||
+            !Number.isSafeInteger(maxLength) ||
+            maxLength < 0 ||
+            maxLength > NativeEditorCreateValidation_1.V2_CREATE_MAX_U32)) {
+        (0, NativeEditorCreateJson_1.invalidV2JsonValue)('policy.maxLength');
+    }
+    for (const key of ['readOnly', 'allowBase64Images']) {
+        const value = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(policy, key);
+        if (value !== undefined && typeof value !== 'boolean') {
+            (0, NativeEditorCreateJson_1.invalidV2JsonValue)(`policy.${key}`);
+        }
+    }
+    const inputFilter = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(policy, 'inputFilter');
+    if (inputFilter !== undefined && typeof inputFilter !== 'string') {
+        (0, NativeEditorCreateJson_1.invalidV2JsonValue)('policy.inputFilter');
+    }
+    return policy;
+}
+function normalizeV2SnapshotMetadata(value) {
+    const metadata = (0, NativeEditorCreateValidation_1.normalizeV2CreateRecord)(value, NativeEditorCreateValidation_1.V2_CREATE_SNAPSHOT_METADATA_KEYS, 'snapshot metadata');
+    const formatVersion = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(metadata, 'formatVersion');
+    if (typeof formatVersion !== 'number' ||
+        !Number.isSafeInteger(formatVersion) ||
+        formatVersion < 0 ||
+        formatVersion > NativeEditorCreateValidation_1.V2_CREATE_MAX_U32) {
+        (0, NativeEditorCreateJson_1.invalidV2JsonValue)('snapshot metadata.formatVersion');
+    }
+    for (const key of ['documentId', 'lineageId', 'fragmentName', 'schemaFingerprint']) {
+        if (typeof (0, NativeEditorCreateValidation_1.ownV2CreateValue)(metadata, key) !== 'string') {
+            (0, NativeEditorCreateJson_1.invalidV2JsonValue)(`snapshot metadata.${key}`);
+        }
+    }
+    return metadata;
+}
+function buildV2CreateRequestUnchecked(config) {
+    if (!(0, NativeEditorCreateValidation_1.isV2CreateRecord)(config)) {
+        throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid v2 create config');
+    }
+    (0, NativeEditorCreateValidation_1.requireKnownV2CreateKeys)(config, NativeEditorCreateValidation_1.V2_CREATE_CONFIG_KEYS, 'config');
+    const initializationValue = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(config, 'initialization');
+    if (!(0, NativeEditorCreateValidation_1.isV2CreateRecord)(initializationValue)) {
+        throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid v2 create config');
+    }
+    const jsonTraversal = {
+        seen: new WeakSet(),
+        work: 0,
+    };
+    const policyValue = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(config, 'policy');
+    const policy = policyValue === undefined
+        ? undefined
+        : normalizeV2CreatePolicy(policyValue);
+    const limitsValue = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(config, 'limits');
+    let limits;
+    if (limitsValue !== undefined) {
+        (0, NativeEditorCreateValidation_1.requireKnownV2CreateKeys)(limitsValue, NativeEditorCreateValidation_1.V2_CREATE_LIMIT_KEYS, 'limits');
+        limits = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+        for (const [group, keys] of [
+            ['resource', NativeEditorCreateValidation_1.V2_CREATE_RESOURCE_LIMIT_KEYS],
+            ['editing', NativeEditorCreateValidation_1.V2_CREATE_EDITING_LIMIT_KEYS],
+            ['collaboration', NativeEditorCreateValidation_1.V2_CREATE_COLLABORATION_LIMIT_KEYS],
+        ]) {
+            const overrides = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(limitsValue, group);
+            if (overrides !== undefined) {
+                limits[group] = (0, NativeEditorCreateValidation_1.normalizeV2CreateRecord)(overrides, keys, `${group} limits`);
+            }
+        }
+    }
+    const envelope = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+    const schema = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(config, 'schema');
+    if (schema === null) {
+        throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid schema for v2 create');
+    }
+    if (schema !== undefined) {
+        if (!(0, NativeEditorCreateValidation_1.isV2CreateRecord)(schema)) {
+            throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid schema for v2 create');
+        }
+        envelope.schema = (0, NativeEditorCreateJson_1.normalizeV2JsonValue)(schema, 'schema', jsonTraversal);
+    }
+    const fragmentName = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(config, 'fragmentName');
+    if (fragmentName !== undefined && typeof fragmentName !== 'string') {
+        throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid fragmentName for v2 create');
+    }
+    if (fragmentName !== undefined)
+        envelope.fragmentName = fragmentName;
+    let snapshotState = null;
+    const initialization = initializationValue;
+    const initializationType = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(initialization, 'type');
+    const initializationKeys = typeof initializationType === 'string'
+        ? NativeEditorCreateValidation_1.V2_CREATE_INITIALIZATION_KEYS[initializationType]
+        : undefined;
+    if (initializationKeys === undefined) {
+        throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: unknown v2 initialization type');
+    }
+    (0, NativeEditorCreateValidation_1.requireKnownV2CreateKeys)(initialization, initializationKeys, 'initialization');
+    switch (initializationType) {
+        case 'localEmpty': {
+            const localEmpty = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+            localEmpty.type = 'localEmpty';
+            envelope.initialization = localEmpty;
+            break;
+        }
+        case 'localJson': {
+            const json = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(initialization, 'json');
+            if (!(0, NativeEditorCreateValidation_1.isV2CreateRecord)(json)) {
+                throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid localJson initialization for v2 create');
+            }
+            const localJson = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+            localJson.type = 'localJson';
+            localJson.json = (0, NativeEditorCreateJson_1.normalizeV2JsonValue)(json, 'localJson initialization', jsonTraversal);
+            envelope.initialization = localJson;
+            break;
+        }
+        case 'localHtml': {
+            const html = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(initialization, 'html');
+            if (typeof html !== 'string') {
+                throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid localHtml initialization for v2 create');
+            }
+            const localHtml = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+            localHtml.type = 'localHtml';
+            localHtml.html = html;
+            envelope.initialization = localHtml;
+            break;
+        }
+        case 'room': {
+            const documentId = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(initialization, 'documentId');
+            const lineageId = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(initialization, 'lineageId');
+            if (typeof documentId !== 'string' || typeof lineageId !== 'string') {
+                throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: invalid room initialization for v2 create');
+            }
+            const room = (0, NativeEditorCreateValidation_1.emptyV2CreateRecord)();
+            room.type = 'room';
+            room.documentId = documentId;
+            room.lineageId = lineageId;
+            const snapshot = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(initialization, 'snapshot');
+            if (snapshot !== undefined) {
+                (0, NativeEditorCreateValidation_1.requireKnownV2CreateKeys)(snapshot, NativeEditorCreateValidation_1.V2_CREATE_ROOM_SNAPSHOT_KEYS, 'room snapshot');
+                const metadataValue = (0, NativeEditorCreateValidation_1.ownV2CreateValue)(snapshot, 'metadata');
+                const metadata = normalizeV2SnapshotMetadata(metadataValue);
+                room.snapshot = metadata;
+                snapshotState = (0, NativeEditorResultNormalization_1.requireV2Bytes)((0, NativeEditorCreateValidation_1.ownV2CreateValue)(snapshot, 'encodedState'), 'snapshot encodedState');
+            }
+            envelope.initialization = room;
+            break;
+        }
+        default:
+            throw (0, NativeEditorCreateValidation_1.invalidV2CreateRequestError)('NativeEditorBridge: unknown v2 initialization type');
+    }
+    if (policy !== undefined)
+        envelope.policy = policy;
+    if (limits !== undefined)
+        envelope.limits = limits;
+    return {
+        envelope,
+        limits: limits,
+        snapshotState,
+    };
+}
+function cloneAndFreezeDescriptorValue(value) {
+    if (value == null || typeof value !== 'object')
+        return value;
+    const setOwnValue = (target, key, child) => {
+        Object.defineProperty(target, key, {
+            value: child,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    };
+    const cloneRoot = (Array.isArray(value) ? [] : {});
+    const clones = new Map([[value, cloneRoot]]);
+    const pending = [{ source: value, target: cloneRoot }];
+    const created = [cloneRoot];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        const keys = Array.isArray(current.source)
+            ? Array.from({ length: current.source.length }, (_, index) => String(index))
+            : Object.keys(current.source);
+        for (const key of keys) {
+            const child = current.source[key];
+            if (child == null || typeof child !== 'object') {
+                setOwnValue(current.target, key, child);
+                continue;
+            }
+            const existing = clones.get(child);
+            if (existing !== undefined) {
+                setOwnValue(current.target, key, existing);
+                continue;
+            }
+            const childClone = (Array.isArray(child) ? [] : {});
+            clones.set(child, childClone);
+            created.push(childClone);
+            setOwnValue(current.target, key, childClone);
+            pending.push({
+                source: child,
+                target: childClone,
+            });
+        }
+    }
+    for (let index = created.length - 1; index >= 0; index -= 1) {
+        Object.freeze(created[index]);
+    }
+    return cloneRoot;
+}
+function cloneAndFreezeDocumentDescriptor(descriptor) {
+    return Object.freeze({
+        schema: cloneAndFreezeDescriptorValue(descriptor.schema),
+        documentNodeName: descriptor.documentNodeName,
+        emptyDocument: cloneAndFreezeDescriptorValue(descriptor.emptyDocument),
+    });
+}
+function buildV2CreateRequest(config) {
+    let normalized;
+    try {
+        normalized = buildV2CreateRequestUnchecked(config);
+    }
+    catch (error) {
+        const message = error instanceof NativeEditorCreateValidation_1.NativeEditorCreateConfigError
+            ? error.message
+            : 'NativeEditorBridge: invalid v2 create config';
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)(message);
+    }
+    (0, NativeEditorCreateValidation_1.validateV2CreateLimits)(normalized.limits);
+    const documentDescriptor = cloneAndFreezeDocumentDescriptor((0, schemas_1.resolveDocumentDescriptor)(normalized.envelope.schema, normalized.limits?.resource));
+    try {
+        const configJson = (0, NativeEditorCreateJson_1.serializeV2CreateEnvelope)(normalized.envelope);
+        return { configJson, snapshotState: normalized.snapshotState, documentDescriptor };
+    }
+    catch {
+        throw (0, NativeEditorResultNormalization_1.invalidV2RequestError)('NativeEditorBridge: invalid v2 create config');
+    }
+}

package/dist/NativeEditorCreateJson.d.ts

@@ -0,0 +1,76 @@
+export declare function invalidV2JsonValue(label: string): never;
+export interface V2JsonNormalizationTraversal {
+    readonly seen: WeakSet<object>;
+    work: number;
+}
+export interface V2JsonNormalizationBudget {
+    bytes: number;
+}
+export type V2JsonNormalizationTarget = Record<string, unknown> | unknown[] | null;
+export interface V2JsonNormalizationValueFrame {
+    readonly type: 'value';
+    readonly value: unknown;
+    readonly depth: number;
+    readonly target: V2JsonNormalizationTarget;
+    readonly key: string | number | null;
+}
+export interface V2JsonNormalizationArrayFrame {
+    readonly type: 'array';
+    readonly value: unknown[];
+    readonly normalized: unknown[];
+    readonly keys: readonly PropertyKey[];
+    readonly length: number;
+    readonly depth: number;
+    readonly nextKeyIndex: number;
+    readonly elementCount: number;
+}
+export interface V2JsonNormalizationObjectFrame {
+    readonly type: 'object';
+    readonly value: Record<string, unknown>;
+    readonly normalized: Record<string, unknown>;
+    readonly keys: readonly PropertyKey[];
+    readonly depth: number;
+    readonly nextKeyIndex: number;
+    readonly fieldCount: number;
+}
+export type V2JsonNormalizationFrame = V2JsonNormalizationValueFrame | V2JsonNormalizationArrayFrame | V2JsonNormalizationObjectFrame;
+export interface V2JsonSerializationState {
+    bytes: number;
+    work: number;
+}
+export interface V2JsonSerializationValueFrame {
+    readonly type: 'value';
+    readonly value: unknown;
+    readonly depth: number;
+}
+export interface V2JsonSerializationArrayFrame {
+    readonly type: 'array';
+    readonly value: unknown[];
+    readonly length: number;
+    readonly depth: number;
+    readonly index: number;
+}
+export interface V2JsonSerializationObjectFrame {
+    readonly type: 'object';
+    readonly value: Record<string, unknown>;
+    readonly keys: readonly string[];
+    readonly depth: number;
+    readonly index: number;
+}
+export type V2JsonSerializationFrame = V2JsonSerializationValueFrame | V2JsonSerializationArrayFrame | V2JsonSerializationObjectFrame;
+export declare function chargeV2JsonWork(state: V2JsonNormalizationTraversal, label: string): void;
+export declare function chargeV2JsonBytes(budget: V2JsonNormalizationBudget, amount: number, label: string): void;
+export declare function chargeV2JsonSerializationWork(state: V2JsonSerializationState, label: string): void;
+export declare function chargeV2JsonSerializationBytes(state: V2JsonSerializationState, amount: number, label: string): void;
+export declare function utf8V2JsonByteLength(value: string): number;
+export declare function serializeV2JsonNumber(value: number, label: string): string;
+export declare function chargeV2JsonStringBytes(value: string, budget: V2JsonNormalizationBudget, label: string): void;
+export declare function normalizeV2JsonValue(value: unknown, label: string, traversal: V2JsonNormalizationTraversal, budget?: V2JsonNormalizationBudget): unknown;
+export declare class V2JsonSerializationWriter {
+    private readonly _chunks;
+    private _current;
+    append(value: string, state: V2JsonSerializationState, label: string): void;
+    finish(): string;
+}
+export declare function appendV2JsonString(writer: V2JsonSerializationWriter, value: string, state: V2JsonSerializationState, label: string): void;
+export declare function serializeV2CreateEnvelope(value: Record<string, unknown>): string;