@sdata/web-vue 3.17.0 → 3.19.0

package/es/rich-text-editor/nodes/inline-component-node.js

@@ -0,0 +1,86 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import { cloneDeep } from "es-toolkit";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+//#region components/rich-text-editor/nodes/inline-component-node.ts
+var InlineComponentNode = class InlineComponentNode extends DecoratorNode {
+	static getType() {
+		return "sd-inline-component";
+	}
+	static clone(node) {
+		return new InlineComponentNode(node.__data, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createInlineComponentNode(serializedNode.data);
+	}
+	constructor(data = {
+		key: "",
+		name: "custom"
+	}, key) {
+		super(key);
+		this.__data = cloneDeep(data);
+	}
+	createDOM() {
+		const element = document.createElement("span");
+		element.className = "sd-rich-text-editor-component";
+		element.dataset.richTextComponent = this.__data.name;
+		element.dataset.richTextComponentKey = this.__data.key;
+		return element;
+	}
+	updateDOM(previousNode, element) {
+		if (previousNode.__data.name !== this.__data.name) element.dataset.richTextComponent = this.__data.name;
+		if (previousNode.__data.key !== this.__data.key) element.dataset.richTextComponentKey = this.__data.key;
+		return false;
+	}
+	decorate(_editor, _config) {
+		return null;
+	}
+	exportDOM() {
+		const element = document.createElement("span");
+		element.dataset.richTextComponent = this.__data.name;
+		element.dataset.richTextComponentKey = this.__data.key;
+		element.textContent = this.getTextContent();
+		return { element };
+	}
+	exportJSON() {
+		return _objectSpread2(_objectSpread2({}, super.exportJSON()), {}, {
+			data: cloneDeep(this.getLatest().__data),
+			type: "sd-inline-component",
+			version: 1
+		});
+	}
+	getData() {
+		return cloneDeep(this.getLatest().__data);
+	}
+	getTextContent() {
+		var _data$textValue, _data$value;
+		const data = this.getLatest().__data;
+		return (_data$textValue = data.textValue) !== null && _data$textValue !== void 0 ? _data$textValue : String((_data$value = data.value) !== null && _data$value !== void 0 ? _data$value : "");
+	}
+	setValue(value) {
+		const writable = this.getWritable();
+		writable.__data = _objectSpread2(_objectSpread2({}, writable.__data), {}, { value: cloneDeep(value) });
+		return writable;
+	}
+	setData(data) {
+		const writable = this.getWritable();
+		writable.__data = cloneDeep(data);
+		return writable;
+	}
+	isInline() {
+		return true;
+	}
+	isIsolated() {
+		return false;
+	}
+	isKeyboardSelectable() {
+		return true;
+	}
+};
+function $createInlineComponentNode(data) {
+	return $applyNodeReplacement(new InlineComponentNode(data));
+}
+function $isInlineComponentNode(node) {
+	return node instanceof InlineComponentNode;
+}
+//#endregion
+export { $createInlineComponentNode, $isInlineComponentNode, InlineComponentNode };

package/es/rich-text-editor/rich-text-editor.js

@@ -0,0 +1,5 @@
+import rich_text_editor_vue_vue_type_script_setup_true_lang_default from "./rich-text-editor.vue_vue_type_script_setup_true_lang.js";
+//#region components/rich-text-editor/rich-text-editor.vue
+var rich_text_editor_default = rich_text_editor_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { rich_text_editor_default as default };

package/es/rich-text-editor/rich-text-editor.vue.d.ts

@@ -0,0 +1,76 @@
+import type { CommandListener, CommandListenerPriority, EditorSetOptions, EditorState, EditorUpdateOptions, Klass, LexicalCommand, LexicalEditor, LexicalNode, MutationListener, NodeKey, TextFormatType, Transform } from 'lexical';
+import type { JsonValue } from 'type-fest';
+import type { CSSProperties } from 'vue';
+import type { RichTextEditorComponentNodeData, RichTextEditorContentItem, RichTextEditorContentSnapshot, RichTextEditorFocusOptions, RichTextEditorInsertOptions, RichTextEditorMutationListenerOptions, RichTextEditorProps, RichTextEditorSlots, RichTextEditorValue } from './types';
+type __VLS_Slots = RichTextEditorSlots;
+declare function dispatchCommand<T>(command: LexicalCommand<T>, payload: T): boolean;
+declare function registerCommand<T>(command: LexicalCommand<T>, listener: CommandListener<T>, priority: CommandListenerPriority): () => void;
+declare function registerNodeTransform<T extends LexicalNode>(klass: Klass<T>, listener: Transform<T>): () => void;
+declare const __VLS_base: import("vue").DefineComponent<RichTextEditorProps, {
+    readonly editor: LexicalEditor | null;
+    readonly editorState: EditorState | null;
+    readonly rootElement: HTMLDivElement | null;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    focus: (callback?: () => void, options?: RichTextEditorFocusOptions) => void;
+    blur: () => void | undefined;
+    clear: () => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    getJSON: () => import("lexical").SerializedEditorState<import("lexical").SerializedLexicalNode> | undefined;
+    setJSON: (value: RichTextEditorValue | string, options?: EditorSetOptions) => void;
+    getContent: () => RichTextEditorContentSnapshot[];
+    setContent: (content: readonly RichTextEditorContentItem[], options?: EditorUpdateOptions) => void;
+    insertContent: (content: readonly RichTextEditorContentItem[], options?: RichTextEditorInsertOptions) => void;
+    getText: () => string;
+    getHTML: () => string;
+    setHTML: (html: string, options?: EditorUpdateOptions) => void;
+    getMarkdown: (transformers?: readonly import("@lexical/markdown").Transformer[]) => string;
+    setMarkdown: (markdown: string, transformers?: readonly import("@lexical/markdown").Transformer[], options?: EditorUpdateOptions) => void;
+    insertText: (text: string, options?: RichTextEditorInsertOptions) => void;
+    insertComponent: (data: RichTextEditorComponentNodeData, options?: RichTextEditorInsertOptions) => void;
+    updateComponent: (nodeKey: NodeKey, value: JsonValue, options?: EditorUpdateOptions) => void;
+    removeComponent: (nodeKey: NodeKey, options?: EditorUpdateOptions) => void;
+    formatText: (format: TextFormatType) => boolean;
+    read: <T>(callback: () => T) => T | undefined;
+    update: (callback: () => void, options?: EditorUpdateOptions) => void | undefined;
+    dispatchCommand: typeof dispatchCommand;
+    registerCommand: typeof registerCommand;
+    registerUpdateListener: (listener: import("lexical").UpdateListener) => () => void;
+    registerMutationListener: (klass: Klass<LexicalNode>, listener: MutationListener, options?: RichTextEditorMutationListenerOptions) => () => void;
+    registerNodeTransform: typeof registerNodeTransform;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    update: (context: import("./types").RichTextEditorChangeContext) => any;
+    error: (error: Error) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: RichTextEditorValue, context: import("./types").RichTextEditorChangeContext) => any;
+    "update:modelValue": (value: RichTextEditorValue) => any;
+    ready: (editor: LexicalEditor) => any;
+}, string, import("vue").PublicProps, Readonly<RichTextEditorProps> & Readonly<{
+    onUpdate?: ((context: import("./types").RichTextEditorChangeContext) => any) | undefined;
+    onError?: ((error: Error) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: RichTextEditorValue, context: import("./types").RichTextEditorChangeContext) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: RichTextEditorValue) => any) | undefined;
+    onReady?: ((editor: LexicalEditor) => any) | undefined;
+}>, {
+    classNames: Partial<Record<import("./types").RichTextEditorSemanticType, string>>;
+    autoSize: boolean | import("./types").RichTextEditorAutoSize;
+    styles: Partial<Record<import("./types").RichTextEditorSemanticType, CSSProperties>>;
+    plugins: readonly import("./types").RichTextEditorPlugin[];
+    transformers: readonly import("@lexical/markdown").Transformer[];
+    history: boolean;
+    historyDelay: number;
+    historyMaxDepth: number | null;
+    spellcheck: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};