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

package/dist/module--rQ2-rvm.js

@@ -0,0 +1,194 @@
+import { n as SSR_REGISTER_ID } from "./ssr-register-CZ_lIN2f.js";
+import { n as compile } from "./compiler-BDi92tYb.js";
+import { hash } from "node:crypto";
+import { relative } from "node:path";
+import { types } from "@babel/core";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+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;
+};
+//#endregion
+//#region src/vite/hmr.ts
+/**
+* 组件的热更新、tree-shaking 标注与 SSR 登记，取自 @vitejs/plugin-vue-jsx 5.1（MIT）：
+*   - 开发时：顶层声明或导出的组件（_component / defineComponent 的结果）登记到 Vue 的热更新运行时，
+*     文件改了只重新加载这些组件；export default 的组件先赋给变量才能登记。工厂函数做的组件
+*     （export const Toolbar = createFlex('nav')，大写开头、由调用得到）运行时确认是组件才登记（同 React Refresh 的判断）。
+*     模块还导出了组件以外的值（函数、常量）时，改动后让导入方重新执行（invalidate），它们才拿到新值
+*   - 构建时：组件调用标为纯调用，没用到的组件能被去掉
+*   - SSR：组件登记到 ssrContext.modules，服务端据此预加载用到的模块
+*/
+/** 组件边界：第一个参数是 setup 函数、结果是组件的调用 */
+const COMPONENT_FACTORIES = ["defineComponent", "_component"];
+/**
+* 编译的第 2 遍末尾加的 Babel 插件。
+* 要登记组件时（热更新、SSR）：`export default _component(…)` 改成先赋给 `__default__` 再导出；
+* 否则（构建）：组件调用标为纯调用
+*/
+function componentMarkers(register) {
+	return {
+		name: "vue-tsx-pro-components",
+		visitor: register ? { ExportDefaultDeclaration(path) {
+			const declaration = unwrapTypeAssertion(path.node.declaration);
+			if (!isComponentCall(declaration)) return;
+			const [variable] = path.replaceWithMultiple([types.variableDeclaration("const", [types.variableDeclarator(types.identifier("__default__"), types.callExpression(declaration.callee, declaration.arguments))]), types.exportDefaultDeclaration(types.identifier("__default__"))]);
+			path.scope.registerDeclaration(variable);
+		} } : { CallExpression(path) {
+			if (isComponentCall(path.node)) path.addComment("leading", "#__PURE__");
+		} }
+	};
+}
+/** 文件顶层声明或导出的组件，以及有没有导出组件以外的值（本文件里定义的，转出别处的不算） */
+function exportedComponents(ast, id) {
+	const declared = /* @__PURE__ */ new Map();
+	const components = [];
+	let otherExports = false;
+	const add = (local, exported, maybe) => components.push({
+		local,
+		exported,
+		id: hash("sha256", id + exported, "hex").slice(0, 8),
+		maybe
+	});
+	for (const node of ast.program.body) {
+		if (types.isVariableDeclaration(node)) for (const [name, maybe] of componentDeclarations(node)) declared.set(name, maybe);
+		if (types.isExportNamedDeclaration(node)) {
+			if (node.source) continue;
+			if (types.isVariableDeclaration(node.declaration)) {
+				const found = componentDeclarations(node.declaration);
+				for (const [name, maybe] of found) add(name, name, maybe);
+				if (found.size < node.declaration.declarations.length) otherExports = true;
+			} else if (node.declaration) otherExports = true;
+			else for (const specifier of node.specifiers) {
+				if (!types.isExportSpecifier(specifier) || !types.isIdentifier(specifier.local)) continue;
+				const maybe = declared.get(specifier.local.name);
+				if (maybe !== void 0 && types.isIdentifier(specifier.exported)) add(specifier.local.name, specifier.exported.name, maybe);
+				else otherExports = true;
+			}
+		}
+		if (types.isExportDefaultDeclaration(node)) {
+			const maybe = types.isIdentifier(node.declaration) ? declared.get(node.declaration.name) : void 0;
+			if (maybe !== void 0) add(node.declaration.name, "default", maybe);
+			else if (isComponentCall(unwrapTypeAssertion(node.declaration))) add("__default__", "default", false);
+			else otherExports = true;
+		}
+	}
+	return {
+		components,
+		otherExports
+	};
+}
+/** 运行时判断是不是组件（工厂函数的结果）：有 setup 或 render 的对象 */
+const IS_COMPONENT = "const __isComponent = (c) => !!c && typeof c === 'object' && (typeof c.setup === 'function' || typeof c.render === 'function')";
+/**
+* 登记到热更新运行时，文件更新时重新加载这些组件；还导出了别的值时让导入方重新执行。
+* 有样式骨架（compiler/style-hot.ts）时：新模块的骨架没变说明只改了样式，新模块执行时已经原地改好规则，
+* 不重新加载组件、也不让导入方重新执行
+*/
+function hmrCode(components, otherExports, skeleton) {
+	const records = components.map(({ local, id, maybe }) => {
+		const record = `\n${local}.__hmrId = "${id}"\n__VUE_HMR_RUNTIME__.createRecord("${id}", ${local})`;
+		return maybe ? `\nif (__isComponent(${local})) {${record}}` : record;
+	});
+	const reloads = components.map(({ exported, id, maybe }) => {
+		const reload = `\n__VUE_HMR_RUNTIME__.reload("${id}", __${exported})`;
+		return maybe ? `\nif (__isComponent(__${exported})) {${reload}} else __other = true` : reload;
+	});
+	const parameters = components.map(({ exported }) => `${exported}: __${exported}`).join(",");
+	const helper = components.some(({ maybe }) => maybe) ? `\n${IS_COMPONENT}` : "";
+	const styleOnly = skeleton ? `\nif (__mod && __mod.__styleSkeleton === ${JSON.stringify(skeleton)}) return` : "";
+	return [
+		helper,
+		...records,
+		`\nimport.meta.hot.accept((__mod) => {${styleOnly}\nconst {${parameters}} = __mod\nlet __other = ${otherExports}`,
+		...reloads,
+		"\nif (__other) import.meta.hot.invalidate('还导出了组件以外的值，导入方重新执行')\n})"
+	].join("");
+}
+/**
+* 有顶层样式的模块导出骨架（去掉样式参数后的源码哈希）；不是组件模块时再自己接住更新：
+* 骨架没变就原地生效，变了（改了样式以外的代码）让导入方重新执行，同没有接住时一样
+*/
+function styleHotCode(skeleton, accepted) {
+	const value = JSON.stringify(skeleton);
+	const code = `\nexport const __styleSkeleton = ${value}`;
+	if (accepted) return code;
+	return `${code}\nimport.meta.hot.accept((__mod) => {\nif (!__mod || __mod.__styleSkeleton !== ${value}) import.meta.hot.invalidate('改了样式以外的代码，导入方重新执行')\n})`;
+}
+/** SSR：组件渲染时把模块路径（相对项目根目录）记进 ssrContext */
+function ssrCode(components, id, root) {
+	const moduleId = relative(root, id).split("\\").join("/");
+	const registers = components.map(({ local, maybe }) => maybe ? `\nif (${local} && typeof ${local} === 'object' && 'setup' in ${local}) ssrRegisterHelper(${local}, __moduleId)` : `\nssrRegisterHelper(${local}, __moduleId)`);
+	return `\nimport { ssrRegisterHelper } from "${SSR_REGISTER_ID}"\nconst __moduleId = ${JSON.stringify(moduleId)}${registers.join("")}`;
+}
+/**
+* 声明里的组件：名字 → 是否只是“可能”（工厂函数的结果）。_component / defineComponent 的结果一定是；
+* 大写开头、由别的调用得到的（createFlex('nav')、createPresetIconButton(…)）运行时再确认
+*/
+function componentDeclarations(node) {
+	const found = /* @__PURE__ */ new Map();
+	for (const declarator of node.declarations) {
+		if (!types.isIdentifier(declarator.id)) continue;
+		const init = unwrapTypeAssertion(declarator.init);
+		if (isComponentCall(init)) found.set(declarator.id.name, false);
+		else if (/^[A-Z]/.test(declarator.id.name) && types.isCallExpression(init)) found.set(declarator.id.name, true);
+	}
+	return found;
+}
+function isComponentCall(node) {
+	return types.isCallExpression(node) && types.isIdentifier(node.callee) && COMPONENT_FACTORIES.includes(node.callee.name);
+}
+function unwrapTypeAssertion(node) {
+	let current = node;
+	while (types.isTSAsExpression(current) || types.isTSSatisfiesExpression(current) || types.isTSTypeAssertion(current)) current = current.expression;
+	return current;
+}
+//#endregion
+//#region src/vite/module.ts
+/**
+* 编译一个模块：compile（compiler/compile.ts）加上组件的热更新、SSR 登记。
+* 主线程（index.ts）与编译线程（compile-worker.ts）共用；设置要能在线程之间复制，所以只放数据。
+*/
+var module_exports = /* @__PURE__ */ __exportAll({ compileModule: () => compileModule });
+/** 编译一个模块；什么都不用做时返回 null */
+async function compileModule(request, setup) {
+	const { code, id, file, lang, own, ssr } = request;
+	const jsx = lang === "tsx" || lang === "jsx";
+	const styleHot = own && setup.hmr && !ssr;
+	const result = await compile(code, {
+		filename: file,
+		lang,
+		runes: own,
+		optimize: setup.optimize,
+		styleBindings: own,
+		styleHot: styleHot ? relative(setup.root, file).split("\\").join("/") : void 0,
+		jsx: setup.jsx,
+		plugins: jsx ? [() => componentMarkers(setup.hmr || ssr)] : void 0
+	});
+	if (!result) return null;
+	let output = result.code;
+	const skeleton = result.styleSkeleton;
+	let accepted = false;
+	if (jsx && (setup.hmr || ssr)) {
+		const { components, otherExports } = exportedComponents(result.ast, id);
+		if (components.length && setup.hmr && !ssr && !/\?vue&type=script/.test(id)) {
+			output += hmrCode(components, otherExports, skeleton);
+			accepted = true;
+		}
+		if (components.length && ssr) output += ssrCode(components, id, setup.root);
+	}
+	if (skeleton) output += styleHotCode(skeleton, accepted);
+	return {
+		code: output,
+		map: result.map,
+		warnings: result.warnings.map((warning) => warning.frame)
+	};
+}
+//#endregion
+export { module_exports as n, compileModule as t };

