@byline/richtext-lexical 0.9.3

package/dist/field/editor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type * as React from 'react';
+import './editor.css';
+export declare const Editor: React.MemoExoticComponent<({ minHeight, maxHeight, }: {
+    minHeight?: number | string;
+    maxHeight?: number | string;
+}) => React.JSX.Element>;
+//# sourceMappingURL=editor.d.ts.map

package/dist/field/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../src/field/editor.tsx"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AA4CnC,OAAO,cAAc,CAAA;AASrB,eAAO,MAAM,MAAM,wDAGhB;IACD,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B,KAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CA+KnB,CAAA"}

package/dist/field/editor.js

@@ -0,0 +1,190 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { memo, useCallback, useEffect, useMemo, useState } from "react";
+import { TRANSFORMERS } from "@lexical/markdown";
+import { AutoFocusPlugin } from "@lexical/react/LexicalAutoFocusPlugin";
+import { CheckListPlugin } from "@lexical/react/LexicalCheckListPlugin";
+import { ClearEditorPlugin } from "@lexical/react/LexicalClearEditorPlugin";
+import { LexicalErrorBoundary } from "@lexical/react/LexicalErrorBoundary";
+import { HistoryPlugin } from "@lexical/react/LexicalHistoryPlugin";
+import { HorizontalRulePlugin } from "@lexical/react/LexicalHorizontalRulePlugin";
+import { ListPlugin } from "@lexical/react/LexicalListPlugin";
+import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
+import { OnChangePlugin } from "@lexical/react/LexicalOnChangePlugin";
+import { PlainTextPlugin } from "@lexical/react/LexicalPlainTextPlugin";
+import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
+import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin";
+import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
+import { useEditorConfig } from "./config/editor-config-context.js";
+import { ContentEditable } from "./content-editable.js";
+import { useSharedHistoryContext } from "./context/shared-history-context.js";
+import { useSharedOnChange } from "./context/shared-on-change-context.js";
+import { Debug } from "./debug.js";
+import { AdmonitionPlugin } from "./plugins/admonition-plugin/index.js";
+import { AutoEmbedPlugin } from "./plugins/auto-embed-plugin/index.js";
+import { CodeHighlightPlugin } from "./plugins/code-highlight-plugin/index.js";
+import { FloatingTextFormatToolbarPlugin } from "./plugins/floating-text-format-toolbar-plugin/index.js";
+import { InlineImagePlugin } from "./plugins/inline-image-plugin/index.js";
+import { LayoutPlugin } from "./plugins/layout-plugin/layout-plugin.js";
+import { AutoLinkPlugin } from "./plugins/link-plugin/auto-link/index.js";
+import { LinkPlugin } from "./plugins/link-plugin/link/index.js";
+import { FloatingLinkEditorPlugin } from "./plugins/link-plugin/link/floating-link-editor.js";
+import { TableActionMenuPlugin } from "./plugins/table-action-menu-plugin/index.js";
+import { TablePlugin as index_js_TablePlugin } from "./plugins/table-plugin/index.js";
+import { ToolbarPlugin } from "./plugins/toolbar-plugin/index.js";
+import { TreeViewPlugin } from "./plugins/treeview-plugin/index.js";
+import { VimeoPlugin } from "./plugins/vimeo-plugin/index.js";
+import { YouTubePlugin } from "./plugins/youtube-plugin/index.js";
+import { CAN_USE_DOM } from "./shared/canUseDOM.js";
+import { Placeholder } from "./ui/placeholder.js";
+import "./editor.css";
+import { APPLY_VALUE_TAG } from "./constants.js";
+const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
+    const [floatingAnchorElem, setFloatingAnchorElem] = useState(null);
+    const [isSmallWidthViewport, setIsSmallWidthViewport] = useState(false);
+    useState(()=>({
+            count: 0
+        }))[0];
+    const { onChange } = useSharedOnChange();
+    const { historyState } = useSharedHistoryContext();
+    const { config: { options: { debug, richText, showTreeView, autoFocusPlugin, tablePlugin, tableActionMenuPlugin, layoutPlugin, inlineImagePlugin, admonitionPlugin, links, autoLinkPlugin, checkListPlugin, listPlugin, codeHighlightPlugin, horizontalRulePlugin, markdownShortcutPlugin, floatingLinkEditorPlugin, floatingTextFormatToolbarPlugin, autoEmbedPlugin }, placeholderText, inlineImageUploadCollection } } = useEditorConfig();
+    const onRef = useCallback((_floatingAnchorElem)=>{
+        if (null != _floatingAnchorElem) setFloatingAnchorElem(_floatingAnchorElem);
+    }, []);
+    const richTextContentEditable = useMemo(()=>/*#__PURE__*/ jsx("div", {
+            className: "editor-scroller",
+            style: {
+                minHeight: minHeight ?? '150px',
+                maxHeight: maxHeight ?? void 0
+            },
+            children: /*#__PURE__*/ jsx("div", {
+                className: "editor",
+                ref: onRef,
+                children: /*#__PURE__*/ jsx(ContentEditable, {})
+            })
+        }), [
+        onRef,
+        minHeight,
+        maxHeight
+    ]);
+    const plainTextContentEditable = useMemo(()=>/*#__PURE__*/ jsx("div", {
+            className: "editor-scroller",
+            style: {
+                minHeight: minHeight ?? '150px',
+                maxHeight: maxHeight ?? void 0
+            },
+            children: /*#__PURE__*/ jsx("div", {
+                className: "editor",
+                children: /*#__PURE__*/ jsx(ContentEditable, {})
+            })
+        }), [
+        minHeight,
+        maxHeight
+    ]);
+    useEffect(()=>{
+        const updateViewPortWidth = ()=>{
+            const isNextSmallWidthViewport = CAN_USE_DOM && window.matchMedia('(max-width: 1025px)').matches;
+            if (isNextSmallWidthViewport !== isSmallWidthViewport) setIsSmallWidthViewport(isNextSmallWidthViewport);
+        };
+        updateViewPortWidth();
+        window.addEventListener('resize', updateViewPortWidth);
+        return ()=>{
+            window.removeEventListener('resize', updateViewPortWidth);
+        };
+    }, [
+        isSmallWidthViewport
+    ]);
+    const content = /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            tablePlugin && /*#__PURE__*/ jsx(index_js_TablePlugin, {}),
+            richText && /*#__PURE__*/ jsx(ToolbarPlugin, {}),
+            /*#__PURE__*/ jsxs("div", {
+                className: `editor-container ${showTreeView ? 'tree-view' : ''} ${!richText ? 'plain-text' : ''}`,
+                children: [
+                    autoFocusPlugin && /*#__PURE__*/ jsx(AutoFocusPlugin, {}),
+                    links && /*#__PURE__*/ jsx(LinkPlugin, {}),
+                    autoEmbedPlugin && /*#__PURE__*/ jsx(AutoEmbedPlugin, {}),
+                    /*#__PURE__*/ jsx(TabIndentationPlugin, {}),
+                    autoLinkPlugin && /*#__PURE__*/ jsx(AutoLinkPlugin, {}),
+                    /*#__PURE__*/ jsx(OnChangePlugin, {
+                        ignoreSelectionChange: true,
+                        onChange: (editorState, editor, tags)=>{
+                            if (tags.has(APPLY_VALUE_TAG)) return;
+                            if (!tags.has('focus') || tags.size > 1) {
+                                if (null != onChange) onChange(editorState, editor, tags);
+                            }
+                        }
+                    }),
+                    richText ? /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(RichTextPlugin, {
+                                contentEditable: richTextContentEditable,
+                                placeholder: /*#__PURE__*/ jsx(Placeholder, {
+                                    children: placeholderText
+                                }),
+                                ErrorBoundary: LexicalErrorBoundary
+                            }),
+                            /*#__PURE__*/ jsx(HistoryPlugin, {
+                                externalHistoryState: historyState
+                            }),
+                            inlineImagePlugin && /*#__PURE__*/ jsx(InlineImagePlugin, {
+                                collection: inlineImageUploadCollection
+                            }),
+                            admonitionPlugin && /*#__PURE__*/ jsx(AdmonitionPlugin, {}),
+                            checkListPlugin && /*#__PURE__*/ jsx(CheckListPlugin, {}),
+                            listPlugin && /*#__PURE__*/ jsx(ListPlugin, {}),
+                            codeHighlightPlugin && /*#__PURE__*/ jsx(CodeHighlightPlugin, {}),
+                            horizontalRulePlugin && /*#__PURE__*/ jsx(HorizontalRulePlugin, {}),
+                            layoutPlugin && /*#__PURE__*/ jsx(LayoutPlugin, {}),
+                            autoEmbedPlugin && /*#__PURE__*/ jsx(YouTubePlugin, {}),
+                            autoEmbedPlugin && /*#__PURE__*/ jsx(VimeoPlugin, {}),
+                            markdownShortcutPlugin && /*#__PURE__*/ jsx(MarkdownShortcutPlugin, {
+                                transformers: TRANSFORMERS
+                            }),
+                            tablePlugin && /*#__PURE__*/ jsx(TablePlugin, {
+                                hasCellMerge: true,
+                                hasCellBackgroundColor: true
+                            }),
+                            null != floatingAnchorElem && !isSmallWidthViewport && /*#__PURE__*/ jsxs(Fragment, {
+                                children: [
+                                    floatingLinkEditorPlugin && /*#__PURE__*/ jsx(FloatingLinkEditorPlugin, {
+                                        anchorElem: floatingAnchorElem
+                                    }),
+                                    tableActionMenuPlugin && /*#__PURE__*/ jsx(TableActionMenuPlugin, {
+                                        anchorElem: floatingAnchorElem,
+                                        cellMerge: false
+                                    }),
+                                    floatingTextFormatToolbarPlugin && /*#__PURE__*/ jsx(FloatingTextFormatToolbarPlugin, {
+                                        anchorElem: floatingAnchorElem
+                                    })
+                                ]
+                            })
+                        ]
+                    }) : /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(PlainTextPlugin, {
+                                contentEditable: plainTextContentEditable,
+                                placeholder: /*#__PURE__*/ jsx(Placeholder, {
+                                    children: placeholderText
+                                }),
+                                ErrorBoundary: LexicalErrorBoundary
+                            }),
+                            /*#__PURE__*/ jsx(HistoryPlugin, {
+                                externalHistoryState: historyState
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(ClearEditorPlugin, {}),
+                    debug && /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx(Debug, {}),
+                            /*#__PURE__*/ jsx(TreeViewPlugin, {})
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+    return content;
+});
+export { editor_Editor as Editor };

