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

package/dist/schemaPresets.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSchema = exports.defaultSchemaSpec = exports.prosemirrorSchema = exports.prosemirrorSchemaSpec = exports.tiptapCompatibleSchema = exports.tiptapCompatibleSchemaSpec = exports.HEADING_LEVELS = exports.IMAGE_NODE_NAME = void 0;
+exports.imageSchemaNodeSpec = imageSchemaNodeSpec;
+exports.imageNodeSpec = imageNodeSpec;
+exports.withImagesSchema = withImagesSchema;
+exports.buildDocumentFragmentJson = buildDocumentFragmentJson;
+exports.buildImageFragmentJson = buildImageFragmentJson;
+const schemaDefinition_1 = require("./schemaDefinition");
+/** Node name the built-in image node is stored under. */
+exports.IMAGE_NODE_NAME = 'image';
+exports.HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
+/**
+ * The built-in image node spec: a void block node carrying
+ * {@link ImageNodeAttributes}. Add it through {@link withImagesSchema}.
+ *
+ * @param name Node name to declare it under. Defaults to {@link IMAGE_NODE_NAME}.
+ */
+function imageSchemaNodeSpec() {
+    return {
+        group: 'block',
+        attrs: {
+            src: {},
+            alt: { default: null },
+            title: { default: null },
+            width: { default: null },
+            height: { default: null },
+        },
+        role: 'block',
+        parseDOM: [{ tag: 'img' }],
+        toDOM: ['img'],
+        isVoid: true,
+        deletableOnBackspace: false,
+    };
+}
+function imageNodeSpec(name = exports.IMAGE_NODE_NAME) {
+    return (0, schemaDefinition_1.defineSchema)({ nodes: { [name]: imageSchemaNodeSpec() } }).nodes[0];
+}
+/**
+ * Return `schema` with the image node added, or `schema` unchanged when it
+ * already declares one. {@link tiptapCompatibleSchema} already includes it.
+ */
+function withImagesSchema(schema) {
+    const hasImageNode = schema.nodes.some((node) => node.name === exports.IMAGE_NODE_NAME);
+    if (hasImageNode) {
+        return schema;
+    }
+    return {
+        ...schema,
+        nodes: [...schema.nodes, imageNodeSpec()],
+    };
+}
+/**
+ * Wrap inline or block nodes in a document root, producing a fragment ready
+ * for `insertContentJson`.
+ *
+ * @param descriptor Document node name to wrap in. Defaults to `doc`; pass a
+ * {@link ResolvedDocumentSchema} when the schema names its root differently.
+ */
+function buildDocumentFragmentJson(content, descriptor = {
+    documentNodeName: 'doc',
+}) {
+    return { type: descriptor.documentNodeName, content };
+}
+/**
+ * Build a document fragment holding one image node, ready for
+ * `insertContentJson`. `RichTextEditorRef.insertImage` does this for
+ * you; use this when assembling a larger insertion by hand.
+ */
+function buildImageFragmentJson(attrs, descriptor) {
+    return buildDocumentFragmentJson([
+        {
+            type: exports.IMAGE_NODE_NAME,
+            attrs,
+        },
+    ], descriptor);
+}
+/**
+ * Keyed authoring definition for the Tiptap-compatible camelCase schema.
+ */
+exports.tiptapCompatibleSchemaSpec = {
+    nodes: {
+        doc: { content: 'block+', role: 'doc' },
+        paragraph: {
+            content: 'inline*',
+            group: 'block',
+            role: 'textBlock',
+            parseDOM: [{ tag: 'p' }],
+            toDOM: ['p', 0],
+        },
+        heading: {
+            content: 'inline*',
+            group: 'block',
+            role: 'heading',
+            attrs: { level: { default: 1 } },
+            parseDOM: exports.HEADING_LEVELS.map((level) => ({
+                tag: `h${level}`,
+                attrs: { level },
+            })),
+            toDOM: {
+                switchOn: 'level',
+                cases: Object.fromEntries(exports.HEADING_LEVELS.map((level) => [level, [`h${level}`, 0]])),
+            },
+        },
+        blockquote: {
+            content: 'block+',
+            group: 'block',
+            role: 'block',
+            parseDOM: [{ tag: 'blockquote' }],
+            toDOM: ['blockquote', 0],
+        },
+        codeBlock: {
+            attrs: { language: { default: null } },
+            content: 'text*',
+            group: 'block',
+            role: 'textBlock',
+            parseDOM: [{ tag: 'pre' }],
+            toDOM: ['pre', 0],
+        },
+        bulletList: {
+            content: 'listItem+',
+            group: 'block',
+            role: 'list',
+            parseDOM: [{ tag: 'ul' }],
+            toDOM: ['ul', 0],
+        },
+        orderedList: {
+            content: 'listItem+',
+            group: 'block',
+            attrs: { start: { default: 1 } },
+            role: 'list',
+            parseDOM: [{ tag: 'ol' }],
+            toDOM: ['ol', 0],
+        },
+        listItem: {
+            content: 'paragraph block*',
+            role: 'listItem',
+            parseDOM: [{ tag: 'li' }],
+            toDOM: ['li', 0],
+        },
+        hardBreak: {
+            group: 'inline',
+            role: 'hardBreak',
+            parseDOM: [{ tag: 'br' }],
+            toDOM: ['br'],
+            isVoid: true,
+        },
+        horizontalRule: {
+            group: 'block',
+            role: 'block',
+            parseDOM: [{ tag: 'hr' }],
+            toDOM: ['hr'],
+            isVoid: true,
+        },
+        [exports.IMAGE_NODE_NAME]: imageSchemaNodeSpec(),
+        text: { group: 'inline', role: 'text' },
+    },
+    marks: {
+        bold: { parseDOM: [{ tag: 'strong' }], toDOM: ['strong', 0] },
+        italic: { parseDOM: [{ tag: 'em' }], toDOM: ['em', 0] },
+        underline: { parseDOM: [{ tag: 'u' }], toDOM: ['u', 0] },
+        strike: { parseDOM: [{ tag: 's' }], toDOM: ['s', 0] },
+        code: { parseDOM: [{ tag: 'code' }], toDOM: ['code', 0] },
+        link: { attrs: { href: {} }, parseDOM: [{ tag: 'a' }], toDOM: ['a', 0] },
+    },
+};
+/** Tiptap-compatible serializable schema using camelCase node names. */
+exports.tiptapCompatibleSchema = (0, schemaDefinition_1.defineSchema)(exports.tiptapCompatibleSchemaSpec);
+/** Keyed authoring definition using ProseMirror names, including upstream `codeBlock`. */
+exports.prosemirrorSchemaSpec = {
+    nodes: {
+        doc: exports.tiptapCompatibleSchemaSpec.nodes.doc,
+        paragraph: exports.tiptapCompatibleSchemaSpec.nodes.paragraph,
+        heading: exports.tiptapCompatibleSchemaSpec.nodes.heading,
+        blockquote: exports.tiptapCompatibleSchemaSpec.nodes.blockquote,
+        codeBlock: exports.tiptapCompatibleSchemaSpec.nodes.codeBlock,
+        bullet_list: {
+            ...exports.tiptapCompatibleSchemaSpec.nodes.bulletList,
+            content: 'list_item+',
+        },
+        ordered_list: {
+            ...exports.tiptapCompatibleSchemaSpec.nodes.orderedList,
+            content: 'list_item+',
+        },
+        list_item: exports.tiptapCompatibleSchemaSpec.nodes.listItem,
+        hard_break: exports.tiptapCompatibleSchemaSpec.nodes.hardBreak,
+        horizontal_rule: exports.tiptapCompatibleSchemaSpec.nodes.horizontalRule,
+        [exports.IMAGE_NODE_NAME]: exports.tiptapCompatibleSchemaSpec.nodes[exports.IMAGE_NODE_NAME],
+        text: exports.tiptapCompatibleSchemaSpec.nodes.text,
+    },
+    marks: exports.tiptapCompatibleSchemaSpec.marks,
+};
+/** ProseMirror-compatible serializable schema, including upstream `codeBlock`. */
+exports.prosemirrorSchema = (0, schemaDefinition_1.defineSchema)(exports.prosemirrorSchemaSpec);
+/** Keyed authoring definition used when callers do not provide a schema. */
+exports.defaultSchemaSpec = exports.prosemirrorSchemaSpec;
+/** Schema used when callers do not provide one. */
+exports.defaultSchema = exports.prosemirrorSchema;

