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

package/dist/ExternalTextComposition.d.ts

@@ -0,0 +1,45 @@
+import { NativeEditorLifecycleError, type NativeEditorErrorBase } from './NativeEditorBoundaryError';
+export type ExternalTextCompositionEndCause = 'consumer' | 'interaction' | 'documentChange' | 'lifecycle';
+export interface ExternalTextCompositionEndEvent {
+    outcome: 'committed' | 'cancelled';
+    cause: ExternalTextCompositionEndCause;
+    text: string;
+    error?: NativeEditorErrorBase;
+}
+export interface ExternalTextCompositionOptions {
+    onEnd?: (event: ExternalTextCompositionEndEvent) => void;
+}
+export interface ExternalTextCompositionSession {
+    update(text: string): Promise<void>;
+    commit(finalText: string): Promise<void>;
+    cancel(): Promise<void>;
+}
+export interface NativeExternalTextCompositionHandle {
+    beginExternalTextComposition?(sessionId: string): Promise<string> | string;
+    updateExternalTextComposition?(sessionId: string, text: string): Promise<string> | string;
+    commitExternalTextComposition?(sessionId: string, text: string): Promise<string> | string;
+    cancelExternalTextComposition?(sessionId: string, cause: 'consumer' | 'documentChange' | 'lifecycle'): Promise<string> | string;
+}
+export declare function createExternalCompositionLifecycleError(code: string, message: string): NativeEditorLifecycleError;
+export declare class ExternalTextCompositionManager {
+    private readonly editorId;
+    private readonly getNativeHandle;
+    private active;
+    private pendingBegin;
+    private pendingEnd;
+    private disposed;
+    private beginTail;
+    private readonly sessionHost;
+    constructor(editorId: string, getNativeHandle: () => NativeExternalTextCompositionHandle | null);
+    supports(): boolean;
+    begin(options?: ExternalTextCompositionOptions): Promise<ExternalTextCompositionSession>;
+    handleNativeEnd(editorId: string, resultJson: string): void;
+    cancelForDocumentChange(): Promise<void>;
+    dispose(): void;
+    private unsupportedError;
+    private invokeBegin;
+    private invokeUpdate;
+    private invokeCommit;
+    private invokeCancel;
+    private beginSerialized;
+}

package/dist/ExternalTextComposition.js

