@pallasoft/ps-input-components 2.2.0 → 3.1.0

package/dist/esm/portable-text-core/services/ps-portable-text-command-service.js

@@ -0,0 +1,73 @@
+import { PsPortableTextCoreConfig } from '../constants/ps-portable-text-core-config';
+import { PsPortableTextEditorService } from './ps-portable-text-editor-service';
+export class PsPortableTextCommandService {
+    static state(editor) {
+        return { active: this.active(editor), linkHref: this.linkHref(editor) };
+    }
+    static active(editor) {
+        const isActive = (name) => (editor === null ? false : editor.isActive(name));
+        const marks = PsPortableTextCoreConfig.decoratorMarks;
+        const decorators = PsPortableTextCoreConfig.decorators;
+        return {
+            bold: isActive(marks[decorators.bold]),
+            bulletedList: isActive(PsPortableTextCoreConfig.nodes.bulletList),
+            code: isActive(marks[decorators.code]),
+            italic: isActive(marks[decorators.italic]),
+            link: isActive(PsPortableTextCoreConfig.linkMark),
+            numberedList: isActive(PsPortableTextCoreConfig.nodes.orderedList),
+            quote: isActive(PsPortableTextCoreConfig.nodes.blockquote),
+            underline: isActive(marks[decorators.underline]),
+        };
+    }
+    static linkHref(editor) {
+        const href = editor === null ? undefined : editor.getAttributes(PsPortableTextCoreConfig.linkMark).href;
+        return typeof href === 'string' ? href : '';
+    }
+    static toggleDecorator(editor, decorator) {
+        const mark = PsPortableTextEditorService.lookup(PsPortableTextCoreConfig.decoratorMarks, decorator);
+        if (editor !== null && mark !== null)
+            editor.chain().focus().toggleMark(mark).run();
+    }
+    static toggleListItem(editor, listItem) {
+        const list = PsPortableTextEditorService.lookup(PsPortableTextCoreConfig.listNodes, listItem);
+        if (editor !== null && list !== null) {
+            editor.chain().focus().toggleList(list, PsPortableTextCoreConfig.nodes.listItem).run();
+        }
+    }
+    static toggleQuote(editor) {
+        if (editor !== null)
+            editor.chain().focus().toggleBlockquote().run();
+    }
+    static setLink(editor, href) {
+        if (editor === null)
+            return;
+        if (editor.state.selection.empty && !editor.isActive(PsPortableTextCoreConfig.linkMark)) {
+            editor
+                .chain()
+                .focus()
+                .insertContent({
+                type: PsPortableTextCoreConfig.nodes.text,
+                text: href.replace(PsPortableTextCoreConfig.mailtoPrefix, ''),
+                marks: [{ type: PsPortableTextCoreConfig.linkMark, attrs: { href } }],
+            })
+                .unsetMark(PsPortableTextCoreConfig.linkMark)
+                .run();
+            return;
+        }
+        editor
+            .chain()
+            .focus()
+            .extendMarkRange(PsPortableTextCoreConfig.linkMark)
+            .setLink({ href })
+            .run();
+    }
+    static removeLink(editor) {
+        if (editor !== null) {
+            editor.chain().focus().extendMarkRange(PsPortableTextCoreConfig.linkMark).unsetLink().run();
+        }
+    }
+    static focus(editor) {
+        if (editor !== null)
+            editor.commands.focus();
+    }
+}

package/dist/esm/portable-text-core/services/ps-portable-text-converter-service.js