package/dist/field/hooks/use-modal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type * as React from 'react';
+export default function useModal(): [
+    React.JSX.Element | null,
+    (title: string, showModal: (onClose: () => void) => React.JSX.Element) => void
+];
+//# sourceMappingURL=use-modal.d.ts.map

package/dist/field/hooks/use-modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-modal.d.ts","sourceRoot":"","sources":["../../../src/field/hooks/use-modal.tsx"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAKnC,MAAM,CAAC,OAAO,UAAU,QAAQ,IAAI;IAClC,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI;IACxB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,KAAK,CAAC,GAAG,CAAC,OAAO,KAAK,IAAI;CAC/E,CAwCA"}

package/dist/field/hooks/use-modal.js

@@ -0,0 +1,37 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from "react";
+import ui_modal from "../ui/modal.js";
+function useModal() {
+    const [modalContent, setModalContent] = useState(null);
+    const onClose = useCallback(()=>{
+        setModalContent(null);
+    }, []);
+    const modal = useMemo(()=>{
+        if (null === modalContent) return null;
+        const { title, content, closeOnClickOutside } = modalContent;
+        return /*#__PURE__*/ jsx(ui_modal, {
+            onClose: onClose,
+            title: title,
+            closeOnClickOutside: closeOnClickOutside,
+            children: content
+        });
+    }, [
+        modalContent,
+        onClose
+    ]);
+    const showModal = useCallback((title, getContent, closeOnClickOutside = false)=>{
+        setModalContent({
+            closeOnClickOutside,
+            content: getContent(onClose),
+            title
+        });
+    }, [
+        onClose
+    ]);
+    return [
+        modal,
+        showModal
+    ];
+}
+export default useModal;