@@ -0,0 +1,537 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalTextCompositionManager = void 0;
+exports.createExternalCompositionLifecycleError = createExternalCompositionLifecycleError;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+let nextExternalCompositionId = 1n;
+function allocateExternalCompositionId() {
+    const id = nextExternalCompositionId.toString(10);
+    nextExternalCompositionId += 1n;
+    return id;
+}
+function createExternalCompositionLifecycleError(code, message) {
+    return new NativeEditorBoundaryError_1.NativeEditorLifecycleError({
+        domain: 'lifecycle',
+        code,
+        message,
+        requestId: null,
+        operationIndex: null,
+        limit: null,
+        actual: null,
+        details: null,
+    });
+}
+function invalidResultError() {
+    return new NativeEditorBoundaryError_1.NativeEditorNonRetryableError({
+        domain: 'boundary',
+        code: 'EXTERNAL_COMPOSITION_RESULT_INVALID',
+        message: 'Native external text composition returned an invalid result',
+        requestId: null,
+        operationIndex: null,
+        limit: null,
+        actual: null,
+        details: null,
+    });
+}
+function endedLifecycleError() {
+    return createExternalCompositionLifecycleError('EXTERNAL_COMPOSITION_ENDED', 'The external text composition session has ended');
+}
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value);
+    return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+const ERROR_KEYS = [
+    'domain',
+    'code',
+    'message',
+    'requestId',
+    'operationIndex',
+    'limit',
+    'actual',
+    'details',
+];
+function parseError(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ERROR_KEYS))
+        return null;
+    return (0, NativeEditorBoundaryError_1.normalizeNativeEditorV2Error)({ error: value });
+}
+function parseNativeCompositionResult(resultJson) {
+    let value;
+    try {
+        value = JSON.parse(resultJson);
+    }
+    catch {
+        throw invalidResultError();
+    }
+    if (!isRecord(value) || value.version !== 1 || typeof value.type !== 'string') {
+        throw invalidResultError();
+    }
+    if (value.type === 'active') {
+        if (!hasExactKeys(value, ['version', 'type', 'sessionId']) ||
+            typeof value.sessionId !== 'string') {
+            throw invalidResultError();
+        }
+        return { version: 1, type: 'active', sessionId: value.sessionId };
+    }
+    if (value.type === 'ended') {
+        const keys = Object.prototype.hasOwnProperty.call(value, 'error')
+            ? ['version', 'type', 'sessionId', 'outcome', 'cause', 'text', 'error']
+            : ['version', 'type', 'sessionId', 'outcome', 'cause', 'text'];
+        const validOutcome = value.outcome === 'committed' || value.outcome === 'cancelled';
+        const validCause = value.cause === 'consumer' ||
+            value.cause === 'interaction' ||
+            value.cause === 'documentChange' ||
+            value.cause === 'lifecycle';
+        const error = keys.includes('error') ? parseError(value.error) : undefined;
+        if (!hasExactKeys(value, keys) ||
+            typeof value.sessionId !== 'string' ||
+            !validOutcome ||
+            !validCause ||
+            typeof value.text !== 'string' ||
+            (keys.includes('error') && error == null)) {
+            throw invalidResultError();
+        }
+        return {
+            version: 1,
+            type: 'ended',
+            sessionId: value.sessionId,
+            outcome: value.outcome,
+            cause: value.cause,
+            text: value.text,
+            ...(error == null ? {} : { error }),
+        };
+    }
+    if (value.type === 'error') {
+        const error = parseError(value.error);
+        if (!hasExactKeys(value, ['version', 'type', 'sessionId', 'error']) ||
+            (value.sessionId !== null && typeof value.sessionId !== 'string') ||
+            error == null) {
+            throw invalidResultError();
+        }
+        return { version: 1, type: 'error', sessionId: value.sessionId, error };
+    }
+    throw invalidResultError();
+}
+function requireActiveResult(result, sessionId) {
+    if (result.type === 'error') {
+        if (result.sessionId !== null && result.sessionId !== sessionId) {
+            throw invalidResultError();
+        }
+        throw (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(result.error);
+    }
+    if (result.type !== 'active' || result.sessionId !== sessionId) {
+        throw invalidResultError();
+    }
+}
+function requireEndResult(result, sessionId) {
+    if (result.type === 'error') {
+        if (result.sessionId !== null && result.sessionId !== sessionId) {
+            throw invalidResultError();
+        }
+        throw (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(result.error);
+    }
+    if (result.type !== 'ended' || result.sessionId !== sessionId) {
+        throw invalidResultError();
+    }
+    return result;
+}
+function settleWaiters(waiters, error) {
+    for (const waiter of waiters) {
+        if (error === undefined)
+            waiter.resolve();
+        else
+            waiter.reject(error);
+    }
+}
+class ManagedExternalTextCompositionSession {
+    constructor(id, host, options) {
+        this.id = id;
+        this.host = host;
+        this.options = options;
+        this.latestText = '';
+        this.terminal = false;
+        this.terminalResult = null;
+        this.terminalError = null;
+        this.terminalCompletion = new Promise((resolve) => {
+            this.resolveTerminal = resolve;
+        });
+        this.closing = null;
+        this.updateInFlight = null;
+        this.inFlightWaiters = [];
+        this.pendingUpdate = null;
+        this.cancelPromise = null;
+    }
+    update(text) {
+        if (!this.canMutate())
+            return Promise.reject(endedLifecycleError());
+        this.latestText = text;
+        return new Promise((resolve, reject) => {
+            const waiter = { resolve, reject };
+            if (this.updateInFlight != null) {
+                if (this.pendingUpdate == null) {
+                    this.pendingUpdate = { text, waiters: [waiter] };
+                }
+                else {
+                    this.pendingUpdate.text = text;
+                    this.pendingUpdate.waiters.push(waiter);
+                }
+                return;
+            }
+            this.startUpdate(text, [waiter]);
+        });
+    }
+    async commit(finalText) {
+        if (!this.canMutate())
+            throw endedLifecycleError();
+        this.closing = 'commit';
+        this.latestText = finalText;
+        if (this.updateInFlight != null) {
+            const update = await this.raceWithTerminal(this.updateInFlight);
+            if (update.type === 'terminal') {
+                this.requireSuccessfulConsumerCommit(update.result, finalText);
+                return;
+            }
+            if (update.type === 'failed')
+                throw update.error;
+        }
+        if (this.terminalResult != null) {
+            this.requireSuccessfulConsumerCommit(this.terminalResult, finalText);
+            return;
+        }
+        if (!this.canFinish())
+            throw endedLifecycleError();
+        const foldedWaiters = this.takePendingWaiters();
+        const commit = await this.raceWithTerminal(this.host.commit(this.id, finalText));
+        if (commit.type === 'terminal') {
+            const error = this.explicitCommitError(commit.result, finalText);
+            settleWaiters(foldedWaiters, error);
+            if (error)
+                throw error;
+            return;
+        }
+        if (commit.type === 'failed') {
+            settleWaiters(foldedWaiters, commit.error);
+            if (!this.terminal && this.host.owns(this))
+                this.closing = null;
+            throw commit.error;
+        }
+        try {
+            this.requireOwnership();
+            const endResult = requireEndResult(commit.value, this.id);
+            const endError = this.explicitCommitError(endResult, finalText);
+            this.finish(endResult);
+            settleWaiters(foldedWaiters, endError);
+            if (endError)
+                throw endError;
+        }
+        catch (error) {
+            settleWaiters(foldedWaiters, error);
+            if (!this.terminal && this.host.owns(this))
+                this.closing = null;
+            throw error;
+        }
+    }
+    cancel() {
+        if (this.terminal)
+            return Promise.resolve();
+        if (this.cancelPromise != null)
+            return this.cancelPromise;
+        if (!this.canMutate())
+            return Promise.reject(endedLifecycleError());
+        this.cancelPromise = this.cancelWithCause('consumer');
+        return this.cancelPromise;
+    }
+    cancelForDocumentChange() {
+        if (this.terminal)
+            return Promise.resolve();
+        if (this.cancelPromise != null)
+            return this.cancelPromise;
+        if (!this.canMutate())
+            return Promise.reject(endedLifecycleError());
+        this.cancelPromise = this.cancelWithCause('documentChange');
+        return this.cancelPromise;
+    }
+    finish(result) {
+        if (this.terminal)
+            return;
+        this.terminal = true;
+        this.terminalResult = result;
+        const error = result.error
+            ? (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(result.error)
+            : endedLifecycleError();
+        this.terminalError = error;
+        const waiterError = this.closing === 'commit' && this.explicitCommitError(result, this.latestText) == null
+            ? undefined
+            : error;
+        settleWaiters(this.inFlightWaiters, waiterError);
+        this.inFlightWaiters = [];
+        if (this.pendingUpdate != null) {
+            settleWaiters(this.pendingUpdate.waiters, waiterError);
+            this.pendingUpdate = null;
+        }
+        this.host.release(this);
+        this.resolveTerminal(result);
+        this.options.onEnd?.({
+            outcome: result.outcome,
+            cause: result.cause,
+            text: result.text,
+            ...(result.error == null ? {} : { error }),
+        });
+    }
+    canMutate() {
+        return !this.terminal && this.closing == null && this.host.owns(this);
+    }
+    canFinish() {
+        return !this.terminal && this.closing != null && this.host.owns(this);
+    }
+    startUpdate(text, waiters) {
+        this.inFlightWaiters = waiters;
+        this.updateInFlight = this.performUpdate(text, waiters);
+    }
+    async performUpdate(text, waiters) {
+        try {
+            const result = await this.host.update(this.id, text);
+            this.requireOwnership();
+            requireActiveResult(result, this.id);
+            settleWaiters(waiters);
+        }
+        catch (error) {
+            settleWaiters(waiters, error);
+        }
+        finally {
+            if (this.inFlightWaiters === waiters)
+                this.inFlightWaiters = [];
+            this.updateInFlight = null;
+            if (!this.terminal && this.closing == null && this.pendingUpdate != null) {
+                const pending = this.pendingUpdate;
+                this.pendingUpdate = null;
+                this.startUpdate(pending.text, pending.waiters);
+            }
+        }
+    }
+    takePendingWaiters() {
+        const waiters = this.pendingUpdate?.waiters ?? [];
+        this.pendingUpdate = null;
+        return waiters;
+    }
+    requireOwnership() {
+        if (!this.host.owns(this))
+            throw endedLifecycleError();
+    }
+    raceWithTerminal(work) {
+        return Promise.race([
+            work.then((value) => ({ type: 'completed', value }), (error) => ({ type: 'failed', error })),
+            this.terminalCompletion.then((result) => ({
+                type: 'terminal',
+                result,
+            })),
+        ]);
+    }
+    explicitCommitError(result, finalText) {
+        if (result.outcome === 'committed' &&
+            result.cause === 'consumer' &&
+            result.text === finalText &&
+            result.error == null) {
+            return undefined;
+        }
+        return result.error ? (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(result.error) : endedLifecycleError();
+    }
+    requireSuccessfulConsumerCommit(result, finalText) {
+        const error = this.explicitCommitError(result, finalText);
+        if (error)
+            throw error;
+    }
+    settleTerminalWaiters(waiters) {
+        settleWaiters(waiters, this.terminalError ?? endedLifecycleError());
+    }
+    async cancelWithCause(cause) {
+        this.closing = 'cancel';
+        if (this.updateInFlight != null) {
+            const update = await this.raceWithTerminal(this.updateInFlight);
+            if (update.type === 'terminal')
+                return;
+            if (update.type === 'failed')
+                throw update.error;
+        }
+        if (!this.canFinish())
+            return;
+        const pendingWaiters = this.takePendingWaiters();
+        const cancellation = await this.raceWithTerminal(this.host.cancel(this.id, cause));
+        if (cancellation.type === 'terminal') {
+            this.settleTerminalWaiters(pendingWaiters);
+            return;
+        }
+        if (cancellation.type === 'failed') {
+            settleWaiters(pendingWaiters, cancellation.error);
+            if (this.host.owns(this)) {
+                this.closing = null;
+                this.cancelPromise = null;
+            }
+            throw cancellation.error;
+        }
+        try {
+            this.requireOwnership();
+            const endResult = requireEndResult(cancellation.value, this.id);
+            const endError = endResult.error
+                ? (0, NativeEditorBoundaryError_1.nativeEditorV2ErrorToException)(endResult.error)
+                : undefined;
+            this.finish(endResult);
+            settleWaiters(pendingWaiters, endError);
+            if (endError)
+                throw endError;
+        }
+        catch (error) {
+            settleWaiters(pendingWaiters, error);
+            if (!this.terminal && this.host.owns(this)) {
+                this.closing = null;
+                this.cancelPromise = null;
+            }
+            throw error;
+        }
+    }
+}
+class ExternalTextCompositionManager {
+    constructor(editorId, getNativeHandle) {
+        this.editorId = editorId;
+        this.getNativeHandle = getNativeHandle;
+        this.active = null;
+        this.pendingBegin = null;
+        this.pendingEnd = null;
+        this.disposed = false;
+        this.beginTail = Promise.resolve();
+        this.sessionHost = {
+            owns: (session) => !this.disposed && this.active === session,
+            release: (session) => {
+                if (this.active === session)
+                    this.active = null;
+            },
+            update: (sessionId, text) => this.invokeUpdate(sessionId, text),
+            commit: (sessionId, text) => this.invokeCommit(sessionId, text),
+            cancel: (sessionId, cause) => this.invokeCancel(sessionId, cause),
+        };
+    }
+    supports() {
+        const handle = this.getNativeHandle();
+        return (typeof handle?.beginExternalTextComposition === 'function' &&
+            typeof handle.updateExternalTextComposition === 'function' &&
+            typeof handle.commitExternalTextComposition === 'function' &&
+            typeof handle.cancelExternalTextComposition === 'function');
+    }
+    begin(options = {}) {
+        const pending = this.beginTail.then(() => this.beginSerialized(options));
+        this.beginTail = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
+    handleNativeEnd(editorId, resultJson) {
+        if (editorId !== this.editorId)
+            return;
+        const result = parseNativeCompositionResult(resultJson);
+        if (result.type !== 'ended')
+            return;
+        if (result.sessionId === this.active?.id) {
+            this.active.finish(result);
+            return;
+        }
+        if (result.sessionId === this.pendingBegin?.id && this.pendingEnd == null) {
+            this.pendingEnd = result;
+            this.pendingBegin.finish(result);
+        }
+    }
+    cancelForDocumentChange() {
+        return this.active?.cancelForDocumentChange() ?? Promise.resolve();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        const active = this.active;
+        if (!active)
+            return;
+        active.finish({
+            version: 1,
+            type: 'ended',
+            sessionId: active.id,
+            outcome: 'cancelled',
+            cause: 'lifecycle',
+            text: active.latestText,
+        });
+        void this.invokeCancel(active.id, 'lifecycle').catch(() => undefined);
+    }
+    unsupportedError() {
+        return createExternalCompositionLifecycleError('EXTERNAL_COMPOSITION_UNSUPPORTED', 'The mounted native editor does not support external text composition');
+    }
+    async invokeBegin(sessionId) {
+        const handle = this.getNativeHandle();
+        const method = handle?.beginExternalTextComposition;
+        if (typeof method !== 'function') {
+            throw this.unsupportedError();
+        }
+        const resultJson = await method.call(handle, sessionId);
+        return parseNativeCompositionResult(resultJson);
+    }
+    async invokeUpdate(sessionId, text) {
+        const handle = this.getNativeHandle();
+        const method = handle?.updateExternalTextComposition;
+        if (typeof method !== 'function') {
+            throw this.unsupportedError();
+        }
+        const resultJson = await method.call(handle, sessionId, text);
+        return parseNativeCompositionResult(resultJson);
+    }
+    async invokeCommit(sessionId, text) {
+        const handle = this.getNativeHandle();
+        const method = handle?.commitExternalTextComposition;
+        if (typeof method !== 'function') {
+            throw this.unsupportedError();
+        }
+        const resultJson = await method.call(handle, sessionId, text);
+        return parseNativeCompositionResult(resultJson);
+    }
+    async invokeCancel(sessionId, cause) {
+        const handle = this.getNativeHandle();
+        const method = handle?.cancelExternalTextComposition;
+        if (typeof method !== 'function') {
+            throw this.unsupportedError();
+        }
+        const resultJson = await method.call(handle, sessionId, cause);
+        return parseNativeCompositionResult(resultJson);
+    }
+    async beginSerialized(options) {
+        if (this.disposed)
+            throw endedLifecycleError();
+        if (!this.supports()) {
+            throw this.unsupportedError();
+        }
+        if (this.active)
+            await this.active.commit(this.active.latestText);
+        if (this.disposed)
+            throw endedLifecycleError();
+        const session = new ManagedExternalTextCompositionSession(allocateExternalCompositionId(), this.sessionHost, options);
+        this.pendingBegin = session;
+        this.pendingEnd = null;
+        try {
+            const result = await this.invokeBegin(session.id);
+            if (this.disposed) {
+                void this.invokeCancel(session.id, 'lifecycle').catch(() => undefined);
+                throw endedLifecycleError();
+            }
+            if (this.pendingBegin !== session)
+                throw endedLifecycleError();
+            requireActiveResult(result, session.id);
+            if (this.pendingEnd != null)
+                throw endedLifecycleError();
+            this.active = session;
+            return session;
+        }
+        finally {
+            if (this.pendingBegin === session) {
+                this.pendingBegin = null;
+                this.pendingEnd = null;
+            }
+        }
+    }
+}
+exports.ExternalTextCompositionManager = ExternalTextCompositionManager;

package/dist/ImageLoadingPolicy.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Bounds on the native image pipeline that fetches and decodes remote and
+ * data-URL images. Set it on `RichTextEditor.imageLoadingPolicy` or
+ * `RichTextViewer.imageLoadingPolicy`.
+ *
+ * Every field is optional; an omitted one uses
+ * {@link DEFAULT_EDITOR_IMAGE_LOADING_POLICY}. Each value must be a positive
+ * integer no greater than the matching
+ * {@link HARD_EDITOR_IMAGE_LOADING_POLICY} ceiling — anything else throws
+ * `NativeEditorBoundaryError` (`IMAGE_POLICY_INVALID`).
+ */
+export interface EditorImageLoadingPolicy {
+    /** Byte ceiling for one image source, applied to remote responses and decoded data-URL payloads alike. */
+    maxSourceBytes?: number;
+    /** Socket connect timeout for a remote image request, in milliseconds. */
+    connectTimeoutMs?: number;
+    /** Socket read timeout for a remote image request, in milliseconds. */
+    readTimeoutMs?: number;
+    /** Overall deadline for one image request, in milliseconds. */
+    requestTimeoutMs?: number;
+    /** Image requests allowed in flight at once. Further requests queue. */
+    maxConcurrentRequests?: number;
+    /** Queued requests allowed while the in-flight slots are full. Requests beyond this are dropped. */
+    maxPendingRequests?: number;
+    /** Ceiling on decoded image width and height, in pixels. Larger images are downsampled. */
+    maxDecodeDimensionPx?: number;
+    /** Decoded pixel bytes this editor or viewer may retain at once. */
+    maxDecodedBytes?: number;
+}
+/** {@link EditorImageLoadingPolicy} with every default filled in. */
+export interface ResolvedEditorImageLoadingPolicy {
+    maxSourceBytes: number;
+    connectTimeoutMs: number;
+    readTimeoutMs: number;
+    requestTimeoutMs: number;
+    maxConcurrentRequests: number;
+    maxPendingRequests: number;
+    maxDecodeDimensionPx: number;
+    maxDecodedBytes: number;
+}
+/** The value used for each {@link EditorImageLoadingPolicy} field left unset. */
+export declare const DEFAULT_EDITOR_IMAGE_LOADING_POLICY: Readonly<ResolvedEditorImageLoadingPolicy>;
+/** The ceiling each {@link EditorImageLoadingPolicy} field may not exceed. */
+export declare const HARD_EDITOR_IMAGE_LOADING_POLICY: Readonly<ResolvedEditorImageLoadingPolicy>;
+/**
+ * Fill in every unset {@link EditorImageLoadingPolicy} field from
+ * {@link DEFAULT_EDITOR_IMAGE_LOADING_POLICY}, validating each value against
+ * {@link HARD_EDITOR_IMAGE_LOADING_POLICY}.
+ *
+ * @throws NativeEditorBoundaryError `IMAGE_POLICY_INVALID` when a value is
+ * not a positive integer within its ceiling.
+ */
+export declare function resolveEditorImageLoadingPolicy(policy?: EditorImageLoadingPolicy): ResolvedEditorImageLoadingPolicy;
+export declare function serializeEditorImageLoadingPolicy(policy?: EditorImageLoadingPolicy): string | undefined;

package/dist/ImageLoadingPolicy.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARD_EDITOR_IMAGE_LOADING_POLICY = exports.DEFAULT_EDITOR_IMAGE_LOADING_POLICY = void 0;
+exports.resolveEditorImageLoadingPolicy = resolveEditorImageLoadingPolicy;
+exports.serializeEditorImageLoadingPolicy = serializeEditorImageLoadingPolicy;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+/** The value used for each {@link EditorImageLoadingPolicy} field left unset. */
+exports.DEFAULT_EDITOR_IMAGE_LOADING_POLICY = {
+    maxSourceBytes: 10 * 1024 * 1024,
+    connectTimeoutMs: 10000,
+    readTimeoutMs: 20000,
+    requestTimeoutMs: 60000,
+    maxConcurrentRequests: 2,
+    maxPendingRequests: 64,
+    maxDecodeDimensionPx: 2048,
+    maxDecodedBytes: 32 * 1024 * 1024,
+};
+/** The ceiling each {@link EditorImageLoadingPolicy} field may not exceed. */
+exports.HARD_EDITOR_IMAGE_LOADING_POLICY = {
+    maxSourceBytes: 64 * 1024 * 1024,
+    connectTimeoutMs: 600000,
+    readTimeoutMs: 600000,
+    requestTimeoutMs: 600000,
+    maxConcurrentRequests: 16,
+    maxPendingRequests: 512,
+    maxDecodeDimensionPx: 8192,
+    maxDecodedBytes: 256 * 1024 * 1024,
+};
+function resolveImagePolicyValue(name, value) {
+    const resolved = value ?? exports.DEFAULT_EDITOR_IMAGE_LOADING_POLICY[name];
+    if (!Number.isSafeInteger(resolved) ||
+        resolved <= 0 ||
+        resolved > exports.HARD_EDITOR_IMAGE_LOADING_POLICY[name]) {
+        throw new NativeEditorBoundaryError_1.NativeEditorBoundaryError('IMAGE_POLICY_INVALID', `${name} must be a positive integer no greater than ${exports.HARD_EDITOR_IMAGE_LOADING_POLICY[name]}`, exports.HARD_EDITOR_IMAGE_LOADING_POLICY[name], resolved);
+    }
+    return resolved;
+}
+/**
+ * Fill in every unset {@link EditorImageLoadingPolicy} field from
+ * {@link DEFAULT_EDITOR_IMAGE_LOADING_POLICY}, validating each value against
+ * {@link HARD_EDITOR_IMAGE_LOADING_POLICY}.
+ *
+ * @throws NativeEditorBoundaryError `IMAGE_POLICY_INVALID` when a value is
+ * not a positive integer within its ceiling.
+ */
+function resolveEditorImageLoadingPolicy(policy) {
+    return {
+        maxSourceBytes: resolveImagePolicyValue('maxSourceBytes', policy?.maxSourceBytes),
+        connectTimeoutMs: resolveImagePolicyValue('connectTimeoutMs', policy?.connectTimeoutMs),
+        readTimeoutMs: resolveImagePolicyValue('readTimeoutMs', policy?.readTimeoutMs),
+        requestTimeoutMs: resolveImagePolicyValue('requestTimeoutMs', policy?.requestTimeoutMs),
+        maxConcurrentRequests: resolveImagePolicyValue('maxConcurrentRequests', policy?.maxConcurrentRequests),
+        maxPendingRequests: resolveImagePolicyValue('maxPendingRequests', policy?.maxPendingRequests),
+        maxDecodeDimensionPx: resolveImagePolicyValue('maxDecodeDimensionPx', policy?.maxDecodeDimensionPx),
+        maxDecodedBytes: resolveImagePolicyValue('maxDecodedBytes', policy?.maxDecodedBytes),
+    };
+}
+function serializeEditorImageLoadingPolicy(policy) {
+    return policy == null ? undefined : JSON.stringify(resolveEditorImageLoadingPolicy(policy));
+}