@proteus-vue/compiler 0.3.0-beta.0 → 0.3.0-beta.3

package/dist/template.js

@@ -1,337 +0,0 @@
-// src/compiler/template.ts
-// 4-1-a Template → WXML
-// 标准 HTML 标签 / Vue 指令 → 小程序标签 / 指令（映射表见 LLM_IMPLEMENTATION_GUIDE §P4-1-a）
-import { parse as domParse, NodeTypes } from '@vue/compiler-dom';
-import { TAG_RULE_BY_TAG } from './transforms/template';
-import { resolveOverrides } from './overrides';
-function escapeXml(s) {
-    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-}
-function kebabCase(s) {
-    return s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-}
-function camelToKebab(s) {
-    return s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-}
-/** 提取表达式节点的文本（兼容 Simple/Compound/Interpolation/Text/字符串） */
-function exprContent(exp) {
-    if (exp == null)
-        return '';
-    if (typeof exp === 'string')
-        return exp;
-    const node = exp;
-    if (node.type === NodeTypes.SIMPLE_EXPRESSION) {
-        return typeof node.content === 'string' ? node.content : '';
-    }
-    if (node.type === NodeTypes.INTERPOLATION) {
-        return exprContent(node.content);
-    }
-    if (node.type === NodeTypes.COMPOUND_EXPRESSION || Array.isArray(node.children)) {
-        return node.children.map((c) => exprContent(c)).join('');
-    }
-    if (node.type === NodeTypes.TEXT) {
-        return typeof node.content === 'string' ? node.content : '';
-    }
-    return '';
-}
-/** 解析 v-for 表达式：(item, idx) in list / item of items */
-function parseForExpr(exp) {
-    const m = exp.trim().match(/^\(?\s*([\w$]+)\s*(?:,\s*([\w$]+))?\s*\)?\s+(?:in|of)\s+(.+)$/);
-    if (!m)
-        return { list: exp };
-    return { list: m[3].trim(), item: m[1], index: m[2] };
-}
-/** 事件处理器：仅支持简单方法引用（方法名 / 方法名($event)） */
-function cleanHandler(exp, warnings) {
-    const t = exp.trim();
-    if (/^[\w$]+$/.test(t))
-        return t;
-    const m = t.match(/^([\w$]+)\(\$event\)$/);
-    if (m)
-        return m[1];
-    warnings.push(`事件处理器 "${t}" 不是简单方法引用（MVP 仅支持方法名），已原样输出`);
-    return t;
-}
-/** :class 绑定：对象语法 → 三元拼接，其余 → {{expr}} */
-function formatClassBinding(exp, warnings) {
-    const t = exp.trim();
-    if (t.startsWith('{')) {
-        const parts = [];
-        const re = /(['"]?)([\w-]+)\1\s*:\s*([^,}]+)/g;
-        let m;
-        while ((m = re.exec(t)))
-            parts.push(`(${m[3].trim()}?'${m[2]} ':'')`);
-        if (parts.length)
-            return `{{${parts.join('+')}}}`;
-    }
-    if (t.startsWith('['))
-        warnings.push(`:class 数组语法暂不支持（MVP），已按表达式输出`);
-    return `{{${t}}}`;
-}
-/** :style 绑定：对象语法 → prop:{{expr}} 拼接，其余 → {{expr}} */
-function formatStyleBinding(exp) {
-    const t = exp.trim();
-    if (t.startsWith('{')) {
-        const parts = [];
-        const re = /(['"]?)([\w-]+)\1\s*:\s*([^,}]+)/g;
-        let m;
-        while ((m = re.exec(t)))
-            parts.push(`${camelToKebab(m[2])}:{{${m[3].trim()}}}`);
-        if (parts.length)
-            return parts.join(';');
-    }
-    return `{{${t}}}`;
-}
-function serializeElement(node, ctx) {
-    const hasVHtml = node.props.some((p) => p.type === NodeTypes.DIRECTIVE && p.name === 'html');
-    const hasClick = node.props.some((p) => p.type === NodeTypes.DIRECTIVE && p.name === 'on');
-    // 导航链接：<a href> / <router-link to>（元素上有 @click 时不作为导航链接，交给事件映射）
-    const isNavLink = (node.tag === 'a' || node.tag === 'router-link') && !hasClick;
-    // 标签映射（★生效配置：tags.ts 常量 + config 覆盖；规则被禁用则按未注册标签原样输出）
-    const tagRuleId = TAG_RULE_BY_TAG[node.tag];
-    let tag = hasVHtml ? 'rich-text' : (ctx.tagMap[node.tag] ?? kebabCase(node.tag));
-    if (node.tag === 'router-link')
-        tag = 'view';
-    if (tagRuleId && ctx.disabled.has(tagRuleId)) {
-        tag = kebabCase(node.tag);
-        ctx.warnings.push(`规则 ${tagRuleId} 已被禁用（rules.disabled），<${node.tag}> 按未注册标签原样输出`);
-    }
-    // 决策 trace：标签映射
-    if (!ctx.disabled.has('tag/unknown-kebab') && !(tagRuleId && ctx.disabled.has(tagRuleId))) {
-        ctx.trace?.add(hasVHtml ? 'tag/rich-text' : node.tag === 'router-link' ? 'tag/router-link' : (TAG_RULE_BY_TAG[node.tag] ?? 'tag/unknown-kebab'), { line: node.loc.start.line, before: `<${node.tag}>`, after: `<${tag}>` });
-    }
-    // 语义标签基础类（h1-h6/p/a → proteus-*，样式侧注入 Web UA 等价默认样式；rich-text 不附加）
-    const baseClass = hasVHtml ? '' : (ctx.semanticClass[node.tag] ?? '');
-    // 语义类随标签规则联动：tag/* 规则被禁用时标签保持原样，基础类也一并取消（避免 class 无意义）
-    const tagDisabled = Boolean(tagRuleId) && ctx.disabled.has(tagRuleId);
-    if (baseClass && (ctx.disabled.has('semantic/base-class') || tagDisabled)) {
-        ctx.warnings.push(`语义基础类已被禁用（${tagDisabled ? `${tagRuleId} 被禁用` : 'semantic/base-class 被禁用'}，rules.disabled），不再附加`);
-    }
-    const effectiveBaseClass = baseClass && !ctx.disabled.has('semantic/base-class') && !tagDisabled ? baseClass : '';
-    if (effectiveBaseClass) {
-        ctx.trace?.add('semantic/base-class', { line: node.loc.start.line, before: node.tag, after: effectiveBaseClass });
-    }
-    const isInputLike = tag === 'input' || tag === 'textarea';
-    const attrs = [];
-    let hasNavTarget = false;
-    for (const prop of node.props) {
-        if (prop.type === NodeTypes.ATTRIBUTE) {
-            const attr = prop;
-            if (isNavLink && (attr.name === 'href' || attr.name === 'to' || attr.name === 'route-type')) {
-                if (ctx.disabled.has('nav/navigate-link')) {
-                    ctx.warnings.push('规则 nav/navigate-link 已被禁用（rules.disabled），<a> 按普通 view 输出（无导航语义）');
-                    break;
-                }
-                if (attr.name === 'route-type' && attr.value) {
-                    attrs.push(`data-route-type="${escapeXml(attr.value.content)}"`);
-                    ctx.trace?.add('nav/route-type', { line: node.loc.start.line, before: `route-type="${attr.value.content}"`, after: `data-route-type="${attr.value.content}"` });
-                }
-                else if (attr.value) {
-                    attrs.push(`data-url="${escapeXml(attr.value.content)}"`);
-                    hasNavTarget = true;
-                }
-                continue;
-            }
-            if (attr.name === 'class' && effectiveBaseClass) {
-                attrs.push(`class="${effectiveBaseClass}${attr.value ? ' ' + escapeXml(attr.value.content) : ''}"`);
-                continue;
-            }
-            attrs.push(attr.value ? `${attr.name}="${escapeXml(attr.value.content)}"` : attr.name);
-            continue;
-        }
-        const dir = prop;
-        if (isNavLink && dir.name === 'bind' && (exprContent(dir.arg) === 'href' || exprContent(dir.arg) === 'to')) {
-            const exp = exprContent(dir.exp);
-            if (exp.trim().startsWith('{')) {
-                ctx.warnings.push('路由链接 :to/:href 对象形式暂不支持（MVP），请改用字符串路径');
-            }
-            else if (!ctx.disabled.has('nav/navigate-link')) {
-                attrs.push(`data-url="{{${exp}}}"`);
-                hasNavTarget = true;
-            }
-            else {
-                ctx.warnings.push('规则 nav/navigate-link 已被禁用（rules.disabled），<a> 按普通 view 输出（无导航语义）');
-            }
-            continue;
-        }
-        switch (dir.name) {
-            case 'if':
-                if (ctx.disabled.has('directive/v-if')) {
-                    ctx.warnings.push('规则 directive/v-if 已被禁用（rules.disabled），v-if 已忽略');
-                    break;
-                }
-                attrs.push(`wx:if="{{${exprContent(dir.exp)}}}"`);
-                ctx.trace?.add('directive/v-if', { line: node.loc.start.line, before: `v-if="${exprContent(dir.exp)}"`, after: `wx:if="{{${exprContent(dir.exp)}}}"` });
-                break;
-            case 'else-if':
-                if (ctx.disabled.has('directive/v-else-if'))
-                    break;
-                attrs.push(`wx:elif="{{${exprContent(dir.exp)}}}"`);
-                ctx.trace?.add('directive/v-else-if', { line: node.loc.start.line, before: 'v-else-if', after: 'wx:elif' });
-                break;
-            case 'else':
-                if (ctx.disabled.has('directive/v-else'))
-                    break;
-                attrs.push('wx:else');
-                ctx.trace?.add('directive/v-else', { line: node.loc.start.line, before: 'v-else', after: 'wx:else' });
-                break;
-            case 'for': {
-                if (ctx.disabled.has('directive/v-for')) {
-                    ctx.warnings.push('规则 directive/v-for 已被禁用（rules.disabled），v-for 已忽略');
-                    break;
-                }
-                const f = parseForExpr(exprContent(dir.exp));
-                attrs.push(`wx:for="{{${f.list}}}"`);
-                if (f.item)
-                    attrs.push(`wx:for-item="${f.item}"`);
-                if (f.index)
-                    attrs.push(`wx:for-index="${f.index}"`);
-                ctx.trace?.add('directive/v-for', { line: node.loc.start.line, before: exprContent(dir.exp), after: `wx:for="{{${f.list}}}"` });
-                break;
-            }
-            case 'on': {
-                if (ctx.disabled.has('event/click-to-tap') && ctx.disabled.has('event/modifier-catch')) {
-                    ctx.warnings.push('事件映射规则已全部禁用（rules.disabled），@事件 原样输出');
-                    const handler = cleanHandler(exprContent(dir.exp), ctx.warnings);
-                    attrs.push(`bind${exprContent(dir.arg)}="${handler}"`);
-                    break;
-                }
-                const raw = exprContent(dir.arg);
-                const mapped = ctx.eventMap[raw] ?? raw;
-                // 修饰符：运行时 modifiers 是 { content }[]（与声明类型 string[] 不一致，做兼容）
-                const mods = dir.modifiers.map((m) => typeof m === 'string' ? m : (m?.content ?? ''));
-                const isCatch = (mods.includes('stop') || mods.includes('prevent')) && !ctx.disabled.has('event/modifier-catch');
-                const handler = cleanHandler(exprContent(dir.exp), ctx.warnings);
-                attrs.push(`${isCatch ? 'catch' : 'bind'}${mapped}="${handler}"`);
-                ctx.trace?.add(isCatch ? 'event/modifier-catch' : 'event/click-to-tap', { line: node.loc.start.line, before: `@${raw}`, after: `${isCatch ? 'catch' : 'bind'}${mapped}` });
-                break;
-            }
-            case 'bind': {
-                const arg = exprContent(dir.arg);
-                const exp = exprContent(dir.exp);
-                if (arg === 'class') {
-                    if (ctx.disabled.has('directive/v-bind-class'))
-                        break;
-                    const cls = formatClassBinding(exp, ctx.warnings);
-                    attrs.push(`class="${effectiveBaseClass ? `${effectiveBaseClass} ` : ''}${cls}"`);
-                    ctx.trace?.add('directive/v-bind-class', { line: node.loc.start.line, before: `:class="${exp}"`, after: cls });
-                }
-                else if (arg === 'style') {
-                    if (ctx.disabled.has('directive/v-bind-style'))
-                        break;
-                    attrs.push(`style="${formatStyleBinding(exp)}"`);
-                    ctx.trace?.add('directive/v-bind-style', { line: node.loc.start.line, before: `:style="${exp}"`, after: formatStyleBinding(exp) });
-                }
-                else if (arg === 'key') {
-                    if (ctx.disabled.has('directive/v-bind-key'))
-                        break;
-                    if (/^[\w$]+$/.test(exp))
-                        attrs.push(`wx:key="${exp}"`);
-                    else
-                        ctx.warnings.push(`:key="${exp}" 不是简单标识符（MVP），wx:key 已忽略`);
-                    ctx.trace?.add('directive/v-bind-key', { line: node.loc.start.line, before: `:key="${exp}"`, after: `wx:key="${exp}"` });
-                }
-                else {
-                    if (ctx.disabled.has('directive/v-bind'))
-                        break;
-                    attrs.push(`${arg}="{{${exp}}}"`);
-                    ctx.trace?.add('directive/v-bind', { line: node.loc.start.line, before: `:${arg}`, after: `${arg}="{{${exp}}}"` });
-                }
-                break;
-            }
-            case 'model': {
-                if (ctx.disabled.has('directive/v-model')) {
-                    ctx.warnings.push('规则 directive/v-model 已被禁用（rules.disabled），v-model 已忽略');
-                    break;
-                }
-                const model = exprContent(dir.exp);
-                if (model && !ctx.vModelBindings.includes(model))
-                    ctx.vModelBindings.push(model);
-                if (isInputLike)
-                    attrs.push(`value="{{${model}}}"`);
-                // 方法名不用 __ 前缀（微信保留前缀，真机绑定可能失效）
-                attrs.push(`bindinput="proteusOn${capitalize(model)}Input"`);
-                ctx.trace?.add('directive/v-model', { line: node.loc.start.line, before: `v-model="${model}"`, after: `bindinput="proteusOn${capitalize(model)}Input"` });
-                break;
-            }
-            case 'html':
-                if (ctx.disabled.has('directive/v-html')) {
-                    ctx.warnings.push('规则 directive/v-html 已被禁用（rules.disabled），v-html 已忽略');
-                    break;
-                }
-                attrs.push(`nodes="{{${exprContent(dir.exp)}}}"`);
-                ctx.trace?.add('directive/v-html', { line: node.loc.start.line, before: 'v-html', after: 'rich-text nodes' });
-                break;
-            case 'show':
-                if (ctx.disabled.has('directive/v-show-limit'))
-                    break;
-                ctx.warnings.push('v-show 暂不支持（MVP），已忽略，请改用 v-if');
-                ctx.trace?.add('directive/v-show-limit', { line: node.loc.start.line, before: 'v-show', after: '（忽略 + 编译期警告）' });
-                break;
-            default:
-                break; // v-slot / v-pre 等：MVP 忽略
-        }
-    }
-    if (hasNavTarget && !ctx.disabled.has('nav/navigate-link')) {
-        // 导航链接：绑定点击跳转（handler 由 script 转换自动注入；方法名避免 __ 前缀）
-        attrs.push('bindtap="proteusNavigateTo"');
-        ctx.usesNavigate = true;
-        ctx.trace?.add('nav/navigate-link', { line: node.loc.start.line, before: `<${node.tag}>` + (node.tag === 'a' ? ' href/to' : ' to'), after: 'data-url + bindtap="proteusNavigateTo"' });
-    }
-    if (effectiveBaseClass && !attrs.some((a) => a.startsWith('class='))) {
-        attrs.push(`class="${effectiveBaseClass}"`);
-    }
-    const attrStr = attrs.length ? ` ${attrs.join(' ')}` : '';
-    // 反黑盒：注入源码行号注释（默认关闭，dev 调试开启）
-    const lineNote = ctx.annotateLines ? `<!-- @${node.loc.start.line} ${node.tag} -->\n` : '';
-    if (lineNote && !ctx.lineNoteTraced) {
-        ctx.lineNoteTraced = true;
-        ctx.trace?.add('annotation/line-note', { line: node.loc.start.line, before: `<${node.tag}>`, after: `<!-- @${node.loc.start.line} ${node.tag} -->` });
-    }
-    if (!node.children.length)
-        return `${lineNote}<${tag}${attrStr} />`;
-    const hasElementChild = node.children.some((c) => c.type === NodeTypes.ELEMENT);
-    if (hasElementChild) {
-        const inner = node.children.map((c) => serializeNode(c, ctx)).join('\n');
-        return `${lineNote}<${tag}${attrStr}>\n${inner}\n</${tag}>`;
-    }
-    // 纯文本/插值子节点：紧凑单行（产物可读性）
-    const inline = node.children.map((c) => serializeNode(c, ctx)).join('');
-    return `${lineNote}<${tag}${attrStr}>${inline}</${tag}>`;
-}
-function serializeNode(node, ctx) {
-    switch (node.type) {
-        case NodeTypes.ELEMENT:
-            return serializeElement(node, ctx);
-        case NodeTypes.TEXT:
-            return escapeXml(node.content);
-        case NodeTypes.INTERPOLATION:
-            ctx.trace?.add('node/interpolation', { line: node.loc.start.line, before: '{{ expr }}', after: '{{ expr }}（原样保留）' });
-            return `{{ ${node.content.content} }}`;
-        case NodeTypes.COMMENT:
-            return `<!-- ${node.content} -->`;
-        default:
-            return '';
-    }
-}
-function capitalize(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-}
-/** template 源码 → WXML（纯函数，独立可测） */
-export function transformTemplateToWxml(source, opts = { px2rpx: true, rpxRatio: 2, annotateLines: false }) {
-    const ctx = {
-        vModelBindings: [],
-        warnings: [],
-        annotateLines: opts.annotateLines ?? false,
-        filename: opts.filename,
-        usesNavigate: false,
-        trace: opts.trace,
-        // ★底线循环 ①③：生效配置 = tags.ts 常量 + config 覆盖（规则改写/禁用即时生效）
-        ...resolveOverrides(opts.rules),
-    };
-    const root = domParse(source, { onError: () => undefined });
-    const wxml = root.children.map((c) => serializeNode(c, ctx)).join('\n');
-    for (const w of ctx.warnings)
-        console.warn(`[mp-transform] ${w}`);
-    return { wxml, vModelBindings: ctx.vModelBindings, usesNavigate: ctx.usesNavigate, warnings: ctx.warnings };
-}

package/dist/trace.js

@@ -1,18 +0,0 @@
-/** 创建空收集器（phase 记录事件所属阶段，formatTransformTrace 分组用） */
-export function createTrace(phase = 'template') {
-    return {
-        events: [],
-        add(ruleId, opts) {
-            this.events.push({ ruleId, phase, ...opts });
-        },
-    };
-}
-/** 由字符偏移计算源码行号（1-based） */
-export function lineAt(source, index) {
-    let line = 1;
-    for (let i = 0; i < index && i < source.length; i++) {
-        if (source[i] === '\n')
-            line++;
-    }
-    return line;
-}

package/dist/transforms/registry.js

@@ -1,48 +0,0 @@
-import { TEMPLATE_RULES } from './template';
-import { SCRIPT_RULES } from './script';
-import { STYLE_RULES } from './style';
-import { VALIDATE_RULES } from './validate';
-/** 全量规则（聚合各阶段，ID 唯一性由 tests/transforms.test.ts 校验） */
-export const TRANSFORM_RULES = [
-    ...TEMPLATE_RULES,
-    ...SCRIPT_RULES,
-    ...STYLE_RULES,
-    ...VALIDATE_RULES,
-];
-const byId = new Map(TRANSFORM_RULES.map((r) => [r.id, r]));
-/** 按阶段枚举规则（省略 phase 返回全部） */
-export function listTransformRules(phase) {
-    return phase ? TRANSFORM_RULES.filter((r) => r.phase === phase) : [...TRANSFORM_RULES];
-}
-/** 按稳定 ID 查单条规则 */
-export function getTransformRule(id) {
-    return byId.get(id);
-}
-/** 渲染单条规则的 AI 说明书（人可读文本，可直接喂给 AI / 写入文档） */
-export function formatTransformRule(rule) {
-    const lines = [
-        `## ${rule.id}（${rule.phase}）`,
-        `**${rule.title}** \`[${rule.status}]\``,
-        `- 输入 → 输出：${rule.description}`,
-        `- 为什么：${rule.why}`,
-        `- 触发条件：${rule.when}`,
-        `- 示例：`,
-        `  - 源码：\`${rule.example.before}\``,
-        `  - 产物：\`${rule.example.after}\``,
-        `- 如何验证：${rule.verify}`,
-        `- 实现位置：${rule.source}`,
-    ];
-    if (rule.decision)
-        lines.push(`- 决策：${rule.decision}`);
-    return lines.join('\n');
-}
-/** 渲染全量规则目录（按阶段分组） */
-export function formatTransformCatalog() {
-    const phases = ['template', 'script', 'style', 'validate'];
-    const blocks = phases.map((phase) => {
-        const rules = listTransformRules(phase);
-        const items = rules.map((r) => `- \`${r.id}\` \`[${r.status}]\` ${r.title}`).join('\n');
-        return `### ${phase} 阶段（${rules.length} 条规则）\n\n${items}`;
-    });
-    return blocks.join('\n\n');
-}

package/dist/transforms/script.js

@@ -1,179 +0,0 @@
-export const SCRIPT_RULES = [
-    {
-        id: 'script/const-to-data',
-        phase: 'script',
-        status: 'implemented',
-        title: '顶层 const（ref/reactive/字面量）→ data',
-        description: '零缩进顶层 const → data 字段；ref(0)/reactive({...})/字面量在构建期静态求值，多行数组/对象字面量完整提取',
-        why: '小程序页面状态在 data 中，响应式声明（ref/reactive）编译期为初始值求值（决策 #60：括号平衡扫描支持多行字面量；只提取零缩进顶层 const，不误取函数体内局部 const）',
-        when: 'script 顶层出现 const 声明且初始值为字面量/ref/reactive/shallowRef/readonly 时',
-        example: {
-            before: 'const count = ref(0)\nconst cards = ref([{ title: "a" }])',
-            after: 'data: {\n  count: 0,\n  cards: [{ "title": "a" }],\n}',
-        },
-        verify: 'tests/mp-transform.test.ts data 提取用例；golden fixture showcase.js（多行数组）',
-        source: 'src/compiler/script.ts → extractData + extractInitializer',
-        decision: '#60 / #22',
-    },
-    {
-        id: 'script/function-to-methods',
-        phase: 'script',
-        status: 'implemented',
-        title: '顶层 function 声明 → methods',
-        description: '顶层 function handleTap() {...} → methods 中的对象简写 handleTap() {...}',
-        why: '小程序页面逻辑在 methods 中；对象字面量内不能输出裸 function 声明（决策 #14：产物方法用对象简写）',
-        when: 'script 顶层出现 function 声明时',
-        example: {
-            before: 'function handleTap() {\n  count.value++\n}',
-            after: 'handleTap() {\n  this.setData({ count: (this.data.count === undefined || this.data.count === null ? 0 : this.data.count) + 1 })\n},',
-        },
-        verify: 'tests/mp-transform.test.ts methods 提取用例',
-        source: 'src/compiler/script.ts → extractMethods',
-        decision: '#14',
-    },
-    {
-        id: 'script/arrow-to-methods',
-        phase: 'script',
-        status: 'implemented',
-        title: 'const 箭头函数 → methods',
-        description: 'const fn = (params) => {...} → methods 中的 fn(params) {...}（支持 async）',
-        why: '小程序页面逻辑在 methods 中；const 箭头函数同样提取为方法',
-        when: 'script 顶层出现 const 箭头函数（含 async）时',
-        example: {
-            before: 'const load = async () => {\n  const r = await fetchData()\n}',
-            after: 'load() {\n  const r = await fetchData()\n},',
-        },
-        verify: 'tests/mp-transform.test.ts methods 提取用例',
-        source: 'src/compiler/script.ts → extractMethods（arrowRe 分支）',
-    },
-    {
-        id: 'script/lifecycle-map',
-        phase: 'script',
-        status: 'implemented',
-        title: '生命周期映射 onMounted → onReady / onUnmounted → onUnload',
-        description: 'onMounted(() => {...}) → onReady() {...}；onUnmounted → onUnload；onLoad 透传',
-        why: 'Vue 组件生命周期与小程序页面生命周期不同名，编译期映射到小程序钩子',
-        when: 'script 出现 onMounted / onUnmounted / onLoad 调用时',
-        example: { before: 'onMounted(() => { doInit() })', after: 'onReady() {\n  doInit()\n},' },
-        verify: 'tests/runtime.test.ts + mp-transform.test.ts 生命周期用例',
-        source: 'src/compiler/script.ts → extractLifecycles',
-    },
-    {
-        id: 'script/ref-read',
-        phase: 'script',
-        status: 'implemented',
-        title: '方法内 ref 读取 → this.data.name',
-        description: '方法/生命周期体内的 name.value 读取 → this.data.name',
-        why: '小程序运行期状态在 this.data 中，编译期把 setup ref 访问重写为 data 访问（决策 #22）',
-        when: '方法或生命周期体内出现 ref.value 读取时',
-        example: { before: 'const v = count.value', after: 'const v = this.data.count' },
-        verify: 'tests/mp-transform.test.ts ref 重写用例',
-        source: 'src/compiler/script.ts → rewriteRefAccess',
-        decision: '#22',
-    },
-    {
-        id: 'script/ref-write',
-        phase: 'script',
-        status: 'implemented',
-        title: '方法内 ref 赋值 → this.setData',
-        description: '方法/生命周期体内的 name.value = expr → this.setData({ name: expr })',
-        why: '小程序更新视图的唯一通道是 setData，编译期把赋值重写为 setData 调用（决策 #22；排除 ==/===/复合赋值）',
-        when: '方法或生命周期体内出现 name.value = expr 时',
-        example: { before: 'count.value = count.value + 1', after: 'this.setData({ count: this.data.count + 1 })' },
-        verify: 'tests/mp-transform.test.ts ref 重写用例',
-        source: 'src/compiler/script.ts → rewriteRefAccess',
-        decision: '#22',
-    },
-    {
-        id: 'script/ref-incdec',
-        phase: 'script',
-        status: 'implemented',
-        title: '方法内 ref 自增/自减 → this.setData',
-        description: 'name.value++ / -- / ++name.value → this.setData({ name: (null 检查 ? 0 : this.data.name) + 1 })',
-        why: '自增/自减无表达式可提取，编译期为显式 setData 并做 null 兜底（决策 #22；不用 ?? 运算符——真机预览报 SyntaxError，决策 #36）',
-        when: '方法或生命周期体内出现 name.value 的自增/自减时',
-        example: {
-            before: 'count.value++',
-            after: 'this.setData({ count: (this.data.count === undefined || this.data.count === null ? 0 : this.data.count) + 1 })',
-        },
-        verify: 'tests/mp-transform.test.ts ref 重写用例；Web E2E tap 计数用例',
-        source: 'src/compiler/script.ts → rewriteRefAccess + numOrZero',
-        decision: '#22 / #36',
-    },
-    {
-        id: 'script/vmodel-handler',
-        phase: 'script',
-        status: 'implemented',
-        title: 'v-model 自动 handler 注入',
-        description: '模板出现 v-model="x" 时注入 proteusOnXInput(e) { this.setData({ x: e.detail.value }) }',
-        why: '小程序无 v-model，回写方向由自动 handler 承担（决策 #29：方法名避免 __ 前缀，微信保留 _ 前缀可能导致绑定失效）',
-        when: 'template 转换返回的 vModelBindings 非空时',
-        example: {
-            before: '（模板）<input v-model="name" />',
-            after: 'proteusOnNameInput(e) { this.setData({ name: e.detail.value }) },',
-        },
-        verify: 'tests/mp-transform.test.ts v-model 用例',
-        source: 'src/compiler/script.ts → transformScriptToPage（vModelBindings 循环）',
-        decision: '#29',
-    },
-    {
-        id: 'script/nav-handler',
-        phase: 'script',
-        status: 'implemented',
-        title: '导航链接自动 handler 注入（proteusNavigateTo）',
-        description: '模板出现导航链接时注入 proteusNavigateTo(e)：读 data-url → wx.navigateTo（routeType 透传，fail 降级普通跳转）',
-        why: '小程序导航统一走 wx.navigateTo；保留前导 / 为绝对路径（决策 #30 真机根因）；fail 降级保证自定义路由失败仍可跳转（#28）；方法名避开 __ 前缀（#29）',
-        when: 'template 转换返回 usesNavigate=true 时',
-        example: {
-            before: '（模板）<a href="/pages/user/index">用户</a>',
-            after: 'proteusNavigateTo(e) {\n  const ds = e.currentTarget.dataset\n  const url = String(ds.url || "")\n  if (!url) return\n  const nav = { url: url, fail: ... }\n  if (ds.routeType) nav.routeType = ds.routeType\n  wx.navigateTo(nav)\n},',
-        },
-        verify: 'tests/mp-transform.test.ts 导航链接用例；真机验证归档 #30',
-        source: 'src/compiler/script.ts → transformScriptToPage（usesNavigate 分支）',
-        decision: '#24 / #28 / #29 / #30',
-    },
-    {
-        id: 'script/onload-params',
-        phase: 'script',
-        status: 'implemented',
-        title: '默认 onLoad 参数自动 decode',
-        description: '无显式 onLoad 时注入默认实现：遍历 options → decodeURIComponent → 结构化值（{/[ 开头）JSON.parse → setData',
-        why: '路由参数经 query 传递，页面需还原为原始类型（决策 #19：仅对结构化值 JSON.parse，普通标量保持字符串——对齐 P3 契约 options.id === "1"）',
-        when: 'script 无显式 onLoad 时（有显式 onLoad 则透传）',
-        example: {
-            before: '（无 onLoad）',
-            after: 'onLoad(options) {\n  const params = {}\n  const keys = Object.keys(options || {})\n  for (let i = 0; i < keys.length; i++) {\n    ...\n  }\n  this.setData(params)\n},',
-        },
-        verify: 'tests/runtime.test.ts 参数 decode 用例',
-        source: 'src/compiler/script.ts → transformScriptToPage（onLoad 分支）',
-        decision: '#19 / #32（ES5 安全：索引循环 Object.keys）',
-    },
-    {
-        id: 'script/component-mode',
-        phase: 'script',
-        status: 'implemented',
-        title: '组件模式 → Component() 构造器',
-        description: 'isComponent=true（components 目录下）→ Component({ data, methods, ... })，页面 → Page({ ... })',
-        why: '小程序页面用 Page()，组件用 Component()（不同构造器形态，isComponent 分支已在 compiler/index.ts 透传）',
-        when: '文件路径包含 components/ 目录时',
-        example: { before: '（组件 SFC）', after: 'Component({ data: {...}, ... })' },
-        verify: 'tests/mp-transform.test.ts 组件形态用例',
-        source: 'src/compiler/script.ts → transformScriptToPage（isComponent 分支）',
-    },
-    {
-        id: 'script/es5-safe',
-        phase: 'script',
-        status: 'implemented',
-        title: '生成代码 ES5 安全',
-        description: '产物规避 ?? / ?. / 数组解构 / 对象展开（显式 null 检查三元、索引循环 Object.keys、直接属性赋值）',
-        why: '微信开发者工具将页面 JS 转 ES5 时依赖 babel helper 模块，helper 不在包内会报错（#32：arrayWithHoles 未定义）；真机预览直接报 ?? 语法错误（#36）',
-        when: '所有生成的 JS 产物（方法体 / onLoad / 自动 handler）',
-        example: {
-            before: '// 禁止出现在产物中\nconst [a, b] = arr\nconst v = x ?? 0',
-            after: '// 产物实际形态\nconst a = arr[0], b = arr[1]\nconst v = (x === undefined || x === null ? 0 : x)',
-        },
-        verify: 'grep 扫描产物零残留（决策 #36 验证方式）',
-        source: 'src/compiler/script.ts 各处（numOrZero / onLoad 实现 / nav handler）',
-        decision: '#32 / #36',
-    },
-];

package/dist/transforms/style.js

@@ -1,74 +0,0 @@
-// src/compiler/transforms/style.ts
-// style 阶段编译规则注册表 —— 每条规则一份 AI 说明书
-import { TAG_MAP, SEMANTIC_CLASS } from '../tags';
-export const STYLE_RULES = [
-    {
-        id: 'style/px-to-rpx',
-        phase: 'style',
-        status: 'implemented',
-        title: 'px → rpx（仅 MP 端编译期生效）',
-        description: 'CSS 数值 px → rpx（rpxRatio 默认 2：48px → 96rpx）；Web 端永不转换（Vite 原生处理）',
-        why: '小程序 rpx 是屏幕等比单位（750 设计稿），跨端 CSS 一致性的编译期吸收（决策 #9：MP 端 px→rpx，Web 端保持标准 CSS）',
-        when: 'style 中出现数值 px（style.px2rpx=true）时',
-        example: { before: 'padding: 48px;', after: 'padding: 96rpx;' },
-        verify: 'tests/mp-transform.test.ts px→rpx 用例',
-        source: 'src/compiler/style.ts → transformStyleToWxss（px2rpx 分支）',
-        decision: '#9',
-    },
-    {
-        id: 'style/selector-tag',
-        phase: 'style',
-        status: 'implemented',
-        title: '选择器 HTML 标签 → 小程序标签',
-        description: '选择器中的标签名重写为小程序标签（.links a → .links view、div > p → view > .proteus-p）；属性选择器/类名/ID/长标识符不误伤',
-        why: '模板已把 div/a/h1 等映射为 view/text，若样式选择器不重写则匹配不到元素（决策 #57 修复的 bug）；命中条件=标签位于选择器起始或组合器之后，避免 .a/#input/tag-a 误伤',
-        when: 'style 选择器中含 TAG_MAP 中的标签名时',
-        example: { before: '.links a { color: #1a7af8; }', after: '.links .proteus-a { color: #1a7af8; }' },
-        verify: 'tests/mp-transform.test.ts 选择器重写用例；产物验证 .links a → .links view 对齐 wxml（决策 #57）',
-        source: 'src/compiler/style.ts → rewriteTagSelectors + TAG_SELECTOR_RE',
-        decision: '#57',
-        mapping: { ...TAG_MAP },
-    },
-    {
-        id: 'style/selector-semantic',
-        phase: 'style',
-        status: 'implemented',
-        title: '语义标签选择器 → proteus-* 类选择器',
-        description: 'h1-h6/p/a 选择器映射为基础类选择器（.card h3 → .card .proteus-h3、.links a → .links .proteus-a），而非标签',
-        why: 'h3 与 p 都映射为 text，若都映射为标签，同特异性规则后写覆盖先写（决策 #61 修复：.card p 的 color 曾污染 h3）；模板侧已附加 proteus-* 类故精确匹配',
-        when: '选择器中含 h1-h6/p/a 标签时',
-        example: { before: '.card h3 { font-weight: 700; }', after: '.card .proteus-h3 { font-weight: 700; }' },
-        verify: 'tests/mp-transform.test.ts 选择器重写用例（showcase.wxss 两条规则独立）',
-        source: 'src/compiler/style.ts → rewriteTagSelectors（semantic 分支）+ src/compiler/tags.ts SEMANTIC_CLASS',
-        decision: '#61',
-        mapping: { ...SEMANTIC_CLASS },
-    },
-    {
-        id: 'style/semantic-base-wxss',
-        phase: 'style',
-        status: 'implemented',
-        title: '注入语义基础 WXSS（h1-h6/p/a 视觉还原）',
-        description: '产物 WXSS 头部注入 .proteus-h1~h6/.proteus-p/.proteus-a 基础样式（对齐 HTML 标准附录 D：字号/字重/单边 em 段距/链接色），位于用户样式之前',
-        why: 'Web 浏览器有 UA 默认样式，小程序 text/view 没有；注入基础类还原两端视觉一致（决策 #58）；margin 用单边 bottom + em 相对自身字号——Skyline 自研引擎不折叠 margin，单边 em 与 Web 折叠在主流程组合下视觉一致（决策 #59）',
-        when: '每次 style 转换（作为产物前缀）',
-        example: {
-            before: '// 源码无样式时产物仍含',
-            after: '.proteus-h1 { display: block; font-size: 64rpx; font-weight: 700; margin: 0 0 0.67em; }\n.proteus-p { display: block; margin: 0 0 1em; }\n.proteus-a { color: #1a7af8; text-decoration: underline; }',
-        },
-        verify: 'golden fixture showcase.wxss；产物验证 <text class="proteus-h1"> + .proteus-h1（决策 #58）',
-        source: 'src/compiler/style.ts → BASE_SEMANTIC_WXSS',
-        decision: '#58 / #59',
-    },
-    {
-        id: 'style/skyline-unsupported',
-        phase: 'style',
-        status: 'implemented',
-        title: 'Skyline 不支持属性编译期警告',
-        description: 'float、position: fixed 出现时编译期警告（不阻断构建）',
-        why: 'Skyline 自研渲染引擎不支持这些布局属性，编译期警告让开发者提前知道（反黑盒原则：警告可见、可统计）',
-        when: 'WXSS 中出现 float: 或 position: fixed 时',
-        example: { before: '.banner { position: fixed; }', after: '警告：WXSS 检测到 Skyline 不支持的属性：position: fixed（编译期警告）' },
-        verify: 'tests/mp-transform.test.ts 警告用例',
-        source: 'src/compiler/style.ts → transformStyleToWxss（unsupported 分支）',
-    },
-];