@alpaca-editor/core 1.0.3767 → 1.0.3769

package/dist/editor/field-types/ReactQuill.d.ts

@@ -0,0 +1,125 @@
+import React from "react";
+import Quill, { type EmitterSource, type Range as RangeStatic, QuillOptions as QuillOptionsStatic } from "quill";
+import type DeltaStatic from "quill-delta";
+declare namespace ReactQuill {
+    type Value = string | DeltaStatic;
+    type Range = RangeStatic | null;
+    interface QuillOptions extends QuillOptionsStatic {
+        scrollingContainer?: HTMLElement | string | undefined;
+        strict?: boolean | undefined;
+        tabIndex?: number;
+    }
+    interface ReactQuillProps {
+        bounds?: string | HTMLElement;
+        children?: React.ReactElement<any>;
+        className?: string;
+        defaultValue?: Value;
+        formats?: string[];
+        id?: string;
+        modules?: QuillOptions["modules"];
+        onChange?(value: string, delta: DeltaStatic, source: EmitterSource, editor: UnprivilegedEditor): void;
+        onChangeSelection?(selection: Range, source: EmitterSource, editor: UnprivilegedEditor): void;
+        onFocus?(selection: Range, source: EmitterSource, editor: UnprivilegedEditor): void;
+        onBlur?(previousSelection: Range, source: EmitterSource, editor: UnprivilegedEditor): void;
+        onKeyDown?: React.EventHandler<any>;
+        onKeyPress?: React.EventHandler<any>;
+        onKeyUp?: React.EventHandler<any>;
+        placeholder?: string;
+        preserveWhitespace?: boolean;
+        readOnly?: boolean;
+        scrollingContainer?: string | HTMLElement;
+        style?: React.CSSProperties;
+        tabIndex?: number;
+        theme?: string;
+        value?: Value;
+    }
+    interface UnprivilegedEditor {
+        getLength: Quill["getLength"];
+        getText: Quill["getText"];
+        getHTML: Quill["getSemanticHTML"];
+        getBounds: Quill["getBounds"];
+        getSelection: Quill["getSelection"];
+        getContents: Quill["getContents"];
+    }
+}
+import Value = ReactQuill.Value;
+import Range = ReactQuill.Range;
+import QuillOptions = ReactQuill.QuillOptions;
+import ReactQuillProps = ReactQuill.ReactQuillProps;
+import UnprivilegedEditor = ReactQuill.UnprivilegedEditor;
+interface ReactQuillState {
+    generation: number;
+}
+export declare class ReactQuill extends React.Component<ReactQuillProps, ReactQuillState> {
+    static displayName: string;
+    static Quill: typeof Quill;
+    dirtyProps: (keyof ReactQuillProps)[];
+    cleanProps: (keyof ReactQuillProps)[];
+    static defaultProps: {
+        theme: string;
+        modules: {};
+        readOnly: boolean;
+    };
+    state: ReactQuillState;
+    editor?: Quill;
+    editingArea?: React.ReactInstance | null;
+    value: Value;
+    selection: Range;
+    lastDeltaChangeSet?: DeltaStatic;
+    regenerationSnapshot?: {
+        delta: DeltaStatic;
+        selection: Range;
+    };
+    unprivilegedEditor?: UnprivilegedEditor;
+    private editingAreaRef;
+    constructor(props: ReactQuillProps);
+    validateProps(props: ReactQuillProps): void;
+    shouldComponentUpdate(nextProps: ReactQuillProps, nextState: ReactQuillState): boolean;
+    shouldComponentRegenerate(nextProps: ReactQuillProps): boolean;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: ReactQuillProps, prevState: ReactQuillState): void;
+    instantiateEditor(): void;
+    destroyEditor(): void;
+    isControlled(): boolean;
+    getEditorConfig(): QuillOptions;
+    getEditor(): Quill;
+    /**
+    Creates an editor on the given element. The editor will be passed the
+    configuration, have its events bound,
+    */
+    createEditor(element: HTMLElement, config: QuillOptions): Quill;
+    hookEditor(editor: Quill): void;
+    unhookEditor(editor: Quill): void;
+    getEditorContents(): Value;
+    getEditorSelection(): Range;
+    isDelta(value: any): boolean;
+    isEqualValue(value: any, nextValue: any): boolean;
+    setEditorContents(editor: Quill, value: Value): void;
+    setEditorSelection(editor: Quill, range: Range): void;
+    setEditorTabIndex(editor: Quill, tabIndex: number): void;
+    setEditorReadOnly(editor: Quill, value: boolean): void;
+    makeUnprivilegedEditor(editor: Quill): {
+        getHTML: () => string;
+        getLength: () => number;
+        getText: {
+            (range?: RangeStatic): string;
+            (index?: number, length?: number): string;
+        };
+        getContents: (index?: number, length?: number) => DeltaStatic;
+        getSelection: {
+            (focus: true): RangeStatic;
+            (focus?: boolean): RangeStatic | null;
+        };
+        getBounds: (index: number | RangeStatic, length?: number) => import("quill").Bounds | null;
+    };
+    getEditingArea(): HTMLElement;
+    renderEditingArea(): React.ReactNode;
+    render(): import("react/jsx-runtime").JSX.Element;
+    onEditorChange: (eventName: "text-change" | "selection-change", rangeOrDelta: Range | DeltaStatic, source: EmitterSource) => void;
+    onEditorChangeText(value: string, delta: DeltaStatic, source: EmitterSource, editor: UnprivilegedEditor): void;
+    onEditorChangeSelection(nextSelection: RangeStatic, source: EmitterSource, editor: UnprivilegedEditor): void;
+    focus(): void;
+    blur(): void;
+}
+export {};