package/dist/ssr-register-CZ_lIN2f.js

@@ -0,0 +1,17 @@
+//#region src/vite/ssr-register.ts
+/** SSR 登记组件模块用的虚拟模块：id 与代码（不依赖 Babel，预设入口要用；生成登记代码见 hmr.ts 的 ssrCode） */
+/** SSR 时登记组件模块的虚拟模块 */
+const SSR_REGISTER_ID = "/__vue-jsx-ssr-register-helper";
+/** SSR_REGISTER_ID 的代码：包一层 setup，渲染时把模块记进 ssrContext.modules */
+const SSR_REGISTER_CODE = `import { useSSRContext } from "vue";
+export function ssrRegisterHelper(comp, filename) {
+  const setup = comp.setup;
+  comp.setup = (props, ctx) => {
+    const ssrContext = useSSRContext();
+    (ssrContext.modules || (ssrContext.modules = new Set())).add(filename);
+    if (setup) return setup(props, ctx);
+  };
+}
+`;
+//#endregion
+export { SSR_REGISTER_ID as n, SSR_REGISTER_CODE as t };

package/dist/state-YxL7IqUO.js

@@ -0,0 +1,108 @@
+import { ReactiveEffect, computed, customRef, effectScope, isRef, toRaw, watch } from "vue";
+//#region src/runtime/state.ts
+/**
+* 编译产物使用的状态工具（作者不直接调用）：
+*   - overridable：let 声明的 _derived、组件的普通 prop
+*   - snapshot：_state.snapshot(x)
+*   - untrack：_untrack(x)
+*/
+/**
+* 跟随来源、可以临时覆盖的值（同 Svelte 5.25 的可覆盖派生）：
+* 读取时是 getter 的结果；写入后读到写入的值，直到 getter 的结果变化，再回到跟随来源。
+*
+*   let likes = _derived(post.likes)   乐观更新：likes += 1，post.likes 一变就以它为准
+*   ({ value }) => … value = x          普通 prop：只改组件本地，父级传入新值时以父级为准
+*/
+function overridable(getter) {
+	const source = computed(getter);
+	let override;
+	return customRef((track, trigger) => {
+		watch(source, () => {
+			override = void 0;
+			trigger();
+		}, { flush: "sync" });
+		return {
+			get() {
+				track();
+				const value = source.value;
+				return override ? override.value : value;
+			},
+			set(value) {
+				override = { value };
+				trigger();
+			}
+		};
+	});
+}
+/** untrack 共用的读取 effect（第一次用时建在独立的作用域里，不随哪个组件停掉） */
+let reader;
+/** 正在 untrack 里：嵌套的 untrack 直接执行（外层已经不追踪） */
+let reading = false;
+const noop = () => {};
+/**
+* 读取但不追踪（同 Svelte 的 untrack）：在共用的读取 effect 里执行，读到的响应式值记在它身上、
+* 变化时什么也不做，外层的 _effect、_derived、渲染函数不会因此依赖它们。用 Vue 公开的 ReactiveEffect，不碰内部 API。
+* 渲染里会频繁调用（样式的响应式绑定每次渲染取一次值），所以复用同一个 effect，不每次新建作用域与 effect
+*/
+function untrack(read) {
+	if (reading) return read();
+	reader ??= effectScope(true).run(() => {
+		const effect = new ReactiveEffect(noop);
+		effect.scheduler = noop;
+		return effect;
+	});
+	reading = true;
+	reader.fn = read;
+	try {
+		return reader.run();
+	} finally {
+		reader.fn = noop;
+		reading = false;
+	}
+}
+/**
+* 去掉响应式代理的静态深拷贝（同 Svelte 的 $state.snapshot），交给 structuredClone、第三方库或日志。
+* 普通对象、数组、Map、Set 逐层拷贝，Date、类型化数组、ArrayBuffer 复制一份，有 toJSON 的取它的结果，
+* 其他值（类实例、函数等）原样保留。
+*/
+function snapshot(value) {
+	return clone(value, /* @__PURE__ */ new Map());
+}
+function clone(value, seen) {
+	const raw = toRaw(value);
+	if (isRef(raw)) return clone(raw.value, seen);
+	if (typeof raw !== "object" || raw === null) return raw;
+	if (seen.has(raw)) return seen.get(raw);
+	if (Array.isArray(raw)) {
+		const copy = [];
+		seen.set(raw, copy);
+		for (const item of raw) copy.push(clone(item, seen));
+		return copy;
+	}
+	if (raw instanceof Map) {
+		const copy = /* @__PURE__ */ new Map();
+		seen.set(raw, copy);
+		for (const [key, item] of raw) copy.set(clone(key, seen), clone(item, seen));
+		return copy;
+	}
+	if (raw instanceof Set) {
+		const copy = /* @__PURE__ */ new Set();
+		seen.set(raw, copy);
+		for (const item of raw) copy.add(clone(item, seen));
+		return copy;
+	}
+	if (raw instanceof Date) return new Date(raw);
+	if (raw instanceof ArrayBuffer) return raw.slice(0);
+	if (ArrayBuffer.isView(raw)) return raw instanceof DataView ? new DataView(raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength)) : raw.slice();
+	const prototype = Object.getPrototypeOf(raw);
+	if (prototype === Object.prototype || prototype === null) {
+		const copy = {};
+		seen.set(raw, copy);
+		for (const [key, item] of Object.entries(raw)) copy[key] = clone(item, seen);
+		return copy;
+	}
+	const json = raw.toJSON;
+	return typeof json === "function" ? clone(json.call(raw), seen) : raw;
+}
+//#endregion
+export { snapshot as n, untrack as r, overridable as t };