@@ -0,0 +1,196 @@
+import { Common } from '@pallasoft/ps-models';
+import { PsPortableTextCoreConfig } from '../constants/ps-portable-text-core-config';
+import { PsPortableTextEditorService } from './ps-portable-text-editor-service';
+export class PsPortableTextConverterService {
+    static toDocument(blocks) {
+        const content = [];
+        let lists = [];
+        let quote = null;
+        (Array.isArray(blocks) ? blocks : [])
+            .filter((block) => block._type === Common.PortableTextConfig.blockType)
+            .forEach((block) => {
+            const paragraph = this.paragraph(block);
+            const listNode = this.listNode(block.listItem);
+            if (listNode === null) {
+                lists = [];
+                if (block.style !== PsPortableTextCoreConfig.styles.blockquote) {
+                    quote = null;
+                    content.push(paragraph);
+                    return;
+                }
+                if (quote === null) {
+                    quote = { type: PsPortableTextCoreConfig.nodes.blockquote, content: [] };
+                    content.push(quote);
+                }
+                this.children(quote).push(paragraph);
+                return;
+            }
+            quote = null;
+            const level = Math.min(this.level(block.level), lists.length + 1);
+            const open = lists.slice(0, level);
+            lists =
+                open.length === level && open[level - 1].type !== listNode ? open.slice(0, -1) : open;
+            if (lists.length < level) {
+                const list = { type: listNode, content: [] };
+                const parent = lists[lists.length - 1];
+                if (parent === undefined)
+                    content.push(list);
+                else
+                    this.children(this.children(parent)[this.children(parent).length - 1]).push(list);
+                lists = [...lists, list];
+            }
+            this.children(lists[level - 1]).push({
+                type: PsPortableTextCoreConfig.nodes.listItem,
+                content: [paragraph],
+            });
+        });
+        return {
+            type: PsPortableTextCoreConfig.nodes.document,
+            content: content.length === 0 ? [{ type: PsPortableTextCoreConfig.nodes.paragraph }] : content,
+        };
+    }
+    static toBlocks(document) {
+        const drafts = this.children(document).flatMap((node) => this.drafts(node, 1));
+        const isBlank = drafts.length === 1 &&
+            drafts[0].listItem === undefined &&
+            drafts[0].style === PsPortableTextCoreConfig.styles.normal &&
+            this.children(drafts[0].paragraph).length === 0;
+        return isBlank
+            ? []
+            : drafts.map((draft, index) => this.block(draft, `${PsPortableTextCoreConfig.keyPrefix.block}${index}`));
+    }
+    static drafts(node, level) {
+        if (node.type === PsPortableTextCoreConfig.nodes.paragraph) {
+            return [{ paragraph: node, style: PsPortableTextCoreConfig.styles.normal }];
+        }
+        if (node.type === PsPortableTextCoreConfig.nodes.blockquote) {
+            return this.children(node)
+                .filter((child) => child.type === PsPortableTextCoreConfig.nodes.paragraph)
+                .map((paragraph) => ({ paragraph, style: PsPortableTextCoreConfig.styles.blockquote }));
+        }
+        const listItem = this.listItem(node.type);
+        if (listItem === null)
+            return [];
+        return this.children(node).flatMap((item) => this.children(item).flatMap((child) => child.type === PsPortableTextCoreConfig.nodes.paragraph
+            ? [
+                {
+                    level: Math.min(level, Common.PortableTextConfig.maxListLevel),
+                    listItem,
+                    paragraph: child,
+                    style: PsPortableTextCoreConfig.styles.normal,
+                },
+            ]
+            : this.drafts(child, level + 1)));
+    }
+    static block(draft, key) {
+        const hrefs = Array.from(new Set(this.children(draft.paragraph).flatMap((node) => this.marks(node)
+            .filter((mark) => mark.type === PsPortableTextCoreConfig.linkMark)
+            .map((mark) => this.href(mark))
+            .filter((href) => href !== null))));
+        const markDefs = hrefs.map((href, index) => ({
+            _key: `${key}${PsPortableTextCoreConfig.keyPrefix.link}${index}`,
+            _type: PsPortableTextCoreConfig.linkAnnotation,
+            href,
+        }));
+        const spans = this.spans(draft.paragraph, markDefs);
+        const children = (spans.length === 0 ? [{ marks: [], text: '' }] : spans).map((span, index) => ({
+            _key: `${key}${PsPortableTextCoreConfig.keyPrefix.span}${index}`,
+            _type: Common.PortableTextConfig.spanType,
+            marks: span.marks,
+            text: span.text,
+        }));
+        const base = {
+            _key: key,
+            _type: Common.PortableTextConfig.blockType,
+            children,
+            markDefs,
+            style: draft.style,
+        };
+        return draft.listItem === undefined
+            ? base
+            : { ...base, level: draft.level, listItem: draft.listItem };
+    }
+    static spans(paragraph, markDefs) {
+        return this.children(paragraph).reduce((spans, node) => {
+            const previous = spans[spans.length - 1];
+            const isBreak = node.type === PsPortableTextCoreConfig.nodes.hardBreak;
+            if (!isBreak && (node.type !== PsPortableTextCoreConfig.nodes.text || !node.text)) {
+                return spans;
+            }
+            const marks = this.spanMarks(node, markDefs);
+            const text = isBreak ? PsPortableTextCoreConfig.lineBreak : String(node.text);
+            return previous !== undefined && this.isSame(previous.marks, marks)
+                ? [...spans.slice(0, -1), { marks, text: previous.text + text }]
+                : [...spans, { marks, text }];
+        }, []);
+    }
+    static spanMarks(node, markDefs) {
+        const types = this.marks(node).map((mark) => mark.type);
+        const decorators = Common.PortableTextConfig.decorators.filter((decorator) => types.includes(PsPortableTextCoreConfig.decoratorMarks[decorator]));
+        const links = this.marks(node)
+            .filter((mark) => mark.type === PsPortableTextCoreConfig.linkMark)
+            .map((mark) => markDefs.find((definition) => definition.href === this.href(mark)))
+            .filter((definition) => definition !== undefined)
+            .map((definition) => definition._key);
+        return [...decorators, ...links];
+    }
+    static paragraph(block) {
+        const links = new Map((Array.isArray(block.markDefs) ? block.markDefs : [])
+            .filter((definition) => definition._type === PsPortableTextCoreConfig.linkAnnotation)
+            .map((definition) => [
+            definition._key,
+            typeof definition.href === 'string'
+                ? PsPortableTextEditorService.normalizeLink(definition.href)
+                : null,
+        ]));
+        const content = (Array.isArray(block.children) ? block.children : [])
+            .filter((child) => child._type === Common.PortableTextConfig.spanType && typeof child.text === 'string')
+            .flatMap((child) => {
+            const marks = (Array.isArray(child.marks) ? child.marks : [])
+                .filter((mark) => typeof mark === 'string')
+                .flatMap((mark) => {
+                const decorator = PsPortableTextEditorService.lookup(PsPortableTextCoreConfig.decoratorMarks, mark);
+                const href = links.get(mark);
+                if (decorator !== null)
+                    return [{ type: decorator }];
+                return typeof href === 'string'
+                    ? [{ type: PsPortableTextCoreConfig.linkMark, attrs: { href } }]
+                    : [];
+            });
+            return String(child.text)
+                .split(PsPortableTextCoreConfig.lineBreak)
+                .flatMap((text, index) => [
+                ...(index === 0 ? [] : [{ type: PsPortableTextCoreConfig.nodes.hardBreak, marks }]),
+                ...(text === '' ? [] : [{ type: PsPortableTextCoreConfig.nodes.text, text, marks }]),
+            ]);
+        });
+        return content.length === 0
+            ? { type: PsPortableTextCoreConfig.nodes.paragraph }
+            : { type: PsPortableTextCoreConfig.nodes.paragraph, content };
+    }
+    static listNode(listItem) {
+        return PsPortableTextEditorService.lookup(PsPortableTextCoreConfig.listNodes, listItem);
+    }
+    static listItem(type) {
+        const match = Object.entries(PsPortableTextCoreConfig.listNodes).find(([, node]) => node === type);
+        return match === undefined ? null : match[0];
+    }
+    static level(level) {
+        return typeof level === 'number' && Number.isInteger(level)
+            ? Math.max(1, Math.min(level, Common.PortableTextConfig.maxListLevel))
+            : 1;
+    }
+    static href(mark) {
+        const href = mark.attrs === undefined ? undefined : mark.attrs.href;
+        return typeof href === 'string' ? PsPortableTextEditorService.normalizeLink(href) : null;
+    }
+    static marks(node) {
+        return Array.isArray(node.marks) ? node.marks : [];
+    }
+    static children(node) {
+        return Array.isArray(node.content) ? node.content : [];
+    }
+    static isSame(first, second) {
+        return first.length === second.length && first.every((mark, index) => mark === second[index]);
+    }
+}

