@zerodep-dev/vue-tsx-pro-tsx 0.0.0-stage → 0.1.0

package/dist/compiler.d.ts

@@ -0,0 +1,104 @@
+import { FileResult, PluginItem, PluginObject, PluginPass, types } from "@babel/core";
+import typescript from "@babel/plugin-transform-typescript";
+import { VueJSXPluginOptions } from "@vue/babel-plugin-jsx";
+//#region src/compiler/detect.d.ts
+/**
+ * 编译之前的快速判断（不依赖 Babel）：Vite 预设的入口只用这些，开发服务器启动时不必载入 Babel 与各插件
+ * （它们在编译线程里、第一次编译时才载入）。
+ */
+/** 文件的语言：.tsx、.jsx 才编译 JSX，.tsx 才在编译时去掉类型（.ts 的类型由打包工具去掉） */
+type Language = 'ts' | 'tsx' | 'js' | 'jsx';
+//#endregion
+//#region src/compiler/errors.d.ts
+/** 符文误用时抛出的错误：带代码帧的说明，以及供编辑器/语言服务定位的起止位置 */
+interface RunesError extends Error {
+  /** 出错代码的起止位置（行从 1、列从 0 开始，同 Babel） */
+  loc?: {
+    start: {
+      line: number;
+      column: number;
+    };
+    end: {
+      line: number;
+      column: number;
+    };
+  };
+}
+/** 编译警告：说明、位置，以及带代码帧的完整文本（给 Vite 输出） */
+interface RunesWarning {
+  /** 说明文字 */
+  message: string;
+  /** 起止位置，同 RunesError.loc */
+  loc?: RunesError['loc'];
+  /** 带代码帧的完整文本 */
+  frame: string;
+}
+//#endregion
+//#region src/compiler/compile.d.ts
+/** 编译结果的 source map（Babel 生成的） */
+type SourceMap = NonNullable<FileResult['map']>;
+/** 去掉类型的插件（@babel/plugin-transform-typescript）的选项 */
+type TypeScriptOptions = Parameters<typeof typescript>[1];
+/** compile 的选项；没开的步骤不做 */
+interface CompileOptions {
+  /** 文件路径（不带查询参数）：报错与 source map 用它 */
+  filename: string;
+  /** 文件的语言，默认按扩展名；Vue 单文件组件里 lang="tsx" 的脚本由调用方传 'tsx' */
+  lang?: Language;
+  /** 编译符文与 _component 的 props，默认 true；依赖包里的文件传 false */
+  runes?: boolean;
+  /** 渲染优化（optimize.ts），默认 true */
+  optimize?: boolean;
+  /** JSX 里的动态样式调用改成响应式绑定（style-bindings.ts） */
+  styleBindings?: boolean;
+  /** 开发服务器：样式热更新原地生效，值是模块 id（相对项目根目录，style-hot.ts） */
+  styleHot?: string;
+  /** Vue JSX 插件的选项 */
+  jsx?: VueJSXPluginOptions;
+  /** 去掉 TS 类型的插件的选项 */
+  typescript?: TypeScriptOptions;
+  /** 追加在最后一遍末尾的插件（只在文件需要编译时运行） */
+  plugins?: PluginItem[];
+  /** 生成 source map，默认 true */
+  sourceMaps?: boolean;
+}
+/** compile 的结果 */
+interface CompileResult {
+  /** 编译后的代码 */
+  code: string;
+  /** 对应原始代码的 source map；关掉 sourceMaps 时为 null */
+  map: SourceMap | null;
+  /** 编译后的 AST：热更新据此找出文件里声明的组件 */
+  ast: types.File;
+  /** 不影响正确性、但多半不是作者本意的写法（符文） */
+  warnings: RunesWarning[];
+  /** 开了 styleHot 且文件里有顶层样式时：去掉样式参数后的源码哈希（style-hot.ts） */
+  styleSkeleton?: string;
+}
+/**
+ * 编译一个文件；什么都不用做（没有符文、样式绑定与热更新，也不是 JSX 文件）时返回 null。
+ * 写法错误时抛出带代码帧的错误。
+ */
+export declare function compile(code: string, options: CompileOptions): Promise<CompileResult | null>;
+//#endregion
+//#region src/compiler/transform.d.ts
+/** 符文编译的选项 */
+interface RunesOptions {
+  /** 渲染优化（稳定插槽、缓存属性里的函数与常量，见 optimize.ts），默认 true */
+  optimize?: boolean;
+}
+/** 符文编译的 Babel 插件：误用直接抛出 RunesError，警告放在文件的 metadata.runesWarnings */
+export declare function runesBabelPlugin(): PluginObject<PluginPass<RunesOptions>>;
+//#endregion
+//#region src/compiler/index.d.ts
+/**
+ * 只编译一个文件里的符文与 _component 参数解构；不需要编译时返回 null。
+ * 结果带 source map 与警告（只拿到初始值的读取等），误用直接抛出 RunesError。
+ */
+export declare function compileRunes(code: string, filename?: string, options?: RunesOptions): Promise<{
+  code: string;
+  map: SourceMap | null;
+  warnings: RunesWarning[];
+} | null>;
+//#endregion
+export type { CompileOptions, CompileResult, RunesError, RunesOptions, RunesWarning, SourceMap };