package/dist/schemaResolution.d.ts

@@ -0,0 +1,9 @@
+import { type ResolvedEditorResourceLimits } from './ResourceLimits';
+import { type DocumentDescriptorLimits } from './schemaPresets';
+import { type SchemaWorkBudget, type AdmittedSchemaCollections } from './schemaNormalization';
+import { type SchemaDefinition } from './schemaDefinition';
+export declare function resolveDescriptorLimits(limits?: DocumentDescriptorLimits): ResolvedEditorResourceLimits;
+export declare function createSchemaWorkBudget(limits: ResolvedEditorResourceLimits): SchemaWorkBudget;
+export declare function admitSchemaCollections(schema: SchemaDefinition, budget: SchemaWorkBudget): AdmittedSchemaCollections | null;
+/** Mirror native's invalid-schema fallback after bounded admission succeeds. */
+export declare function resolveDocumentSchema(schema?: SchemaDefinition, limits?: DocumentDescriptorLimits): SchemaDefinition;

package/dist/schemaResolution.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDescriptorLimits = resolveDescriptorLimits;
+exports.createSchemaWorkBudget = createSchemaWorkBudget;
+exports.admitSchemaCollections = admitSchemaCollections;
+exports.resolveDocumentSchema = resolveDocumentSchema;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+const ResourceLimits_1 = require("./ResourceLimits");
+const contentExpression_1 = require("./contentExpression");
+const schemaPresets_1 = require("./schemaPresets");
+const schemaNormalization_1 = require("./schemaNormalization");
+const schemaDocumentConstruction_1 = require("./schemaDocumentConstruction");
+function resolveDescriptorLimits(limits) {
+    return (0, ResourceLimits_1.resolveEditorResourceLimits)(limits);
+}
+function createSchemaWorkBudget(limits) {
+    return {
+        limit: limits.maxSchemaNodes * 64 + limits.maxSchemaExpressionBytes * 32,
+        work: 0,
+        exhausted: false,
+    };
+}
+function admitSchemaCollections(schema, budget) {
+    const groupsByNode = new Map();
+    const attrsByNode = new Map();
+    for (let nodeIndex = 0; nodeIndex < schema.nodes.length; nodeIndex += 1) {
+        const node = schema.nodes[nodeIndex];
+        if (node == null || typeof node !== 'object')
+            return null;
+        const groups = [];
+        if (typeof node.group === 'string') {
+            if (!(0, schemaNormalization_1.forEachGroupToken)(node.group, (group) => groups.push(group), () => (0, schemaNormalization_1.consumeSchemaWork)(budget), () => (0, schemaNormalization_1.consumeSchemaWork)(budget))) {
+                throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
+            }
+        }
+        const attrs = (0, schemaNormalization_1.collectOwnAttrs)(node.attrs, budget);
+        if (attrs == null)
+            return null;
+        const projectionAttrs = (0, schemaNormalization_1.collectOwnAttrs)(node.json?.attrs, budget);
+        if (projectionAttrs == null)
+            return null;
+        if (node.json != null &&
+            ((typeof node.json.type === 'string' &&
+                !(0, schemaNormalization_1.consumeSchemaStringWork)(budget, node.json.type)) ||
+                projectionAttrs.some(([name, rawValue]) => {
+                    const value = rawValue;
+                    return (!(0, schemaNormalization_1.consumeSchemaStringWork)(budget, name) ||
+                        (typeof value === 'string'
+                            ? !(0, schemaNormalization_1.consumeSchemaStringWork)(budget, value)
+                            : !(0, schemaNormalization_1.consumeSchemaWork)(budget)));
+                }))) {
+            throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
+        }
+        if (budget.exhausted) {
+            throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
+        }
+        groupsByNode.set(node, groups);
+        attrsByNode.set(node, attrs);
+    }
+    for (let markIndex = 0; markIndex < schema.marks.length; markIndex += 1) {
+        const mark = schema.marks[markIndex];
+        if (!(0, schemaNormalization_1.consumeSchemaWork)(budget)) {
+            throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
+        }
+        if (mark == null || typeof mark !== 'object')
+            return null;
+        const attrs = (0, schemaNormalization_1.collectOwnAttrs)(mark.attrs, budget);
+        if (attrs == null)
+            return null;
+        if (budget.exhausted) {
+            throw (0, schemaNormalization_1.schemaBoundaryError)(budget.limit, budget.limit + 1);
+        }
+    }
+    return { groupsByNode, attrsByNode };
+}
+/** Mirror native's invalid-schema fallback after bounded admission succeeds. */
+function resolveDocumentSchema(schema, limits) {
+    if (schema == null)
+        return schemaPresets_1.defaultSchema;
+    if (!Array.isArray(schema.nodes))
+        return schemaPresets_1.defaultSchema;
+    if (!Array.isArray(schema.marks)) {
+        schema = { ...schema, marks: [] };
+    }
+    const resolvedLimits = resolveDescriptorLimits(limits);
+    if (schema.nodes.length > resolvedLimits.maxSchemaNodes) {
+        throw (0, schemaNormalization_1.schemaBoundaryError)(resolvedLimits.maxSchemaNodes, schema.nodes.length);
+    }
+    let expressionBytes = 0;
+    for (let nodeIndex = 0; nodeIndex < schema.nodes.length; nodeIndex += 1) {
+        const node = schema.nodes[nodeIndex];
+        if (node != null && typeof node.content === 'string') {
+            expressionBytes += (0, schemaNormalization_1.utf8ByteLengthUpTo)(node.content, resolvedLimits.maxSchemaExpressionBytes - expressionBytes);
+            if (expressionBytes > resolvedLimits.maxSchemaExpressionBytes) {
+                throw (0, schemaNormalization_1.schemaBoundaryError)(resolvedLimits.maxSchemaExpressionBytes, expressionBytes);
+            }
+        }
+    }
+    const schemaBudget = createSchemaWorkBudget(resolvedLimits);
+    if (admitSchemaCollections(schema, schemaBudget) == null)
+        return schemaPresets_1.defaultSchema;
+    const normalizedSchema = (0, schemaNormalization_1.normalizeSchemaDefinition)(schema, schemaBudget);
+    if (normalizedSchema == null)
+        return schemaPresets_1.defaultSchema;
+    schema = normalizedSchema;
+    const admittedCollections = admitSchemaCollections(schema, {
+        limit: Number.MAX_SAFE_INTEGER,
+        work: 0,
+        exhausted: false,
+    });
+    if (admittedCollections == null)
+        return schemaPresets_1.defaultSchema;
+    const nodeNames = new Set();
+    const markNames = new Set();
+    let docRoles = 0;
+    let textRoles = 0;
+    for (const node of schema.nodes) {
+        if (node == null ||
+            typeof node.name !== 'string' ||
+            node.name.length === 0 ||
+            typeof node.content !== 'string' ||
+            typeof node.role !== 'string' ||
+            nodeNames.has(node.name)) {
+            return schemaPresets_1.defaultSchema;
+        }
+        nodeNames.add(node.name);
+        if (node.role === 'doc')
+            docRoles += 1;
+        if (node.role === 'text')
+            textRoles += 1;
+    }
+    for (const mark of schema.marks) {
+        if (mark == null ||
+            typeof mark.name !== 'string' ||
+            mark.name.length === 0 ||
+            markNames.has(mark.name)) {
+            return schemaPresets_1.defaultSchema;
+        }
+        markNames.add(mark.name);
+    }
+    if (docRoles !== 1 || textRoles !== 1)
+        return schemaPresets_1.defaultSchema;
+    const groups = new Set();
+    const nodesBySymbol = new Map();
+    const addCandidate = (symbol, node) => {
+        const candidates = nodesBySymbol.get(symbol);
+        if (candidates)
+            candidates.push(node);
+        else
+            nodesBySymbol.set(symbol, [node]);
+    };
+    for (const node of schema.nodes) {
+        addCandidate(node.name, node);
+        for (const group of admittedCollections.groupsByNode.get(node) ?? []) {
+            groups.add(group);
+            addCandidate(group, node);
+        }
+    }
+    for (const node of schema.nodes) {
+        const symbols = (0, contentExpression_1.contentExpressionSymbols)(node.content);
+        if (symbols == null ||
+            symbols.some((symbol) => !nodeNames.has(symbol) && !groups.has(symbol))) {
+            return schemaPresets_1.defaultSchema;
+        }
+    }
+    const generatable = new Set();
+    const consumeWork = () => (0, schemaNormalization_1.consumeSchemaWork)(schemaBudget);
+    const contentIsConstructible = (node) => {
+        if (!consumeWork())
+            return false;
+        return ((0, contentExpression_1.minimalContentMatch)(node.content, (symbol) => {
+            const candidates = nodesBySymbol.get(symbol) ?? [];
+            for (const candidate of candidates) {
+                if (!consumeWork())
+                    return undefined;
+                if (generatable.has(candidate.name))
+                    return { type: candidate.name };
+            }
+            return undefined;
+        }, consumeWork) != null);
+    };
+    while (true) {
+        const before = generatable.size;
+        for (const node of schema.nodes) {
+            const hasRequiredAttrs = (admittedCollections.attrsByNode.get(node) ?? []).some(([, attr]) => attr.default === undefined);
+            if (node.role !== 'text' && !hasRequiredAttrs && contentIsConstructible(node)) {
+                generatable.add(node.name);
+            }
+        }
+        if (generatable.size === before)
+            break;
+    }
+    if (schemaBudget.exhausted) {
+        throw (0, schemaNormalization_1.schemaBoundaryError)(schemaBudget.limit, schemaBudget.limit + 1);
+    }
+    const hasUnconstructibleNode = schema.nodes.some((node) => !contentIsConstructible(node));
+    if (schemaBudget.exhausted) {
+        throw (0, schemaNormalization_1.schemaBoundaryError)(schemaBudget.limit, schemaBudget.limit + 1);
+    }
+    if (hasUnconstructibleNode)
+        return schemaPresets_1.defaultSchema;
+    try {
+        (0, schemaDocumentConstruction_1.constructDefaultEmptyDocument)(schema, resolvedLimits, admittedCollections);
+        return schema;
+    }
+    catch (error) {
+        if (error instanceof NativeEditorBoundaryError_1.NativeEditorBoundaryError)
+            throw error;
+        return schemaPresets_1.defaultSchema;
+    }
+}

