@moldable-ai/editor 0.1.7 → 0.1.9

package/dist/components/markdown-editor.d.ts

@@ -1,4 +1,7 @@
-interface MarkdownEditorProps {
+import { type MarkdownEditorHandle } from '../lib/lexical/find-replace-plugin';
+import { type MarkdownReferenceOption } from '../lib/lexical/file-reference-plugin';
+import { type MarkdownMediaUpload } from '../lib/lexical/media-plugin';
+export interface MarkdownEditorProps {
     value: string;
     onChange: (value: string) => void;
     placeholder?: string;
@@ -9,7 +12,13 @@ interface MarkdownEditorProps {
     minHeight?: string;
     maxHeight?: string;
     hideMarkdownHint?: boolean;
+    findQuery?: string;
+    currentFindMatch?: number;
+    onFindMatchCountChange?: (count: number) => void;
+    onMediaUpload?: MarkdownMediaUpload;
+    resolveMediaUrl?: (src: string) => string;
+    referenceOptions?: MarkdownReferenceOption[];
 }
-export declare function MarkdownEditor({ value, onChange, placeholder, disabled, autoFocus, className, contentClassName, minHeight, maxHeight, hideMarkdownHint, }: MarkdownEditorProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const MarkdownEditor: import("react").ForwardRefExoticComponent<MarkdownEditorProps & import("react").RefAttributes<MarkdownEditorHandle>>;
+export type { MarkdownEditorHandle };
 //# sourceMappingURL=markdown-editor.d.ts.map

package/dist/components/markdown-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown-editor.d.ts","sourceRoot":"","sources":["../../src/components/markdown-editor.tsx"],"names":[],"mappings":"AAsCA,UAAU,mBAAmB;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,QAAQ,EACR,WAAkC,EAClC,QAAgB,EAChB,SAAiB,EACjB,SAAS,EACT,gBAAgB,EAChB,SAAmB,EACnB,SAAkB,EAClB,gBAAwB,GACzB,EAAE,mBAAmB,2CAsGrB"}
+{"version":3,"file":"markdown-editor.d.ts","sourceRoot":"","sources":["../../src/components/markdown-editor.tsx"],"names":[],"mappings":"AAoBA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,oCAAoC,CAAA;AAkB3C,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,sCAAsC,CAAA;AAG7C,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,6BAA6B,CAAA;AAOpC,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,sBAAsB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD,aAAa,CAAC,EAAE,mBAAmB,CAAA;IACnC,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACzC,gBAAgB,CAAC,EAAE,uBAAuB,EAAE,CAAA;CAC7C;AAED,eAAO,MAAM,cAAc,sHAmJzB,CAAA;AAEF,YAAY,EAAE,oBAAoB,EAAE,CAAA"}

package/dist/components/markdown-editor.js

@@ -13,21 +13,28 @@ import { MarkdownShortcutPlugin } from '@lexical/react/LexicalMarkdownShortcutPl
 import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin';
 import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
 import { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin';
-import { useCallback, useRef } from 'react';
+import { forwardRef, useCallback, useRef } from 'react';
 import { cn } from '@moldable-ai/ui';
 import { LINK_MATCHERS } from '../lib/lexical/auto-link-config';
 import { ClickableLinkPlugin } from '../lib/lexical/clickable-link-plugin';
 import { editorTheme } from '../lib/lexical/editor-theme';
+import { FIND_REPLACE_UPDATE_TAG, FindReplacePlugin, } from '../lib/lexical/find-replace-plugin';
 import { $convertFromMarkdownString, $convertToMarkdownString, markdownTransformers, } from '../lib/lexical/markdown-transformers';
-import { SyncPlugin } from '../lib/lexical/sync-plugin';
+import { EXTERNAL_MARKDOWN_SYNC_TAG, SyncPlugin, } from '../lib/lexical/sync-plugin';
 import { FloatingToolbar } from './floating-toolbar';
 import { CodeHighlightNode, CodeNode } from '@lexical/code';
 import { HorizontalRuleNode } from '@lexical/extension';
 import { AutoLinkNode, LinkNode } from '@lexical/link';
 import { ListItemNode, ListNode } from '@lexical/list';
+import { MarkNode } from '@lexical/mark';
 import { HeadingNode, QuoteNode } from '@lexical/rich-text';
 import { $createParagraphNode, $getRoot } from 'lexical';
-export function MarkdownEditor({ value, onChange, placeholder = 'Write something...', disabled = false, autoFocus = false, className, contentClassName, minHeight = '150px', maxHeight = '50vh', hideMarkdownHint = false, }) {
+import { FileReferencePlugin, } from '../lib/lexical/file-reference-plugin';
+import { ImageNode } from '../lib/lexical/image-node';
+import { MediaNode } from '../lib/lexical/media-node';
+import { MediaPasteDropPlugin, } from '../lib/lexical/media-plugin';
+import { MediaProvider } from '../lib/lexical/media-context';
+export const MarkdownEditor = forwardRef(function MarkdownEditor({ value, onChange, placeholder = 'Write something...', disabled = false, autoFocus = false, className, contentClassName, minHeight = '150px', maxHeight = '50vh', hideMarkdownHint = false, findQuery = '', currentFindMatch = 0, onFindMatchCountChange, onMediaUpload, resolveMediaUrl, referenceOptions, }, ref) {
     const initialValueRef = useRef(value);
     const initialConfig = {
         namespace: 'MarkdownEditor',
@@ -38,8 +45,9 @@ export function MarkdownEditor({ value, onChange, placeholder = 'Write something
                     markdown: value,
                     transformers: markdownTransformers,
                     node: root,
-                    shouldPreserveNewLines: true,
+                    shouldPreserveNewLines: false,
                 });
+                root.selectEnd();
             }
             else {
                 root.append($createParagraphNode());
@@ -54,7 +62,10 @@ export function MarkdownEditor({ value, onChange, placeholder = 'Write something
             CodeHighlightNode,
             AutoLinkNode,
             LinkNode,
+            MarkNode,
             HorizontalRuleNode,
+            ImageNode,
+            MediaNode,
         ],
         onError: (error) => {
             console.error('MarkdownEditor error:', error);
@@ -62,12 +73,15 @@ export function MarkdownEditor({ value, onChange, placeholder = 'Write something
         theme: editorTheme,
         editable: !disabled,
     };
-    const handleChange = useCallback((editorState) => {
+    const handleChange = useCallback((editorState, _editor, tags) => {
+        if (tags.has(FIND_REPLACE_UPDATE_TAG))
+            return;
+        if (tags.has(EXTERNAL_MARKDOWN_SYNC_TAG))
+            return;
         editorState.read(() => {
-            // Use shouldPreserveNewLines: true to preserve empty paragraphs as extra newlines
             const markdown = $convertToMarkdownString({
                 transformers: markdownTransformers,
-                shouldPreserveNewLines: true,
+                shouldPreserveNewLines: false,
             });
             // Only call onChange if the value actually changed
             if (markdown !== initialValueRef.current) {
@@ -76,5 +90,5 @@ export function MarkdownEditor({ value, onChange, placeholder = 'Write something
             }
         });
     }, [onChange]);
-    return (_jsx(LexicalComposer, { initialConfig: initialConfig, children: _jsxs("div", { className: cn('relative h-full', className), "data-lexical-editor-container": true, children: [_jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: cn('prose prose-sm caret-primary dark:prose-invert max-w-none resize-none overflow-auto bg-transparent outline-none', disabled && 'cursor-not-allowed opacity-50', contentClassName), style: { minHeight, maxHeight }, "aria-placeholder": placeholder, "data-lexical-editor": "true", placeholder: _jsx("div", { className: "text-muted-foreground pointer-events-none absolute left-0 top-1 text-sm opacity-75", children: placeholder }) }), ErrorBoundary: LexicalErrorBoundary }), _jsx(HistoryPlugin, {}), autoFocus && _jsx(AutoFocusPlugin, {}), _jsx(ListPlugin, {}), _jsx(CheckListPlugin, {}), _jsx(TabIndentationPlugin, {}), _jsx(LinkPlugin, {}), _jsx(AutoLinkPlugin, { matchers: LINK_MATCHERS }), _jsx(ClickableLinkPlugin, {}), _jsx(FloatingToolbar, {}), _jsx(MarkdownShortcutPlugin, { transformers: markdownTransformers }), _jsx(OnChangePlugin, { onChange: handleChange, ignoreSelectionChange: true }), _jsx(SyncPlugin, { value: value, initialValueRef: initialValueRef }), !hideMarkdownHint && (_jsx("div", { className: "mt-1 flex justify-end", children: _jsx("span", { className: "text-muted-foreground/60 text-xs", children: "Markdown supported" }) }))] }) }));
-}
+    return (_jsx(LexicalComposer, { initialConfig: initialConfig, children: _jsx(MediaProvider, { value: { resolveMediaUrl }, children: _jsxs("div", { className: cn('relative h-full', className), "data-lexical-editor-container": true, children: [_jsx(RichTextPlugin, { contentEditable: _jsx(ContentEditable, { className: cn('prose prose-sm caret-primary dark:prose-invert max-w-none resize-none overflow-auto bg-transparent outline-none', disabled && 'cursor-not-allowed opacity-50', contentClassName), style: { minHeight, maxHeight }, "aria-placeholder": placeholder, "data-lexical-editor": "true", placeholder: _jsx("div", { className: cn('pointer-events-none absolute inset-x-0 top-1 overflow-hidden whitespace-nowrap', contentClassName, 'text-muted-foreground text-sm opacity-75'), children: placeholder }) }), ErrorBoundary: LexicalErrorBoundary }), _jsx(HistoryPlugin, {}), autoFocus && _jsx(AutoFocusPlugin, {}), _jsx(ListPlugin, {}), _jsx(CheckListPlugin, {}), _jsx(TabIndentationPlugin, {}), _jsx(LinkPlugin, {}), _jsx(AutoLinkPlugin, { matchers: LINK_MATCHERS }), _jsx(ClickableLinkPlugin, {}), _jsx(FloatingToolbar, {}), _jsx(MarkdownShortcutPlugin, { transformers: markdownTransformers }), _jsx(FileReferencePlugin, { references: referenceOptions }), _jsx(MediaPasteDropPlugin, { onMediaUpload: onMediaUpload }), _jsx(OnChangePlugin, { onChange: handleChange, ignoreSelectionChange: true }), _jsx(FindReplacePlugin, { query: findQuery, currentIndex: currentFindMatch, onMatchCountChange: onFindMatchCountChange, editorRef: ref }), _jsx(SyncPlugin, { value: value, initialValueRef: initialValueRef }), !hideMarkdownHint && (_jsx("div", { className: "mt-1 flex justify-end", children: _jsx("span", { className: "text-muted-foreground/60 text-xs", children: "Markdown supported" }) }))] }) }) }));
+});

package/dist/index.d.ts

@@ -1,6 +1,10 @@
-export { MarkdownEditor } from './components/markdown-editor';
+export { MarkdownEditor, type MarkdownEditorHandle, type MarkdownEditorProps, } from './components/markdown-editor';
 export { FloatingToolbar } from './components/floating-toolbar';
-export { $convertFromMarkdownString, $convertToMarkdownString, markdownTransformers, HR, } from './lib/lexical/markdown-transformers';
+export { $convertFromMarkdownString, $convertToMarkdownString, markdownTransformers, HR, IMAGE, OBSIDIAN_IMAGE_EMBED, MEDIA, } from './lib/lexical/markdown-transformers';
+export { ImageNode, $createImageNode, $isImageNode, type ImagePayload, } from './lib/lexical/image-node';
+export { MediaNode, $createMediaNode, $isMediaNode, type MediaKind, type MediaPayload, } from './lib/lexical/media-node';
+export { MediaPasteDropPlugin, type MarkdownMediaKind, type MarkdownMediaUpload, type MarkdownMediaUploadResult, } from './lib/lexical/media-plugin';
+export { FileReferencePlugin, type MarkdownReferenceOption, } from './lib/lexical/file-reference-plugin';
 export { editorTheme } from './lib/lexical/editor-theme';
 export { LINK_MATCHERS, URL_REGEX, EMAIL_REGEX, } from './lib/lexical/auto-link-config';
 export { useFloatingToolbar, type FloatingToolbarState, } from './lib/lexical/floating-toolbar-plugin';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAG/D,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,oBAAoB,EACpB,EAAE,GACH,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EACL,aAAa,EACb,SAAS,EACT,WAAW,GACZ,MAAM,gCAAgC,CAAA;AACvC,OAAO,EACL,kBAAkB,EAClB,KAAK,oBAAoB,GAC1B,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,EACL,mBAAmB,EACnB,SAAS,GACV,MAAM,qCAAqC,CAAA;AAG5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAG/D,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,oBAAoB,EACpB,EAAE,EACF,KAAK,EACL,oBAAoB,EACpB,KAAK,GACN,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,KAAK,SAAS,EACd,KAAK,YAAY,GAClB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,GAC/B,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,mBAAmB,EACnB,KAAK,uBAAuB,GAC7B,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EACL,aAAa,EACb,SAAS,EACT,WAAW,GACZ,MAAM,gCAAgC,CAAA;AACvC,OAAO,EACL,kBAAkB,EAClB,KAAK,oBAAoB,GAC1B,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,EACL,mBAAmB,EACnB,SAAS,GACV,MAAM,qCAAqC,CAAA;AAG5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAA"}

package/dist/index.js

@@ -1,8 +1,12 @@
 // Components
-export { MarkdownEditor } from './components/markdown-editor';
+export { MarkdownEditor, } from './components/markdown-editor';
 export { FloatingToolbar } from './components/floating-toolbar';
 // Lexical utilities (for advanced use cases)
-export { $convertFromMarkdownString, $convertToMarkdownString, markdownTransformers, HR, } from './lib/lexical/markdown-transformers';
+export { $convertFromMarkdownString, $convertToMarkdownString, markdownTransformers, HR, IMAGE, OBSIDIAN_IMAGE_EMBED, MEDIA, } from './lib/lexical/markdown-transformers';
+export { ImageNode, $createImageNode, $isImageNode, } from './lib/lexical/image-node';
+export { MediaNode, $createMediaNode, $isMediaNode, } from './lib/lexical/media-node';
+export { MediaPasteDropPlugin, } from './lib/lexical/media-plugin';
+export { FileReferencePlugin, } from './lib/lexical/file-reference-plugin';
 export { editorTheme } from './lib/lexical/editor-theme';
 export { LINK_MATCHERS, URL_REGEX, EMAIL_REGEX, } from './lib/lexical/auto-link-config';
 export { useFloatingToolbar, } from './lib/lexical/floating-toolbar-plugin';

package/dist/lib/lexical/editor-theme.d.ts

@@ -32,6 +32,8 @@ export declare const editorTheme: {
         listitemUnchecked: string;
     };
     link: string;
+    mark: string;
+    markOverlap: string;
     quote: string;
     code: string;
 };

package/dist/lib/lexical/editor-theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editor-theme.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/editor-theme.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCvB,CAAA"}
+{"version":3,"file":"editor-theme.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/editor-theme.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCvB,CAAA"}

package/dist/lib/lexical/editor-theme.js

@@ -32,6 +32,8 @@ export const editorTheme = {
         listitemUnchecked: 'lexical-listitem-unchecked',
     },
     link: 'text-primary underline hover:text-primary/80 cursor-pointer',
+    mark: 'lexical-mark',
+    markOverlap: 'lexical-mark-overlap',
     quote: 'border-l-4 border-muted px-4 py-2 my-2 text-muted-foreground',
     code: 'bg-muted p-3 my-4 rounded-md overflow-x-auto font-mono text-sm leading-loose text-muted-foreground',
 };

package/dist/lib/lexical/file-reference-plugin.d.ts

@@ -0,0 +1,9 @@
+export interface MarkdownReferenceOption {
+    path: string;
+    title?: string;
+    kind?: 'note' | 'file';
+}
+export declare function FileReferencePlugin({ references, }: {
+    references?: MarkdownReferenceOption[];
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=file-reference-plugin.d.ts.map

package/dist/lib/lexical/file-reference-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reference-plugin.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/file-reference-plugin.tsx"],"names":[],"mappings":"AAYA,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CACvB;AAqDD,wBAAgB,mBAAmB,CAAC,EAClC,UAAU,GACX,EAAE;IACD,UAAU,CAAC,EAAE,uBAAuB,EAAE,CAAA;CACvC,2CAmGA"}

package/dist/lib/lexical/file-reference-plugin.js

@@ -0,0 +1,99 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LexicalTypeaheadMenuPlugin, MenuOption, useBasicTypeaheadTriggerMatch, } from '@lexical/react/LexicalTypeaheadMenuPlugin';
+import { $createTextNode } from 'lexical';
+import { useMemo, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { cn } from '@moldable-ai/ui';
+class FileReferenceOption extends MenuOption {
+    path;
+    title;
+    isCreate;
+    constructor(path, title, isCreate = false) {
+        super(`${isCreate ? 'create' : 'reference'}:${path}`);
+        this.path = path;
+        this.title = title;
+        this.isCreate = isCreate;
+    }
+}
+function referenceTarget(path) {
+    return path.replace(/\.md$/, '');
+}
+function titleFromPath(path) {
+    return path.split('/').pop()?.replace(/\.md$/, '') ?? path;
+}
+function slugifyReference(value) {
+    const segments = value
+        .split('/')
+        .map((segment) => segment
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9 -]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/^-+|-+$/g, ''))
+        .filter(Boolean);
+    return segments.join('/') || 'untitled';
+}
+function referenceScore(option, query) {
+    const needle = query.trim().toLowerCase();
+    if (!needle)
+        return 1;
+    const title = (option.title ?? titleFromPath(option.path)).toLowerCase();
+    const path = option.path.toLowerCase();
+    if (title === needle || path === needle || path === `${needle}.md`)
+        return 100;
+    if (title.startsWith(needle))
+        return 80;
+    if (path.startsWith(needle))
+        return 70;
+    if (title.includes(needle))
+        return 50;
+    if (path.includes(needle))
+        return 40;
+    return 0;
+}
+export function FileReferencePlugin({ references, }) {
+    const [query, setQuery] = useState(null);
+    const triggerFn = useBasicTypeaheadTriggerMatch('@', {
+        allowWhitespace: true,
+        maxLength: 80,
+        minLength: 0,
+    });
+    const options = useMemo(() => {
+        const matching = (references ?? [])
+            .map((reference) => ({
+            reference,
+            score: referenceScore(reference, query ?? ''),
+        }))
+            .filter(({ score }) => score > 0)
+            .sort((a, b) => b.score - a.score || a.reference.path.localeCompare(b.reference.path))
+            .slice(0, 8)
+            .map(({ reference }) => new FileReferenceOption(reference.path, reference.title ?? titleFromPath(reference.path)));
+        const trimmed = query?.trim();
+        if (!trimmed)
+            return matching;
+        const createPath = `${slugifyReference(trimmed)}.md`;
+        const hasExact = (references ?? []).some((reference) => reference.path.toLowerCase() === createPath.toLowerCase() ||
+            reference.path.replace(/\.md$/, '').toLowerCase() ===
+                createPath.replace(/\.md$/, '').toLowerCase());
+        return hasExact
+            ? matching
+            : [
+                ...matching,
+                new FileReferenceOption(createPath, `Create ${trimmed}`, true),
+            ].slice(0, 9);
+    }, [query, references]);
+    return (_jsx(LexicalTypeaheadMenuPlugin, { triggerFn: triggerFn, options: options, onQueryChange: setQuery, preselectFirstItem: true, onSelectOption: (option, textNodeContainingQuery, closeMenu) => {
+            if (!textNodeContainingQuery)
+                return;
+            const node = $createTextNode(`[[${referenceTarget(option.path)}]]`);
+            textNodeContainingQuery.replace(node);
+            node.selectEnd();
+            closeMenu();
+        }, menuRenderFn: (anchorElementRef, { selectedIndex, selectOptionAndCleanUp, setHighlightedIndex }) => {
+            if (!anchorElementRef.current || options.length === 0)
+                return null;
+            return createPortal(_jsx("div", { className: "moldable-editor-reference-menu", children: options.map((option, index) => (_jsxs("button", { ref: option.setRefElement, type: "button", role: "option", "aria-selected": selectedIndex === index, className: cn('moldable-editor-reference-option', selectedIndex === index &&
+                        'moldable-editor-reference-option-selected'), onMouseEnter: () => setHighlightedIndex(index), onMouseDown: (event) => event.preventDefault(), onClick: () => selectOptionAndCleanUp(option), children: [_jsx("span", { className: "moldable-editor-reference-title", children: option.title }), _jsx("span", { className: "moldable-editor-reference-path", children: option.isCreate ? 'New note' : option.path })] }, option.key))) }), anchorElementRef.current);
+        } }));
+}

package/dist/lib/lexical/find-replace-plugin.d.ts

@@ -0,0 +1,31 @@
+import { type ForwardedRef } from 'react';
+import { type LexicalEditor } from 'lexical';
+export interface MarkdownEditorHandle {
+    replaceCurrentFindMatch: (replacement: string) => boolean;
+    replaceAllFindMatches: (replacement: string) => number;
+    focus: () => void;
+}
+interface FindReplacePluginProps {
+    query: string;
+    currentIndex: number;
+    onMatchCountChange?: (count: number) => void;
+    editorRef: ForwardedRef<MarkdownEditorHandle>;
+}
+export interface FindMatch {
+    start: number;
+    end: number;
+}
+export declare const FIND_MATCH_MARK_ID = "moldable-find-match";
+export declare const FIND_CURRENT_MARK_ID = "moldable-find-current";
+export declare const FIND_REPLACE_UPDATE_TAG = "moldable-find-replace";
+export declare function getTextMatches(text: string, query: string): FindMatch[];
+export declare function $clearFindMarks(): void;
+export declare function $getFindMatches(query: string): FindMatch[];
+export declare function $applyFindHighlights(query: string, currentIndex: number): number;
+export declare function updateFindHighlights(editor: LexicalEditor, query: string, currentIndex: number): number;
+export declare function registerFindMarkResolver(editor: LexicalEditor): () => void;
+export declare function replaceFindMatch(editor: LexicalEditor, query: string, replacement: string, currentIndex: number): boolean;
+export declare function replaceAllFindMatches(editor: LexicalEditor, query: string, replacement: string): number;
+export declare function FindReplacePlugin({ query, currentIndex, onMatchCountChange, editorRef, }: FindReplacePluginProps): null;
+export {};
+//# sourceMappingURL=find-replace-plugin.d.ts.map

package/dist/lib/lexical/find-replace-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-replace-plugin.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/find-replace-plugin.tsx"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,YAAY,EAKlB,MAAM,OAAO,CAAA;AASd,OAAO,EAML,KAAK,aAAa,EAGnB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,oBAAoB;IACnC,uBAAuB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAA;IACzD,qBAAqB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAA;IACtD,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,UAAU,sBAAsB;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,MAAM,CAAA;IACpB,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,SAAS,EAAE,YAAY,CAAC,oBAAoB,CAAC,CAAA;CAC9C;AAaD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,eAAO,MAAM,kBAAkB,wBAAwB,CAAA;AACvD,eAAO,MAAM,oBAAoB,0BAA0B,CAAA;AAC3D,eAAO,MAAM,uBAAuB,0BAA0B,CAAA;AAM9D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAiBvE;AAwDD,wBAAgB,eAAe,SAgB9B;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,eAG5C;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAoBvE;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAcrB;AAeD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,cAa7D;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,WAsBrB;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,UAsBpB;AAED,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,YAAY,EACZ,kBAAkB,EAClB,SAAS,GACV,EAAE,sBAAsB,QAqDxB"}

package/dist/lib/lexical/find-replace-plugin.js

@@ -0,0 +1,205 @@
+'use client';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useCallback, useEffect, useImperativeHandle, useRef, } from 'react';
+import { $createMarkNode, $isMarkNode, $unwrapMarkNode, $wrapSelectionInMarkNode, MarkNode, } from '@lexical/mark';
+import { mergeRegister, registerNestedElementResolver } from '@lexical/utils';
+import { $createRangeSelection, $getRoot, $getSelection, $nodesOfType, $setSelection, } from 'lexical';
+export const FIND_MATCH_MARK_ID = 'moldable-find-match';
+export const FIND_CURRENT_MARK_ID = 'moldable-find-current';
+export const FIND_REPLACE_UPDATE_TAG = 'moldable-find-replace';
+function getNormalizedQuery(query) {
+    return query.trim().toLocaleLowerCase();
+}
+export function getTextMatches(text, query) {
+    const normalizedQuery = getNormalizedQuery(query);
+    if (!normalizedQuery)
+        return [];
+    const normalizedText = text.toLocaleLowerCase();
+    const matches = [];
+    let searchFrom = 0;
+    while (searchFrom <= normalizedText.length - normalizedQuery.length) {
+        const start = normalizedText.indexOf(normalizedQuery, searchFrom);
+        if (start === -1)
+            break;
+        matches.push({ start, end: start + normalizedQuery.length });
+        searchFrom = start + normalizedQuery.length;
+    }
+    return matches;
+}
+function $collectTextEntries() {
+    const entries = [];
+    let text = '';
+    for (const node of $getRoot().getAllTextNodes()) {
+        const value = node.getTextContent();
+        const start = text.length;
+        text += value;
+        entries.push({ node, start, end: text.length });
+    }
+    return { entries, text };
+}
+function getTextPosition(entries, offset, bias) {
+    if (bias === 'next') {
+        for (const entry of entries) {
+            if (offset >= entry.start && offset < entry.end) {
+                return { node: entry.node, offset: offset - entry.start };
+            }
+        }
+    }
+    else {
+        for (const entry of entries) {
+            if (offset > entry.start && offset <= entry.end) {
+                return { node: entry.node, offset: offset - entry.start };
+            }
+        }
+    }
+    const fallback = bias === 'next' ? entries[0] : entries.at(-1);
+    if (!fallback)
+        return null;
+    return {
+        node: fallback.node,
+        offset: bias === 'next' ? 0 : fallback.node.getTextContentSize(),
+    };
+}
+function $createSelectionForMatch(match) {
+    const { entries } = $collectTextEntries();
+    const start = getTextPosition(entries, match.start, 'next');
+    const end = getTextPosition(entries, match.end, 'previous');
+    if (!start || !end)
+        return null;
+    const selection = $createRangeSelection();
+    selection.setTextNodeRange(start.node, start.offset, end.node, end.offset);
+    return selection;
+}
+export function $clearFindMarks() {
+    for (const markNode of $nodesOfType(MarkNode)) {
+        let nextNode = markNode;
+        if (nextNode.hasID(FIND_MATCH_MARK_ID)) {
+            nextNode = nextNode.deleteID(FIND_MATCH_MARK_ID);
+        }
+        if (nextNode.hasID(FIND_CURRENT_MARK_ID)) {
+            nextNode = nextNode.deleteID(FIND_CURRENT_MARK_ID);
+        }
+        if (nextNode.getIDs().length === 0) {
+            $unwrapMarkNode(nextNode);
+        }
+    }
+}
+export function $getFindMatches(query) {
+    const { text } = $collectTextEntries();
+    return getTextMatches(text, query);
+}
+export function $applyFindHighlights(query, currentIndex) {
+    $clearFindMarks();
+    const matches = $getFindMatches(query);
+    for (let index = matches.length - 1; index >= 0; index -= 1) {
+        const selection = $createSelectionForMatch(matches[index]);
+        if (selection) {
+            $wrapSelectionInMarkNode(selection, false, FIND_MATCH_MARK_ID);
+        }
+    }
+    const currentMatch = matches[currentIndex] ?? matches[0];
+    if (currentMatch) {
+        const selection = $createSelectionForMatch(currentMatch);
+        if (selection) {
+            $wrapSelectionInMarkNode(selection, false, FIND_CURRENT_MARK_ID);
+        }
+    }
+    return matches.length;
+}
+export function updateFindHighlights(editor, query, currentIndex) {
+    let matchCount = 0;
+    editor.update(() => {
+        const previousSelection = $getSelection()?.clone() ?? null;
+        matchCount = $applyFindHighlights(query, currentIndex);
+        $setSelection(previousSelection);
+    }, { discrete: true, tag: FIND_REPLACE_UPDATE_TAG });
+    return matchCount;
+}
+function scrollCurrentMatchIntoView(editor) {
+    const editorRoot = editor.getRootElement();
+    const currentMatch = editorRoot?.querySelector('.lexical-mark-overlap');
+    currentMatch?.scrollIntoView({
+        behavior: 'smooth',
+        block: 'center',
+        inline: 'nearest',
+    });
+}
+export function registerFindMarkResolver(editor) {
+    return registerNestedElementResolver(editor, MarkNode, (from) => $createMarkNode(from.getIDs()), (from, to) => {
+        if (!$isMarkNode(to))
+            return;
+        for (const id of from.getIDs()) {
+            to.addID(id);
+        }
+    });
+}
+export function replaceFindMatch(editor, query, replacement, currentIndex) {
+    let replaced = false;
+    editor.update(() => {
+        $clearFindMarks();
+        const matches = $getFindMatches(query);
+        const match = matches[currentIndex] ?? matches[0];
+        if (!match)
+            return;
+        const selection = $createSelectionForMatch(match);
+        if (!selection)
+            return;
+        $setSelection(selection);
+        selection.insertText(replacement);
+        replaced = true;
+    }, { discrete: true });
+    return replaced;
+}
+export function replaceAllFindMatches(editor, query, replacement) {
+    let replacedCount = 0;
+    editor.update(() => {
+        $clearFindMarks();
+        const matches = $getFindMatches(query);
+        for (let index = matches.length - 1; index >= 0; index -= 1) {
+            const selection = $createSelectionForMatch(matches[index]);
+            if (!selection)
+                continue;
+            $setSelection(selection);
+            selection.insertText(replacement);
+            replacedCount += 1;
+        }
+    }, { discrete: true });
+    return replacedCount;
+}
+export function FindReplacePlugin({ query, currentIndex, onMatchCountChange, editorRef, }) {
+    const [editor] = useLexicalComposerContext();
+    const onMatchCountChangeRef = useRef(onMatchCountChange);
+    useEffect(() => {
+        onMatchCountChangeRef.current = onMatchCountChange;
+    }, [onMatchCountChange]);
+    useImperativeHandle(editorRef, () => ({
+        replaceCurrentFindMatch: (replacement) => replaceFindMatch(editor, query, replacement, currentIndex),
+        replaceAllFindMatches: (replacement) => replaceAllFindMatches(editor, query, replacement),
+        focus: () => editor.focus(),
+    }), [currentIndex, editor, query]);
+    const applyHighlights = useCallback(() => {
+        const matchCount = updateFindHighlights(editor, query, currentIndex);
+        onMatchCountChangeRef.current?.(matchCount);
+        if (getNormalizedQuery(query) && matchCount > 0) {
+            window.requestAnimationFrame(() => scrollCurrentMatchIntoView(editor));
+        }
+    }, [currentIndex, editor, query]);
+    useEffect(() => {
+        return registerFindMarkResolver(editor);
+    }, [editor]);
+    useEffect(() => {
+        applyHighlights();
+        const unregister = mergeRegister(editor.registerUpdateListener(({ tags }) => {
+            if (tags.has(FIND_REPLACE_UPDATE_TAG))
+                return;
+            applyHighlights();
+        }), () => {
+            editor.update(() => $clearFindMarks(), {
+                discrete: true,
+                tag: FIND_REPLACE_UPDATE_TAG,
+            });
+        });
+        return unregister;
+    }, [applyHighlights, editor]);
+    return null;
+}

package/dist/lib/lexical/headless-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headless-editor.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/headless-editor.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAgB,4BAA4B,oCAkB3C"}
+{"version":3,"file":"headless-editor.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/headless-editor.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,wBAAgB,4BAA4B,oCAqB3C"}

package/dist/lib/lexical/headless-editor.js

@@ -4,7 +4,10 @@ import { HorizontalRuleNode } from '@lexical/extension';
 import { createHeadlessEditor } from '@lexical/headless';
 import { AutoLinkNode, LinkNode } from '@lexical/link';
 import { ListItemNode, ListNode } from '@lexical/list';
+import { MarkNode } from '@lexical/mark';
 import { HeadingNode, QuoteNode } from '@lexical/rich-text';
+import { ImageNode } from './image-node';
+import { MediaNode } from './media-node';
 /**
  * Creates a headless Lexical editor for server-side operations.
  * Use this for translation, content extraction, etc.
@@ -20,7 +23,10 @@ export function createMoldableHeadlessEditor() {
             CodeHighlightNode,
             AutoLinkNode,
             LinkNode,
+            MarkNode,
             HorizontalRuleNode,
+            ImageNode,
+            MediaNode,
         ],
         theme: editorTheme,
         onError: (error) => {

package/dist/lib/lexical/image-component.d.ts

@@ -0,0 +1,8 @@
+import { type NodeKey } from 'lexical';
+export declare function ImageComponent({ altText, nodeKey, src, width, }: {
+    altText: string;
+    nodeKey: NodeKey;
+    src: string;
+    width?: number;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=image-component.d.ts.map

package/dist/lib/lexical/image-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-component.d.ts","sourceRoot":"","sources":["../../../src/lib/lexical/image-component.tsx"],"names":[],"mappings":"AAKA,OAAO,EAQL,KAAK,OAAO,EACb,MAAM,SAAS,CAAA;AAiBhB,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,2CAoIA"}