@tmagic/editor 1.7.6 → 1.7.8-beta.1

package/dist/es/components/ContentMenu.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,160 @@
+import ToolButton_default from "./ToolButton.js";
+import { useZIndex } from "@tmagic/design";
+import { Fragment, Teleport, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, renderSlot, resolveComponent, useTemplateRef, vShow, withCtx, withDirectives, withModifiers } from "vue";
+//#region packages/editor/src/components/ContentMenu.vue?vue&type=script&setup=true&lang.ts
+var ContentMenu_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "MEditorContentMenu",
+	__name: "ContentMenu",
+	props: {
+		menuData: { default: () => [] },
+		isSubMenu: {
+			type: Boolean,
+			default: false
+		},
+		active: {},
+		autoHide: {
+			type: Boolean,
+			default: true
+		}
+	},
+	emits: [
+		"hide",
+		"show",
+		"mouseenter"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const menuEl = useTemplateRef("menu");
+		const buttonRefs = useTemplateRef("buttons");
+		const subMenuRef = useTemplateRef("subMenu");
+		const visible = ref(false);
+		const subMenuData = ref([]);
+		const zIndex = useZIndex();
+		const curZIndex = ref(0);
+		const menuPosition = ref({
+			left: 0,
+			top: 0
+		});
+		const menuStyle = computed(() => ({
+			top: `${menuPosition.value.top + 2}px`,
+			left: `${menuPosition.value.left + 2}px`,
+			zIndex: curZIndex.value
+		}));
+		const contains = (el) => menuEl.value?.contains(el) || subMenuRef.value?.contains(el);
+		const hide = () => {
+			if (!visible.value) return;
+			visible.value = false;
+			subMenuRef.value?.hide();
+			emit("hide");
+		};
+		const clickHandler = (event) => {
+			if (!props.autoHide) return;
+			if (event.button === 0) hide();
+		};
+		const outsideClickHideHandler = (e) => {
+			if (!props.autoHide) return;
+			const target = e.target;
+			if (!visible.value || !target) return;
+			if (contains(target)) return;
+			hide();
+		};
+		const setPosition = (e) => {
+			const menuHeight = menuEl.value?.clientHeight || 0;
+			let top = e.clientY;
+			if (menuHeight + e.clientY > document.body.clientHeight) top = document.body.clientHeight - menuHeight;
+			menuPosition.value = {
+				top,
+				left: e.clientX
+			};
+		};
+		const show = (e) => {
+			visible.value = true;
+			nextTick(() => {
+				e && setPosition(e);
+				curZIndex.value = zIndex.nextZIndex();
+				emit("show");
+			});
+		};
+		const showSubMenu = (item, index) => {
+			const menuItem = item;
+			if (typeof item !== "object") return;
+			subMenuData.value = menuItem.items || [];
+			setTimeout(() => {
+				if (!visible.value) return;
+				if (menuEl.value) {
+					let y = menuEl.value.offsetTop;
+					if (buttonRefs.value?.[index].$el) y = (buttonRefs.value?.[index].$el.getBoundingClientRect()).top;
+					subMenuRef.value?.show({
+						clientX: menuEl.value.offsetLeft + menuEl.value.clientWidth - 2,
+						clientY: y
+					});
+				}
+			}, 0);
+		};
+		const mouseenterHandler = () => {
+			emit("mouseenter");
+		};
+		onMounted(() => {
+			if (props.isSubMenu) return;
+			globalThis.addEventListener("mousedown", outsideClickHideHandler, true);
+		});
+		onBeforeUnmount(() => {
+			if (props.isSubMenu) return;
+			globalThis.removeEventListener("mousedown", outsideClickHideHandler, true);
+		});
+		__expose({
+			menu: menuEl,
+			menuPosition,
+			hide,
+			show,
+			contains,
+			setPosition
+		});
+		return (_ctx, _cache) => {
+			const _component_content_menu = resolveComponent("content-menu", true);
+			return openBlock(), createBlock(Transition, {
+				name: "fade",
+				persisted: ""
+			}, {
+				default: withCtx(() => [withDirectives(createElementVNode("div", {
+					class: "magic-editor-content-menu",
+					ref: "menu",
+					style: normalizeStyle(menuStyle.value),
+					onMouseenter: _cache[0] || (_cache[0] = ($event) => mouseenterHandler()),
+					onContextmenu: _cache[1] || (_cache[1] = withModifiers(() => {}, ["prevent"]))
+				}, [
+					renderSlot(_ctx.$slots, "title"),
+					createElementVNode("div", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.menuData, (item, index) => {
+						return openBlock(), createBlock(ToolButton_default, {
+							"event-type": "mouseup",
+							ref_for: true,
+							ref: "buttons",
+							class: normalizeClass({ active: __props.active && item.id === __props.active }),
+							data: item,
+							key: index,
+							onMouseup: clickHandler,
+							onMouseenter: ($event) => showSubMenu(item, index)
+						}, null, 8, [
+							"class",
+							"data",
+							"onMouseenter"
+						]);
+					}), 128))]),
+					(openBlock(), createBlock(Teleport, { to: "body" }, [subMenuData.value.length ? (openBlock(), createBlock(_component_content_menu, {
+						key: 0,
+						class: "sub-menu",
+						ref: "subMenu",
+						active: __props.active,
+						"menu-data": subMenuData.value,
+						"is-sub-menu": true,
+						onHide: hide
+					}, null, 8, ["active", "menu-data"])) : createCommentVNode("v-if", true)]))
+				], 36), [[vShow, visible.value]])]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+export { ContentMenu_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/FloatingBox.js

@@ -0,0 +1,5 @@
+import FloatingBox_vue_vue_type_script_setup_true_lang_default from "./FloatingBox.vue_vue_type_script_setup_true_lang.js";
+//#region packages/editor/src/components/FloatingBox.vue
+var FloatingBox_default = FloatingBox_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { FloatingBox_default as default };

package/dist/es/components/FloatingBox.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,161 @@
+import { useServices } from "../hooks/use-services.js";
+import Icon_default from "./Icon.js";
+import { TMagicButton, useZIndex } from "@tmagic/design";
+import { Teleport, computed, createBlock, createCommentVNode, createElementVNode, createVNode, defineComponent, mergeModels, nextTick, normalizeStyle, onBeforeUnmount, openBlock, provide, ref, renderSlot, toDisplayString, unref, useModel, useTemplateRef, watch, withCtx } from "vue";
+import { Close } from "@element-plus/icons-vue";
+import VanillaMoveable from "moveable";
+//#region packages/editor/src/components/FloatingBox.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	ref: "title",
+	class: "m-editor-float-box-title"
+};
+var FloatingBox_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "FloatingBox",
+	props: /* @__PURE__ */ mergeModels({
+		position: { default: () => ({
+			left: 0,
+			top: 0
+		}) },
+		title: { default: "" },
+		beforeClose: {}
+	}, {
+		"width": { default: 0 },
+		"widthModifiers": {},
+		"height": { default: 0 },
+		"heightModifiers": {},
+		"visible": {
+			type: Boolean,
+			default: false
+		},
+		"visibleModifiers": {}
+	}),
+	emits: [
+		"update:width",
+		"update:height",
+		"update:visible"
+	],
+	setup(__props, { expose: __expose }) {
+		const width = useModel(__props, "width");
+		const height = useModel(__props, "height");
+		const visible = useModel(__props, "visible");
+		const props = __props;
+		const targetEl = useTemplateRef("target");
+		const titleEl = useTemplateRef("title");
+		const zIndex = useZIndex();
+		const curZIndex = ref(0);
+		const titleHeight = ref(0);
+		const bodyHeight = computed(() => {
+			if (height.value) return height.value - titleHeight.value;
+			if (targetEl.value) return targetEl.value.clientHeight - titleHeight.value;
+			return "auto";
+		});
+		const { uiService } = useServices();
+		const frameworkWidth = computed(() => uiService.get("frameworkRect").width || 0);
+		const style = computed(() => {
+			let { left } = props.position;
+			if (width.value) left = left + width.value > frameworkWidth.value ? frameworkWidth.value - width.value : left;
+			return {
+				left: `${left}px`,
+				top: `${props.position.top}px`,
+				width: width.value ? `${width.value}px` : "auto",
+				height: height.value ? `${height.value}px` : "auto"
+			};
+		});
+		let moveable = null;
+		const initMoveable = () => {
+			moveable = new VanillaMoveable(globalThis.document.body, {
+				className: "m-editor-floating-box-moveable",
+				target: targetEl.value,
+				draggable: true,
+				resizable: true,
+				edge: true,
+				keepRatio: false,
+				origin: false,
+				snappable: true,
+				dragTarget: titleEl.value,
+				dragTargetSelf: false,
+				linePadding: 10,
+				controlPadding: 10,
+				bounds: {
+					left: 0,
+					top: 0,
+					right: 0,
+					bottom: 0,
+					position: "css"
+				}
+			});
+			moveable.on("drag", (e) => {
+				e.target.style.transform = e.transform;
+			});
+			moveable.on("resize", (e) => {
+				width.value = e.width;
+				height.value = e.height;
+				e.target.style.width = `${e.width}px`;
+				e.target.style.height = `${e.height}px`;
+				e.target.style.transform = e.drag.transform;
+			});
+		};
+		const destroyMoveable = () => {
+			moveable?.destroy();
+			moveable = null;
+		};
+		watch(visible, async (visible) => {
+			if (visible) {
+				await nextTick();
+				curZIndex.value = zIndex.nextZIndex();
+				const targetRect = targetEl.value?.getBoundingClientRect();
+				if (targetRect) {
+					width.value = targetRect.width;
+					height.value = targetRect.height;
+					initMoveable();
+				}
+				if (titleEl.value) titleHeight.value = titleEl.value.getBoundingClientRect().height;
+			} else destroyMoveable();
+		}, { immediate: true });
+		onBeforeUnmount(() => {
+			destroyMoveable();
+		});
+		const hide = (cancel) => {
+			if (cancel !== false) visible.value = false;
+		};
+		const closeHandler = () => {
+			if (typeof props.beforeClose === "function") props.beforeClose(hide);
+			else hide();
+		};
+		const nextZIndex = () => {
+			curZIndex.value = zIndex.nextZIndex();
+		};
+		provide("parentFloating", targetEl);
+		__expose({
+			bodyHeight,
+			target: targetEl,
+			titleEl
+		});
+		return (_ctx, _cache) => {
+			return visible.value ? (openBlock(), createBlock(Teleport, {
+				key: 0,
+				to: "body"
+			}, [createElementVNode("div", {
+				ref: "target",
+				class: "m-editor-float-box",
+				style: normalizeStyle({
+					...style.value,
+					zIndex: curZIndex.value
+				}),
+				onMousedown: nextZIndex
+			}, [createElementVNode("div", _hoisted_1, [renderSlot(_ctx.$slots, "title", {}, () => [createElementVNode("span", null, toDisplayString(__props.title), 1)]), createElementVNode("div", null, [createVNode(unref(TMagicButton), {
+				link: "",
+				size: "small",
+				onClick: closeHandler
+			}, {
+				default: withCtx(() => [createVNode(Icon_default, { icon: unref(Close) }, null, 8, ["icon"])]),
+				_: 1
+			})])], 512), createElementVNode("div", {
+				class: "m-editor-float-box-body",
+				style: normalizeStyle({ height: `${bodyHeight.value}px` })
+			}, [renderSlot(_ctx.$slots, "body")], 4)], 36)])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+//#endregion
+export { FloatingBox_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/Icon.js

@@ -0,0 +1,5 @@
+import Icon_vue_vue_type_script_setup_true_lang_default from "./Icon.vue_vue_type_script_setup_true_lang.js";
+//#region packages/editor/src/components/Icon.vue
+var Icon_default = Icon_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Icon_default as default };

package/dist/es/components/Icon.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,39 @@
+import { TMagicIcon } from "@tmagic/design";
+import { createBlock, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, resolveDynamicComponent, toRaw, unref, withCtx } from "vue";
+import { Edit } from "@element-plus/icons-vue";
+//#region packages/editor/src/components/Icon.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["src"];
+var Icon_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "MEditorIcon",
+	__name: "Icon",
+	props: { icon: {} },
+	setup(__props) {
+		const isRelativePath = (str) => /^(\.|(\.\.)?\/)/.test(str);
+		return (_ctx, _cache) => {
+			return !__props.icon ? (openBlock(), createBlock(unref(TMagicIcon), {
+				key: 0,
+				class: "magic-editor-icon"
+			}, {
+				default: withCtx(() => [createVNode(unref(Edit))]),
+				_: 1
+			})) : typeof __props.icon === "string" && (__props.icon.startsWith("http") || isRelativePath(__props.icon)) ? (openBlock(), createBlock(unref(TMagicIcon), {
+				key: 1,
+				class: "magic-editor-icon"
+			}, {
+				default: withCtx(() => [createElementVNode("img", { src: __props.icon }, null, 8, _hoisted_1)]),
+				_: 1
+			})) : typeof __props.icon === "string" ? (openBlock(), createElementBlock("i", {
+				key: 2,
+				class: normalizeClass(["magic-editor-icon", __props.icon])
+			}, null, 2)) : (openBlock(), createBlock(unref(TMagicIcon), {
+				key: 3,
+				class: "magic-editor-icon"
+			}, {
+				default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(toRaw(__props.icon))))]),
+				_: 1
+			}));
+		};
+	}
+});
+//#endregion
+export { Icon_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/Resizer.js

@@ -0,0 +1,5 @@
+import Resizer_vue_vue_type_script_setup_true_lang_default from "./Resizer.vue_vue_type_script_setup_true_lang.js";
+//#region packages/editor/src/components/Resizer.vue
+var Resizer_default = Resizer_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Resizer_default as default };