package/dist/esm/portable-text-core/services/ps-portable-text-editor-service.js

@@ -27,4 +27,8 @@ export class PsPortableTextEditorService {
     static isSame(first, second) {
         return JSON.stringify(first) === JSON.stringify(second);
     }
+    static lookup(record, key) {
+        const match = Object.entries(record).find(([name]) => name === key);
+        return match === undefined ? null : match[1];
+    }
 }

package/dist/esm/portable-text-core/services/ps-portable-text-extension-service.js

@@ -0,0 +1,89 @@
+import { Common } from '@pallasoft/ps-models';
+import { Extension } from '@tiptap/core';
+import { Blockquote } from '@tiptap/extension-blockquote';
+import { Bold } from '@tiptap/extension-bold';
+import { Code } from '@tiptap/extension-code';
+import { Document } from '@tiptap/extension-document';
+import { HardBreak } from '@tiptap/extension-hard-break';
+import { Italic } from '@tiptap/extension-italic';
+import { Link } from '@tiptap/extension-link';
+import { BulletList, ListItem, ListKeymap, OrderedList } from '@tiptap/extension-list';
+import { Paragraph } from '@tiptap/extension-paragraph';
+import { Text } from '@tiptap/extension-text';
+import { Underline } from '@tiptap/extension-underline';
+import { Placeholder, UndoRedo } from '@tiptap/extensions';
+import { PsPortableTextCoreConfig } from '../constants/ps-portable-text-core-config';
+import { PsPortableTextEditorService } from './ps-portable-text-editor-service';
+export class PsPortableTextExtensionService {
+    static extensions({ classNames, onLinkShortcut, placeholder, }) {
+        return [
+            Document,
+            Paragraph,
+            Text,
+            HardBreak,
+            Bold,
+            Italic,
+            Underline,
+            Code.extend({ excludes: Code.name }).configure({
+                HTMLAttributes: { class: classNames.code },
+            }),
+            Blockquote.extend({ content: PsPortableTextCoreConfig.blockquoteContent }).configure({
+                HTMLAttributes: { class: classNames.blockquote },
+            }),
+            BulletList.configure({ HTMLAttributes: { class: classNames.bulletList } }),
+            OrderedList.configure({ HTMLAttributes: { class: classNames.orderedList } }),
+            ListItem.extend({
+                content: PsPortableTextCoreConfig.listItemContent,
+                addKeyboardShortcuts() {
+                    return {
+                        ...this.parent?.(),
+                        [PsPortableTextCoreConfig.shortcuts.nest]: () => PsPortableTextExtensionService.nest(this.editor),
+                        [PsPortableTextCoreConfig.shortcuts.unnest]: () => PsPortableTextExtensionService.unnest(this.editor),
+                    };
+                },
+            }),
+            ListKeymap,
+            Link.configure({
+                autolink: true,
+                defaultProtocol: PsPortableTextCoreConfig.defaultLinkProtocol,
+                HTMLAttributes: { class: classNames.link },
+                isAllowedUri: (url, context) => context.defaultValidate(url) && PsPortableTextEditorService.normalizeLink(url) !== null,
+                linkOnPaste: true,
+                openOnClick: false,
+            }),
+            Placeholder.configure({
+                emptyEditorClass: classNames.placeholder,
+                placeholder: ({ editor }) => (editor.isEmpty ? placeholder : ''),
+            }),
+            UndoRedo,
+            Extension.create({
+                name: PsPortableTextCoreConfig.linkShortcutExtension,
+                addKeyboardShortcuts: () => ({
+                    [PsPortableTextCoreConfig.shortcuts.link]: () => {
+                        onLinkShortcut();
+                        return true;
+                    },
+                }),
+            }),
+        ];
+    }
+    static listDepth(editor) {
+        const { $from } = editor.state.selection;
+        return Array.from({ length: $from.depth }, (_, index) => $from.node(index + 1)).filter((node) => node.type.name === PsPortableTextCoreConfig.nodes.listItem).length;
+    }
+    static nest(editor) {
+        const depth = PsPortableTextExtensionService.listDepth(editor);
+        if (depth === 0)
+            return false;
+        if (depth < Common.PortableTextConfig.maxListLevel) {
+            editor.commands.sinkListItem(PsPortableTextCoreConfig.nodes.listItem);
+        }
+        return true;
+    }
+    static unnest(editor) {
+        if (PsPortableTextExtensionService.listDepth(editor) === 0)
+            return false;
+        editor.commands.liftListItem(PsPortableTextCoreConfig.nodes.listItem);
+        return true;
+    }
+}