package/dist/field/hooks/use-report.js

@@ -0,0 +1,39 @@
+import { useCallback, useEffect, useRef } from "react";
+const getElement = ()=>{
+    let element = document.getElementById('report-container');
+    if (null === element) {
+        element = document.createElement('div');
+        element.id = 'report-container';
+        element.style.position = 'fixed';
+        element.style.top = '50%';
+        element.style.left = '50%';
+        element.style.fontSize = '32px';
+        element.style.transform = 'translate(-50%, -50px)';
+        element.style.padding = '20px';
+        element.style.background = 'rgba(240, 240, 240, 0.4)';
+        element.style.borderRadius = '20px';
+        if (document.body) document.body.appendChild(element);
+    }
+    return element;
+};
+function useReport() {
+    const timer = useRef(null);
+    const cleanup = useCallback(()=>{
+        if (null !== timer) clearTimeout(timer.current);
+        if (document.body) document.body.removeChild(getElement());
+    }, []);
+    useEffect(()=>cleanup, [
+        cleanup
+    ]);
+    return useCallback((content)=>{
+        console.log(content);
+        const element = getElement();
+        clearTimeout(timer.current);
+        element.innerHTML = content;
+        timer.current = setTimeout(cleanup, 1000);
+        return timer.current;
+    }, [
+        cleanup
+    ]);
+}
+export default useReport;