package/dist/es/components/Resizer.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,20 @@
+import { useGetSo } from "../hooks/use-getso.js";
+import { createElementBlock, defineComponent, normalizeClass, openBlock, renderSlot, unref, useTemplateRef } from "vue";
+//#region packages/editor/src/components/Resizer.vue?vue&type=script&setup=true&lang.ts
+var Resizer_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "MEditorResizer",
+	__name: "Resizer",
+	emits: ["change"],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		const { isDragging } = useGetSo(useTemplateRef("target"), emit);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				ref: "target",
+				class: normalizeClass(["m-editor-resizer", { "m-editor-resizer-dragging": unref(isDragging) }])
+			}, [renderSlot(_ctx.$slots, "default")], 2);
+		};
+	}
+});
+//#endregion
+export { Resizer_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/ScrollBar.js

@@ -0,0 +1,6 @@
+import ScrollBar_vue_vue_type_script_setup_true_lang_default from "./ScrollBar.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                          */
+//#region packages/editor/src/components/ScrollBar.vue
+var ScrollBar_default = ScrollBar_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ScrollBar_default as default };

package/dist/es/components/ScrollBar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,72 @@
+import { computed, createElementBlock, createElementVNode, defineComponent, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, useTemplateRef } from "vue";
+import Gesto from "gesto";
+//#region packages/editor/src/components/ScrollBar.vue?vue&type=script&setup=true&lang.ts
+var ScrollBar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "MEditorScrollBar",
+	__name: "ScrollBar",
+	props: {
+		size: {},
+		scrollSize: {},
+		isHorizontal: { type: Boolean },
+		pos: {}
+	},
+	emits: ["scroll"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const barEl = useTemplateRef("bar");
+		const thumbEl = useTemplateRef("thumb");
+		const thumbSize = computed(() => props.size * (props.size / props.scrollSize));
+		const thumbPos = computed(() => props.pos / props.scrollSize * props.size);
+		const thumbStyle = computed(() => ({
+			[props.isHorizontal ? "width" : "height"]: `${thumbSize.value}px`,
+			transform: `translate${props.isHorizontal ? "X" : "Y"}(${thumbPos.value}px)`
+		}));
+		let gesto;
+		onMounted(() => {
+			if (!thumbEl.value) return;
+			gesto = new Gesto(thumbEl.value, { container: window });
+			gesto.on("dragStart", (e) => {
+				e.inputEvent.stopPropagation();
+				e.inputEvent.preventDefault();
+			}).on("drag", (e) => {
+				scrollBy(getDelta(e));
+			});
+			barEl.value?.addEventListener("wheel", wheelHandler, false);
+		});
+		onBeforeUnmount(() => {
+			if (gesto) gesto.off();
+			barEl.value?.removeEventListener("wheel", wheelHandler, false);
+		});
+		const wheelHandler = (e) => {
+			const delta = props.isHorizontal ? e.deltaX : e.deltaY;
+			if (delta) e.preventDefault();
+			scrollBy(delta);
+		};
+		const getDelta = (e) => {
+			const ratio = (props.isHorizontal ? e.deltaX : e.deltaY) / props.size;
+			return props.scrollSize * ratio;
+		};
+		const scrollBy = (delta) => {
+			if (delta < 0) if (props.pos <= 0) emit("scroll", 0);
+			else emit("scroll", -Math.min(-delta, props.pos));
+			else {
+				const leftPos = props.size - (thumbSize.value + thumbPos.value);
+				if (leftPos <= 0) emit("scroll", 0);
+				else emit("scroll", Math.min(delta, leftPos));
+			}
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref: "bar",
+				class: normalizeClass(["m-editor-scroll-bar", __props.isHorizontal ? "horizontal" : "vertical"])
+			}, [createElementVNode("div", {
+				ref: "thumb",
+				class: "m-editor-scroll-bar-thumb",
+				style: normalizeStyle(thumbStyle.value)
+			}, null, 4)], 2);
+		};
+	}
+});
+//#endregion
+export { ScrollBar_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/ScrollViewer.js

@@ -0,0 +1,5 @@
+import ScrollViewer_vue_vue_type_script_setup_true_lang_default from "./ScrollViewer.vue_vue_type_script_setup_true_lang.js";
+//#region packages/editor/src/components/ScrollViewer.vue
+var ScrollViewer_default = ScrollViewer_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ScrollViewer_default as default };