package/dist/schemas.d.ts

@@ -0,0 +1,5 @@
+export { type AttrSpec, type DOMOutputSpec, type ParseDOMRule, type AttributeDOMOutputSpec, type NodeJSONProjection, type NodeHtmlRules, type NodeSpec, type MarkSpec, type SchemaDefinition, type SchemaNodeSpec, type SchemaMarkSpec, type SchemaSpec, defineSchema, } from './schemaDefinition';
+export { type ImageNodeAttributes, type ResolvedDocumentSchema, IMAGE_NODE_NAME, imageNodeSpec, withImagesSchema, buildDocumentFragmentJson, buildImageFragmentJson, tiptapCompatibleSchemaSpec, tiptapCompatibleSchema, prosemirrorSchemaSpec, prosemirrorSchema, defaultSchemaSpec, defaultSchema, } from './schemaPresets';
+export { resolveDocumentSchema } from './schemaResolution';
+export { defaultEmptyDocument, resolveDocumentDescriptor, normalizeDocumentJson, } from './schemaDocument';
+export { ATOM_HTML_DENIED_ATTRS, ATOM_HTML_DENIED_TAGS, ATOM_HTML_IDENTIFIER, RESERVED_WIRE_NODE_TYPES, } from './atomPolicy';

package/dist/schemas.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESERVED_WIRE_NODE_TYPES = exports.ATOM_HTML_IDENTIFIER = exports.ATOM_HTML_DENIED_TAGS = exports.ATOM_HTML_DENIED_ATTRS = exports.normalizeDocumentJson = exports.resolveDocumentDescriptor = exports.defaultEmptyDocument = exports.resolveDocumentSchema = exports.defaultSchema = exports.defaultSchemaSpec = exports.prosemirrorSchema = exports.prosemirrorSchemaSpec = exports.tiptapCompatibleSchema = exports.tiptapCompatibleSchemaSpec = exports.buildImageFragmentJson = exports.buildDocumentFragmentJson = exports.withImagesSchema = exports.imageNodeSpec = exports.IMAGE_NODE_NAME = exports.defineSchema = void 0;
+var schemaDefinition_1 = require("./schemaDefinition");
+Object.defineProperty(exports, "defineSchema", { enumerable: true, get: function () { return schemaDefinition_1.defineSchema; } });
+var schemaPresets_1 = require("./schemaPresets");
+Object.defineProperty(exports, "IMAGE_NODE_NAME", { enumerable: true, get: function () { return schemaPresets_1.IMAGE_NODE_NAME; } });
+Object.defineProperty(exports, "imageNodeSpec", { enumerable: true, get: function () { return schemaPresets_1.imageNodeSpec; } });
+Object.defineProperty(exports, "withImagesSchema", { enumerable: true, get: function () { return schemaPresets_1.withImagesSchema; } });
+Object.defineProperty(exports, "buildDocumentFragmentJson", { enumerable: true, get: function () { return schemaPresets_1.buildDocumentFragmentJson; } });
+Object.defineProperty(exports, "buildImageFragmentJson", { enumerable: true, get: function () { return schemaPresets_1.buildImageFragmentJson; } });
+Object.defineProperty(exports, "tiptapCompatibleSchemaSpec", { enumerable: true, get: function () { return schemaPresets_1.tiptapCompatibleSchemaSpec; } });
+Object.defineProperty(exports, "tiptapCompatibleSchema", { enumerable: true, get: function () { return schemaPresets_1.tiptapCompatibleSchema; } });
+Object.defineProperty(exports, "prosemirrorSchemaSpec", { enumerable: true, get: function () { return schemaPresets_1.prosemirrorSchemaSpec; } });
+Object.defineProperty(exports, "prosemirrorSchema", { enumerable: true, get: function () { return schemaPresets_1.prosemirrorSchema; } });
+Object.defineProperty(exports, "defaultSchemaSpec", { enumerable: true, get: function () { return schemaPresets_1.defaultSchemaSpec; } });
+Object.defineProperty(exports, "defaultSchema", { enumerable: true, get: function () { return schemaPresets_1.defaultSchema; } });
+var schemaResolution_1 = require("./schemaResolution");
+Object.defineProperty(exports, "resolveDocumentSchema", { enumerable: true, get: function () { return schemaResolution_1.resolveDocumentSchema; } });
+var schemaDocument_1 = require("./schemaDocument");
+Object.defineProperty(exports, "defaultEmptyDocument", { enumerable: true, get: function () { return schemaDocument_1.defaultEmptyDocument; } });
+Object.defineProperty(exports, "resolveDocumentDescriptor", { enumerable: true, get: function () { return schemaDocument_1.resolveDocumentDescriptor; } });
+Object.defineProperty(exports, "normalizeDocumentJson", { enumerable: true, get: function () { return schemaDocument_1.normalizeDocumentJson; } });
+var atomPolicy_1 = require("./atomPolicy");
+Object.defineProperty(exports, "ATOM_HTML_DENIED_ATTRS", { enumerable: true, get: function () { return atomPolicy_1.ATOM_HTML_DENIED_ATTRS; } });
+Object.defineProperty(exports, "ATOM_HTML_DENIED_TAGS", { enumerable: true, get: function () { return atomPolicy_1.ATOM_HTML_DENIED_TAGS; } });
+Object.defineProperty(exports, "ATOM_HTML_IDENTIFIER", { enumerable: true, get: function () { return atomPolicy_1.ATOM_HTML_IDENTIFIER; } });
+Object.defineProperty(exports, "RESERVED_WIRE_NODE_TYPES", { enumerable: true, get: function () { return atomPolicy_1.RESERVED_WIRE_NODE_TYPES; } });