package/dist/editor/field-types/ReactQuill.js

@@ -1,75 +1,94 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactQuill = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
+import { jsx as _jsx } from "react/jsx-runtime";
 /*
 React-Quill
 https://github.com/zenoamaro/react-quill
 */
-const react_1 = __importDefault(require("react"));
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const quill_1 = __importDefault(require("quill"));
-class ReactQuill extends react_1.default.Component {
+import React from "react";
+import isEqual from "lodash/isEqual";
+import Quill from "quill";
+export class ReactQuill extends React.Component {
+    static displayName = "React Quill";
+    /*
+    Export Quill to be able to call `register`
+    */
+    static Quill = Quill;
+    /*
+    Changing one of these props should cause a full re-render and a
+    re-instantiation of the Quill editor.
+    */
+    dirtyProps = [
+        "modules",
+        "formats",
+        "bounds",
+        "theme",
+        "children",
+    ];
+    /*
+    Changing one of these props should cause a regular update. These are mostly
+    props that act on the container, rather than the quillized editing area.
+    */
+    cleanProps = [
+        "id",
+        "className",
+        "style",
+        "placeholder",
+        "tabIndex",
+        "onChange",
+        "onChangeSelection",
+        "onFocus",
+        "onBlur",
+        "onKeyPress",
+        "onKeyDown",
+        "onKeyUp",
+    ];
+    static defaultProps = {
+        theme: "snow",
+        modules: {},
+        readOnly: false,
+    };
+    state = {
+        generation: 0,
+    };
+    /*
+    The Quill Editor instance.
+    */
+    editor;
+    /*
+    Reference to the element holding the Quill editing area.
+    */
+    editingArea;
+    /*
+    Tracks the internal value of the Quill editor
+    */
+    value;
+    /*
+    Tracks the internal selection of the Quill editor
+    */
+    selection = null;
+    /*
+    Used to compare whether deltas from `onChange` are being used as `value`.
+    */
+    lastDeltaChangeSet;
+    /*
+    Stores the contents of the editor to be restored after regeneration.
+    */
+    regenerationSnapshot;
+    /*
+    A weaker, unprivileged proxy for the editor that does not allow accidentally
+    modifying editor state.
+    */
+    unprivilegedEditor;
+    editingAreaRef = React.createRef();
     constructor(props) {
         super(props);
-        /*
-        Changing one of these props should cause a full re-render and a
-        re-instantiation of the Quill editor.
-        */
-        this.dirtyProps = [
-            "modules",
-            "formats",
-            "bounds",
-            "theme",
-            "children",
-        ];
-        /*
-        Changing one of these props should cause a regular update. These are mostly
-        props that act on the container, rather than the quillized editing area.
-        */
-        this.cleanProps = [
-            "id",
-            "className",
-            "style",
-            "placeholder",
-            "tabIndex",
-            "onChange",
-            "onChangeSelection",
-            "onFocus",
-            "onBlur",
-            "onKeyPress",
-            "onKeyDown",
-            "onKeyUp",
-        ];
-        this.state = {
-            generation: 0,
-        };
-        /*
-        Tracks the internal selection of the Quill editor
-        */
-        this.selection = null;
-        this.editingAreaRef = react_1.default.createRef();
-        this.onEditorChange = (eventName, rangeOrDelta, 
-        //oldRangeOrDelta: Range | DeltaStatic,
-        source) => {
-            if (eventName === "text-change") {
-                this.onEditorChangeText?.(this.editor.root.innerHTML, rangeOrDelta, source, this.unprivilegedEditor);
-            }
-            else if (eventName === "selection-change") {
-                this.onEditorChangeSelection?.(rangeOrDelta, source, this.unprivilegedEditor);
-            }
-        };
         const value = this.isControlled() ? props.value : props.defaultValue;
         this.value = value ?? "";
     }
     validateProps(props) {
-        if (react_1.default.Children.count(props.children) > 1)
+        if (React.Children.count(props.children) > 1)
             throw new Error("The Quill editing area can only be composed of a single React element.");
-        if (react_1.default.Children.count(props.children)) {
-            const child = react_1.default.Children.only(props.children);
+        if (React.Children.count(props.children)) {
+            const child = React.Children.only(props.children);
             if (child?.type === "textarea")
                 throw new Error("Quill does not support editing on a <textarea>. Use a <div> instead.");
         }
@@ -105,13 +124,13 @@ class ReactQuill extends react_1.default.Component {
         }
         // Clean and Dirty props require a render
         return [...this.cleanProps, ...this.dirtyProps].some((prop) => {
-            return !(0, isEqual_1.default)(nextProps[prop], this.props[prop]);
+            return !isEqual(nextProps[prop], this.props[prop]);
         });
     }
     shouldComponentRegenerate(nextProps) {
         // Whenever a `dirtyProp` changes, the editor needs reinstantiation.
         return this.dirtyProps.some((prop) => {
-            return !(0, isEqual_1.default)(nextProps[prop], this.props[prop]);
+            return !isEqual(nextProps[prop], this.props[prop]);
         });
     }
     componentDidMount() {
@@ -185,7 +204,7 @@ class ReactQuill extends react_1.default.Component {
     configuration, have its events bound,
     */
     createEditor(element, config) {
-        const editor = new quill_1.default(element, config);
+        const editor = new Quill(element, config);
         if (config.tabIndex != null) {
             this.setEditorTabIndex(editor, config.tabIndex);
         }
@@ -220,10 +239,10 @@ class ReactQuill extends react_1.default.Component {
     */
     isEqualValue(value, nextValue) {
         if (this.isDelta(value) && this.isDelta(nextValue)) {
-            return (0, isEqual_1.default)(value.ops, nextValue.ops);
+            return isEqual(value.ops, nextValue.ops);
         }
         else {
-            return (0, isEqual_1.default)(value, nextValue);
+            return isEqual(value, nextValue);
         }
     }
     /*
@@ -292,16 +311,26 @@ class ReactQuill extends react_1.default.Component {
     renderEditingArea() {
         const { children, preserveWhitespace } = this.props;
         const { generation } = this.state;
-        if (react_1.default.Children.count(children)) {
-            return react_1.default.cloneElement(react_1.default.Children.only(children), {
+        if (React.Children.count(children)) {
+            return React.cloneElement(React.Children.only(children), {
                 ref: this.editingAreaRef,
             });
         }
-        return preserveWhitespace ? ((0, jsx_runtime_1.jsx)("pre", { ref: this.editingAreaRef }, generation)) : ((0, jsx_runtime_1.jsx)("div", { ref: this.editingAreaRef }, generation));
+        return preserveWhitespace ? (_jsx("pre", { ref: this.editingAreaRef }, generation)) : (_jsx("div", { ref: this.editingAreaRef }, generation));
     }
     render() {
-        return ((0, jsx_runtime_1.jsx)("div", { id: this.props.id, style: this.props.style, className: `quill ${this.props.className ?? ""}`, onKeyPress: this.props.onKeyPress, onKeyDownCapture: this.props.onKeyDown, onKeyUp: this.props.onKeyUp, children: this.renderEditingArea() }, this.state.generation));
+        return (_jsx("div", { id: this.props.id, style: this.props.style, className: `quill ${this.props.className ?? ""}`, onKeyPress: this.props.onKeyPress, onKeyDownCapture: this.props.onKeyDown, onKeyUp: this.props.onKeyUp, children: this.renderEditingArea() }, this.state.generation));
     }
+    onEditorChange = (eventName, rangeOrDelta, 
+    //oldRangeOrDelta: Range | DeltaStatic,
+    source) => {
+        if (eventName === "text-change") {
+            this.onEditorChangeText?.(this.editor.root.innerHTML, rangeOrDelta, source, this.unprivilegedEditor);
+        }
+        else if (eventName === "selection-change") {
+            this.onEditorChangeSelection?.(rangeOrDelta, source, this.unprivilegedEditor);
+        }
+    };
     onEditorChangeText(value, delta, source, editor) {
         if (!this.editor)
             return;
@@ -324,7 +353,7 @@ class ReactQuill extends react_1.default.Component {
         const currentSelection = this.getEditorSelection();
         const hasGainedFocus = !currentSelection && nextSelection;
         const hasLostFocus = currentSelection && !nextSelection;
-        if ((0, isEqual_1.default)(nextSelection, currentSelection))
+        if (isEqual(nextSelection, currentSelection))
             return;
         this.selection = nextSelection;
         this.props.onChangeSelection?.(nextSelection, source, editor);
@@ -347,17 +376,6 @@ class ReactQuill extends react_1.default.Component {
         this.editor.blur();
     }
 }
-exports.ReactQuill = ReactQuill;
-ReactQuill.displayName = "React Quill";
-/*
-Export Quill to be able to call `register`
-*/
-ReactQuill.Quill = quill_1.default;
-ReactQuill.defaultProps = {
-    theme: "snow",
-    modules: {},
-    readOnly: false,
-};
 /*
 Small helper to execute a function in the next micro-tick.
 */

package/dist/editor/field-types/RichTextEditor.d.ts

@@ -0,0 +1,5 @@
+import { Field } from "../pageModel";
+export declare function RichTextEditor({ field, readOnly, }: {
+    field: Field;
+    readOnly?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/editor/field-types/RichTextEditor.js

@@ -1,46 +1,7 @@
 "use client";
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RichTextEditor = RichTextEditor;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const dynamic_1 = __importDefault(require("next/dynamic"));
-const RichTextEditorComponent = (0, dynamic_1.default)(() => Promise.resolve().then(() => __importStar(require("./RichTextEditorComponent"))).then((dnd) => dnd.RichTextEditorComponent), { ssr: false });
-function RichTextEditor({ field, readOnly, }) {
-    return (0, jsx_runtime_1.jsx)(RichTextEditorComponent, { field: field, readOnly: readOnly });
+import { jsx as _jsx } from "react/jsx-runtime";
+import dynamic from "next/dynamic";
+const RichTextEditorComponent = dynamic(() => import("./RichTextEditorComponent").then((dnd) => dnd.RichTextEditorComponent), { ssr: false });
+export function RichTextEditor({ field, readOnly, }) {
+    return _jsx(RichTextEditorComponent, { field: field, readOnly: readOnly });
 }

package/dist/editor/field-types/RichTextEditorComponent.d.ts

@@ -0,0 +1,6 @@
+import "react-quill-new/dist/quill.snow.css";
+import { Field } from "../pageModel";
+export declare function RichTextEditorComponent({ field, readOnly, }: {
+    field: Field;
+    readOnly?: boolean;
+}): import("react/jsx-runtime").JSX.Element | undefined;

package/dist/editor/field-types/RichTextEditorComponent.js

@@ -1,22 +1,19 @@
 "use client";
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RichTextEditorComponent = RichTextEditorComponent;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const editContext_1 = require("../client/editContext");
-const use_debounce_1 = require("use-debounce");
-const react_1 = require("react");
-const ReactQuill_1 = require("./ReactQuill");
-require("react-quill-new/dist/quill.snow.css");
-const utils_1 = require("primereact/utils");
-function RichTextEditorComponent({ field, readOnly, }) {
-    const editContextRef = (0, editContext_1.useEditContextRef)();
-    const modifiedFieldsContext = (0, editContext_1.useModifiedFieldsContext)();
-    const state = (0, react_1.useRef)({ focus: false });
-    const inputRef = (0, react_1.useRef)(null);
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEditContextRef, useModifiedFieldsContext, } from "../client/editContext";
+import { useThrottledCallback } from "use-debounce";
+import { useEffect, useRef, useState } from "react";
+import { ReactQuill } from "./ReactQuill";
+import "react-quill-new/dist/quill.snow.css";
+import { classNames } from "primereact/utils";
+export function RichTextEditorComponent({ field, readOnly, }) {
+    const editContextRef = useEditContextRef();
+    const modifiedFieldsContext = useModifiedFieldsContext();
+    const state = useRef({ focus: false });
+    const inputRef = useRef(null);
     if (!editContextRef.current)
         return;
-    const [value, setValue] = (0, react_1.useState)(field.value);
+    const [value, setValue] = useState(field.value);
     const fieldItem = field.descriptor.item;
     if (!fieldItem)
         return;
@@ -24,7 +21,7 @@ function RichTextEditorComponent({ field, readOnly, }) {
         x.item.id === fieldItem.id &&
         x.item.language === fieldItem.language &&
         x.item.version === fieldItem.version);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (!state.current.focus ||
             !document.activeElement?.classList.contains("ql-editor")) {
             if (field.isHistoric)
@@ -33,7 +30,7 @@ function RichTextEditorComponent({ field, readOnly, }) {
                 setValue(modifiedField?.value ?? field.value);
         }
     }, [field.value, modifiedFieldsContext?.modifiedFields]);
-    const debouncedSetFieldvalue = (0, use_debounce_1.useThrottledCallback)((value) => {
+    const debouncedSetFieldvalue = useThrottledCallback((value) => {
         editContextRef.current?.operations.editField({
             field: field.descriptor,
             value: value,
@@ -62,7 +59,7 @@ function RichTextEditorComponent({ field, readOnly, }) {
     //   //   debouncedSetFieldvalue(val);
     //   // }}
     // />
-    (0, jsx_runtime_1.jsx)("div", { className: (0, utils_1.classNames)(readOnly ? "bg-gray-100" : "bg-white", "focus-shadow"), children: (0, jsx_runtime_1.jsx)(ReactQuill_1.ReactQuill, { ref: inputRef, theme: "snow", value: value, onChange: handleChange, onFocus: () => {
+    _jsx("div", { className: classNames(readOnly ? "bg-gray-100" : "bg-white", "focus-shadow"), children: _jsx(ReactQuill, { ref: inputRef, theme: "snow", value: value, onChange: handleChange, onFocus: () => {
                 setTimeout(() => {
                     state.current.focus = true;
                 }, 101);

package/dist/editor/field-types/SingleLineText.d.ts

@@ -0,0 +1,6 @@
+import { Field } from "../pageModel";
+export declare function SingleLineText({ field, readOnly, updateFieldValue, }: {
+    field: Field;
+    readOnly?: boolean;
+    updateFieldValue: (value: string) => void;
+}): import("react/jsx-runtime").JSX.Element | undefined;

package/dist/editor/field-types/SingleLineText.js

@@ -1,27 +1,24 @@
 "use client";
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleLineText = SingleLineText;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const inputtext_1 = require("primereact/inputtext");
-const editContext_1 = require("../client/editContext");
-const react_1 = require("react");
-function SingleLineText({ field, readOnly, updateFieldValue, }) {
-    const editContextRef = (0, editContext_1.useEditContextRef)();
-    const editContext = (0, editContext_1.useEditContext)();
-    const modifiedFieldsContext = (0, editContext_1.useModifiedFieldsContext)();
-    const inputRef = (0, react_1.useRef)(null);
+import { jsx as _jsx } from "react/jsx-runtime";
+import { InputText } from "primereact/inputtext";
+import { useEditContext, useEditContextRef, useModifiedFieldsContext, } from "../client/editContext";
+import { useEffect, useRef, useState } from "react";
+export function SingleLineText({ field, readOnly, updateFieldValue, }) {
+    const editContextRef = useEditContextRef();
+    const editContext = useEditContext();
+    const modifiedFieldsContext = useModifiedFieldsContext();
+    const inputRef = useRef(null);
     // const [selectionStart, setSelectionStart] = useState(0);
     // const [selectionEnd, setSelectionEnd] = useState(0);
     if (!editContextRef.current)
         return;
     const fieldItem = field.descriptor.item;
-    const [value, setValue] = (0, react_1.useState)(undefined);
+    const [value, setValue] = useState(undefined);
     const modifiedField = modifiedFieldsContext?.modifiedFields.find((x) => x.fieldId === field.id &&
         x.item.id === fieldItem.id &&
         x.item.language === fieldItem.language &&
         x.item.version === fieldItem.version);
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (inputRef.current !== document.activeElement) {
             if (field.isHistoric)
                 setValue(field.value);
@@ -52,7 +49,7 @@ function SingleLineText({ field, readOnly, updateFieldValue, }) {
         };
         editContextRef.current?.setSelectedRange(range);
     };
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (editContextRef.current?.focusedField?.fieldId === field.id &&
             editContextRef.current?.focusedField?.item.id === fieldItem.id &&
             editContextRef.current?.focusedField?.item.language ===
@@ -88,5 +85,5 @@ function SingleLineText({ field, readOnly, updateFieldValue, }) {
     //     width: `${width}px`,
     //   };
     // };
-    return ((0, jsx_runtime_1.jsx)("div", { className: "relative", children: (0, jsx_runtime_1.jsx)(inputtext_1.InputText, { ref: inputRef, value: value || "", disabled: readOnly, className: "p-1.5 focus-shadow text-sm", style: { width: "100%" }, onChange: handleChange, onSelect: handleSelect }, fieldItem.id + field.id + fieldItem.language + fieldItem.version) }));
+    return (_jsx("div", { className: "relative", children: _jsx(InputText, { ref: inputRef, value: value || "", disabled: readOnly, className: "p-1.5 focus-shadow text-sm", style: { width: "100%" }, onChange: handleChange, onSelect: handleSelect }, fieldItem.id + field.id + fieldItem.language + fieldItem.version) }));
 }

package/dist/editor/field-types/TreeListEditor.d.ts

@@ -0,0 +1,5 @@
+import { TreeListField } from "../fieldTypes";
+export default function TreeListEditor({ field, readOnly, }: {
+    field: TreeListField;
+    readOnly?: boolean;
+}): import("react/jsx-runtime").JSX.Element | undefined;