package/dist/es/components/ScrollViewer.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,104 @@
+import { ScrollViewer } from "../utils/scroll-viewer.js";
+import ScrollBar_default from "./ScrollBar.js";
+import { isNumber } from "@tmagic/utils";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, useTemplateRef, watch } from "vue";
+//#region packages/editor/src/components/ScrollViewer.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	class: "m-editor-scroll-viewer-container",
+	ref: "container"
+};
+var ScrollViewer_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "MEditorScrollViewer",
+	__name: "ScrollViewer",
+	props: {
+		width: { default: 0 },
+		height: { default: 0 },
+		wrapWidth: { default: 0 },
+		wrapHeight: { default: 0 },
+		zoom: { default: 1 },
+		correctionScrollSize: { default: () => ({
+			width: 0,
+			height: 0
+		}) }
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const containerEl = useTemplateRef("container");
+		const el = useTemplateRef("target");
+		const style = computed(() => `
+        width: ${isNumber(`${props.width}`) ? `${props.width}px` : props.width};
+        height: ${isNumber(`${props.height}`) ? `${props.height}px` : props.height};
+        position: absolute;
+        margin-top: 30px;
+      `);
+		const scrollWidth = ref(0);
+		const scrollHeight = ref(0);
+		let scrollViewer;
+		onMounted(() => {
+			if (!containerEl.value || !el.value) return;
+			scrollViewer = new ScrollViewer({
+				container: containerEl.value,
+				target: el.value,
+				zoom: props.zoom,
+				correctionScrollSize: props.correctionScrollSize
+			});
+			scrollViewer.on("scroll", (data) => {
+				hOffset.value = data.scrollLeft;
+				vOffset.value = data.scrollTop;
+				scrollWidth.value = data.scrollWidth;
+				scrollHeight.value = data.scrollHeight;
+			});
+		});
+		onBeforeUnmount(() => {
+			scrollViewer.destroy();
+		});
+		watch(() => props.zoom, () => {
+			scrollViewer.setZoom(props.zoom);
+		});
+		const vOffset = ref(0);
+		const vScrollHandler = (delta) => {
+			vOffset.value += delta;
+			scrollViewer.scrollTo({ top: vOffset.value });
+		};
+		const hOffset = ref(0);
+		const hScrollHandler = (delta) => {
+			hOffset.value += delta;
+			scrollViewer.scrollTo({ left: hOffset.value });
+		};
+		__expose({ container: containerEl });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createElementVNode("div", {
+					ref: "target",
+					style: normalizeStyle(style.value)
+				}, [renderSlot(_ctx.$slots, "default")], 4),
+				renderSlot(_ctx.$slots, "content"),
+				scrollHeight.value > __props.wrapHeight ? (openBlock(), createBlock(ScrollBar_default, {
+					key: 0,
+					"scroll-size": scrollHeight.value,
+					pos: vOffset.value,
+					size: __props.wrapHeight,
+					onScroll: vScrollHandler
+				}, null, 8, [
+					"scroll-size",
+					"pos",
+					"size"
+				])) : createCommentVNode("v-if", true),
+				scrollWidth.value > __props.wrapWidth ? (openBlock(), createBlock(ScrollBar_default, {
+					key: 1,
+					"is-horizontal": true,
+					"scroll-size": scrollWidth.value,
+					pos: hOffset.value,
+					size: __props.wrapWidth,
+					onScroll: hScrollHandler
+				}, null, 8, [
+					"scroll-size",
+					"pos",
+					"size"
+				])) : createCommentVNode("v-if", true)
+			], 512);
+		};
+	}
+});
+//#endregion
+export { ScrollViewer_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/SearchInput.js

@@ -0,0 +1,5 @@
+import SearchInput_vue_vue_type_script_setup_true_lang_default from "./SearchInput.vue_vue_type_script_setup_true_lang.js";
+//#region packages/editor/src/components/SearchInput.vue
+var SearchInput_default = SearchInput_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SearchInput_default as default };