package/dist/esm/portable-text-engine/index.js

@@ -0,0 +1 @@
+export * from '../portable-text-core/components/ps-portable-text-core-editor';

package/dist/esm/portable-text-engine/worker.js

@@ -0,0 +1 @@
+export * from '../portable-text-core/components/ps-portable-text-core-editor-stub';

package/dist/portable-text/index.d.ts

@@ -1,3 +1,3 @@
 export * from '../components/ps-portable-text-editor';
 export * from '../portable-text-core/interfaces/ps-portable-text-editor-labels';
-export type { PortableTextBlock } from '@portabletext/editor';
+export type { PortableTextBlock } from '@portabletext/schema';

package/dist/portable-text-core/components/ps-portable-text-core-editor-stub.d.ts

@@ -0,0 +1,2 @@
+import type { PsPortableTextCoreProps } from '../interfaces/ps-portable-text-core-props';
+export declare const PsPortableTextCoreEditor: ({ className, fallback }: PsPortableTextCoreProps) => import("react").JSX.Element;

package/dist/portable-text-core/components/ps-portable-text-core-editor-stub.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsPortableTextCoreEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const PsPortableTextCoreEditor = ({ className, fallback }) => ((0, jsx_runtime_1.jsx)("div", { className: className, children: fallback }));
+exports.PsPortableTextCoreEditor = PsPortableTextCoreEditor;