package/dist/compiler.js

@@ -0,0 +1 @@
+export { n as compile, t as compileRunes, r as runesBabelPlugin } from "./compiler-BDi92tYb.js";

package/dist/detect-s3UM7xuN.js

@@ -0,0 +1,17 @@
+//#region src/compiler/detect.ts
+/** 样式入口（src/styles）：编译器按从它导入的 create 找样式 */
+const STYLE_SOURCE = "@zerodep-dev/vue-tsx-pro-tsx/styles";
+/**
+* 模块的语言：Vue 单文件组件里的脚本（X.vue?vue&type=script&lang.tsx）看查询参数，其他看扩展名；
+* 不是脚本时返回 undefined
+*/
+function languageOf(id) {
+	const [file = "", query = ""] = id.split("?");
+	return (/(?:^|&)lang\.([jt]sx?)(?:&|$)/.exec(query) ?? /\.[cm]?([jt]sx?)$/.exec(file))?.[1];
+}
+/** Babel 解析插件：.ts 不能开 JSX，否则 <T>value 类型断言、<T>(x) => x 泛型箭头函数会被当作 JSX 解析 */
+function parserPlugins(lang) {
+	return lang === "ts" ? ["typescript"] : ["jsx", "typescript"];
+}
+//#endregion
+export { languageOf as n, parserPlugins as r, STYLE_SOURCE as t };

package/dist/index.d.ts

