@kdesigner/amis-vue 0.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,995 @@
+import { PageApis, UserApis, ajaxFetch, bindActions, createPage, default_isCurrentUrl, default_jumpTo, default_updateLocation, deletePageCache, getSchemaProcessorType, isCancel, providePage, transformPageJson, useAdapter, useDebug } from "@kdesigner/core";
+import { deepClone, isString } from "@kdesigner/shared";
+import { Fragment, Teleport, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, guardReactiveProps, h, markRaw, mergeProps, normalizeClass, normalizeProps, normalizeStyle, onBeforeUnmount, onMounted, onUnmounted, openBlock, ref, resolveComponent, resolveDynamicComponent, shallowRef, unref, watch, watchEffect, withKeys } from "vue";
+import { FormItem, Renderer, ScopedContext, ToastComponent, clearStoresCache, render, setDefaultLocale, toast } from "amis";
+import React, { Fragment as Fragment$1, createElement } from "react";
+import { applyPureVueInReact } from "veaury";
+import { useRoute } from "vue-router";
+import copy from "copy-to-clipboard";
+import { createRoot } from "react-dom/client";
+import "moment/locale/zh-cn";
+import yaml from "js-yaml";
+import { createObject, resolveVariableAndFilter } from "amis-core";
+import "@kdesigner/amis-extensions/style.css";
+import "@kdesigner/components/style";
+export * from "@kdesigner/core";
+export * from "@kdesigner/components";
+export * from "@kdesigner/amis-extensions";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region src/editor/AmisPageEditor.vue?vue&type=script&lang.ts
+var AmisPageEditor_vue_vue_type_script_lang_default = defineComponent({
+	props: {
+		schema: Object,
+		rollbackPageSource: Function,
+		getPageSource: {
+			type: Function,
+			required: true
+		},
+		savePageSource: {
+			type: Function,
+			required: true
+		}
+	},
+	emits: ["exit"],
+	setup(props, { emit }) {
+		const editorRef = ref(null);
+		let fetched = false;
+		let editorInited = false;
+		const { savePageSource, rollbackPageSource, getPageSource } = props;
+		function pushSchema(schema) {
+			postMsg({
+				type: "setSchema",
+				data: schema
+			});
+		}
+		/** 首次初始化：有 schema 直接推；否则自行拉取（宿主已去掉前置 loading） */
+		function applyInitialSchema() {
+			if (fetched) return;
+			if (props.schema != null) {
+				fetched = true;
+				pushSchema(props.schema);
+				return;
+			}
+			fetched = true;
+			getPageSource(true).then((page) => {
+				pushSchema(page);
+			}).catch((e) => {
+				fetched = false;
+				postMsg({
+					type: "toast",
+					level: "error",
+					message: e.message || e.toString()
+				});
+			});
+		}
+		function handleEvent(event) {
+			if (event.data == "amis-editor-inited") {
+				editorInited = true;
+				applyInitialSchema();
+			} else if (event.data === "amis-editor-reload") {
+				fetched = false;
+				startFetch();
+			} else if (event.data === "amis-editor-exit") emit("exit");
+			else if (event.data === "amis-editor-rollback") {
+				if (rollbackPageSource) rollbackPageSource().then(() => {
+					postMsg({
+						type: "toast",
+						level: "info",
+						message: "回滚成功"
+					});
+				}).catch((e) => {
+					postMsg({
+						type: "toast",
+						level: "error",
+						message: e.message || e.toString()
+					});
+				}).then(() => {
+					fetched = false;
+					return startFetch();
+				});
+			} else if (isString(event.data) && event.data.startsWith("{")) {
+				var data = JSON.parse(event.data);
+				if (data.type == "save") savePageSource(data.data).then(() => {
+					postMsg({
+						type: "toast",
+						message: "保存成功"
+					});
+				}).catch((e) => {
+					postMsg({
+						type: "toast",
+						level: "error",
+						message: e.message || e.toString()
+					});
+				});
+				else if (data.type == "ajaxFetch") ajaxFetch(data.data).then((result) => {
+					postMsg({
+						type: "ajaxComplete",
+						reqId: data.reqId,
+						result
+					});
+				});
+			} else console.log("unknown-message", event.data);
+		}
+		function postMsg(msg) {
+			const frame = editorRef.value;
+			if (!frame) return;
+			const str = isString(msg) ? msg : JSON.stringify(msg);
+			frame.contentWindow.postMessage(str, "*");
+		}
+		function startFetch() {
+			if (!editorRef.value) return;
+			fetched = true;
+			return getPageSource(true).then((page) => {
+				postMsg({
+					type: "toast",
+					level: "info",
+					message: "页面加载成功"
+				});
+				postMsg({
+					type: "setSchema",
+					data: page
+				});
+			}).catch((e) => {
+				postMsg({
+					type: "toast",
+					level: "error",
+					message: e.message || e.toString()
+				});
+				throw e;
+			});
+		}
+		window.addEventListener("message", handleEvent);
+		watch(() => props.schema, (schema) => {
+			if (!editorInited || schema == null) return;
+			fetched = true;
+			pushSchema(schema);
+		});
+		onUnmounted(() => {
+			console.log("editor unmounted");
+			window.removeEventListener("message", handleEvent);
+		});
+		return { editorRef };
+	}
+});
+//#endregion
+//#region \0plugin-vue:export-helper
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+//#endregion
+//#region src/editor/AmisPageEditor.vue
+const _hoisted_1$3 = {
+	style: {
+		"width": "100%",
+		"height": "100%",
+		"border": "none"
+	},
+	ref: "editorRef",
+	src: "/amis-editor/index.html"
+};
+function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
+	return openBlock(), createElementBlock("iframe", _hoisted_1$3, null, 512);
+}
+var AmisPageEditor_default = /*#__PURE__*/ _plugin_vue_export_helper_default(AmisPageEditor_vue_vue_type_script_lang_default, [["render", _sfc_render$3]]);
+//#endregion
+//#region src/editor/XuiPageEditor.vue
+var XuiPageEditor_default = /* @__PURE__ */ defineComponent({
+	__name: "XuiPageEditor",
+	props: {
+		rollbackPageSource: Function,
+		getPageSource: {
+			type: Function,
+			required: true
+		},
+		savePageSource: {
+			type: Function,
+			required: true
+		}
+	},
+	emits: ["exit"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const { getPageSource } = props;
+		const { useI18n } = useAdapter();
+		const emit = __emit;
+		function handleExit() {
+			emit("exit");
+		}
+		const componentType = shallowRef(markRaw(AmisPageEditor_default));
+		const schemaRef = shallowRef();
+		watchEffect(() => {
+			getPageSource(false).then((schema) => {
+				if (!schema) schema = {};
+				schemaRef.value = markRaw(schema);
+				const schemaTypeName = schema["xui:schema-type"];
+				if (!schemaTypeName) {
+					componentType.value = markRaw(AmisPageEditor_default);
+					return;
+				}
+				const schemaType = getSchemaProcessorType(schemaTypeName);
+				if (!schemaType) {
+					const { t } = useI18n();
+					useAdapter().notify("error", t("nop.err.unknown-schema-type"));
+					throw new Error("nop.err.unknown-schema-type");
+				}
+				componentType.value = markRaw(schemaType.editorComponentType);
+			});
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(componentType.value), mergeProps(props, {
+				schema: schemaRef.value,
+				onExit: handleExit
+			}), null, 16, ["schema"]);
+		};
+	}
+});
+//#endregion
+//#region src/editor/XuiPageEditorDialog.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$2 = {
+	key: 0,
+	class: "page-editor-root",
+	role: "dialog",
+	"aria-modal": "true"
+};
+//#endregion
+//#region src/editor/XuiPageEditorDialog.vue
+var XuiPageEditorDialog_default = /* @__PURE__ */ defineComponent({
+	__name: "XuiPageEditorDialog",
+	props: {
+		modelValue: Boolean,
+		rollbackPageSource: Function,
+		getPageSource: {
+			type: Function,
+			required: true
+		},
+		savePageSource: {
+			type: Function,
+			required: true
+		}
+	},
+	emits: ["update:modelValue", "exit"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		let prevBodyOverflow = "";
+		watch(() => props.modelValue, (open) => {
+			if (open) {
+				prevBodyOverflow = document.body.style.overflow;
+				document.body.style.overflow = "hidden";
+			} else document.body.style.overflow = prevBodyOverflow;
+		});
+		onUnmounted(() => {
+			document.body.style.overflow = prevBodyOverflow;
+		});
+		function handleEditorExit() {
+			emit("update:modelValue", false);
+			emit("exit");
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createCommentVNode(" 自绘全屏层：不依赖 element-plus 样式（宿主常未引入） "), (openBlock(), createBlock(Teleport, { to: "body" }, [__props.modelValue ? (openBlock(), createElementBlock("div", _hoisted_1$2, [createVNode(XuiPageEditor_default, {
+				savePageSource: __props.savePageSource,
+				rollbackPageSource: __props.rollbackPageSource,
+				getPageSource: __props.getPageSource,
+				onExit: handleEditorExit
+			}, null, 8, [
+				"savePageSource",
+				"rollbackPageSource",
+				"getPageSource"
+			])])) : createCommentVNode("v-if", true)]))], 2112);
+		};
+	}
+});
+//#endregion
+//#region src/editor/XuiLoading.vue
+const _sfc_main = {};
+const _hoisted_1$1 = {
+	class: "app-loading",
+	role: "status",
+	"aria-live": "polite",
+	"aria-label": "Loading"
+};
+function _sfc_render$2(_ctx, _cache) {
+	return openBlock(), createElementBlock("div", _hoisted_1$1, [..._cache[0] || (_cache[0] = [createElementVNode("div", { class: "app-loading-spinner" }, null, -1)])]);
+}
+var XuiLoading_default = /*#__PURE__*/ _plugin_vue_export_helper_default(_sfc_main, [["render", _sfc_render$2], ["__scopeId", "data-v-a382f6ec"]]);
+//#endregion
+//#region src/runtime/env.ts
+function createEnv(page) {
+	const { debug } = useDebug();
+	const adapter = useAdapter();
+	const env = {
+		session: page.id,
+		affixOffsetTop: 0,
+		fetcher(options) {
+			providePage(page);
+			options._page = page;
+			return ajaxFetch(options);
+		},
+		jumpTo(to, _action, _ctx) {
+			const router = adapter.useRouter();
+			return default_jumpTo(router, to);
+		},
+		isCancel,
+		isCurrentUrl: default_isCurrentUrl,
+		updateLocation(to, replace) {
+			default_updateLocation(to, !!replace);
+		},
+		notify: adapter.notify,
+		enableAMISDebug: debug.value,
+		alert: adapter.alert,
+		confirm: adapter.confirm,
+		copy: (contents, options) => {
+			if (options === void 0) options = {};
+			const { t } = adapter.useI18n();
+			const ret = copy(contents, options);
+			if (ret && (!options || options.shutup !== true)) toast.info(t("Copy To Clipboard"));
+			return ret;
+		}
+	};
+	env._page = page;
+	page.env = env;
+	return env;
+}
+//#endregion
+//#region src/runtime/react-adapter.ts
+function defineReactPageComponent(builder) {
+	return defineComponent({
+		props: {
+			schema: Object,
+			data: Object,
+			registerPage: Function,
+			actions: Object
+		},
+		setup(props) {
+			const domRef = ref();
+			let root;
+			const options = builder({ actions: props.actions });
+			const page = createPage(options);
+			props.registerPage?.(page);
+			function destroyPage() {
+				if (root) {
+					root.unmount();
+					options.onDestroyPage?.(page);
+					root = void 0;
+				}
+			}
+			function renderPage() {
+				const schema = deepClone(props.schema);
+				root = createRoot(domRef.value);
+				const r = root;
+				Promise.resolve(options.onRenderPage(schema, props.data, page)).then((v) => r.render(v));
+			}
+			watchEffect(() => {
+				destroyPage();
+				if (props.schema && domRef.value) renderPage();
+			});
+			onBeforeUnmount(() => {
+				destroyPage();
+				return { domRef };
+			});
+			return () => h("div", {
+				ref: domRef,
+				style: {
+					width: "100%",
+					height: "100%"
+				},
+				class: "nop-page"
+			});
+		}
+	});
+}
+//#endregion
+//#region src/page/AmisSchemaPage.ts
+var AmisSchemaPage_default = defineReactPageComponent((props) => {
+	let amisScoped;
+	const route = useRoute();
+	return {
+		actions: props.actions,
+		getComponent(name) {
+			return get_component(name);
+		},
+		getScopedStore(name) {
+			return get_component(name)?.props?.store;
+		},
+		getState(name) {
+			return get_root_store().get(name);
+		},
+		setState(name, value) {
+			get_root_store().set(name, value);
+		},
+		onDestroyPage(page) {
+			clearStoresCache(page.id);
+		},
+		async onRenderPage(schema, data, page) {
+			const env = createEnv(page);
+			const locale = useAdapter().useLocale();
+			let globalScopeData = {};
+			try {
+				globalScopeData = await UserApis.LoginApi__getLoginUserInfo();
+			} catch (e) {
+				console.error(e);
+			}
+			const opts = {
+				data: {
+					...data,
+					globalScopeData,
+					route: {
+						meta: route.meta,
+						path: route.path,
+						name: route.name,
+						query: route.query,
+						params: route.params,
+						fullPath: route.fullPath,
+						hash: route.hash
+					}
+				},
+				onConfirm: page.getAction("ok") || function() {},
+				onClose: function(b) {
+					if (b) page.getAction("ok")?.();
+					else page.getAction("cancel")?.();
+				},
+				scopeRef: (scoped) => {
+					amisScoped = scoped;
+				},
+				locale,
+				theme: "cxd"
+			};
+			setDefaultLocale(locale);
+			schema = await transformPageJson(schema.__baseUrl, schema);
+			await bindActions(schema.__baseUrl, schema, page);
+			return render(schema, opts, env);
+		}
+	};
+	function get_root() {
+		return amisScoped?.getComponents()[0];
+	}
+	function get_root_store() {
+		return get_root()?.context.store;
+	}
+	function get_component(name) {
+		if (name[0] == "#") {
+			const pos = name.indexOf(".");
+			if (pos < 0) return get_root()?.context.getComponentById(name.substring(1));
+			else return get_root()?.context.getComponentById(name.substring(1)).getComponentByName(name.substring(pos + 1));
+		} else return get_root()?.context.getComponentByName(name);
+	}
+});
+//#endregion
+//#region src/page/XuiSchemaPage.vue?vue&type=script&lang.ts
+/**
+* 嵌入到vue中的amis页面。每个AmisSchemaPage都对应一个ReactRooot。schema发生变化时会重新创建react组件
+*/
+var XuiSchemaPage_vue_vue_type_script_lang_default = defineComponent({
+	props: {
+		schema: Object,
+		data: Object,
+		registerPage: Function,
+		actions: Object
+	},
+	setup(props) {
+		const { useI18n } = useAdapter();
+		let componentType = ref(markRaw(AmisSchemaPage_default));
+		watchEffect(() => {
+			const schemaTypeName = props.schema?.["xui:schema-type"];
+			if (!schemaTypeName) componentType.value = markRaw(AmisSchemaPage_default);
+			else {
+				const schemaType = getSchemaProcessorType(schemaTypeName);
+				if (!schemaType) {
+					const { t } = useI18n();
+					useAdapter().notify("error", t("nop.err.unknown-schema-type"));
+					throw new Error("nop.err.unknown-schema-type");
+				}
+				componentType.value = markRaw(schemaType.componentType);
+			}
+		});
+		return { componentType };
+	}
+});
+//#endregion
+//#region src/page/XuiSchemaPage.vue
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+	return openBlock(), createBlock(resolveDynamicComponent(_ctx.componentType), normalizeProps(guardReactiveProps(_ctx.$props)), null, 16);
+}
+var XuiSchemaPage_default = /*#__PURE__*/ _plugin_vue_export_helper_default(XuiSchemaPage_vue_vue_type_script_lang_default, [["render", _sfc_render$1]]);
+//#endregion
+//#region src/debug/debugger.ts
+var debugger_default = {
+	type: "page",
+	"xui:schema": "amis",
+	body: {
+		type: "form",
+		title: null,
+		actions: [
+			{
+				label: "Cancel",
+				type: "action",
+				actionType: "ajax",
+				level: "default",
+				api: {
+					url: "action://cancel",
+					messages: { success: "_" }
+				}
+			},
+			{
+				label: "Apply",
+				type: "action",
+				actionType: "ajax",
+				level: "success",
+				api: "action://change"
+			},
+			{
+				label: "Yaml/JSON",
+				type: "action",
+				actionType: "ajax",
+				level: "primary",
+				api: "action://toggleYaml"
+			},
+			{
+				label: "Submit",
+				type: "action",
+				actionType: "ajax",
+				level: "primary",
+				api: "action://ok"
+			}
+		],
+		body: [{
+			type: "editor",
+			name: "schema",
+			placeholder: "{}",
+			visibleOn: "this.lang !='yaml'"
+		}, {
+			type: "yaml-editor",
+			name: "schema",
+			placeholder: {},
+			visibleOn: "this.lang == 'yaml'"
+		}]
+	}
+};
+//#endregion
+//#region src/debug/XuiDebugger.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = { class: "schema-modal-panel" };
+const _hoisted_2 = { class: "schema-modal-body" };
+const POSITION_KEY = "kdesigner:xui-debugger-pos";
+//#endregion
+//#region src/page/XuiPage.vue?vue&type=script&lang.ts
+/**
+* 在AmisSchemaPage的基础上增加AmisDebugger调试功能，以及根据path动态加载schema的功能
+*/
+var XuiPage_vue_vue_type_script_lang_default = defineComponent({
+	name: "amis-page",
+	props: {
+		path: {
+			type: String,
+			required: true
+		},
+		data: Object,
+		config: Object,
+		registerPage: Function,
+		actions: Object
+	},
+	components: {
+		XuiDebugger: /* @__PURE__ */ defineComponent({
+			__name: "XuiDebugger",
+			props: {
+				path: {
+					type: String,
+					required: true
+				},
+				schema: Object
+			},
+			emits: ["update:schema", "rebuild"],
+			setup(__props, { emit: __emit }) {
+				const props = __props;
+				const emit = __emit;
+				const schemaVisible = ref(false);
+				const designerVisible = ref(false);
+				const dragging = ref(false);
+				const pos = ref(null);
+				let prevBodyOverflow = "";
+				const positionStyle = computed(() => {
+					if (!pos.value) return void 0;
+					return {
+						left: `${pos.value.left}px`,
+						top: `${pos.value.top}px`,
+						right: "auto"
+					};
+				});
+				onMounted(() => {
+					try {
+						const raw = sessionStorage.getItem(POSITION_KEY);
+						if (!raw) return;
+						const parsed = JSON.parse(raw);
+						if (Number.isFinite(parsed.left) && Number.isFinite(parsed.top)) pos.value = clampPos(parsed.left, parsed.top);
+					} catch {}
+				});
+				onUnmounted(() => {
+					restoreBodyScroll();
+				});
+				watch(schemaVisible, (open) => {
+					if (open) lockBodyScroll();
+					else restoreBodyScroll();
+				});
+				function lockBodyScroll() {
+					prevBodyOverflow = document.body.style.overflow;
+					document.body.style.overflow = "hidden";
+				}
+				function restoreBodyScroll() {
+					document.body.style.overflow = prevBodyOverflow;
+				}
+				function clampPos(left, top) {
+					const maxLeft = Math.max(8, window.innerWidth - 100);
+					const maxTop = Math.max(8, window.innerHeight - 48);
+					return {
+						left: Math.min(Math.max(8, left), maxLeft),
+						top: Math.min(Math.max(8, top), maxTop)
+					};
+				}
+				/** 仅手柄可拖；S/V 保持正常 click，避免 pointer capture 吞事件 */
+				function onPointerDown(e) {
+					if (e.button !== 0 && e.pointerType === "mouse") return;
+					e.preventDefault();
+					const handle = e.currentTarget;
+					const panel = handle.closest(".page-debugger");
+					if (!panel) return;
+					const rect = panel.getBoundingClientRect();
+					const startX = e.clientX;
+					const startY = e.clientY;
+					const originLeft = rect.left;
+					const originTop = rect.top;
+					dragging.value = true;
+					handle.setPointerCapture(e.pointerId);
+					const onMove = (ev) => {
+						pos.value = clampPos(originLeft + (ev.clientX - startX), originTop + (ev.clientY - startY));
+					};
+					const onUp = (ev) => {
+						dragging.value = false;
+						handle.releasePointerCapture(ev.pointerId);
+						handle.removeEventListener("pointermove", onMove);
+						handle.removeEventListener("pointerup", onUp);
+						handle.removeEventListener("pointercancel", onUp);
+						if (pos.value) try {
+							sessionStorage.setItem(POSITION_KEY, JSON.stringify(pos.value));
+						} catch {}
+					};
+					handle.addEventListener("pointermove", onMove);
+					handle.addEventListener("pointerup", onUp);
+					handle.addEventListener("pointercancel", onUp);
+				}
+				const schemaData = shallowRef({
+					schema: "",
+					lang: "json"
+				});
+				const { PageProvider__getPageSource, PageProvider__rollbackPageSource, PageProvider__savePageSource } = PageApis;
+				function getPageSource(silent) {
+					return PageProvider__getPageSource(props.path, silent);
+				}
+				function savePageSource(data) {
+					deletePageCache(props.path);
+					PageProvider__savePageSource(props.path, data, true);
+				}
+				function rollbackPageSource() {
+					PageProvider__rollbackPageSource(props.path, true);
+				}
+				function openSchemaEditor() {
+					schemaData.value = {
+						schema: yaml.dump(props.schema),
+						lang: "yaml"
+					};
+					schemaVisible.value = true;
+				}
+				const schemaActions = {
+					ok: handleOk,
+					cancel: handleCancel,
+					change: handleChange,
+					rebuild: handleRebuild,
+					toggleYaml: handleToggleYaml
+				};
+				function handleChange(options) {
+					const data = options.data;
+					let json = schemaData.value.lang == "yaml" ? yaml.load(data.schema) : JSON.parse(data.schema);
+					emit("update:schema", json);
+				}
+				function handleOk(data) {
+					handleChange(data);
+					schemaVisible.value = false;
+				}
+				function handleCancel() {
+					schemaVisible.value = false;
+				}
+				function handleRebuild() {
+					emit("rebuild");
+				}
+				function handleToggleYaml(options) {
+					let schema = options.data.schema;
+					if (options.data.lang == "yaml") schemaData.value = {
+						lang: "json",
+						schema: JSON.stringify(yaml.load(schema), null, "  ")
+					};
+					else schemaData.value = {
+						lang: "yaml",
+						schema: yaml.dump(JSON.parse(schema))
+					};
+				}
+				function openXuiPageEditor() {
+					designerVisible.value = true;
+				}
+				return (_ctx, _cache) => {
+					return openBlock(), createElementBlock(Fragment, null, [
+						createElementVNode("span", {
+							class: normalizeClass(["page-debugger", { "is-dragging": dragging.value }]),
+							style: normalizeStyle(positionStyle.value)
+						}, [
+							createElementVNode("button", {
+								type: "button",
+								class: "debug-handle",
+								title: "拖动",
+								"aria-label": "拖动调试工具",
+								onPointerdown: onPointerDown
+							}, " ⋮⋮ ", 32),
+							createElementVNode("button", {
+								type: "button",
+								class: "debug-btn",
+								title: "Schema Json Editor",
+								onClick: openSchemaEditor
+							}, " S "),
+							__props.path ? (openBlock(), createElementBlock("button", {
+								key: 0,
+								type: "button",
+								class: "debug-btn",
+								title: "Page Visual Designer",
+								onClick: openXuiPageEditor
+							}, " V ")) : createCommentVNode("v-if", true)
+						], 6),
+						createCommentVNode(" 自绘浮层：宿主未必引入 element-plus 样式，el-dialog 会掉进文档流撑高页面 "),
+						(openBlock(), createBlock(Teleport, { to: "body" }, [schemaVisible.value ? (openBlock(), createElementBlock("div", {
+							key: 0,
+							class: "schema-modal-root",
+							role: "dialog",
+							"aria-modal": "true",
+							"aria-label": "Page Schema",
+							onKeydown: withKeys(handleCancel, ["esc"])
+						}, [createElementVNode("div", {
+							class: "schema-modal-mask",
+							onClick: handleCancel
+						}), createElementVNode("div", _hoisted_1, [createElementVNode("header", { class: "schema-modal-header" }, [_cache[1] || (_cache[1] = createElementVNode("h2", { class: "schema-modal-title" }, "Page Schema", -1)), createElementVNode("button", {
+							type: "button",
+							class: "schema-modal-close",
+							"aria-label": "关闭",
+							onClick: handleCancel
+						}, " × ")]), createElementVNode("div", _hoisted_2, [createVNode(unref(AmisSchemaPage_default), {
+							schema: unref(debugger_default),
+							actions: schemaActions,
+							data: schemaData.value
+						}, null, 8, ["schema", "data"])])])], 32)) : createCommentVNode("v-if", true)])),
+						createVNode(XuiPageEditorDialog_default, {
+							modelValue: designerVisible.value,
+							"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => designerVisible.value = $event),
+							savePageSource,
+							rollbackPageSource,
+							getPageSource
+						}, null, 8, ["modelValue"])
+					], 64);
+				};
+			}
+		}),
+		XuiSchemaPage: XuiSchemaPage_default
+	},
+	setup(props) {
+		const { getPage } = useAdapter();
+		let pageSchema = shallowRef();
+		function registerPage(p) {
+			props.registerPage?.(p);
+		}
+		watchEffect(() => {
+			getPage(props.path).then((res) => {
+				res.__baseUrl = props.path;
+				updateSchema(res);
+			});
+		});
+		function updateSchema(value) {
+			pageSchema.value = value;
+		}
+		function rebuild() {
+			pageSchema.value = deepClone(pageSchema.value);
+		}
+		const { debug } = useDebug();
+		return {
+			pageSchema,
+			updateSchema,
+			rebuild,
+			registerPage,
+			debug,
+			actions: { ...props.actions },
+			data: props.data
+		};
+	}
+});
+//#endregion
+//#region src/page/XuiPage.vue
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_xui_debugger = resolveComponent("xui-debugger");
+	const _component_XuiSchemaPage = resolveComponent("XuiSchemaPage");
+	return openBlock(), createElementBlock(Fragment, null, [_ctx.debug ? (openBlock(), createBlock(_component_xui_debugger, {
+		key: 0,
+		path: _ctx.path,
+		schema: _ctx.pageSchema,
+		"onUpdate:schema": _ctx.updateSchema,
+		onRebuild: _ctx.rebuild
+	}, null, 8, [
+		"path",
+		"schema",
+		"onUpdate:schema",
+		"onRebuild"
+	])) : createCommentVNode("v-if", true), createVNode(_component_XuiSchemaPage, {
+		schema: _ctx.pageSchema,
+		registerPage: _ctx.registerPage,
+		action: _ctx.actions,
+		data: _ctx.data
+	}, null, 8, [
+		"schema",
+		"registerPage",
+		"action",
+		"data"
+	])], 64);
+}
+var XuiPage_default = /*#__PURE__*/ _plugin_vue_export_helper_default(XuiPage_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+//#region src/toast/AmisToast.vue
+var AmisToast_default = /* @__PURE__ */ defineComponent({
+	__name: "AmisToast",
+	setup(__props) {
+		const domRef = ref();
+		let root;
+		onMounted(() => {
+			root = createRoot(domRef.value);
+			root.render(createElement(Fragment$1, {}, createElement(ToastComponent, { position: "top-right" })));
+		});
+		onBeforeUnmount(() => {
+			if (root) {
+				root.unmount();
+				root = void 0;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "domRef",
+				ref: domRef
+			}, null, 512);
+		};
+	}
+});
+//#endregion
+//#region src/runtime/AmisVueComponent.ts
+var VueControl = class extends React.Component {
+	constructor(props) {
+		super(props);
+		const { resolveVueComponent } = useAdapter();
+		const name = props.vueComponent || props.componentName;
+		const resolved = typeof name === "string" && name ? resolveVueComponent(name) : name;
+		if (!resolved) {
+			this.missingComponentName = String(name || "unknown");
+			this.vueComponent = null;
+			console.error(`[amis-vue] Vue component not registered: ${this.missingComponentName}`);
+			return;
+		}
+		this.vueComponent = applyPureVueInReact(resolved);
+	}
+	doAction(action, _data, _throwErrors) {
+		const { resetValue, onChange } = this.props;
+		const actionType = action?.actionType;
+		if (actionType === "clear") onChange(void 0);
+		else if (actionType === "reset") onChange(resetValue);
+	}
+	async dispatchChangeEvent(eventData = {}) {
+		const { dispatchEvent, data, onChange } = this.props;
+		if ((await dispatchEvent("change", createObject(data, { value: eventData })))?.prevented) return;
+		onChange?.(eventData);
+	}
+	render() {
+		if (!this.vueComponent) return React.createElement("div", {
+			className: "cxd-Form-label",
+			style: {
+				color: "var(--colors-error-5, #ff4d4f)",
+				padding: "4px 0"
+			}
+		}, `Vue 组件未注册: ${this.missingComponentName}`);
+		let { props, value, env, store } = this.props;
+		if (props) {
+			props = { ...props };
+			for (const key of Object.keys(props)) if (typeof props[key] === "string") props[key] = resolveVariableAndFilter(props[key], this.props.data, "| raw");
+		}
+		const mergedProps = {
+			env,
+			store,
+			...props,
+			value,
+			"onUpdate:value": (value) => this.dispatchChangeEvent(value)
+		};
+		return React.createElement(this.vueComponent, mergedProps);
+	}
+};
+var VueRenderer = class extends VueControl {
+	constructor(props) {
+		super(props);
+		const scoped = this.context;
+		if (scoped) scoped.registerComponent(this);
+	}
+	componentWillUnmount() {
+		const scoped = this.context;
+		if (scoped) scoped.unRegisterComponent(this);
+	}
+};
+VueRenderer.contextType = ScopedContext;
+Renderer({
+	type: "vue-renderer",
+	autoVar: false
+})(VueRenderer);
+var VueFormItem = class extends VueControl {};
+FormItem({
+	type: "vue-form-item",
+	autoVar: false
+})(VueFormItem);
+//#endregion
+//#region src/lib.ts
+var lib_exports = /* @__PURE__ */ __exportAll({
+	AmisPageEditor: () => AmisPageEditor_default,
+	AmisSchemaPage: () => AmisSchemaPage_default,
+	AmisToast: () => AmisToast_default,
+	AmisVueComponent: () => VueControl,
+	XuiLoading: () => XuiLoading_default,
+	XuiPage: () => XuiPage_default,
+	XuiPageEditor: () => XuiPageEditor_default,
+	XuiSchemaPage: () => XuiSchemaPage_default,
+	createEnv: () => createEnv,
+	defineReactPageComponent: () => defineReactPageComponent
+});
+import * as import__kdesigner_core from "@kdesigner/core";
+__reExport(lib_exports, import__kdesigner_core);
+import * as import__kdesigner_components from "@kdesigner/components";
+__reExport(lib_exports, import__kdesigner_components);
+import * as import__kdesigner_amis_extensions from "@kdesigner/amis-extensions";
+__reExport(lib_exports, import__kdesigner_amis_extensions);
+__reExport(/* @__PURE__ */ __exportAll({
+	AmisPageEditor: () => AmisPageEditor_default,
+	AmisSchemaPage: () => AmisSchemaPage_default,
+	AmisToast: () => AmisToast_default,
+	AmisVueComponent: () => VueControl,
+	XuiLoading: () => XuiLoading_default,
+	XuiPage: () => XuiPage_default,
+	XuiPageEditor: () => XuiPageEditor_default,
+	XuiSchemaPage: () => XuiSchemaPage_default,
+	createEnv: () => createEnv,
+	defineReactPageComponent: () => defineReactPageComponent
+}), lib_exports);
+lib_exports.registerModule?.("@kdesigner/amis-vue", lib_exports);
+//#endregion
+export { AmisPageEditor_default as AmisPageEditor, AmisSchemaPage_default as AmisSchemaPage, AmisToast_default as AmisToast, VueControl as AmisVueComponent, XuiLoading_default as XuiLoading, XuiPage_default as XuiPage, XuiPageEditor_default as XuiPageEditor, XuiSchemaPage_default as XuiSchemaPage, createEnv, defineReactPageComponent };
+
+//# sourceMappingURL=index.js.map