@prismicio/editor-fields 0.1.0-rc.2

package/README.md

@@ -0,0 +1 @@
+# editor-fields

package/dist/DocumentEditor.d.ts

@@ -0,0 +1,14 @@
+import { type CustomType as DynamicCustomType } from "@prismicio/types-internal/lib/customtypes";
+import { type FC } from "react";
+import { type DocumentContent } from "./domain/Document";
+import { type SharedSlices } from "./domain/SharedSlices";
+declare type DocumentEditorProps = Readonly<{
+    content: DocumentContent;
+    customType: DynamicCustomType;
+    onContentChange: (content: DocumentContent) => void;
+    readOnly?: boolean | undefined;
+    sectionName: string | undefined;
+    sharedSlices: SharedSlices;
+}>;
+export declare const DocumentEditor: FC<DocumentEditorProps>;
+export {};

package/dist/GroupEditor.d.ts

@@ -0,0 +1,12 @@
+import type { Group } from "@prismicio/types-internal/lib/customtypes/widgets";
+import type { GroupContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { FC } from "react";
+declare type GroupEditorProps = Readonly<{
+    content: GroupContent | undefined;
+    group: Group;
+    id: string;
+    onContentChange: (content: GroupContent) => void;
+    readOnly: boolean;
+}>;
+export declare const GroupEditor: FC<GroupEditorProps>;
+export {};

package/dist/NestableWidgetSwitch.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 NestableWidgetSwitchProps = Readonly<{
+    content: NestableWidgetContent | undefined;
+    id: string;
+    nestableWidget: NestableWidget;
+    onContentChange: (content: NestableWidgetContent | undefined) => void;
+    readOnly: boolean;
+}>;
+export declare const NestableWidgetSwitch: FC<NestableWidgetSwitchProps>;
+export {};

package/dist/SectionEditor.d.ts

@@ -0,0 +1,12 @@
+import type { StaticSection as Section } from "@prismicio/types-internal/lib/customtypes/Section";
+import { type FC } from "react";
+import { type SectionContent } from "./domain/Section";
+declare type SectionEditorProps = Readonly<{
+    content: SectionContent;
+    id: string;
+    onContentChange: (content: SectionContent) => void;
+    readOnly: boolean;
+    section: Section;
+}>;
+export declare const SectionEditor: FC<SectionEditorProps>;
+export {};

package/dist/domain/Document.d.ts

@@ -0,0 +1,8 @@
+import type { StaticCustomType as CustomType } from "@prismicio/types-internal/lib/customtypes";
+import type { StaticSection as Section } from "@prismicio/types-internal/lib/customtypes/Section";
+import type { WidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { SectionContent } from "./Section";
+export declare type DocumentContent = Readonly<Partial<Record<string, WidgetContent>>>;
+export declare function isEmptyCustomType(customType: CustomType): boolean;
+export declare function getSection(customType: CustomType, sectionName: string): Section;
+export declare function getSectionContent(section: Section, documentContent: DocumentContent): SectionContent;

package/dist/domain/Field.d.ts

@@ -0,0 +1,5 @@
+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 {};

package/dist/domain/Group.d.ts

@@ -0,0 +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;
+export declare function getRepeatableZone(group: Group): RepeatableZone;
+export declare function updateRepeatableZoneContent(groupContent: GroupContent | undefined, repeatableZoneContent: RepeatableZoneContent): GroupContent;

package/dist/domain/NestableWidget.d.ts

@@ -0,0 +1,12 @@
+import { type NonEmptySimpleWidgetContent, type UIDContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { FieldContent as StringContent, GeoPointContentO as GeoPointContent, ImageContentO as ImageContent } from "@prismicio/types-internal/lib/documents/widgets/nestable";
+export declare type NestableWidgetContent = Exclude<NonEmptySimpleWidgetContent, UIDContent>;
+export declare function isColorContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;
+export declare function isDateContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;
+export declare function isGeoPointContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is GeoPointContent;
+export declare function isImageContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is ImageContent;
+export declare function isKeyTextContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;
+export declare function isNumberContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;
+export declare function isRangeContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;
+export declare function isSelectContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;
+export declare function isTimestampContent(nestableWidgetContent: NestableWidgetContent): nestableWidgetContent is StringContent;

package/dist/domain/Section.d.ts

@@ -0,0 +1,10 @@
+import type { StaticSection as Section } from "@prismicio/types-internal/lib/customtypes/Section";
+import type { StaticSlices as SliceZone } from "@prismicio/types-internal/lib/customtypes/widgets/slices/Slices";
+import { type WidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { StaticZone, StaticZoneContent } from "./zones/StaticZone";
+export declare type SectionContent = Readonly<Partial<Record<string, WidgetContent>>>;
+export declare type PartitionedSection = readonly [StaticZone, SliceZones];
+declare type SliceZones = readonly (readonly [string, SliceZone])[];
+export declare function getPartitionedSection(section: Section): PartitionedSection;
+export declare function getStaticZoneContent(staticZone: StaticZone, sectionContent: SectionContent): StaticZoneContent;
+export {};

package/dist/domain/SharedSlices.d.ts

@@ -0,0 +1,3 @@
+import type { SharedSlice } from "@prismicio/types-internal/lib/customtypes/widgets/slices";
+export declare type SharedSlices = Readonly<Partial<Record<string, SharedSlice>>>;
+export declare function compactSharedSlices(sharedSlices: SharedSlices): Map<string, SharedSlice>;

package/dist/domain/StaticWidget.d.ts

@@ -0,0 +1,7 @@
+import type { StaticSlices as SliceZone } from "@prismicio/types-internal/lib/customtypes/widgets/slices/Slices";
+import type { StaticWidget as Widget } from "@prismicio/types-internal/lib/customtypes/widgets/Widget";
+import { type GroupContent, type StaticWidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { NestableWidgetContent } from "./NestableWidget";
+export declare type StaticWidget = Exclude<Widget, SliceZone>;
+export declare function isGroupContent(staticWidgetContent: StaticWidgetContent): staticWidgetContent is GroupContent;
+export declare function isNestableWidgetContent(staticWidgetContent: StaticWidgetContent): staticWidgetContent is NestableWidgetContent;

package/dist/domain/Widget.d.ts

@@ -0,0 +1,10 @@
+import type { StaticSlices as SliceZone } from "@prismicio/types-internal/lib/customtypes/widgets/slices/Slices";
+import type { StaticWidget as Widget } from "@prismicio/types-internal/lib/customtypes/widgets/Widget";
+import { type WidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { SlicesContent as SliceZoneContent } from "@prismicio/types-internal/lib/documents/widgets/slices";
+import type { Refinement } from "fp-ts/Refinement";
+export declare function isSliceZone(widget: Widget): widget is SliceZone;
+export declare function isSliceZoneContent(widgetContent: WidgetContent): widgetContent is SliceZoneContent;
+export declare type Widgets<T> = T extends Record<string, infer V> ? readonly (readonly [string, NonNullable<V>])[] : never;
+export declare function getWidgets<V extends Widget>(record: Readonly<Partial<Record<string, V>>>): Widgets<Readonly<Partial<Record<string, V>>>>;
+export declare function refineWidgetContent<A extends WidgetContent, B extends A>(widgetContent: A | undefined, refinement: Refinement<A, B>): B | undefined;

package/dist/domain/slices/CompositeSlice.d.ts

@@ -0,0 +1,6 @@
+import type { CompositeSlice } from "@prismicio/types-internal/lib/customtypes/widgets/slices";
+import type { NonRepeatableZone } from "../zones/NonRepeatableZone";
+import type { RepeatableZone } from "../zones/RepeatableZone";
+export declare function getCompositeSliceLegend(compositeSlice: CompositeSlice): string;
+export declare function getNonRepeatableZone(compositeSlice: CompositeSlice): NonRepeatableZone;
+export declare function getRepeatableZone(compositeSlice: CompositeSlice): RepeatableZone;

package/dist/domain/slices/LegacySlice.d.ts

@@ -0,0 +1,4 @@
+import type { LegacySlice } from "@prismicio/types-internal/lib/customtypes/widgets/slices";
+import type { NonEmptyStaticWidgetContent, UIDContent } from "@prismicio/types-internal/lib/documents/widgets";
+export declare type LegacySliceContent = Exclude<NonEmptyStaticWidgetContent, UIDContent>;
+export declare function getLegacySliceLegend(legacySlice: LegacySlice): string;

package/dist/domain/slices/SharedSlice.d.ts

@@ -0,0 +1,9 @@
+import type { SharedSlice, Variation } from "@prismicio/types-internal/lib/customtypes/widgets/slices";
+import type { SharedSliceContent } from "@prismicio/types-internal/lib/documents/widgets/slices";
+import type { NonRepeatableZone } from "../zones/NonRepeatableZone";
+import type { RepeatableZone } from "../zones/RepeatableZone";
+export declare function defaultSharedSliceContent(variationId: string): SharedSliceContent;
+export declare function getVariation(sharedSlice: SharedSlice, variationId: string): Variation | undefined;
+export declare function getSharedSliceLegend(sharedSlice: SharedSlice, variation: Variation): string;
+export declare function getNonRepeatableZone(variation: Variation): NonRepeatableZone;
+export declare function getRepeatableZone(variation: Variation): RepeatableZone;

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

@@ -0,0 +1,5 @@
+import type { NestableWidget } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { SimpleWidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
+export declare type NonRepeatableZone = Readonly<Partial<Record<string, NestableWidget>>>;
+export declare type NonRepeatableZoneContent = Readonly<Record<string, SimpleWidgetContent>>;
+export declare function updateNonRepeatableWidgetContent(nonRepeatableZoneContent: NonRepeatableZoneContent, nonRepeatableWidgetId: string, nonRepeatableWidgetContent: SimpleWidgetContent | undefined): NonRepeatableZoneContent;

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

@@ -0,0 +1,8 @@
+import type { NestableWidget } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+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 getGroupItemContentValue(groupItemContent: GroupItemContent): Readonly<Partial<Record<string, SimpleWidgetContent>>>;
+export declare function updateRepeatableWidgetContent(repeatableZoneContent: RepeatableZoneContent, groupItemContentIndex: number, repeatableWidgetIndex: number, repeatableWidgetId: string, repeatableWidgetContent: NestableWidgetContent | undefined): RepeatableZoneContent;

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

@@ -0,0 +1,8 @@
+import { EmptyContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { CompositeSliceContent, SharedSliceContent, SlicesContent as SliceZoneContent, SliceWidgetContent as SliceContent } from "@prismicio/types-internal/lib/documents/widgets/slices";
+import type { LegacySliceContent } from "../slices/LegacySlice";
+export declare function isSharedSliceContent(sliceContent: SliceContent): sliceContent is SharedSliceContent;
+export declare function isCompositeSliceContent(sliceContent: SliceContent): sliceContent is CompositeSliceContent;
+export declare function isLegacySliceContent(sliceContent: SliceContent): sliceContent is LegacySliceContent;
+export declare function isEmptyContent(sliceContent: SliceContent): sliceContent is EmptyContent;
+export declare function updateSliceContent(sliceZoneContent: SliceZoneContent, sliceZoneItemContentIndex: number, sliceContent: SliceContent | undefined): SliceZoneContent;

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

@@ -0,0 +1,5 @@
+import type { StaticWidgetContent } from "@prismicio/types-internal/lib/documents/widgets";
+import type { StaticWidget } from "../StaticWidget";
+export declare type StaticZone = Readonly<Partial<Record<string, StaticWidget>>>;
+export declare type StaticZoneContent = Readonly<Partial<Record<string, StaticWidgetContent>>>;
+export declare function getStaticZoneLegend(): string;

package/dist/fields/KeyTextField.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { Editor } from "@tiptap/core";
+import { type FC } from "react";
+declare type BubbleMenuProps = Readonly<{
+    editor: Editor;
+    nodeTypes: readonly string[];
+}>;
+export declare const BubbleMenu: FC<BubbleMenuProps>;
+export {};

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

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

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

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

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

@@ -0,0 +1,12 @@
+import type { Node as ProsemirrorNode, Schema } from "prosemirror-model";
+declare function splitTextToNodes(schema: Schema, text: string): (textToNode: (strText: string) => ProsemirrorNode) => Array<ProsemirrorNode>;
+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;
+    };
+    splitTextToNodes: typeof splitTextToNodes;
+};
+export default EditorHardBreak;

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

@@ -0,0 +1,45 @@
+import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { ReadonlyNonEmptyArray } from "fp-ts/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;
+        })[];
+    };
+    placeholder: string;
+};
+export default _default;
+export declare function mergeLists(lists: ReadonlyNonEmptyArray<ProsemirrorNode>): ProsemirrorNode | undefined;

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

@@ -0,0 +1,3 @@
+import { type ExtensionPlaceholder } from "../models";
+declare const _default: (placeholderByNodeType: Partial<Record<string, ExtensionPlaceholder>>) => import("@tiptap/core").Extension<import("@tiptap/extension-placeholder").PlaceholderOptions, any>;
+export default _default;

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

@@ -0,0 +1,4 @@
+import { Extension } from "@tiptap/core";
+export declare const SlashCommands: Extension<Readonly<{
+    nodeTypes: readonly string[];
+}>, any>;

package/dist/fields/RichTextField/coreExtensions/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 "../globalExtensions/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/coreExtensions/index.d.ts

@@ -0,0 +1,9 @@
+import { type RichText } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { Node } from "@tiptap/core";
+import { type NodeExtension } from "../models";
+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 { Document, HardBreak, ListItem, Text };

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

@@ -0,0 +1,3 @@
+import { MarkExtension } from "../models/EditorExtension";
+declare const EditorBold: MarkExtension<unknown>;
+export default EditorBold;

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

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

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

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

package/dist/fields/RichTextField/extensions/Embed/EmbedView.d.ts

@@ -0,0 +1,3 @@
+import { type FC } from "react";
+declare const EmbedView: FC;
+export default EmbedView;

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

@@ -0,0 +1,10 @@
+import { EmbedExtension } from "../../models";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        embed: {
+            setEmbed: () => ReturnType;
+        };
+    }
+}
+declare const _default: EmbedExtension;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import { type Level as TTLevel } from "@tiptap/extension-heading";
+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 = {
+    fullName: RichTextNodeType;
+    level: Level;
+};
+export declare const HeadingName: {
+    byLevel(level: Level): RichTextNodeType;
+    default(level: Level): HeadingName;
+    fromPrismic(headingName: string, levels?: ReadonlyNonEmptyArray<Level>): HeadingName | undefined;
+    fromProsemirror(nodeAttributes: ProsemirrorNode["attrs"], levels: ReadonlyNonEmptyArray<Level>): HeadingName | undefined;
+};
+declare const _default: {
+    name: string;
+    build: (nodeTypes?: Set<RichTextNodeType> | undefined) => HeadingTextExtension | undefined;
+};
+export default _default;

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