@@ -0,0 +1,140 @@
+import { InjectionKey, Ref, SetupContext, VNode, VNodeChild } from "vue";
+//#region src/runtime/component.d.ts
+/** setup 返回渲染函数；setup 本身只执行一次 */
+type Render = () => VNodeChild;
+/**
+ * 组件在类型上是“接收 props 的函数”，返回值带 '~tsx' 标记：JSX 类型（types/jsx-runtime.d.ts）
+ * 据此把它和 Vue 的其他函数式组件区分开，只有它的子节点按 children prop 检查。
+ * 标记放在返回值上而不是函数上，泛型组件的类型参数推导才不受影响。
+ */
+interface TsxNode extends VNode {
+  /** 只存在于类型上的标记，运行时没有这个属性 */
+  readonly '~tsx': true;
+}
+/** _component 的结果在类型上的样子：JSX 按参数 P 检查属性与 children */
+type TsxComponent<P> = (props: P) => TsxNode;
+/** _component 的第二个参数；一般不用写，编译器会补上 */
+interface ComponentOptions {
+  /** 组件名，DevTools 与警告信息里显示；编译器从 const X = _component(...) 自动补上 */
+  name?: string;
+  /** Vue 的 props 声明（名字列表）；编译器从参数解构自动生成 */
+  props?: string[];
+}
+/**
+ * 类型上把组件描述为“接收 props 的函数”：JSX 直接按参数类型检查属性，
+ * 泛型组件 _component(<T,>(props: { items: T[] }) => …) 的类型参数也能保留下来。
+ */
+export declare function _component<P extends object = {}>(setup: (props: P) => Render, options?: ComponentOptions): TsxComponent<P>;
+/**
+ * 参数解构里的 ...rest（编译器生成）：没有声明为 prop 的属性（Vue 的 attrs），再加上 children。
+ * TypeScript 推出的 rest 类型含 children，运行时也要有：`<Collapse {...rest} />` 才能把内容转交下去。
+ * children 读取时才执行插槽；没有内容时不出现在键里。展开到原生元素前由 ui 的 elementProps 去掉。
+ * 已经单独解构出 children 时（withChildren = false）rest 里没有它，上层转交下来的 children 属性也去掉。
+ */
+export declare function restProps(props: {
+  children?: unknown;
+}, ctx: SetupContext, withChildren?: boolean): object;
+/** 交给子组件的插槽对象；$stable 告诉 Vue 父组件重新渲染时不必为了插槽更新子组件 */
+type ForwardedSlots = {
+  default: unknown;
+  $stable: boolean;
+};
+/**
+ * 本组件收到的内容是否稳定（编译器生成的调用）：没有内容，或上层的插槽标了 $stable。
+ * 内容经 children 属性传来时不算（attrs 不是响应式的）
+ */
+export declare function childrenStable(): boolean;
+/**
+ * 原样转交内容 <X>{children}</X>（编译器生成的调用）：稳不稳定跟着本组件收到的，
+ * 上层的内容每次都变，交出去的也每次都变；带参数的渲染函数原样交出，由 X 调用。
+ */
+export declare function forwardChildren(props: {
+  children?: unknown;
+}): ForwardedSlots;
+//#endregion
+//#region src/runtime/context.d.ts
+/** createContext 的结果：同一个键的提供与读取 */
+interface Context<T> {
+  /** Vue 的注入键：应用级提供时 `app.provide(Context.key, value)` */
+  readonly key: InjectionKey<T>;
+  /** 在组件 setup 里向子树提供值 */
+  provide(value: T): void;
+  /** 读取最近的祖先提供的值；没有时报错，说明要放在哪个组件之内 */
+  inject(): T;
+  /** 读取最近的祖先提供的值；没有时（包括在 setup 之外调用）返回 fallback */
+  inject<F>(fallback: F): T | F;
+}
+/** 声明一个带类型的上下文；name 用于报错信息（“需要放在 <name> 之内”）与调试 */
+export declare function createContext<T>(name: string): Context<T>;
+//#endregion
+//#region src/runtime/props.d.ts
+type Props = Record<string, unknown>;
+type Emit = (event: string, ...args: unknown[]) => void;
+/** 编译器原样传入的字面量默认值 */
+type Literal = string | number | boolean | bigint | null;
+/**
+ * 普通 prop：父级传了值就用父级的，否则用默认值；组件内可以临时覆盖（见 overridable），
+ * 父级传入新值时以父级为准。
+ *
+ * 默认值第一次用到时才求值，并用 computed 缓存：
+ *   - [] / {} / 函数调用每个实例各自一份，读多少次都是同一个值
+ *   - 引用了其他 prop 的默认值（icon = pick(size)）会随那个 prop 更新
+ */
+export declare function prop<T>(props: Props, key: string, fallback?: () => T): Ref<T>;
+/**
+ * 组件里从没写入过的普通 prop（编译器确定时生成，大多数 prop 是这样）：只读的 getter ref，
+ * 不像 prop 那样每个实例再建 computed、customRef 与同步 watch，创建快十倍。
+ * 默认值的处理与 prop 相同；有默认值时在 setup 里先读一次（prop 的 watch 也是这时求值），
+ * 默认值里调用的组合式函数（useId() 等）才拿得到组件实例
+ */
+export declare function readonlyProp<T>(props: Props, key: string, fallback?: (() => T) | Literal): Ref<T>;
+/**
+ * 解构出的 children：每次读取都重新执行插槽，不缓存（普通 prop 用 computed 缓存）。
+ * 父级重新渲染时传来新的插槽，里面可能只有父级渲染时算好的值、没有响应式读取：
+ * 缓存不会失效，子组件就一直显示旧内容。子组件因父级更新而重新渲染时读到的总是新插槽。
+ */
+export declare function childrenProp<T>(props: Props, fallback?: () => T): Ref<T>;
+/**
+ * 双向 prop，走标准 v-model 协议（父级 _属性={可写的值} 编译为 key + onUpdate:key）。
+ * 与 Vue 的 useModel 一样，父级同时传了值和 onUpdate:key 才算受控：
+ *
+ *   - 受控：值以父级为准。写入后同步读取先拿到新值，本轮更新结束时回到父级的值，
+ *     所以父级拒绝或修正（例如限制最大值）时组件会跟着回去
+ *   - 只传了值：作为初始值，组件可以在本地修改，父级传入新值时以父级为准
+ *   - 都没传：就是组件自己的状态
+ *
+ * 父级传 undefined 等同没传，使用默认值（与普通 prop 一致）；写入总会发出 update:key。
+ */
+export declare function bindable<T>(props: Props, key: string, fallback: (() => T) | undefined, emit: Emit): Ref<T>;
+//#endregion
+//#region src/runtime/state.d.ts
+/**
+ * 跟随来源、可以临时覆盖的值（同 Svelte 5.25 的可覆盖派生）：
+ * 读取时是 getter 的结果；写入后读到写入的值，直到 getter 的结果变化，再回到跟随来源。
+ *
+ *   let likes = _derived(post.likes)   乐观更新：likes += 1，post.likes 一变就以它为准
+ *   ({ value }) => … value = x          普通 prop：只改组件本地，父级传入新值时以父级为准
+ */
+export declare function overridable<T>(getter: () => T): Ref<T>;
+/**
+ * 读取但不追踪（同 Svelte 的 untrack）：在共用的读取 effect 里执行，读到的响应式值记在它身上、
+ * 变化时什么也不做，外层的 _effect、_derived、渲染函数不会因此依赖它们。用 Vue 公开的 ReactiveEffect，不碰内部 API。
+ * 渲染里会频繁调用（样式的响应式绑定每次渲染取一次值），所以复用同一个 effect，不每次新建作用域与 effect
+ */
+export declare function untrack<T>(read: () => T): T;
+/**
+ * 去掉响应式代理的静态深拷贝（同 Svelte 的 $state.snapshot），交给 structuredClone、第三方库或日志。
+ * 普通对象、数组、Map、Set 逐层拷贝，Date、类型化数组、ArrayBuffer 复制一份，有 toJSON 的取它的结果，
+ * 其他值（类实例、函数等）原样保留。
+ */
+export declare function snapshot<T>(value: T): T;
+//#endregion
+//#region src/runtime/effect.d.ts
+/** 副作用函数可以返回清理函数：下次执行前、以及销毁时调用 */
+type EffectFn = () => void | (() => void);
+/** _effect / _effect.pre 编译后的调用：在当前作用域里创建，随组件销毁 */
+export declare function effect(fn: EffectFn, flush?: 'pre' | 'post'): void;
+/** _effect.root 编译后的调用：独立的作用域，返回手动清理函数 */
+export declare function effectRoot(fn: EffectFn): () => void;
+//#endregion
+export type { ComponentOptions, Context, TsxComponent, TsxNode };

