@vitarx/plugin-vite 0.0.1-alpha.0

package/dist/utils/jsx-helpers.js

@@ -0,0 +1,168 @@
+/**
+ * JSX 相关工具函数
+ * @module utils/jsx-helpers
+ */
+import * as t from '@babel/types';
+import { isJSXElement, isJSXText } from '@babel/types';
+import { DIRECTIVE_PREFIX, PURE_COMPILE_COMPONENTS } from '../constants/index.js';
+import { isWhitespaceJSXText } from './ast-guards.js';
+import { createError } from '../error.js';
+/**
+ * 获取 JSX 元素的名称
+ */
+export function getJSXElementName(node) {
+    const nameNode = node.openingElement.name;
+    return nameNode.type === 'JSXIdentifier' ? nameNode.name : null;
+}
+/**
+ * 判断名称是否为纯编译组件
+ */
+export function isPureCompileComponent(name) {
+    return PURE_COMPILE_COMPONENTS.includes(name);
+}
+/**
+ * 判断名称是否为组件（首字母大写）
+ */
+export function isComponent(name) {
+    return name[0] === name[0]?.toUpperCase();
+}
+/**
+ * 判断名称是否为原生元素
+ */
+export function isNativeElement(name) {
+    return !isComponent(name);
+}
+/**
+ * 根据名称获取 JSX 属性
+ */
+export function getJSXAttributeByName(node, name) {
+    for (const attr of node.openingElement.attributes) {
+        if (attr.type === 'JSXAttribute' &&
+            attr.name.type === 'JSXIdentifier' &&
+            attr.name.name === name) {
+            return attr;
+        }
+    }
+    return undefined;
+}
+/**
+ * 检查元素是否具有指定指令
+ */
+export function hasDirective(node, directiveName) {
+    for (const attr of node.openingElement.attributes) {
+        if (attr.type === 'JSXAttribute') {
+            const attrName = attr.name;
+            if (attrName.type === 'JSXNamespacedName') {
+                if (attrName.namespace.name === 'v' && attrName.name.name === directiveName.slice(2)) {
+                    return true;
+                }
+            }
+            else if (attrName.type === 'JSXIdentifier' && attrName.name === directiveName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * 获取指令的值
+ */
+export function getDirectiveValue(node, directiveName) {
+    for (const attr of node.openingElement.attributes) {
+        if (attr.type === 'JSXAttribute') {
+            const attrName = attr.name;
+            let matches = false;
+            if (attrName.type === 'JSXNamespacedName') {
+                matches = attrName.namespace.name === 'v' && attrName.name.name === directiveName.slice(2);
+            }
+            else if (attrName.type === 'JSXIdentifier') {
+                matches = attrName.name === directiveName;
+            }
+            if (matches) {
+                const value = attr.value;
+                if (value?.type === 'JSXExpressionContainer') {
+                    return value.expression;
+                }
+                if (value?.type === 'StringLiteral') {
+                    return value;
+                }
+                return t.booleanLiteral(true);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * 检查元素是否为 v-if 链的一部分
+ */
+export function isVIfChain(node) {
+    return (hasDirective(node, 'v-if') || hasDirective(node, 'v-else-if') || hasDirective(node, 'v-else'));
+}
+/**
+ * 检查元素是否有 v-if 指令
+ */
+export function isVIf(node) {
+    return hasDirective(node, 'v-if');
+}
+/**
+ * 检查元素是否有 v-else-if 指令
+ */
+export function isVElseIf(node) {
+    return hasDirective(node, 'v-else-if');
+}
+/**
+ * 检查元素是否有 v-else 指令
+ */
+export function isVElse(node) {
+    return hasDirective(node, 'v-else');
+}
+/**
+ * 移除元素上所有 v- 开头的指令属性
+ */
+export function removeVDirectives(node) {
+    node.openingElement.attributes = node.openingElement.attributes.filter(attr => {
+        if (attr.type === 'JSXAttribute' && attr.name.type === 'JSXIdentifier') {
+            return !attr.name.name.startsWith(DIRECTIVE_PREFIX);
+        }
+        return true;
+    });
+}
+/**
+ * 移除元素上指定名称的属性
+ */
+export function removeAttribute(node, attrName) {
+    const index = node.openingElement.attributes.findIndex(attr => {
+        if (attr.type === 'JSXAttribute') {
+            const name = attr.name;
+            if (name.type === 'JSXIdentifier')
+                return name.name === attrName;
+            if (name.type === 'JSXNamespacedName') {
+                return `${name.namespace.name}:${name.name.name}` === attrName;
+            }
+        }
+        return false;
+    });
+    if (index !== -1) {
+        node.openingElement.attributes.splice(index, 1);
+    }
+}
+/**
+ * 过滤掉空白文本子节点
+ */
+export function filterWhitespaceChildren(children) {
+    return children.filter(child => !isJSXText(child) || !isWhitespaceJSXText(child));
+}
+/**
+ * 校验 Match 组件必须在 Switch 内使用
+ * @param children - 子节点数组
+ */
+export function validateMatchInSwitch(children) {
+    for (const child of children) {
+        if (isJSXElement(child)) {
+            const childName = getJSXElementName(child);
+            if (childName === 'Match') {
+                throw createError('E012', child);
+            }
+        }
+    }
+}

package/dist/utils/pattern-helpers.js

@@ -0,0 +1,47 @@
+/**
+ * 从绑定模式中收集变量名
+ * 支持标识符、对象模式、数组模式
+ * @param pattern - 绑定模式
+ * @param variables - 变量名集合
+ */
+export function collectPatternBindings(pattern, variables) {
+    if (pattern.type === 'Identifier') {
+        variables.add(pattern.name);
+    }
+    else if (pattern.type === 'ObjectPattern') {
+        for (const prop of pattern.properties) {
+            if (prop.type === 'RestElement') {
+                collectPatternBindings(prop.argument, variables);
+            }
+            else {
+                collectPatternBindings(prop.value, variables);
+            }
+        }
+    }
+    else if (pattern.type === 'ArrayPattern') {
+        for (const elem of pattern.elements) {
+            if (elem) {
+                collectPatternBindings(elem, variables);
+            }
+        }
+    }
+}
+/**
+ * 从对象解构模式中收集变量名
+ * 专门用于 toRefs 解构场景
+ * @param pattern - 对象模式
+ * @param variables - 变量名集合
+ */
+export function collectObjectPatternBindings(pattern, variables) {
+    for (const prop of pattern.properties) {
+        if (prop.type === 'RestElement') {
+            collectPatternBindings(prop.argument, variables);
+        }
+        else if (prop.value.type === 'Identifier') {
+            variables.add(prop.value.name);
+        }
+        else if (prop.value.type === 'ObjectPattern') {
+            collectObjectPatternBindings(prop.value, variables);
+        }
+    }
+}

package/dist/utils/vif-helpers.js

@@ -0,0 +1,127 @@
+/**
+ * v-if 链处理工具模块
+ * 统一处理 v-if/v-else-if/v-else 链的验证和收集
+ * @module utils/vif-helpers
+ */
+import * as t from '@babel/types';
+import { isJSXElement, isJSXText } from '@babel/types';
+import { createError } from '../error.js';
+import { isWhitespaceJSXText } from './ast-guards.js';
+import { getDirectiveValue, hasDirective, isVElse, isVElseIf, isVIf, isVIfChain } from './jsx-helpers.js';
+/**
+ * 验证 v-if 链的合法性
+ */
+export function validateVIfChain(children) {
+    if (children.length === 0)
+        return;
+    if (!hasDirective(children[0], 'v-if')) {
+        throw createError('E008', children[0], 'First element must have v-if directive');
+    }
+    for (let i = 1; i < children.length; i++) {
+        const child = children[i];
+        const prevChild = children[i - 1];
+        const hasVElseIf = hasDirective(child, 'v-else-if');
+        const hasVElse = hasDirective(child, 'v-else');
+        if (!hasVElseIf && !hasVElse) {
+            throw createError('E008', child, 'Elements after v-if must have v-else-if or v-else directive');
+        }
+        if (hasVElse && i !== children.length - 1) {
+            throw createError('E008', child, 'v-else must be the last element');
+        }
+        if (hasVElseIf && hasDirective(prevChild, 'v-else')) {
+            throw createError('E008', child, 'v-else-if cannot follow v-else');
+        }
+    }
+}
+/**
+ * 从 JSX 元素数组收集 v-if 链信息
+ */
+export function collectVIfChainInfo(nodes) {
+    const conditions = [];
+    for (const node of nodes) {
+        const vIfValue = getDirectiveValue(node, 'v-if');
+        if (vIfValue) {
+            conditions.push(vIfValue);
+            continue;
+        }
+        const vElseIfValue = getDirectiveValue(node, 'v-else-if');
+        if (vElseIfValue) {
+            conditions.push(vElseIfValue);
+            continue;
+        }
+        if (hasDirective(node, 'v-else')) {
+            conditions.push(t.booleanLiteral(true));
+            continue;
+        }
+        throw createError('E008', node, 'Element missing v-if/v-else-if/v-else directive');
+    }
+    return { nodes, conditions, endIndex: nodes.length - 1 };
+}
+/**
+ * 收集 Fragment 中的 v-if 链
+ */
+export function collectFragmentVIfChains(children) {
+    const chains = [];
+    let i = 0;
+    while (i < children.length) {
+        const child = children[i];
+        if (isJSXText(child)) {
+            i++;
+            continue;
+        }
+        if (!isJSXElement(child)) {
+            i++;
+            continue;
+        }
+        if (!isVIfChain(child)) {
+            i++;
+            continue;
+        }
+        if (isVIf(child)) {
+            const chain = collectSingleChainFromFragment(children, i);
+            chains.push(chain);
+            i = chain.endIndex + 1;
+        }
+        else if (isVElseIf(child) || isVElse(child)) {
+            throw createError(isVElse(child) ? 'E003' : 'E004', child);
+        }
+        else {
+            i++;
+        }
+    }
+    return chains;
+}
+/**
+ * 从 Fragment 收集单个 v-if 链
+ */
+function collectSingleChainFromFragment(children, startIndex) {
+    const nodes = [children[startIndex]];
+    const conditions = [getDirectiveValue(nodes[0], 'v-if')];
+    let j = startIndex + 1;
+    while (j < children.length) {
+        const nextChild = children[j];
+        if (isJSXText(nextChild) && isWhitespaceJSXText(nextChild)) {
+            j++;
+            continue;
+        }
+        if (!isJSXElement(nextChild))
+            break;
+        if (!isVIfChain(nextChild))
+            break;
+        if (isVElseIf(nextChild)) {
+            nodes.push(nextChild);
+            conditions.push(getDirectiveValue(nextChild, 'v-else-if'));
+            j++;
+        }
+        else if (isVElse(nextChild)) {
+            nodes.push(nextChild);
+            conditions.push(t.booleanLiteral(true));
+            j++;
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    return { nodes, conditions, endIndex: j - 1 };
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@vitarx/plugin-vite",
+  "version": "0.0.1-alpha.0",
+  "description": "The official plugin for Vitarx support in Vite.",
+  "author": "ZhuChongLin <8210856@qq.com>",
+  "license": "MIT",
+  "keywords": [
+    "vitarx",
+    "vite-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/vitarx/plugin-vite.git"
+  },
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "peerDependencies": {
+    "vitarx": "^4.0.0-0",
+    "vite": "^8.0.0-0"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.29.1",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.4.2",
+    "@commitlint/config-conventional": "^20.4.2",
+    "@commitlint/types": "^20.4.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/node": "^25.3.2",
+    "husky": "^9.1.7",
+    "node": "^25.7.0",
+    "rimraf": "^6.1.3",
+    "vitarx": "^4.0.0-beta.0",
+    "vite": "^8.0.0-beta.16",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "test": "vitest run",
+    "release": "release-cli"
+  }
+}