package/dist/portable-text-core/components/ps-portable-text-core-editor.d.ts

@@ -0,0 +1,2 @@
+import type { PsPortableTextCoreProps } from '../interfaces/ps-portable-text-core-props';
+export declare const PsPortableTextCoreEditor: ({ className, classNames, disabled, editableClassName, label, minRows, onChange, placeholder, toolbar, value, }: PsPortableTextCoreProps) => import("react").JSX.Element;

package/dist/portable-text-core/components/ps-portable-text-core-editor.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsPortableTextCoreEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_2 = require("@tiptap/react");
+const ps_portable_text_core_context_1 = require("../contexts/ps-portable-text-core-context");
+const ps_portable_text_command_service_1 = require("../services/ps-portable-text-command-service");
+const ps_portable_text_converter_service_1 = require("../services/ps-portable-text-converter-service");
+const ps_portable_text_editor_service_1 = require("../services/ps-portable-text-editor-service");
+const ps_portable_text_extension_service_1 = require("../services/ps-portable-text-extension-service");
+const PsPortableTextCoreEditor = ({ className, classNames, disabled = false, editableClassName = '', label, minRows = 4, onChange, placeholder = '', toolbar, value, }) => {
+    const [isLinkOpen, setIsLinkOpen] = (0, react_1.useState)(false);
+    const lastValue = (0, react_1.useRef)(value);
+    const editor = (0, react_2.useEditor)({
+        content: ps_portable_text_converter_service_1.PsPortableTextConverterService.toDocument(value),
+        editable: !disabled,
+        editorProps: {
+            attributes: {
+                ...(label === undefined ? {} : { 'aria-label': label }),
+                'aria-multiline': 'true',
+                'class': editableClassName,
+                'role': 'textbox',
+                'style': `min-height: ${ps_portable_text_editor_service_1.PsPortableTextEditorService.minHeight(minRows)}`,
+            },
+        },
+        extensions: ps_portable_text_extension_service_1.PsPortableTextExtensionService.extensions({
+            classNames,
+            onLinkShortcut: () => setIsLinkOpen(true),
+            placeholder,
+        }),
+        immediatelyRender: true,
+    }, []);
+    const state = (0, react_2.useEditorState)({
+        editor,
+        selector: ({ editor: current }) => ps_portable_text_command_service_1.PsPortableTextCommandService.state(current),
+    });
+    (0, react_1.useEffect)(() => {
+        editor.setEditable(!disabled, false);
+    }, [editor, disabled]);
+    (0, react_1.useEffect)(() => {
+        const update = () => {
+            const next = ps_portable_text_converter_service_1.PsPortableTextConverterService.toBlocks(editor.getJSON());
+            lastValue.current = next;
+            onChange(next);
+        };
+        editor.on('update', update);
+        return () => {
+            editor.off('update', update);
+        };
+    }, [editor, onChange]);
+    (0, react_1.useEffect)(() => {
+        if (ps_portable_text_editor_service_1.PsPortableTextEditorService.isSame(value, lastValue.current))
+            return;
+        lastValue.current = value;
+        editor.commands.setContent(ps_portable_text_converter_service_1.PsPortableTextConverterService.toDocument(value), {
+            emitUpdate: false,
+        });
+    }, [editor, value]);
+    return ((0, jsx_runtime_1.jsx)("div", { className: className, children: (0, jsx_runtime_1.jsxs)(ps_portable_text_core_context_1.PsPortableTextCoreContext.Provider, { value: {
+                closeLink: () => setIsLinkOpen(false),
+                editor,
+                isLinkOpen,
+                openLink: () => setIsLinkOpen(true),
+                state,
+            }, children: [toolbar, (0, jsx_runtime_1.jsx)(react_2.EditorContent, { editor: editor })] }) }));
+};
+exports.PsPortableTextCoreEditor = PsPortableTextCoreEditor;