package/dist/field/lexical-populate-shared.d.ts

@@ -0,0 +1,97 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Shared utilities for the Lexical adapter's server-side populate. Each
+ * Lexical plugin contributes a `LexicalNodeVisitor` describing what it
+ * looks for and how to refresh it; the driver below walks each rich-text
+ * value once, dispatches across every visitor, batches per source
+ * collection, and applies the refresh.
+ *
+ * Pure / framework-agnostic. No React, no DOM, no Lexical runtime — safe
+ * to import from the package's `server` entry.
+ */
+import type { BylineClient } from '@byline/client';
+import type { ReadContext } from '@byline/core';
+/**
+ * Lexical-shaped node — only the fields the visitors need to read or
+ * mutate. Carries an unknown `children` array because nodes nest
+ * (paragraphs, lists, tables, …). Per-node-type fields (link / inline-
+ * image attributes) are spread flat onto the node and accessed
+ * structurally rather than through a discriminated union, since each
+ * visitor knows its own shape.
+ */
+export interface LexicalNodeLike {
+    type?: string;
+    children?: LexicalNodeLike[];
+    targetDocumentId?: string;
+    targetCollectionId?: string;
+    targetCollectionPath?: string;
+    document?: Record<string, any>;
+    linkType?: 'custom' | 'internal';
+    attributes?: Record<string, any>;
+}
+/**
+ * Read a rich-text field value (Lexical JSON object or stringified) and
+ * return its root node, or `null` if the value is not a parseable Lexical
+ * tree. Tolerates both shapes Byline has shipped — the wrapped form
+ * (`{ root: { … } }`) and the raw root node.
+ */
+export declare function getLexicalRoot(value: unknown): LexicalNodeLike | null;
+/**
+ * Top-down recursive walk over a Lexical tree. Yields every node including
+ * the root. Mutating fields on yielded nodes is safe — the walk doesn't
+ * revisit and is order-independent for our visitors.
+ */
+export declare function iterAllNodes(node: LexicalNodeLike): Generator<LexicalNodeLike, void, void>;
+/**
+ * One pending hydration unit. The visitor decides whether a node matches,
+ * and if so produces a `PendingHydration` describing how to refresh it.
+ */
+export interface PendingHydration {
+    node: LexicalNodeLike;
+    collectionPath: string;
+    documentId: string;
+    /**
+     * Apply the freshly-fetched target document to the node. Mutates `node`
+     * in place; `target.fields` is the shaped collection record. Receives
+     * the full target so the visitor can pick whatever projection it cares
+     * about.
+     */
+    apply: (target: Record<string, any>) => void;
+}
+/**
+ * Visitor contract — one per node type that participates in populate.
+ * `match` is called for every node in the tree; when it returns a
+ * `PendingHydration`, the driver enqueues it for batch fetch.
+ */
+export interface LexicalNodeVisitor {
+    match: (node: LexicalNodeLike) => PendingHydration | null;
+}
+interface RunPopulateOptions {
+    client: BylineClient;
+    readContext: ReadContext;
+    visitors: LexicalNodeVisitor[];
+    /**
+     * One or more rich-text values to walk. The framework's read pipeline
+     * calls the registered populate function once per leaf, so the typical
+     * shape here is a single-element array — but the driver supports
+     * multiple values for batching across an entire document tree if a
+     * future caller wants the optimisation.
+     */
+    values: unknown[];
+}
+/**
+ * Walk every supplied rich-text value, collect the union of pending
+ * hydrations across all visitors, batch-fetch by source collection, and
+ * apply. Threading `readContext` keeps the visited-set / `afterReadFired`
+ * / read-budget machinery in sync with relation populate and user-land
+ * `afterRead` hooks.
+ */
+export declare function runLexicalPopulate(options: RunPopulateOptions): Promise<void>;
+export {};
+//# sourceMappingURL=lexical-populate-shared.d.ts.map