package/dist/index.js

@@ -0,0 +1,283 @@
+import { n as snapshot, r as untrack, t as overridable } from "./state-YxL7IqUO.js";
+import { computed, customRef, effectScope, getCurrentInstance, getCurrentScope, hasInjectionContext, inject, nextTick, provide, toRef, watch, watchEffect } from "vue";
+//#region src/runtime/component.ts
+/**
+* _component()：唯一的组件边界。
+*
+* 一切基于 props：作者只写参数解构与默认值，编译器（compiler/props.ts）把它们换成
+* prop 访问器，并补上组件名与 props 声明作为第二个参数。运行时这里只做两件事：
+*
+*   1. 返回一个普通的 Vue 组件对象（Vue 组件本来就是对象，不需要 defineComponent）
+*   2. 把默认插槽映射成 props.children，内容也是 prop
+*/
+function _component(setup, options = {}) {
+	return {
+		inheritAttrs: false,
+		...options,
+		setup: (props, ctx) => setup(withChildren(props, ctx, getCurrentInstance()), ctx)
+	};
+}
+/** withChildren 包着的 Vue props 本身 */
+const VUE_PROPS = Symbol("vueProps");
+/** 只拦截 children，其余属性原样交给 Vue 的 props（保持依赖收集） */
+function withChildren(props, ctx, instance) {
+	return new Proxy(props, { get(target, key, receiver) {
+		if (key === "children") return readChildren(ctx, instance);
+		return key === VUE_PROPS ? target : Reflect.get(target, key, receiver);
+	} });
+}
+/**
+* 编译器传给 prop 访问器的 props 背后的 Vue props：访问器只读声明过的 prop，直接读它（同样是响应式的），
+* 不必每次再穿过 withChildren 这层 Proxy（渲染时读 prop 是最频繁的操作之一）
+*/
+function vueProps(props) {
+	return props[VUE_PROPS] ?? props;
+}
+/**
+* 参数解构里的 ...rest（编译器生成）：没有声明为 prop 的属性（Vue 的 attrs），再加上 children。
+* TypeScript 推出的 rest 类型含 children，运行时也要有：`<Collapse {...rest} />` 才能把内容转交下去。
+* children 读取时才执行插槽；没有内容时不出现在键里。展开到原生元素前由 ui 的 elementProps 去掉。
+* 已经单独解构出 children 时（withChildren = false）rest 里没有它，上层转交下来的 children 属性也去掉。
+*/
+function restProps(props, ctx, withChildren = true) {
+	const hasChildren = () => withChildren && (ctx.slots.default != null || "children" in ctx.attrs);
+	return new Proxy(ctx.attrs, {
+		get: (target, key, receiver) => {
+			if (key !== "children") return Reflect.get(target, key, receiver);
+			return withChildren ? props.children : void 0;
+		},
+		has: (target, key) => key === "children" ? hasChildren() : Reflect.has(target, key),
+		ownKeys: (target) => {
+			const keys = Reflect.ownKeys(target);
+			const index = keys.indexOf("children");
+			if (index >= 0) keys.splice(index, 1);
+			if (hasChildren()) keys.push("children");
+			return keys;
+		},
+		getOwnPropertyDescriptor: (target, key) => {
+			if (key !== "children") return Reflect.getOwnPropertyDescriptor(target, key);
+			return hasChildren() ? {
+				value: props.children,
+				enumerable: true,
+				configurable: true,
+				writable: false
+			} : void 0;
+		}
+	});
+}
+/**
+* JSX 子节点被编译成默认插槽，这里还原成 children prop：
+*   - 带参数的函数子节点（<List>{(item) => …}</List>）是渲染函数，原样交给组件按需调用
+*   - 其余内容在读取时才执行插槽：读取发生在子组件的渲染函数里，内容是惰性的，依赖也归属子组件
+*
+* Vue 会把插槽统一包一层 (...args) => …，参数个数只能从 vnode 上的原始插槽判断。
+*/
+function readChildren(ctx, instance) {
+	const raw = instance.vnode.children?.default;
+	if (typeof raw === "function" && raw.length > 0) return raw;
+	return ctx.slots.default?.() ?? ctx.attrs.children;
+}
+/**
+* 本组件收到的内容是否稳定（编译器生成的调用）：没有内容，或上层的插槽标了 $stable。
+* 内容经 children 属性传来时不算（attrs 不是响应式的）
+*/
+function childrenStable() {
+	const instance = getCurrentInstance();
+	if (!instance || "children" in instance.attrs) return false;
+	const received = instance.vnode.children;
+	return received == null || received.$stable === true;
+}
+/**
+* 原样转交内容 <X>{children}</X>（编译器生成的调用）：稳不稳定跟着本组件收到的，
+* 上层的内容每次都变，交出去的也每次都变；带参数的渲染函数原样交出，由 X 调用。
+*/
+function forwardChildren(props) {
+	const raw = getCurrentInstance().vnode.children?.default;
+	const $stable = childrenStable();
+	if (typeof raw === "function" && raw.length > 0) return {
+		default: raw,
+		$stable
+	};
+	return {
+		default: () => [props.children],
+		$stable
+	};
+}
+//#endregion
+//#region src/runtime/context.ts
+/**
+* 复合组件（Tabs、Select、Form 等）之间共享状态：声明一次，提供与读取都带类型。
+*
+*   const TabsContext = createContext<TabsState>('Tabs');
+*   TabsContext.provide(state);            // 父组件 setup 里
+*   const tabs = TabsContext.inject();     // 子组件 setup 里；不在父组件内时报错说明
+*   const form = FormContext.inject(null); // 可选：不在父组件内时返回给定的值
+*   app.provide(TabsContext.key, state);   // 应用级提供（Vue 插件里）
+*/
+const MISSING = Symbol("missing");
+/** 声明一个带类型的上下文；name 用于报错信息（“需要放在 <name> 之内”）与调试 */
+function createContext(name) {
+	const key = Symbol(name);
+	return {
+		key,
+		provide: (value) => provide(key, value),
+		inject(...fallback) {
+			if (!hasInjectionContext()) {
+				if (fallback.length) return fallback[0];
+				throw new Error(`${name} 的上下文只能在组件的 setup 里读取`);
+			}
+			const value = inject(key, MISSING);
+			if (value !== MISSING) return value;
+			if (fallback.length) return fallback[0];
+			throw new Error(`${name} 的子组件需要放在 <${name}> 之内使用`);
+		}
+	};
+}
+//#endregion
+//#region src/runtime/props.ts
+/**
+* prop 访问器：编译器把 _component 的参数解构换成对这几个函数的调用。
+* 作者不直接使用它们；思路来自 Svelte 5 的 $.prop。
+*
+* 返回的都是真正的 Vue Ref（读写改写为 .value），因此 _toRef(size) 可以交给 watch 等 Vue API。
+*/
+/**
+* 普通 prop：父级传了值就用父级的，否则用默认值；组件内可以临时覆盖（见 overridable），
+* 父级传入新值时以父级为准。
+*
+* 默认值第一次用到时才求值，并用 computed 缓存：
+*   - [] / {} / 函数调用每个实例各自一份，读多少次都是同一个值
+*   - 引用了其他 prop 的默认值（icon = pick(size)）会随那个 prop 更新
+*/
+function prop(props, key, fallback) {
+	return overridable(propReader(props, key, fallback));
+}
+/**
+* 组件里从没写入过的普通 prop（编译器确定时生成，大多数 prop 是这样）：只读的 getter ref，
+* 不像 prop 那样每个实例再建 computed、customRef 与同步 watch，创建快十倍。
+* 默认值的处理与 prop 相同；有默认值时在 setup 里先读一次（prop 的 watch 也是这时求值），
+* 默认值里调用的组合式函数（useId() 等）才拿得到组件实例
+*/
+function readonlyProp(props, key, fallback) {
+	if (fallback !== void 0 && typeof fallback !== "function") {
+		const source = vueProps(props);
+		return toRef(() => source[key] !== void 0 ? source[key] : fallback);
+	}
+	const read = propReader(props, key, fallback);
+	if (fallback) read();
+	return toRef(read);
+}
+/** 父级传了值就用父级的，否则用默认值（第一次用到时求值，computed 缓存） */
+function propReader(props, key, fallback) {
+	const source = vueProps(props);
+	let fallbackValue;
+	return () => {
+		const value = source[key];
+		if (value !== void 0 || !fallback) return value;
+		fallbackValue ??= computed(fallback);
+		return fallbackValue.value;
+	};
+}
+/**
+* 解构出的 children：每次读取都重新执行插槽，不缓存（普通 prop 用 computed 缓存）。
+* 父级重新渲染时传来新的插槽，里面可能只有父级渲染时算好的值、没有响应式读取：
+* 缓存不会失效，子组件就一直显示旧内容。子组件因父级更新而重新渲染时读到的总是新插槽。
+*/
+function childrenProp(props, fallback) {
+	return customRef(() => ({
+		get: () => props.children ?? fallback?.(),
+		set: () => {}
+	}));
+}
+/**
+* 双向 prop，走标准 v-model 协议（父级 _属性={可写的值} 编译为 key + onUpdate:key）。
+* 与 Vue 的 useModel 一样，父级同时传了值和 onUpdate:key 才算受控：
+*
+*   - 受控：值以父级为准。写入后同步读取先拿到新值，本轮更新结束时回到父级的值，
+*     所以父级拒绝或修正（例如限制最大值）时组件会跟着回去
+*   - 只传了值：作为初始值，组件可以在本地修改，父级传入新值时以父级为准
+*   - 都没传：就是组件自己的状态
+*
+* 父级传 undefined 等同没传，使用默认值（与普通 prop 一致）；写入总会发出 update:key。
+*/
+function bindable(props, key, fallback, emit) {
+	const instance = getCurrentInstance();
+	const source = vueProps(props);
+	const names = [key, hyphenate(key)];
+	const listeners = names.map((name) => `onUpdate:${name}`);
+	const passed = (candidates) => {
+		const raw = instance.vnode.props;
+		return !!raw && candidates.some((name) => name in raw);
+	};
+	const isControlled = () => passed(names) && passed(listeners);
+	const fallbackValue = fallback?.();
+	const parentValue = () => source[key] !== void 0 ? source[key] : fallbackValue;
+	let local = parentValue();
+	/** 受控时写入的值，只在本轮更新内有效 */
+	let pending;
+	let writes = 0;
+	return customRef((track, trigger) => {
+		watch(() => source[key], (value) => {
+			if (value !== void 0) local = value;
+			trigger();
+		}, { flush: "sync" });
+		return {
+			get() {
+				track();
+				if (pending) return pending.value;
+				return isControlled() ? parentValue() : local;
+			},
+			set(value) {
+				local = value;
+				if (isControlled()) {
+					pending = { value };
+					const write = ++writes;
+					nextTick(() => {
+						if (write !== writes) return;
+						pending = void 0;
+						trigger();
+					});
+				}
+				trigger();
+				emit(`update:${key}`, value);
+			}
+		};
+	});
+}
+/** checkedValue → checked-value：父级可能用连字符写法传入 */
+function hyphenate(name) {
+	return name.replace(/\B([A-Z])/g, "-$1").toLowerCase();
+}
+//#endregion
+//#region src/runtime/effect.ts
+/**
+* _effect 的运行时（作者不直接调用）：语义同 Svelte 5 的 $effect，底层是 Vue 的 watchEffect。
+*
+*   _effect(fn)       → effect(fn)         挂载后、每次 DOM 更新后执行
+*   _effect.pre(fn)   → effect(fn, 'pre')  DOM 更新前执行
+*   _effect.root(fn)  → effectRoot(fn)     不随组件销毁，返回手动清理函数
+*/
+/** _effect / _effect.pre 编译后的调用：在当前作用域里创建，随组件销毁 */
+function effect(fn, flush = "post") {
+	if (!getCurrentScope()) throw new Error("_effect 需要在组件函数体、组件里调用的组合式函数、或另一个 _effect 里创建，否则不会自动停止；需要手动管理时用 _effect.root");
+	if (typeof document === "undefined") return;
+	watchEffect((onCleanup) => {
+		const scope = effectScope();
+		const cleanup = scope.run(fn);
+		onCleanup(() => {
+			scope.stop();
+			if (typeof cleanup === "function") cleanup();
+		});
+	}, { flush });
+}
+/** _effect.root 编译后的调用：独立的作用域，返回手动清理函数 */
+function effectRoot(fn) {
+	const scope = effectScope(true);
+	const cleanup = scope.run(fn);
+	return () => {
+		scope.stop();
+		if (typeof cleanup === "function") cleanup();
+	};
+}
+//#endregion
+export { _component, bindable, childrenProp, childrenStable, createContext, effect, effectRoot, forwardChildren, overridable, prop, readonlyProp, restProps, snapshot, untrack };