package/dist/portable-text-core/components/ps-portable-text-core.d.ts

@@ -1,17 +1,2 @@
-import { type ReactNode } from 'react';
-import { type PortableTextBlock, type RenderAnnotationFunction, type RenderBlockFunction, type RenderDecoratorFunction, type RenderPlaceholderFunction } from '@portabletext/editor';
-export interface PsPortableTextCoreProps {
-    className?: string;
-    disabled?: boolean;
-    editableClassName?: string;
-    fallback?: ReactNode;
-    minRows?: number;
-    onChange: (value: PortableTextBlock[]) => void;
-    renderAnnotation?: RenderAnnotationFunction;
-    renderBlock?: RenderBlockFunction;
-    renderDecorator?: RenderDecoratorFunction;
-    renderPlaceholder?: RenderPlaceholderFunction;
-    toolbar?: ReactNode;
-    value: PortableTextBlock[];
-}
-export declare const PsPortableTextCore: ({ className, disabled, editableClassName, fallback, minRows, onChange, renderAnnotation, renderBlock, renderDecorator, renderPlaceholder, toolbar, value, }: PsPortableTextCoreProps) => import("react").JSX.Element;
+import type { PsPortableTextCoreProps } from '../interfaces/ps-portable-text-core-props';
+export declare const PsPortableTextCore: (props: PsPortableTextCoreProps) => import("react").JSX.Element;

package/dist/portable-text-core/components/ps-portable-text-core.js