@@ -0,0 +1,3 @@
+import { MarkExtension } from "../models/EditorExtension";
+declare const EditorItalic: MarkExtension<unknown>;
+export default EditorItalic;

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

@@ -0,0 +1,4 @@
+import { LinkContent } from "@prismicio/types-internal/lib/documents/widgets/nestable/Link";
+import { MarkExtension } from "../models";
+declare const EditorLink: MarkExtension<LinkContent>;
+export default EditorLink;

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

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

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

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

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

@@ -0,0 +1,14 @@
+import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { WidgetExtension } from "../models";
+import { default as Bold } from "./Bold";
+import { default as BulletList } from "./BulletList";
+import { default as CodeBlock } from "./CodeBlock";
+import { default as Embed } from "./Embed";
+import { default as Heading } from "./Heading";
+import { default as Italic } from "./Italic";
+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 { Bold, BulletList, CodeBlock, Embed, Heading, Italic, OrderedList, Paragraph, };

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

@@ -0,0 +1,40 @@
+import { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+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"
+}
+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 richTextNodeType = RichTextNodeType.rtl;
+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>;
+};
+export {};

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

@@ -0,0 +1 @@
+export * as TextDirection from "./TextDirection";

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

@@ -0,0 +1 @@
+export { RichTextField } from "./RichTextField";

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