package/dist/field/lexical-populate-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexical-populate-shared.d.ts","sourceRoot":"","sources":["../../src/field/lexical-populate-shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;IAG5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAG9B,QAAQ,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IAIhC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CACjC;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAerE;AAED;;;;GAIG;AACH,wBAAiB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,CAAC,CAQ3F;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,eAAe,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,CAAA;CAC7C;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,gBAAgB,GAAG,IAAI,CAAA;CAC1D;AAED,UAAU,kBAAkB;IAC1B,MAAM,EAAE,YAAY,CAAA;IACpB,WAAW,EAAE,WAAW,CAAA;IACxB,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B;;;;;;OAMG;IACH,MAAM,EAAE,OAAO,EAAE,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkDnF"}

package/dist/field/lexical-populate-shared.js

@@ -0,0 +1,60 @@
+function getLexicalRoot(value) {
+    if (null == value) return null;
+    let parsed = null;
+    if ('string' == typeof value) try {
+        parsed = JSON.parse(value);
+    } catch  {
+        return null;
+    }
+    else if ('object' == typeof value) parsed = value;
+    if (null == parsed) return null;
+    if ('root' in parsed && null != parsed.root) return parsed.root;
+    return parsed;
+}
+function* iterAllNodes(node) {
+    if (null == node) return;
+    yield node;
+    if (Array.isArray(node.children)) for (const child of node.children)yield* iterAllNodes(child);
+}
+async function runLexicalPopulate(options) {
+    const { client, readContext, visitors, values } = options;
+    const pending = [];
+    for (const value of values){
+        const root = getLexicalRoot(value);
+        if (root) for (const node of iterAllNodes(root))for (const visitor of visitors){
+            const item = visitor.match(node);
+            if (null != item) pending.push(item);
+        }
+    }
+    if (0 === pending.length) return;
+    const idsByCollection = new Map();
+    for (const p of pending){
+        let bucket = idsByCollection.get(p.collectionPath);
+        if (!bucket) {
+            bucket = new Set();
+            idsByCollection.set(p.collectionPath, bucket);
+        }
+        bucket.add(p.documentId);
+    }
+    const fetched = new Map();
+    await Promise.all(Array.from(idsByCollection.entries()).map(async ([collectionPath, idSet])=>{
+        const ids = Array.from(idSet);
+        const result = await client.collection(collectionPath).find({
+            where: {
+                id: {
+                    $in: ids
+                }
+            },
+            pageSize: ids.length,
+            _readContext: readContext
+        });
+        const byId = new Map();
+        for (const d of result.docs)if ('string' == typeof d.id) byId.set(d.id, d);
+        fetched.set(collectionPath, byId);
+    }));
+    for (const p of pending){
+        const target = fetched.get(p.collectionPath)?.get(p.documentId);
+        if (target) p.apply(target);
+    }
+}
+export { getLexicalRoot, iterAllNodes, runLexicalPopulate };

package/dist/field/nodes/admonition-node/admonition-node-component.css

