@weapp-vite/glass-easel-web-adapter 0.1.7 → 0.2.0

package/README.md

@@ -1,10 +1,89 @@
 # @weapp-vite/glass-easel-web-adapter
 
-实验性的 glass-easel Web 组件后端。它复用 glass-easel 官方组件树、模板编译和浏览器 backend，向 weapp-vite Web host 提供受控的组件挂载、数据更新、事件和生命周期桥接。
+实验性的 glass-easel Web 组件后端。它使用官方组件树、模板编译器和浏览器 backend，提供独立的组件注册、挂载、数据更新、事件和生命周期桥接。
 
-该包不会替换 `@weapp-vite/web`，也不实现页面路由、WXSS/rpx、微信 API 或全部原生组件。调用方必须显式创建 adapter；当前默认 Web runtime 不受影响。
+每个 adapter 持有自己的 `ComponentSpace`。`usingComponents` 声明组件依赖，父模板中的默认和命名 slot 由官方组件树处理，投影内容随父级数据更新，并保留其事件处理上下文。注册支持 `data`、`properties`、`methods`、`observers`、`options` 和 `lifetimes`。
 
-`mountComponent` 的第四个参数可传入 `slots`，用于将受控 HTML 投影到模板中的 `<slot />`。这是 PoC 的 DOM 桥接，复杂 slot 关系仍需由后续组件树适配器实现。
+## 组件树示例
+
+在浏览器入口显式创建 adapter：
+
+```ts
+import { createGlassEaselWebAdapter } from '@weapp-vite/glass-easel-web-adapter'
+
+const adapter = createGlassEaselWebAdapter()
+
+adapter.registerComponent({
+  name: 'demo',
+  usingComponents: { counter: '/counter' },
+  data: { title: '计数器', last: 0 },
+  template: `
+    <counter label="{{title}}" bind:change="changed">
+      <b slot="heading">{{title}}</b>
+      <span>已提交 {{last}}</span>
+    </counter>
+  `,
+  methods: {
+    changed(event: { detail: { value: number } }) {
+      this.setData({ last: event.detail.value })
+    },
+  },
+})
+
+adapter.registerComponent({
+  name: 'counter',
+  properties: { label: String },
+  data: { count: 0 },
+  options: { multipleSlots: true },
+  template: `
+    <section>
+      <header><slot name="heading" /></header>
+      <button bind:click="increment">{{label}}：{{count}}</button>
+      <slot />
+    </section>
+  `,
+  methods: {
+    increment() {
+      const value = this.data.count + 1
+      this.setData({ count: value })
+      this.triggerEvent('change', { value })
+    },
+  },
+})
+
+const container = document.createElement('div')
+document.body.append(container)
+const instance = adapter.mountComponent('demo', container)
+
+adapter.updateComponent(instance, { title: '新的标题' })
+console.log(adapter.getSnapshot(instance))
+
+// 宿主页面卸载时调用；重复清理不会重复触发 detached。
+export function cleanup() {
+  adapter.dispose()
+  container.remove()
+}
+```
+
+可以先注册父组件，再注册子组件；挂载前必须完成整棵树的依赖注册。组件名使用项目内的 POSIX 组件路径，例如 `components/counter`；注册与挂载统一规范化前导 `/`、`.` 和路径内的 `..`，拒绝越出组件空间的路径、反斜杠、query、hash 与 URL scheme。`usingComponents` 支持官方的绝对和相对组件引用。方法与生命周期回调中的 `this` 是官方 core 的 `GeneralComponent`，并非完整的小程序 API adapter。
+
+## 实例与资源所有权
+
+- `mountComponent` 返回只读的 `GlassEaselWebInstance` 句柄；更新、触发事件、卸载和读取快照都要求由同一个 adapter 创建的实例，不能用普通对象代替。
+- `updateComponent` 交给官方 `setData`，支持数据路径更新。快照读取实际组件数据，因此能观察到方法内部的更新；容器值使用官方深复制隔离快照，函数值保持可调用。列表重排由官方 keyed 更新保留节点身份。
+- 同一个容器可以挂载多个实例，卸载只移除对应的根节点，保留已有兄弟内容。`virtualHost` 根组件由具有实体根节点的内部父组件承载。
+- `unmountComponent` 递归触发官方组件树的 `detached` 并释放 backend 节点；`dispose` 清理 adapter 的全部挂载实例。二者可以重复调用，已卸载实例仍可读取快照。
+- 官方 DOM backend 的事件委托监听绑定到 `document.body`，其 `destroy()` 没有提供移除这些监听的实现。adapter 按文档共享同一个 backend，避免多个根或 adapter 重复派发同一浏览器事件，只向官方树中仍挂载的节点派发。已卸载节点即使重新插入 DOM 也不再处理事件；文档级监听保留到文档销毁，不属于单个实例的卸载范围。
+
+旧的第四个 `slots` 参数继续接受调用方控制的模板字符串，但现在会编译成真实父组件的 WXML，由官方 slot 机制投影，更新时不会再手工替换 DOM。需要父级作用域和事件处理的动态 slot 时，使用上面的父子组件模板写法。模板字符串应来自可信的应用源码。
+
+## 当前范围
+
+这是独立的组件后端实验，尚未接入 `wv dev -p web` / `wv build -p web` 的默认 runtime，也没有新增 renderer 配置。页面路由、WXSS/rpx、微信 API 和小程序原生组件适配仍由后续 Web host 集成承担。
+
+当前注册阶段仍在浏览器中调用含 WASM 的模板编译器；生产接入前需要拆出构建期编译入口。官方 core 挂载会触发 `created` / `attached`，卸载会触发 `detached`；`ready` 需要宿主在渲染提交后驱动，当前 adapter 不自动补发。本阶段的浏览器验证不代表微信 DevTools、真机或六个平台的行为已达成一致。
+
+所有模式都要求可用的官方 DOM backend；旧 `strict` 选项仅保留调用兼容，已移除字符串渲染降级。
 
 ## 验证
 