@@ -0,0 +1,109 @@
+import type { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+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 { Mark as ProsemirrorMark, Node as ProsemirrorNode, Schema } from "prosemirror-model";
+import type { Level } from "../extensions/Heading";
+export declare enum ExtensionType {
+    Document = "document",
+    Mark = "mark",
+    Node = "node"
+}
+export declare enum NodeType {
+    Text = "text",
+    Embed = "embed",
+    Image = "image"
+}
+export declare type Extension = WidgetExtension | DocumentExtension;
+export declare type WidgetExtension = MarkExtension<unknown> | NodeExtension;
+export declare type ExtensionPlaceholder = string | ((nodeAttrs: ProsemirrorNode["attrs"]) => string | undefined) | undefined;
+export declare class DocumentExtension {
+    readonly name: string;
+    readonly component: (multiLines: boolean) => Node;
+    readonly converter: (extensions: ReadonlyArray<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>) => {
+        fromPrismic(schema: Schema, defaultTextConverter?: (block: TextBlock) => ProsemirrorNode | undefined): (elmt: RichTextContent) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): RichTextContent | undefined;
+    });
+}
+export declare class MarkExtension<P> {
+    readonly richTextNodeTypes: NonEmptyArray<RichTextNodeType>;
+    readonly name: string;
+    readonly component: Mark;
+    readonly converter: {
+        fromPrismic(schema: Schema): (elmt: P) => ProsemirrorMark | undefined;
+        toPrismic(elmt: ProsemirrorMark): P | undefined;
+    };
+    extType: ExtensionType.Mark;
+    constructor(richTextNodeTypes: NonEmptyArray<RichTextNodeType>, name: string, component: Mark, converter: {
+        fromPrismic(schema: Schema): (elmt: P) => ProsemirrorMark | undefined;
+        toPrismic(elmt: ProsemirrorMark): P | undefined;
+    });
+}
+export declare type NodeExtension = TextExtension | EmbedExtension | ImageExtension;
+export declare class TextExtension {
+    readonly richTextNodeTypes: ReadonlyNonEmptyArray<RichTextNodeType>;
+    readonly name: string;
+    readonly component: Node;
+    readonly converter: {
+        fromPrismic(schema: Schema): (elmt: TextBlock) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): TextBlock | ReadonlyArray<TextBlock> | undefined;
+    };
+    readonly placeholder?: ExtensionPlaceholder;
+    readonly lockedFormat: boolean;
+    extType: ExtensionType.Node;
+    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;
+    }, placeholder?: ExtensionPlaceholder, lockedFormat?: boolean);
+}
+export declare class EmbedExtension {
+    readonly richTextNodeTypes: NonEmptyArray<RichTextNodeType>;
+    readonly name: string;
+    readonly component: Node;
+    readonly converter: {
+        fromPrismic(schema: Schema): (elmt: EmbedBlock) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): EmbedBlock | undefined;
+    };
+    extType: ExtensionType;
+    nodeType: NodeType.Embed;
+    constructor(richTextNodeTypes: NonEmptyArray<RichTextNodeType>, name: string, component: Node, converter: {
+        fromPrismic(schema: Schema): (elmt: EmbedBlock) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): EmbedBlock | undefined;
+    });
+}
+export declare class ImageExtension {
+    readonly richTextNodeTypes: NonEmptyArray<RichTextNodeType>;
+    readonly name: string;
+    readonly component: Node;
+    readonly converter: {
+        fromPrismic(schema: Schema): (elmt: ImageBlock) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): ImageBlock | undefined;
+    };
+    extType: ExtensionType.Node;
+    nodeType: NodeType.Image;
+    constructor(richTextNodeTypes: NonEmptyArray<RichTextNodeType>, name: string, component: Node, converter: {
+        fromPrismic(schema: Schema): (elmt: ImageBlock) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): ImageBlock | undefined;
+    });
+}
+export declare class HeadingTextExtension extends TextExtension {
+    readonly levels: ReadonlyArray<Level>;
+    constructor(richTextNodeTypes: ReadonlyNonEmptyArray<RichTextNodeType>, Component: Node, levels: ReadonlyArray<Level>, Converter: {
+        fromPrismic(schema: Schema): (elmt: TextBlock) => ProsemirrorNode | undefined;
+        toPrismic(elmt: ProsemirrorNode): TextBlock | undefined;
+    }, placeholder?: ExtensionPlaceholder);
+}
+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>;
+    });
+}

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

@@ -0,0 +1,24 @@
+import { RichTextNodeType } from "@prismicio/types-internal/lib/customtypes/widgets/nestable";
+import type { Editor, Range } from "@tiptap/core";
+import type { ReactNode } from "react";
+export declare type MenuItem = Readonly<{
+    nodeType: RichTextNodeType;
+    icon: ReactNode;
+    isActive: (editor: Editor) => boolean;
+    runCommands: (editor: Editor, options?: RunCommandsOptions) => boolean;
+} & ({
+    shortText: string;
+    text: string;
+} | {
+    shortText?: undefined;
+    text?: undefined;
+})>;
+declare type RunCommandsOptions = Readonly<{
+    can?: boolean | undefined;
+    deleteRange?: Range | undefined;
+}>;
+export declare const ALL_NODE_ITEMS: readonly MenuItem[];
+export declare const ALL_MARK_ITEMS: readonly MenuItem[];
+export declare const ALL_EXTRA_ITEMS: readonly MenuItem[];
+export declare function filterMenuItems(menuItems: readonly MenuItem[], nodeTypes: readonly string[]): readonly MenuItem[];
+export {};