@@ -0,0 +1,119 @@
+.LexicalEditor__admonition .Admonition__container {
+  border: 1px solid #666;
+  border-radius: 2px;
+  margin-top: .5rem;
+  margin-bottom: 1.5rem;
+  padding: 8px;
+  position: relative;
+}
+
+.LexicalEditor__admonition .Admonition__container.focused {
+  outline: 2px solid #3c84f4;
+}
+
+.LexicalEditor__admonition .Admonition__container .admonition-edit-button {
+  z-index: 1;
+  color: #fff;
+  cursor: pointer;
+  -webkit-user-select: none;
+  user-select: none;
+  background-color: #00000080;
+  border: 1px solid #ffffff4d;
+  border-radius: 5px;
+  min-width: 60px;
+  margin: 0 auto;
+  padding: 3px 4px;
+  font-size: .9rem;
+  display: block;
+  position: absolute;
+  top: 8px;
+  right: 12px;
+}
+
+.LexicalEditor__admonition .Admonition__container .admonition-edit-button:hover {
+  background-color: #3c84f480;
+}
+
+.LexicalEditor__admonition .AdmonitionNode__header {
+  align-items: center;
+  margin-bottom: .75rem;
+  font-size: 1.5rem;
+  font-weight: bold;
+  display: flex;
+}
+
+.LexicalEditor__admonition .AdmonitionNode__content {
+  position: relative;
+}
+
+.LexicalEditor__admonition .AdmonitionNode__contentEditable {
+  color: #000;
+  background-color: #f4f4f4;
+  min-width: 100%;
+  display: block;
+  position: relative;
+  overflow: hidden;
+}
+
+.LexicalEditor__admonition .AdmonitionNode__contentEditable .tree-view-output {
+  border-radius: 0;
+  margin: 0;
+}
+
+.LexicalEditor__admonition .admonition-content-button:hover {
+  background-color: #3c84f480;
+}
+
+.LexicalEditor__admonition .AdmonitionNode__contentEditable {
+  resize: none;
+  cursor: text;
+  caret-color: #050505;
+  -moz-tab-size: 1;
+  tab-size: 1;
+  -webkit-user-select: text;
+  user-select: text;
+  white-space: pre-wrap;
+  word-break: break-word;
+  border: 0;
+  outline: 0;
+  min-height: 20px;
+  padding: 10px;
+  font-size: 16px;
+  line-height: 1.4em;
+  display: block;
+  position: relative;
+}
+
+.AdmonitionNode__contentEditable p {
+  margin-bottom: .25em;
+}
+
+.Admonition__placeholder {
+  color: #888;
+  text-overflow: ellipsis;
+  top: 10px;
+  left: 10px;
+  right: unset;
+  -webkit-user-select: none;
+  user-select: none;
+  white-space: nowrap;
+  pointer-events: none;
+  font-size: 12px;
+  display: inline-block;
+  position: absolute;
+  overflow: hidden;
+}
+
+.dark .AdmonitionNode__contentEditable {
+  color: #eee;
+  caret-color: auto;
+}
+
+.dark .LexicalEditor__admonition .AdmonitionNode__contentEditable {
+  background-color: #222;
+}
+
+.dark .AdmonitionNode__placeholder {
+  color: #888;
+}
+

package/dist/field/nodes/admonition-node/admonition-node-component.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type * as React from 'react';
+import type { LexicalEditor, NodeKey } from 'lexical';
+import type { AdmonitionType } from './types';
+import './admonition-node-component.css';
+export default function AdmonitionNodeComponent({ admonitionType, title, content, nodeKey, }: {
+    admonitionType: AdmonitionType;
+    title: string;
+    content: LexicalEditor;
+    nodeKey: NodeKey;
+}): React.JSX.Element;
+//# sourceMappingURL=admonition-node-component.d.ts.map

package/dist/field/nodes/admonition-node/admonition-node-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admonition-node-component.d.ts","sourceRoot":"","sources":["../../../../src/field/nodes/admonition-node/admonition-node-component.tsx"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAYnC,OAAO,KAAK,EAAiB,aAAa,EAAE,OAAO,EAAiC,MAAM,SAAS,CAAA;AA0BnG,OAAO,KAAK,EAAwB,cAAc,EAAE,MAAM,SAAS,CAAA;AAEnE,OAAO,iCAAiC,CAAA;AASxC,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,EAC9C,cAAc,EACd,KAAK,EACL,OAAO,EACP,OAAO,GACR,EAAE;IACD,cAAc,EAAE,cAAc,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,aAAa,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CA0LpB"}