@@ -15,3 +94,5 @@ pnpm --filter @weapp-vite/glass-easel-web-adapter test:types
 pnpm --filter @weapp-vite/glass-easel-web-adapter test:browser
 pnpm --filter @weapp-vite/glass-easel-web-adapter build
 ```
+
+包级测试覆盖组件空间隔离、真实 slot、属性与 observer、路径更新、列表节点身份和递归卸载；浏览器测试使用构建后的包，在一个页面中验证多实例、真实点击和组件事件，并在结束时关闭测试浏览器与服务。

package/dist/index.d.mts

@@ -1,53 +1,60 @@
-//#region src/index.d.ts
-export interface GlassEaselWebHost {
+import * as glassEasel from "glass-easel";
+type ComponentParams = glassEasel.typeUtils.ComponentParams<glassEasel.typeUtils.DataList, glassEasel.typeUtils.PropertyList, glassEasel.typeUtils.MethodList>;
+interface GlassEaselWebHost {
   createElement?: (tagName: string) => HTMLElement;
   dispatchEvent?: (event: Event, context: unknown) => void;
   warn?: (message: string) => void;
 }
-export interface GlassEaselComponentDefinition {
+interface GlassEaselComponentDefinition {
   name: string;
   template: string;
-  properties?: Record<string, unknown>;
-  methods?: Record<string, (...args: unknown[]) => unknown>;
-  lifetimes?: Record<string, (...args: unknown[]) => void>;
+  data?: ComponentParams['data'];
+  properties?: ComponentParams['properties'];
+  methods?: ComponentParams['methods'] & ThisType<glassEasel.GeneralComponent>;
+  lifetimes?: ComponentParams['lifetimes'] & ThisType<glassEasel.GeneralComponent>;
+  observers?: ComponentParams['observers'] & ThisType<glassEasel.GeneralComponent>;
+  usingComponents?: Record<string, string>;
+  options?: glassEasel.ComponentOptions;
 }
-export interface GlassEaselWebAdapterOptions {
+interface GlassEaselWebAdapterOptions {
   host?: GlassEaselWebHost;
+  /** 保留旧调用兼容；所有模式都要求官方 DOM backend，不再使用字符串降级渲染。 */
   strict?: boolean;
 }
-export interface GlassEaselWebSnapshot {
+interface GlassEaselWebSnapshot {
   name: string;
   props: Record<string, unknown>;
   html: string;
   lifecycle: string[];
   disposed: boolean;
 }
-export interface GlassEaselWebAdapter {
+declare const instanceBrand: unique symbol;
+interface GlassEaselWebInstance {
+  readonly [instanceBrand]: true;
+  readonly root: HTMLElement;
+  readonly definition: GlassEaselComponentDefinition;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly disposed: boolean;
+  readonly native: glassEasel.GeneralComponent;
+}
+interface GlassEaselWebAdapter {
   registerComponent: (definition: GlassEaselComponentDefinition) => void;
   mountComponent: (name: string, container: Element, props?: Record<string, unknown>, slots?: Record<string, string>) => GlassEaselWebInstance;
-  updateComponent: (instance: unknown, props: Record<string, unknown>) => void;
-  triggerEvent: (instance: unknown, name: string, detail?: unknown) => void;
-  unmountComponent: (instance: unknown) => void;
-  getSnapshot: (instance: unknown) => GlassEaselWebSnapshot;
+  updateComponent: (instance: GlassEaselWebInstance, props: Record<string, unknown>) => void;
+  triggerEvent: (instance: GlassEaselWebInstance, name: string, detail?: unknown) => void;
+  unmountComponent: (instance: GlassEaselWebInstance) => void;
+  getSnapshot: (instance: GlassEaselWebInstance) => GlassEaselWebSnapshot;
   dispose: () => void;
 }
-/** 使用官方 ComponentSpace API 创建可复用的 glass-easel 组件定义。 */
-export declare function createGlassEaselComponentDefinition(definition: GlassEaselComponentDefinition): unknown;
-export interface GlassEaselWebInstance {
-  root: HTMLElement;
-  definition: GlassEaselComponentDefinition;
-  props: Record<string, unknown>;
-  disposed: boolean;
-  native?: any;
-  backendContext?: any;
-  lifecycle: string[];
-}
-export declare function createGlassEaselWebAdapter(options?: GlassEaselWebAdapterOptions): GlassEaselWebAdapter;
-export interface GlassEaselRuntimeInfo {
+interface GlassEaselRuntimeInfo {
   version: string;
   hasDomBackend: boolean;
   hasTemplateCompiler: boolean;
 }
-/** 返回当前安装的 glass-easel 能力探针，供宿主决定是否启用实验后端。 */
+/** 独立定义不进入其他 adapter 的组件空间。 */
+export declare function createGlassEaselComponentDefinition(definition: GlassEaselComponentDefinition): glassEasel.GeneralComponentDefinition;
+/** 使用官方组件树承接模板、slot、数据更新和组件生命周期。 */
+export declare function createGlassEaselWebAdapter(options?: GlassEaselWebAdapterOptions): GlassEaselWebAdapter;
+/** 返回构建所使用的官方依赖版本和当前环境能力。 */
 export declare function getGlassEaselRuntimeInfo(): GlassEaselRuntimeInfo;
-//#endregion
+export type { GlassEaselComponentDefinition, GlassEaselRuntimeInfo, GlassEaselWebAdapter, GlassEaselWebAdapterOptions, GlassEaselWebHost, GlassEaselWebInstance, GlassEaselWebSnapshot };

package/dist/index.mjs

@@ -1,135 +1,246 @@
 import * as glassEasel from "glass-easel";
 import { wxml } from "glass-easel-template-compiler";
-//#region src/index.ts
-/** 使用官方 ComponentSpace API 创建可复用的 glass-easel 组件定义。 */
+import glassEaselPackage from "glass-easel/package.json" with { type: "json" };
+// src/backend.ts
+const documentBackends = /* @__PURE__ */ new WeakMap();
+function getDocumentBackend() {
+	if (typeof document === "undefined" || typeof glassEasel.CurrentWindowBackendContext !== "function") throw new Error("glass-easel Web backend is unavailable in this environment");
+	let backend = documentBackends.get(document);
+	if (!backend) {
+		backend = new glassEasel.CurrentWindowBackendContext();
+		backend.onEvent((element, ...args) => {
+			if (glassEasel.Element.isAttached(element)) return glassEasel.Event.triggerBackendEvent(element, ...args);
+		});
+		documentBackends.set(document, backend);
+	}
+	return backend;
+}
+// src/definition.ts
+function normalizeComponentName(name) {
+	if (!name || /[\\?#:]/.test(name)) throw new TypeError("glass-easel component name must be a root-relative POSIX path");
+	const segments = [];
+	for (const segment of name.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (!segments.length) throw new TypeError("glass-easel component name cannot escape its component space");
+			segments.pop();
+		} else segments.push(segment);
+	}
+	if (!segments.length) throw new TypeError("glass-easel component name must not be empty");
+	return segments.join("/");
+}
+function registerDefinition(space, definition, records) {
+	const lifetimes = { ...definition.lifetimes };
+	for (const name of [
+		"created",
+		"attached",
+		"ready",
+		"detached"
+	]) {
+		const callback = lifetimes[name];
+		lifetimes[name] = function(...args) {
+			let lifecycle = records.get(this);
+			if (!lifecycle) {
+				lifecycle = [];
+				records.set(this, lifecycle);
+			}
+			lifecycle.push(name);
+			return callback?.apply(this, args);
+		};
+	}
+	return space.define(definition.name).usingComponents(definition.usingComponents ?? {}).definition({
+		template: wxml(definition.template),
+		data: definition.data,
+		properties: definition.properties,
+		methods: definition.methods,
+		observers: definition.observers,
+		options: definition.options,
+		lifetimes
+	}).registerComponent().general();
+}
+/** 独立定义不进入其他 adapter 的组件空间。 */
 function createGlassEaselComponentDefinition(definition) {
-	const space = glassEasel.getDefaultComponentSpace();
-	const params = { template: wxml(definition.template) };
-	if (definition.properties) params.properties = definition.properties;
-	if (definition.methods) params.methods = definition.methods;
-	if (definition.lifetimes) params.lifetimes = definition.lifetimes;
-	return space.define().definition(params).registerComponent();
+	return registerDefinition(new glassEasel.ComponentSpace(), {
+		...definition,
+		name: normalizeComponentName(definition.name)
+	}, /* @__PURE__ */ new WeakMap());
 }
-function render(template, props, host) {
-	const root = host.createElement?.("div") ?? document.createElement("div");
-	root.innerHTML = template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_, key) => String(key.split(".").reduce((value, part) => value?.[part], props) ?? ""));
-	return root;
+/** 旧 slots 参数通过真实父组件投影，字符串仅作为调用方控制的 WXML 输入。 */
+function createSlotParent(space, definition, slots) {
+	const content = Object.entries(slots).map(([name, source]) => {
+		return `<block${name === "default" ? "" : ` slot="${name.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;")}"`}>${source}</block>`;
+	}).join("");
+	return space.define().usingComponents({ "adapter-content": definition }).definition({ template: wxml(`<adapter-content>${content}</adapter-content>`) }).registerComponent().general();
 }
+// src/index.ts
+/** 使用官方组件树承接模板、slot、数据更新和组件生命周期。 */
 function createGlassEaselWebAdapter(options = {}) {
+	let space = new glassEasel.ComponentSpace();
+	space.updateComponentOptions({ writeIdToDOM: true });
 	const definitions = /* @__PURE__ */ new Map();
-	const instances = /* @__PURE__ */ new Set();
-	if (options.strict && !getGlassEaselRuntimeInfo().hasDomBackend) throw new Error("glass-easel Web backend is unavailable in this environment");
+	const inputs = /* @__PURE__ */ new Map();
+	const registeredInputs = /* @__PURE__ */ new WeakMap();
+	const lifecycle = /* @__PURE__ */ new WeakMap();
+	const ownership = /* @__PURE__ */ new WeakMap();
+	const mounted = /* @__PURE__ */ new Set();
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new Error("cannot use a disposed glass-easel adapter");
+	};
+	const getOwned = (instance) => {
+		const record = ownership.get(instance);
+		if (!record) throw new Error("glass-easel component is not owned by this adapter");
+		return record;
+	};
+	const getLive = (instance) => {
+		const record = getOwned(instance);
+		assertActive();
+		if (record.disposed || record.releasing) throw new Error("cannot use a disposed glass-easel component");
+		return record;
+	};
+	const release = (record) => {
+		if (record.disposed || record.releasing) return;
+		record.releasing = true;
+		try {
+			glassEasel.Element.pretendDetached(record.tree);
+			record.tree.destroyBackendElementOnSubtree();
+			record.instance.root.remove();
+			record.disposed = true;
+			mounted.delete(record);
+		} finally {
+			record.releasing = false;
+		}
+	};
+	const assertDependencies = (currentSpace, root) => {
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (definition) => {
+			if (visited.has(definition)) return;
+			visited.add(definition);
+			for (const [alias, url] of Object.entries(registeredInputs.get(definition)?.usingComponents ?? {})) {
+				const dependency = currentSpace.getComponentByUrlWithoutDefault(url, definition.is);
+				if (!dependency || !registeredInputs.has(dependency)) throw new Error(`component dependency is not registered: ${definition.is} -> ${alias} (${url})`);
+				visit(dependency);
+			}
+		};
+		visit(root);
+	};
 	return {
 		registerComponent(definition) {
+			assertActive();
 			if (!definition.name || !definition.template) throw new TypeError("glass-easel component requires name and template");
-			if (definitions.has(definition.name)) throw new Error(`component already registered: ${definition.name}`);
-			definitions.set(definition.name, {
+			definition = Object.freeze({
 				...definition,
-				native: createGlassEaselComponentDefinition(definition)
+				name: normalizeComponentName(definition.name),
+				usingComponents: Object.freeze({ ...definition.usingComponents })
 			});
+			if (definitions.has(definition.name)) throw new Error(`component already registered: ${definition.name}`);
+			const registered = registerDefinition(space, definition, lifecycle);
+			definitions.set(definition.name, registered);
+			inputs.set(definition.name, definition);
+			registeredInputs.set(registered, definition);
 		},
 		mountComponent(name, container, props = {}, slots = {}) {
+			assertActive();
+			name = normalizeComponentName(name);
 			const definition = definitions.get(name);
 			if (!definition) throw new Error(`component is not registered: ${name}`);
-			let root;
-			let native;
-			let backendContext;
-			if (definition.native && getGlassEaselRuntimeInfo().hasDomBackend) {
-				const placeholder = document.createElement("glass-easel-placeholder");
-				container.append(placeholder);
-				backendContext = new glassEasel.CurrentWindowBackendContext();
-				backendContext.onEvent(glassEasel.Event.triggerBackendEvent);
-				native = glassEasel.Component.createWithContext(name, definition.native, backendContext, (component) => {
-					component.setData(props);
-				});
-				glassEasel.Element.replaceDocumentElement(native, placeholder.parentNode, placeholder);
-				root = container.firstElementChild;
-				projectSlots(root, slots);
-			} else {
-				root = render(definition.template, props, options.host ?? {});
-				container.append(root);
+			assertDependencies(space, definition);
+			const backend = getDocumentBackend();
+			if (container.ownerDocument !== document) throw new Error("glass-easel components must mount in the current document");
+			const hasParent = Object.keys(slots).length > 0 || definition.getComponentOptions().virtualHost;
+			const rootDefinition = hasParent ? createSlotParent(space, definition, slots) : definition;
+			const tree = glassEasel.Component.createWithContext("glass-easel-root", rootDefinition, backend, (component) => {
+				component.setData(props);
+			});
+			const native = hasParent ? tree.getShadowRoot()?.childNodes[0]?.asGeneralComponent() : tree;
+			if (!native) {
+				tree.destroyBackendElementOnSubtree();
+				throw new Error("glass-easel slot parent did not create its content component");
 			}
+			if (hasParent) native.setData(props);
+			const root = tree.getBackendElement();
+			let record;
 			const instance = {
 				root,
-				definition,
-				props: { ...props },
-				disposed: false,
 				native,
-				backendContext,
-				lifecycle: []
+				definition: inputs.get(name),
+				get props() {
+					return glassEasel.dataUtils.deepCopy(native.data, true);
+				},
+				get disposed() {
+					return record.disposed;
+				}
 			};
-			for (const name of [
-				"created",
-				"attached",
-				"ready",
-				"detached"
-			]) instance.native?.addLifetimeListener?.(name, () => instance.lifecycle.push(name));
-			instances.add(instance);
-			return instance;
-		},
-		updateComponent(value, props) {
-			const instance = value;
-			if (instance.disposed) throw new Error("cannot update a disposed glass-easel component");
-			instance.props = {
-				...instance.props,
-				...props
+			record = {
+				tree,
+				instance,
+				disposed: false,
+				releasing: false
 			};
-			if (instance.native) instance.native.setData(props);
-			else {
-				const replacement = render(instance.definition.template, instance.props, options.host ?? {});
-				instance.root.replaceWith(replacement);
-				instance.root = replacement;
+			ownership.set(instance, record);
+			let placeholder;
+			let insertedPlaceholder = false;
+			try {
+				assertActive();
+				placeholder = options.host?.createElement?.("glass-easel-placeholder") ?? document.createElement("glass-easel-placeholder");
+				if (placeholder.parentNode || placeholder.ownerDocument !== document) throw new Error("glass-easel placeholder must be a new element in the current document");
+				assertActive();
+				container.append(placeholder);
+				insertedPlaceholder = true;
+				glassEasel.Element.replaceDocumentElement(tree, container, placeholder);
+				assertActive();
+				mounted.add(record);
+				return instance;
+			} catch (cause) {
+				if (insertedPlaceholder) placeholder?.remove();
+				release(record);
+				throw cause;
 			}
 		},
-		triggerEvent(value, name, detail) {
-			const instance = value;
-			if (instance.disposed) throw new Error("cannot trigger an event on a disposed glass-easel component");
-			if (instance.native) instance.native.triggerEvent(name, detail);
+		updateComponent(instance, props) {
+			const record = getLive(instance);
+			if (record.tree !== instance.native) record.tree.setData(props);
+			instance.native.setData(props);
+		},
+		triggerEvent(instance, name, detail) {
+			getLive(instance);
+			instance.native.triggerEvent(name, detail);
 			options.host?.dispatchEvent?.(new CustomEvent(name, { detail }), instance);
 		},
-		unmountComponent(value) {
-			const instance = value;
-			if (!instances.delete(instance) || instance.disposed) return;
-			instance.native?.triggerLifetime?.("detached");
-			if (!instance.native) instance.lifecycle.push("detached");
-			instance.root?.remove();
-			instance.disposed = true;
+		unmountComponent(instance) {
+			release(getOwned(instance));
 		},
-		getSnapshot(value) {
-			const instance = value;
+		getSnapshot(instance) {
+			const record = getOwned(instance);
 			return {
 				name: instance.definition.name,
-				props: { ...instance.props },
+				props: glassEasel.dataUtils.deepCopy(instance.native.data, true),
 				html: instance.root.innerHTML,
-				lifecycle: [...instance.lifecycle],
-				disposed: instance.disposed
+				lifecycle: [...lifecycle.get(instance.native) ?? []],
+				disposed: record.disposed
 			};
 		},
 		dispose() {
-			for (const instance of [...instances]) this.unmountComponent(instance);
+			disposed = true;
+			const errors = [];
+			for (const record of mounted) try {
+				release(record);
+			} catch (cause) {
+				errors.push(cause);
+			}
 			definitions.clear();
+			inputs.clear();
+			space = void 0;
+			if (errors.length) throw new AggregateError(errors, "glass-easel adapter cleanup failed");
 		}
 	};
 }
-/** 将受控 PoC slot 内容投影到官方 backend 生成的 DOM。复杂 slot 仍需由宿主组件树实现。 */
-function projectSlots(root, slots) {
-	let projected = false;
-	for (const slot of Array.from(root.querySelectorAll("slot"))) {
-		const content = slots[slot.getAttribute("name") || "default"];
-		if (content === void 0) continue;
-		const fragment = document.createRange().createContextualFragment(content);
-		slot.replaceWith(fragment);
-		projected = true;
-	}
-	if (!projected && slots.default !== void 0) (root.firstElementChild ?? root).insertAdjacentHTML("beforeend", slots.default);
-}
-/** 返回当前安装的 glass-easel 能力探针，供宿主决定是否启用实验后端。 */
+/** 返回构建所使用的官方依赖版本和当前环境能力。 */
 function getGlassEaselRuntimeInfo() {
 	return {
-		version: "1.2.0",
-		hasDomBackend: typeof glassEasel.CurrentWindowBackendContext === "function",
+		version: glassEaselPackage.version,
+		hasDomBackend: typeof document !== "undefined" && typeof glassEasel.CurrentWindowBackendContext === "function",
 		hasTemplateCompiler: typeof wxml === "function"
 	};
 }
-//#endregion
 export { createGlassEaselComponentDefinition, createGlassEaselWebAdapter, getGlassEaselRuntimeInfo };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@weapp-vite/glass-easel-web-adapter",
   "type": "module",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Experimental glass-easel component backend for weapp-vite Web runtime",
   "license": "MIT",
   "homepage": "https://github.com/weapp-vite/weapp-vite#readme",
@@ -43,10 +43,10 @@
   "devDependencies": {
     "playwright": "1.64.1",
     "tsd": "0.33.0",
-    "tsdown": "0.23.1",
+    "tsdown": "0.23.2",
     "tsx": "4.23.15",
     "typescript": "^6.0.3",
-    "vite": "8.3.4",
+    "vite": "8.3.5",
     "vitest": "~5.0.5"
   },
   "publishConfig": {