@prismicio/editor-fields 0.1.0-rc.3 → 0.1.0-rc.4

package/dist/domain/Field.d.ts

@@ -1,5 +1,5 @@
+import { Group } from "@prismicio/types-internal/lib/customtypes/widgets";
 import type { BooleanField, NestableWidget, Separator } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
-declare type Field = Exclude<NestableWidget, Separator>;
-export declare function getFieldLabel(field: Field | Separator): string;
-export declare function getFieldPlaceholder(field: Exclude<Field, BooleanField>): string;
-export {};
+export declare function getFieldLabel(field: NestableWidget | Group): string;
+export declare function getFieldPlaceholder(field: Exclude<NestableWidget, Separator | BooleanField>): string;
+export declare function getFieldPlaceholder(field: BooleanField, value: boolean): string;

package/dist/domain/Group.d.ts

@@ -1,6 +1,6 @@
 import type { Group } from "@prismicio/types-internal/lib/customtypes/widgets";
-import type { GroupContent } from "@prismicio/types-internal/lib/documents/widgets";
-import type { RepeatableZone, RepeatableZoneContent } from "./zones/RepeatableZone";
-export declare function getGroupLabel(group: Group): string;
+import { GroupContent, GroupItemContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { RepeatableZone } from "./zones/RepeatableZone";
 export declare function getRepeatableZone(group: Group): RepeatableZone;
-export declare function updateRepeatableZoneContent(groupContent: GroupContent | undefined, repeatableZoneContent: RepeatableZoneContent): GroupContent;
+export declare function updateRepeatableZoneContent(groupContent: GroupContent | undefined, repeatableZoneContent: GroupItemContent[]): GroupContent;
+export declare const emptyGroupItemContent: () => GroupItemContent;

package/dist/domain/__tests__/Document.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domain/zones/RepeatableZone.d.ts

@@ -2,7 +2,6 @@ import type { NestableWidget } from "@prismicio/types-internal/lib/customtypes/w
 import type { GroupItemContent, SimpleWidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
 import type { NestableWidgetContent } from "../NestableWidget";
 export declare type RepeatableZone = Readonly<Partial<Record<string, NestableWidget>>>;
-export declare type RepeatableZoneContent = GroupItemContent[];
-export declare function defaultRepeatableZoneContentIfUndefined(repeatableZoneContent: RepeatableZoneContent | undefined): RepeatableZoneContent;
+export declare function defaultRepeatableZoneContentIfUndefined(repeatableZoneContent: GroupItemContent[] | undefined): GroupItemContent[];
 export declare function getGroupItemContentValue(groupItemContent: GroupItemContent): Readonly<Partial<Record<string, SimpleWidgetContent>>>;
-export declare function updateRepeatableWidgetContent(repeatableZoneContent: RepeatableZoneContent, groupItemContentIndex: number, repeatableWidgetIndex: number, repeatableWidgetId: string, repeatableWidgetContent: NestableWidgetContent | undefined): RepeatableZoneContent;
+export declare function updateRepeatableWidgetContent(repeatableZoneContent: GroupItemContent[], groupItemContentIndex: number, repeatableWidgetIndex: number, repeatableWidgetId: string, repeatableWidgetContent: NestableWidgetContent | undefined): GroupItemContent[];

package/dist/fields/BooleanField.d.ts

@@ -0,0 +1,12 @@
+import type { BooleanField as BooleanT } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { BooleanContent } from "@prismicio/types-internal/lib/documents/widgets/nestable";
+import type { FC } from "react";
+declare type BooleanFieldProps = Readonly<{
+    content: BooleanContent | undefined;
+    field: BooleanT;
+    id: string;
+    onContentChange: (content: BooleanContent) => void;
+    readOnly: boolean;
+}>;
+export declare const BooleanField: FC<BooleanFieldProps>;
+export {};

package/dist/fields/NestableField.d.ts

@@ -0,0 +1,12 @@
+import type { NestableWidget } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { FC } from "react";
+import type { NestableWidgetContent } from "../domain/NestableWidget";
+declare type NestableFieldProps = Readonly<{
+    content: NestableWidgetContent | undefined;
+    id: string;
+    nestableWidget: NestableWidget;
+    onContentChange: (content: NestableWidgetContent | undefined) => void;
+    readOnly: boolean;
+}>;
+export declare const NestableField: FC<NestableFieldProps>;
+export {};

package/dist/fields/NumberField.d.ts

@@ -0,0 +1,12 @@
+import type { Number as NumberT } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { FieldContent as NumberContent } from "@prismicio/types-internal/lib/documents/widgets/nestable";
+import type { FC } from "react";
+declare type NumberFieldProps = Readonly<{
+    content: NumberContent | undefined;
+    field: NumberT;
+    id: string;
+    onContentChange: (content: NumberContent | undefined) => void;
+    readOnly: boolean;
+}>;
+export declare const NumberField: FC<NumberFieldProps>;
+export {};

package/dist/fields/RichTextField/MenuBar/MenuBar.d.ts

@@ -0,0 +1,9 @@
+import "./MenuBar.css";
+import type { Editor } from "@tiptap/react";
+import { type FC } from "react";
+declare type MenuBarProps = Readonly<{
+    editor: Editor;
+    extensions: ReadonlyArray<string>;
+}>;
+declare const MenuBar: FC<MenuBarProps>;
+export default MenuBar;

package/dist/fields/RichTextField/MenuBar/MenuItem.d.ts

@@ -0,0 +1,10 @@
+import "./MenuItem.css";
+import type { FC } from "react";
+export declare type MenuItemProps = Readonly<{
+    action: () => boolean;
+    icon: string;
+    isActive?: () => boolean;
+    title: string;
+}>;
+declare const MenuItem: FC<MenuItemProps>;
+export default MenuItem;

package/dist/fields/RichTextField/MenuBar/index.d.ts

@@ -0,0 +1,2 @@
+import MenuBar from "./MenuBar";
+export default MenuBar;

package/dist/fields/RichTextField/core-extensions/Document.d.ts

@@ -0,0 +1,3 @@
+import { DocumentExtension } from "../models";
+declare const EditorDocument: DocumentExtension;
+export default EditorDocument;

package/dist/fields/RichTextField/core-extensions/HardBreak.d.ts

@@ -0,0 +1,11 @@
+import type { Node as ProsemirrorNode, Schema } from "prosemirror-model";
+export declare const HARD_BREAK_STR = "\n";
+declare const EditorHardBreak: {
+    name: string;
+    Component: import("@tiptap/core").Node<import("@tiptap/extension-hard-break").HardBreakOptions, any>;
+    Converter: {
+        fromPrismic(schema: Schema): (text: string) => ProsemirrorNode | undefined;
+        toPrismic(node: ProsemirrorNode): string | undefined;
+    };
+};
+export default EditorHardBreak;

package/dist/fields/RichTextField/core-extensions/ListItem.d.ts

@@ -0,0 +1,44 @@
+import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { ReadonlyNonEmptyArray } from "fp-ts/lib/ReadonlyNonEmptyArray";
+import type { Node as ProsemirrorNode, Schema } from "prosemirror-model";
+declare const _default: {
+    Component: import("@tiptap/core").Node<import("@tiptap/extension-list-item").ListItemOptions, any>;
+    Converter: {
+        fromPrismic(schema: Schema<any, any>): (list: {
+            type: RichTextNodeType;
+            content: {
+                text: string;
+            } & {
+                spans?: ({
+                    data?: unknown;
+                } & {
+                    start: number;
+                    end: number;
+                    type: RichTextNodeType;
+                })[];
+            };
+        } & {
+            label?: string;
+            direction?: string;
+        }) => ProsemirrorNode<any> | undefined;
+        toPrismic(node: ProsemirrorNode<any>, nodeType: RichTextNodeType.list | RichTextNodeType.orderedList): readonly ({
+            type: RichTextNodeType;
+            content: {
+                text: string;
+            } & {
+                spans?: ({
+                    data?: unknown;
+                } & {
+                    start: number;
+                    end: number;
+                    type: RichTextNodeType;
+                })[];
+            };
+        } & {
+            label?: string;
+            direction?: string;
+        })[];
+    };
+};
+export default _default;
+export declare function mergeLists(lists: ReadonlyNonEmptyArray<ProsemirrorNode>): ProsemirrorNode | undefined;

package/dist/fields/RichTextField/core-extensions/Text.d.ts

@@ -0,0 +1,15 @@
+import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { TextBlock } from "@prismicio/types-internal/lib/documents/widgets/nestable/StructuredTextContent/Block";
+import type { Node as ProsemirrorNode, Schema } from "prosemirror-model";
+import type { Direction } from "../global-extensions/TextDirection";
+declare const EditorText: {
+    name: string;
+    Component: import("@tiptap/core").Node<any, any>;
+    Converter: {
+        fromPrismic(schema: Schema): (extensionName: string, textBlock: TextBlock, preventHardbreaks?: boolean) => Array<ProsemirrorNode>;
+        toPrismic(node: ProsemirrorNode, nodeType: RichTextNodeType, attributes?: {
+            direction?: Direction;
+        } | undefined): TextBlock;
+    };
+};
+export default EditorText;

package/dist/fields/RichTextField/core-extensions/index.d.ts

@@ -0,0 +1,95 @@
+import D from "./Document";
+import HB from "./HardBreak";
+import LI from "./ListItem";
+import T from "./Text";
+export declare const Document: import("../models").DocumentExtension;
+export declare const HardBreak: {
+    name: string;
+    Component: import("@tiptap/core").Node<import("@tiptap/extension-hard-break").HardBreakOptions, any>;
+    Converter: {
+        fromPrismic(schema: import("prosemirror-model").Schema<any, any>): (text: string) => import("prosemirror-model").Node<any> | undefined;
+        toPrismic(node: import("prosemirror-model").Node<any>): string | undefined;
+    };
+};
+export declare const Text: {
+    name: string;
+    Component: import("@tiptap/core").Node<any, any>;
+    Converter: {
+        fromPrismic(schema: import("prosemirror-model").Schema<any, any>): (extensionName: string, textBlock: {
+            type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+            content: {
+                text: string;
+            } & {
+                spans?: ({
+                    data?: unknown;
+                } & {
+                    start: number;
+                    end: number;
+                    type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+                })[];
+            };
+        } & {
+            label?: string;
+            direction?: string;
+        }, preventHardbreaks?: boolean) => import("prosemirror-model").Node<any>[];
+        toPrismic(node: import("prosemirror-model").Node<any>, nodeType: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType, attributes?: {
+            direction?: import("../global-extensions/TextDirection").Direction;
+        } | undefined): {
+            type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+            content: {
+                text: string;
+            } & {
+                spans?: ({
+                    data?: unknown;
+                } & {
+                    start: number;
+                    end: number;
+                    type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+                })[];
+            };
+        } & {
+            label?: string;
+            direction?: string;
+        };
+    };
+};
+export declare const ListItem: {
+    Component: import("@tiptap/core").Node<import("@tiptap/extension-list-item").ListItemOptions, any>;
+    Converter: {
+        fromPrismic(schema: import("prosemirror-model").Schema<any, any>): (list: {
+            type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+            content: {
+                text: string;
+            } & {
+                spans?: ({
+                    data?: unknown;
+                } & {
+                    start: number;
+                    end: number;
+                    type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+                })[];
+            };
+        } & {
+            label?: string;
+            direction?: string;
+        }) => import("prosemirror-model").Node<any> | undefined;
+        toPrismic(node: import("prosemirror-model").Node<any>, nodeType: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType.list | import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType.orderedList): readonly ({
+            type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+            content: {
+                text: string;
+            } & {
+                spans?: ({
+                    data?: unknown;
+                } & {
+                    start: number;
+                    end: number;
+                    type: import("@prismicio/types-internal/lib/customtypes/widgets/nestable").RichTextNodeType;
+                })[];
+            };
+        } & {
+            label?: string;
+            direction?: string;
+        })[];
+    };
+};
+export declare type CoreExtension = typeof D | typeof HB | typeof T | typeof LI;

package/dist/fields/RichTextField/coreExtensions/HardBreak.d.ts

@@ -1,5 +1,5 @@
 import type { Node as ProsemirrorNode, Schema } from "prosemirror-model";
-declare function splitTextToNodes(schema: Schema, text: string): (textToNode: (strText: string) => ProsemirrorNode) => Array<ProsemirrorNode>;
+declare function splitTextToNodes(schema: Schema, text: string): (textToNode: (strText: string) => ProsemirrorNode) => ProsemirrorNode[];
 declare const EditorHardBreak: {
     name: string;
     component: import("@tiptap/core").Node<import("@tiptap/extension-hard-break").HardBreakOptions, any>;

package/dist/fields/RichTextField/coreExtensions/ListItem.d.ts

@@ -19,8 +19,8 @@ declare const _default: {
         } & {
             label?: string;
             direction?: string;
-        }) => ProsemirrorNode<any> | undefined;
-        toPrismic(node: ProsemirrorNode<any>, nodeType: "list-item" | "o-list-item"): readonly ({
+        }) => ProsemirrorNode | undefined;
+        toPrismic(node: ProsemirrorNode, nodeType: "list-item" | "o-list-item"): readonly ({
             type: "em" | "embed" | "strong" | "image" | "paragraph" | "list-item" | "o-list-item" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "preformatted" | "hyperlink" | "rtl";
             content: {
                 text: string;

package/dist/fields/RichTextField/coreExtensions/Text.d.ts

@@ -6,10 +6,10 @@ declare const EditorText: {
     name: string;
     component: import("@tiptap/core").Node<any, any>;
     converter: {
-        fromPrismic(schema: Schema): (extensionName: string, textBlock: TextBlock, preventHardbreaks?: boolean) => Array<ProsemirrorNode>;
+        fromPrismic(schema: Schema): (extensionName: string, textBlock: TextBlock, preventHardbreaks?: boolean) => ProsemirrorNode[];
         toPrismic(node: ProsemirrorNode, nodeType: RichTextNodeType, attributes?: {
             direction?: Direction;
-        } | undefined): TextBlock;
+        }): TextBlock;
     };
 };
 export default EditorText;

package/dist/fields/RichTextField/coreExtensions/index.d.ts

@@ -5,5 +5,5 @@ import { default as Document } from "./Document";
 import { default as HardBreak } from "./HardBreak";
 import { default as ListItem } from "./ListItem";
 import { default as Text } from "./Text";
-export declare function CoreComponents(field: RichText, nodeExtensions: ReadonlyArray<NodeExtension>): ReadonlyArray<Node>;
+export declare function CoreComponents(field: RichText, nodeExtensions: readonly NodeExtension[]): readonly Node[];
 export { Document, HardBreak, ListItem, Text };

package/dist/fields/RichTextField/extensions/Heading.d.ts

@@ -4,10 +4,10 @@ import { type ReadonlyNonEmptyArray } from "fp-ts/ReadonlyNonEmptyArray";
 import type { Node as ProsemirrorNode } from "prosemirror-model";
 import { HeadingTextExtension } from "../models";
 export declare type Level = TTLevel;
-declare type HeadingName = {
+interface HeadingName {
     fullName: RichTextNodeType;
     level: Level;
-};
+}
 export declare const HeadingName: {
     byLevel(level: Level): RichTextNodeType;
     default(level: Level): HeadingName;
@@ -16,6 +16,6 @@ export declare const HeadingName: {
 };
 declare const _default: {
     name: string;
-    build: (nodeTypes?: Set<RichTextNodeType> | undefined) => HeadingTextExtension | undefined;
+    build: (nodeTypes?: Set<RichTextNodeType>) => HeadingTextExtension | undefined;
 };
 export default _default;

package/dist/fields/RichTextField/extensions/index.d.ts

@@ -10,5 +10,5 @@ import { default as OrderedList } from "./OrderedList";
 import { default as Paragraph } from "./Paragraph";
 export declare const DefaultExtension: import("../models").TextExtension;
 export declare const MarkExtensions: import("../models").MarkExtension<unknown>[];
-export declare const Extensions: (nodeTypes?: Set<RichTextNodeType> | undefined) => ReadonlyArray<WidgetExtension>;
+export declare const Extensions: (nodeTypes?: Set<RichTextNodeType>) => readonly WidgetExtension[];
 export { Bold, BulletList, CodeBlock, Embed, Heading, Italic, OrderedList, Paragraph, };

package/dist/fields/RichTextField/global-extensions/TextDirection.d.ts

@@ -0,0 +1,38 @@
+import type { TextBlock } from "@prismicio/types-internal/lib/documents/widgets/nestable/StructuredTextContent/Block";
+import { Extension } from "@tiptap/core";
+import type { Node as ProsemirrorNode } from "prosemirror-model";
+export declare enum Direction {
+    LeftToRight = "ltr",
+    RightToLeft = "rtl"
+}
+export interface TextDirectionOptions {
+    supportedExtensionNames: ReadonlyArray<string>;
+}
+export declare const TEXT_DIRECTION_ATTR_NAME = "text-direction";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        [TEXT_DIRECTION_ATTR_NAME]: {
+            setDirection: (direction: Direction) => ReturnType;
+            toggleDirection: (direction: Direction) => ReturnType;
+            /**
+             * Set the text direction attribute
+             */
+            setRightToLeft: () => ReturnType;
+            /**
+             * Unset the text direction attribute
+             */
+            setLeftToRight: () => ReturnType;
+        };
+    }
+}
+export declare const name = "textDirection";
+export declare const Component: Extension<TextDirectionOptions, any>;
+export declare const Converter: {
+    parseNodeAttrsDirection(attributes: Partial<Record<string, unknown>>): Direction;
+    fromPrismic(textBlock: TextBlock): {
+        [TEXT_DIRECTION_ATTR_NAME]: Direction;
+    };
+    toPrismic(node: ProsemirrorNode): {
+        direction: Direction;
+    } | Record<string, never>;
+};

package/dist/fields/RichTextField/global-extensions/index.d.ts

@@ -0,0 +1,3 @@
+import * as TD from "./TextDirection";
+export declare const TextDirection: typeof TD;
+export declare type GlobalExtension = typeof TD;

package/dist/fields/RichTextField/globalExtensions/TextDirection.d.ts

@@ -6,7 +6,7 @@ export declare enum Direction {
     RightToLeft = "rtl"
 }
 interface TextDirectionOptions {
-    supportedExtensionNames: ReadonlyArray<string>;
+    supportedExtensionNames: readonly string[];
 }
 export declare const TEXT_DIRECTION_ATTR_NAME = "text-direction";
 declare module "@tiptap/core" {
@@ -34,6 +34,6 @@ export declare const converter: {
     };
     toPrismic(node: ProsemirrorNode): {
         direction: Direction;
-    } | Record<string, never>;
+    };
 };
 export {};

package/dist/fields/RichTextField/models/Block.d.ts

@@ -0,0 +1,5 @@
+import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { TextBlock } from "@prismicio/types-internal/lib/documents/widgets/nestable/StructuredTextContent/Block";
+export declare type TextBlockWithNodeType = TextBlock & {
+    type: RichTextNodeType;
+};

package/dist/fields/RichTextField/models/EditorExtension.d.ts

@@ -2,8 +2,8 @@ import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes
 import type { StructuredTextContent as RichTextContent } from "@prismicio/types-internal/lib/documents/widgets/nestable";
 import type { EmbedBlock, ImageBlock, TextBlock } from "@prismicio/types-internal/lib/documents/widgets/nestable/StructuredTextContent/Block";
 import type { Mark, Node } from "@tiptap/core";
-import type { ReadonlyNonEmptyArray } from "fp-ts/lib/ReadonlyNonEmptyArray";
 import type { NonEmptyArray } from "fp-ts/NonEmptyArray";
+import type { ReadonlyNonEmptyArray } from "fp-ts/ReadonlyNonEmptyArray";
 import type { Mark as ProsemirrorMark, Node as ProsemirrorNode, Schema } from "prosemirror-model";
 import type { Level } from "../extensions/Heading";
 export declare enum ExtensionType {
@@ -22,12 +22,12 @@ export declare type ExtensionPlaceholder = string | ((nodeAttrs: ProsemirrorNode
 export declare class DocumentExtension {
     readonly name: string;
     readonly component: (multiLines: boolean) => Node;
-    readonly converter: (extensions: ReadonlyArray<NodeExtension>) => {
+    readonly converter: (extensions: readonly NodeExtension[]) => {
         fromPrismic(schema: Schema, defaultTextConverter?: (block: TextBlock) => ProsemirrorNode | undefined): (elmt: RichTextContent) => ProsemirrorNode | undefined;
         toPrismic(elmt: ProsemirrorNode): RichTextContent | undefined;
     };
     extType: ExtensionType.Document;
-    constructor(name: string, component: (multiLines: boolean) => Node, converter: (extensions: ReadonlyArray<NodeExtension>) => {
+    constructor(name: string, component: (multiLines: boolean) => Node, converter: (extensions: readonly NodeExtension[]) => {
         fromPrismic(schema: Schema, defaultTextConverter?: (block: TextBlock) => ProsemirrorNode | undefined): (elmt: RichTextContent) => ProsemirrorNode | undefined;
         toPrismic(elmt: ProsemirrorNode): RichTextContent | undefined;
     });
@@ -53,7 +53,7 @@ export declare class TextExtension {
     readonly component: Node;
     readonly converter: {
         fromPrismic(schema: Schema): (elmt: TextBlock) => ProsemirrorNode | undefined;
-        toPrismic(elmt: ProsemirrorNode): TextBlock | ReadonlyArray<TextBlock> | undefined;
+        toPrismic(elmt: ProsemirrorNode): TextBlock | readonly TextBlock[] | undefined;
     };
     readonly placeholder?: ExtensionPlaceholder;
     readonly lockedFormat: boolean;
@@ -61,7 +61,7 @@ export declare class TextExtension {
     nodeType: NodeType.Text;
     constructor(richTextNodeTypes: ReadonlyNonEmptyArray<RichTextNodeType>, name: string, component: Node, converter: {
         fromPrismic(schema: Schema): (elmt: TextBlock) => ProsemirrorNode | undefined;
-        toPrismic(elmt: ProsemirrorNode): TextBlock | ReadonlyArray<TextBlock> | undefined;
+        toPrismic(elmt: ProsemirrorNode): TextBlock | readonly TextBlock[] | undefined;
     }, placeholder?: ExtensionPlaceholder, lockedFormat?: boolean);
 }
 export declare class EmbedExtension {
@@ -95,8 +95,8 @@ export declare class ImageExtension {
     });
 }
 export declare class HeadingTextExtension extends TextExtension {
-    readonly levels: ReadonlyArray<Level>;
-    constructor(richTextNodeTypes: ReadonlyNonEmptyArray<RichTextNodeType>, Component: Node, levels: ReadonlyArray<Level>, Converter: {
+    readonly levels: readonly Level[];
+    constructor(richTextNodeTypes: ReadonlyNonEmptyArray<RichTextNodeType>, Component: Node, levels: readonly Level[], Converter: {
         fromPrismic(schema: Schema): (elmt: TextBlock) => ProsemirrorNode | undefined;
         toPrismic(elmt: ProsemirrorNode): TextBlock | undefined;
     }, placeholder?: ExtensionPlaceholder);
@@ -104,6 +104,6 @@ export declare class HeadingTextExtension extends TextExtension {
 export declare class ListExtension extends TextExtension {
     constructor(richTextNodeTypes: NonEmptyArray<RichTextNodeType>, name: string, Component: Node, Converter: {
         fromPrismic(schema: Schema): (elmt: TextBlock) => ProsemirrorNode | undefined;
-        toPrismic(elmt: ProsemirrorNode): ReadonlyArray<TextBlock>;
+        toPrismic(elmt: ProsemirrorNode): readonly TextBlock[];
     });
 }

package/dist/fields/RichTextField/models/Span.d.ts

@@ -1,12 +1,12 @@
 import type { Span } from "@prismicio/types-internal/lib/documents/widgets/nestable/StructuredTextContent/Block";
 export declare const SpanUtils: {
-    groupBy<K extends unknown>(spans: ReadonlyArray<Span>, f: (span: Span) => K): Map<K, readonly ({
+    groupBy<K extends unknown>(spans: readonly Span[], f: (span: Span) => K): Map<K, readonly ({
         data?: unknown;
     } & {
         start: number;
         end: number;
         type: "label" | "em" | "embed" | "strong" | "image" | "paragraph" | "list-item" | "o-list-item" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "preformatted" | "hyperlink" | "rtl";
     })[]>;
-    sort(spans: ReadonlyArray<Span>): ReadonlyArray<Span>;
-    mergeOverlap(spans: ReadonlyArray<Span>): ReadonlyArray<Span>;
+    sort(spans: readonly Span[]): readonly Span[];
+    mergeOverlap(spans: readonly Span[]): readonly Span[];
 };

package/dist/fields/RichTextField/models/helpers/Arrays.d.ts

@@ -0,0 +1 @@
+export declare function filterTyped<I, O>(array: Array<I>, transformOrFilter: (elmt: I) => O | undefined): Array<O>;

package/dist/fields/RichTextField/models/helpers/DOMParser.d.ts

@@ -0,0 +1 @@
+export declare function getAttributes<T>(processor: (elmt: globalThis.Element) => T): (dom: string | globalThis.Node) => false | T;

package/dist/fields/RichTextField/models/helpers/NodeUtils.d.ts

@@ -5,11 +5,11 @@ export declare const NodeUtils: {
         reduce<T>(node: ProsemirrorNode, f: (acc: T, child: ProsemirrorNode, index: number) => T, defaultValue: T): T;
         map<T_1>(node: ProsemirrorNode, f: (child: ProsemirrorNode) => T_1): readonly T_1[];
         exists(node: ProsemirrorNode, f: (child: ProsemirrorNode) => boolean): boolean;
-        filter(node: ProsemirrorNode, predicate: (child: ProsemirrorNode) => boolean): ReadonlyArray<ProsemirrorNode>;
+        filter(node: ProsemirrorNode, predicate: (child: ProsemirrorNode) => boolean): readonly ProsemirrorNode[];
     };
     marks: {
         reduce<T_2>(node: ProsemirrorNode, f: (acc: T_2, child: ProsemirrorMark, index: number) => T_2, defaultValue: T_2): T_2;
         map<T_3>(node: ProsemirrorNode, f: (mark: ProsemirrorMark) => T_3): readonly T_3[];
-        filter(node: ProsemirrorNode, predicate: (mark: ProsemirrorMark) => boolean): ReadonlyArray<ProsemirrorMark>;
+        filter(node: ProsemirrorNode, predicate: (mark: ProsemirrorMark) => boolean): readonly ProsemirrorMark[];
     };
 };

package/dist/fields/RichTextField/models/helpers/Objects.d.ts

@@ -0,0 +1,3 @@
+export declare function filterTyped<Input, Output>(obj: {
+    [key: string]: Input;
+}, transformOrFilter: (elmt: [string, Input]) => [string, Output] | undefined): Partial<Record<string, Output>>;