@@ -3,33 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsPortableTextCore = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
-const editor_1 = require("@portabletext/editor");
-const plugins_1 = require("@portabletext/editor/plugins");
-const ps_portable_text_core_config_1 = require("../constants/ps-portable-text-core-config");
-const ps_portable_text_editor_service_1 = require("../services/ps-portable-text-editor-service");
-const PsPortableTextCore = ({ className, disabled = false, editableClassName, fallback, minRows = 4, onChange, renderAnnotation, renderBlock, renderDecorator, renderPlaceholder, toolbar, value, }) => {
+const portable_text_engine_1 = require("@pallasoft/ps-input-components/portable-text-engine");
+const PsPortableTextCore = (props) => {
     const [isMounted, setIsMounted] = (0, react_1.useState)(false);
-    const [version, setVersion] = (0, react_1.useState)(0);
-    const lastValue = (0, react_1.useRef)(value);
     (0, react_1.useEffect)(() => {
         setIsMounted(true);
     }, []);
-    (0, react_1.useEffect)(() => {
-        if (ps_portable_text_editor_service_1.PsPortableTextEditorService.isSame(value, lastValue.current))
-            return;
-        lastValue.current = value;
-        setVersion((current) => current + 1);
-    }, [value]);
-    return ((0, jsx_runtime_1.jsx)("div", { className: className, children: isMounted ? ((0, jsx_runtime_1.jsxs)(editor_1.EditorProvider, { initialConfig: {
-                initialValue: value,
-                readOnly: disabled,
-                schemaDefinition: ps_portable_text_core_config_1.PsPortableTextCoreConfig.schemaDefinition,
-            }, children: [(0, jsx_runtime_1.jsx)(plugins_1.EventListenerPlugin, { on: (event) => {
-                        if (event.type !== 'mutation')
-                            return;
-                        const next = Array.isArray(event.value) ? event.value : [];
-                        lastValue.current = next;
-                        onChange(next);
-                    } }), toolbar, (0, jsx_runtime_1.jsx)(editor_1.PortableTextEditable, { className: editableClassName, readOnly: disabled, renderAnnotation: renderAnnotation, renderBlock: renderBlock, renderDecorator: renderDecorator, renderPlaceholder: renderPlaceholder, style: { minHeight: ps_portable_text_editor_service_1.PsPortableTextEditorService.minHeight(minRows) } })] }, version)) : (fallback) }));
+    return isMounted ? ((0, jsx_runtime_1.jsx)(portable_text_engine_1.PsPortableTextCoreEditor, { ...props })) : ((0, jsx_runtime_1.jsx)("div", { className: props.className, children: props.fallback }));
 };
 exports.PsPortableTextCore = PsPortableTextCore;

package/dist/portable-text-core/constants/ps-portable-text-core-config.d.ts

@@ -3,6 +3,13 @@ export declare const PsPortableTextCoreConfig: {
     readonly mailtoPrefix: "mailto:";
     readonly emailPattern: RegExp;
     readonly lineHeightRem: 1.5;
+    readonly lineBreak: "\n";
+    readonly defaultLinkProtocol: "https";
+    readonly keyPrefix: {
+        readonly block: "b";
+        readonly link: "l";
+        readonly span: "s";
+    };
     readonly decorators: {
         readonly bold: "strong";
         readonly code: "code";
@@ -17,31 +24,41 @@ export declare const PsPortableTextCoreConfig: {
         readonly bullet: "bullet";
         readonly number: "number";
     };
-    readonly schemaDefinition: {
-        readonly annotations: readonly [{
-            readonly name: "link";
-            readonly fields: readonly [{
-                readonly name: "href";
-                readonly type: "string";
-            }];
-        }];
-        readonly blockObjects: readonly [];
-        readonly decorators: {
-            name: "code" | "em" | "strong" | "underline";
-        }[];
-        readonly inlineObjects: readonly [];
-        readonly lists: {
-            name: "number" | "bullet";
-        }[];
-        readonly styles: {
-            name: "blockquote" | "normal";
-        }[];
+    readonly decoratorMarks: {
+        readonly strong: "bold";
+        readonly em: "italic";
+        readonly underline: "underline";
+        readonly code: "code";
+    };
+    readonly listNodes: {
+        readonly bullet: "bulletList";
+        readonly number: "orderedList";
+    };
+    readonly nodes: {
+        readonly blockquote: "blockquote";
+        readonly bulletList: "bulletList";
+        readonly document: "doc";
+        readonly hardBreak: "hardBreak";
+        readonly listItem: "listItem";
+        readonly orderedList: "orderedList";
+        readonly paragraph: "paragraph";
+        readonly text: "text";
+    };
+    readonly linkMark: "link";
+    readonly linkShortcutExtension: "psLinkShortcut";
+    readonly listItemContent: "paragraph (bulletList | orderedList)*";
+    readonly blockquoteContent: "paragraph+";
+    readonly shortcuts: {
+        readonly link: "Mod-k";
+        readonly nest: "Tab";
+        readonly unnest: "Shift-Tab";
     };
     readonly labels: {
         bold: string;
         bulletedList: string;
         cancel: string;
         code: string;
+        editor: string;
         invalidLink: string;
         italic: string;
         link: string;