package/dist/es/components/SearchInput.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,40 @@
+import { TMagicIcon, TMagicInput } from "@tmagic/design";
+import { createBlock, createVNode, defineComponent, openBlock, ref, unref, withCtx } from "vue";
+import { Search } from "@element-plus/icons-vue";
+//#region packages/editor/src/components/SearchInput.vue?vue&type=script&setup=true&lang.ts
+var SearchInput_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "MEditorSearchInput",
+	__name: "SearchInput",
+	emits: ["search"],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		const filterText = ref("");
+		let timer = null;
+		const filterTextChangeHandler = () => {
+			timer && clearTimeout(timer);
+			timer = setTimeout(() => {
+				emit("search", filterText.value);
+				timer = null;
+			}, 300);
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(TMagicInput), {
+				modelValue: filterText.value,
+				"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => filterText.value = $event),
+				class: "search-input",
+				size: "small",
+				placeholder: "输入关键字进行过滤",
+				clearable: "",
+				onInput: filterTextChangeHandler
+			}, {
+				prefix: withCtx(() => [createVNode(unref(TMagicIcon), null, {
+					default: withCtx(() => [createVNode(unref(Search))]),
+					_: 1
+				})]),
+				_: 1
+			}, 8, ["modelValue"]);
+		};
+	}
+});
+//#endregion
+export { SearchInput_vue_vue_type_script_setup_true_lang_default as default };

package/dist/es/components/SplitView.js

@@ -0,0 +1,5 @@
+import SplitView_vue_vue_type_script_setup_true_lang_default from "./SplitView.vue_vue_type_script_setup_true_lang.js";
+//#region packages/editor/src/components/SplitView.vue
+var SplitView_default = SplitView_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SplitView_default as default };