package/dist/specs/PreparedProseViewerNativeComponent.d.ts

@@ -0,0 +1,37 @@
+import { type ViewProps } from 'react-native';
+import type { DirectEventHandler, Double, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+export interface NativeProps extends ViewProps {
+    sourceKind?: WithDefault<'json' | 'html', 'json'>;
+    source: string;
+    configJson: string;
+    themeJson?: string;
+    imagePolicyJson?: string;
+    imagesEnabled?: WithDefault<boolean, true>;
+    collapsesWhenEmpty?: WithDefault<boolean, true>;
+    enableLinkTaps?: WithDefault<boolean, true>;
+    mentionInteractionsEnabled?: WithDefault<boolean, false>;
+    fontEnvironmentRevision: Int32;
+    onPressLink?: DirectEventHandler<{
+        href: string;
+        text: string;
+    }>;
+    onPressMention?: DirectEventHandler<{
+        docPos: Double;
+        label: string;
+        attrsJson: string;
+    }>;
+    onAtomLayout?: DirectEventHandler<{
+        generation: string;
+        revision: string;
+        layoutWidth: Double;
+        atomsJson: string;
+    }>;
+    onError?: DirectEventHandler<{
+        domain: string;
+        code: string;
+        message: string;
+        fatal: boolean;
+    }>;
+}
+declare const _default: import("react-native").HostComponent<NativeProps>;
+export default _default;

package/dist/specs/PreparedProseViewerNativeComponent.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = (0, react_native_1.codegenNativeComponent)('PreparedProseViewer', {
+    interfaceOnly: true,
+});

package/dist/useEditorToolbarInteractions.d.ts

@@ -0,0 +1,12 @@
+import { useEditorToolbarState } from './useEditorToolbarState';
+import { useEditorToolbarItems } from './useEditorToolbarItems';
+import { type ToolbarButton, type ToolbarGroupButton } from './EditorToolbarTypes';
+export declare function useEditorToolbarInteractions(context: Pick<ReturnType<typeof useEditorToolbarState>, 'showTopBorder' | 'theme' | 'registrationIdRef' | 'rootRef' | 'publishesFocusFrames' | 'frameOwnerId' | 'framePublisherMountedRef' | 'publishesFocusFramesRef' | 'frameOwnerIdRef' | 'menuRegistrationIdRef' | 'menuCardRef' | 'menuState' | 'menuStateRef' | 'framePublishAnimationFramesRef' | 'framePublishTimeoutsRef' | 'expandedGroupKey' | 'windowHeight' | 'windowWidth' | 'toolbarInteractionActiveRef' | 'setExpandedGroupKey' | 'setMenuState' | 'shouldRenderMentionSuggestions' | 'preserveEditorFocus' | 'groupButtonRefs'> & Pick<ReturnType<typeof useEditorToolbarItems>, 'startItems' | 'scrollItems' | 'endItems' | 'groupsByKey'>): {
+    handleToolbarPressIn: () => void;
+    handleToolbarPressOut: () => void;
+    handleGroupPress: (group: ToolbarGroupButton) => void;
+    handleButtonPress: (button: ToolbarButton) => void;
+    handleToolbarLayout: () => void;
+    resolvedShowTopBorder: boolean;
+    handleMenuLayout: () => void;
+};