@qilitt-mickey/vue3-temp-skill 1.1.74 → 1.1.76

package/parser/loader.js

@@ -1,66 +1,66 @@
-/**
- * loader.js — mapping/ 目录读取与合并
- *
- * 递归遍历 mapping/ 下所有 .json 文件，按目录层级合并为完整映射数据集。
- * 合并顺序（后加载覆盖先加载，同 ID 时场景级扩展全局定义）：
- *   basic/ → layout/ → component/ → scenes/<scene>/
- */
-
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export const MAPPING_ROOT = path.resolve(__dirname, "..", "mapping");
-
-/** 递归收集 JSON 文件（按目录名字典序，保证合并顺序稳定） */
-function collectJsonFiles(dir) {
-  const out = [];
-  for (const name of readdirSync(dir).sort()) {
-    if (name.startsWith("_") || name.startsWith("."))
-      continue;
-    const full = path.join(dir, name);
-    const st = statSync(full);
-    if (st.isDirectory())
-      out.push(...collectJsonFiles(full));
-    else if (name.endsWith(".json"))
-      out.push(full);
-  }
-  return out;
-}
-
-/**
- * 构建映射数据集。
- * @returns {{ files: Record<string, object>, fileCount: number, ids: Record<string, {file, meta}> }}
- */
-export function buildMappingDataset() {
-  const files = {};
-  const idSource = {};
-
-  for (const filePath of collectJsonFiles(MAPPING_ROOT)) {
-    const rel = path.relative(MAPPING_ROOT, filePath).replaceAll("\\", "/");
-    let data;
-    try {
-      data = JSON.parse(readFileSync(filePath, "utf-8"));
-    }
-    catch (e) {
-      throw new Error(`[mapping/${rel}] JSON 解析失败：${e.message}`);
-    }
-    files[rel] = data;
-
-    if (data.mappings) {
-      for (const id of Object.keys(data.mappings)) {
-        if (id.startsWith("$"))
-          continue;
-        if (idSource[id])
-          console.warn(`  ⚠ 语义 ID「${id}」在 ${idSource[id].file} 与 ${rel} 中重复，后者覆盖`);
-        idSource[id] = { file: rel, meta: data.meta || {} };
-      }
-    }
-  }
-
-  return { files, fileCount: Object.keys(files).length, idSource };
-}
-
-/** 供 validator 使用的别名（保持独立可测） */
-export { buildMappingDataset as buildMappingDatasetForValidator };
+/**
+ * loader.js — mapping/ 目录读取与合并
+ *
+ * 递归遍历 mapping/ 下所有 .json 文件，按目录层级合并为完整映射数据集。
+ * 合并顺序（后加载覆盖先加载，同 ID 时场景级扩展全局定义）：
+ *   basic/ → layout/ → component/ → scenes/<scene>/
+ */
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const MAPPING_ROOT = path.resolve(__dirname, "..", "mapping");
+
+/** 递归收集 JSON 文件（按目录名字典序，保证合并顺序稳定） */
+function collectJsonFiles(dir) {
+  const out = [];
+  for (const name of readdirSync(dir).sort()) {
+    if (name.startsWith("_") || name.startsWith("."))
+      continue;
+    const full = path.join(dir, name);
+    const st = statSync(full);
+    if (st.isDirectory())
+      out.push(...collectJsonFiles(full));
+    else if (name.endsWith(".json"))
+      out.push(full);
+  }
+  return out;
+}
+
+/**
+ * 构建映射数据集。
+ * @returns {{ files: Record<string, object>, fileCount: number, ids: Record<string, {file, meta}> }}
+ */
+export function buildMappingDataset() {
+  const files = {};
+  const idSource = {};
+
+  for (const filePath of collectJsonFiles(MAPPING_ROOT)) {
+    const rel = path.relative(MAPPING_ROOT, filePath).replaceAll("\\", "/");
+    let data;
+    try {
+      data = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch (e) {
+      throw new Error(`[mapping/${rel}] JSON 解析失败：${e.message}`);
+    }
+    files[rel] = data;
+
+    if (data.mappings) {
+      for (const id of Object.keys(data.mappings)) {
+        if (id.startsWith("$"))
+          continue;
+        if (idSource[id])
+          console.warn(`  ⚠ 语义 ID「${id}」在 ${idSource[id].file} 与 ${rel} 中重复，后者覆盖`);
+        idSource[id] = { file: rel, meta: data.meta || {} };
+      }
+    }
+  }
+
+  return { files, fileCount: Object.keys(files).length, idSource };
+}
+
+/** 供 validator 使用的别名（保持独立可测） */
+export { buildMappingDataset as buildMappingDatasetForValidator };

package/parser/validator.js

@@ -1,206 +1,206 @@
-/**
- * validator.js — 映射规则校验器
- *
- * 对 mapping/ 目录合并后的映射数据集做全量校验：
- *   1. 字段完整性（必须字段存在且类型正确）
- *   2. 枚举合法性（type/forms 值域）
- *   3. 层级一致性（children 引用的 ID 必须存在于同级或同场景映射集）
- *   4.  三字段结构：anchors（kind/layer 枚举 + target 必填）、
- *      preconditions（非空字符串数组）、priority（strategy 枚举）
- *
- * 说明：selector / anchors.target 的「挂载点存在性」需要在**目标项目源码**里查证，
- * 本文件只做映射数据的自洽校验；存在性检查由 index.js 的 audit 子命令完成。
- *
- * 校验不通过：抛出带文件定位的错误并 exit 1（阻断构建）。
- *
- * 用法（由 index.js 调用，也可独立执行）：
- *   node parser/validator.js          # 校验 mapping/ 全目录
- */
-
-import { buildMappingDataset } from "./loader.js";
-
-/** 映射条目允许的 type 枚举 */
-const TYPE_ENUM = ["module", "component", "element", "global_component", "global_token"];
-
-/** 必须字段及其类型 */
-const REQUIRED_FIELDS = {
-  type: "string",
-  style_scope: "string",
-};
-
-/** 语义 ID 格式：小写字母数字 + 下划线 + 点分层级，最多 4 段 */
-const ID_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*){1,3}$/;
-
-/** anchors 承载通道类型枚举（class = 选择器锚点 / css_var = CSS 变量锚点 / attr = 属性锚点） */
-const ANCHOR_KINDS = ["class", "css_var", "attr"];
-
-/** 落点层级枚举：host = 宿主盒；inner = 内层文本盒（专治「值对了、位置不对」） */
-const LAYER_ENUM = ["host", "inner"];
-
-/** 覆写优先级策略枚举（design-apply 提权依据） */
-const PRIORITY_ENUM = ["scope_qualified", "self_plus_important", "deep_qualified"];
-
-export function validateMappingDataset(dataset) {
-  const errors = [];
-  const warnings = [];
-
-  for (const [file, data] of Object.entries(dataset.files)) {
-    // meta 校验
-    if (!data.meta) {
-      errors.push(`[${file}] 缺少 meta 节点`);
-      continue;
-    }
-    for (const key of ["layer", "version", "tech_stack"]) {
-      if (!data.meta[key])
-        errors.push(`[${file}] meta 缺少 ${key}`);
-    }
-
-    // tokens 型文件（basic/layout 域）：token 值必须是非空对象
-    if (data.tokens) {
-      for (const [field, def] of Object.entries(data.tokens)) {
-        if (field.startsWith("$"))
-          continue;
-        if (typeof def !== "object" || def === null)
-          errors.push(`[${file}] tokens.${field} 必须为对象`);
-        else if (!def.token && !def.value && !def.hook)
-          errors.push(`[${file}] tokens.${field} 缺少 token/value 定义`);
-      }
-    }
-
-    // mappings 型文件（component/scenes 域）：条目字段校验
-    if (data.mappings) {
-      for (const [id, entry] of Object.entries(data.mappings)) {
-        if (id.startsWith("$"))
-          continue;
-
-        // ID 命名规范
-        if (!ID_PATTERN.test(id))
-          errors.push(`[${file}] 语义 ID「${id}」不符合命名规范（小写下划线、2~4 段点分层级）`);
-
-        // 必须字段
-        for (const [field, kind] of Object.entries(REQUIRED_FIELDS)) {
-          if (typeof entry[field] !== kind)
-            errors.push(`[${file}] ${id} 缺少 ${field} 或类型非 ${kind}`);
-        }
-
-        // type 枚举
-        if (entry.type && !TYPE_ENUM.includes(entry.type))
-          errors.push(`[${file}] ${id}.type「${entry.type}」不在枚举 ${TYPE_ENUM.join("/")} 内`);
-
-        // css_vars / custom_style_map 必须为对象（可空对象）
-        for (const field of ["css_vars", "custom_style_map"]) {
-          if (entry[field] !== undefined && typeof entry[field] !== "object")
-            errors.push(`[${file}] ${id}.${field} 必须为对象`);
-        }
-
-        // css_vars 值必须以 -- 开头（EP/项目 CSS 变量约定）
-        if (entry.css_vars) {
-          for (const [k, v] of Object.entries(entry.css_vars)) {
-            if (typeof v === "string" && !v.trim().startsWith("--"))
-              errors.push(`[${file}] ${id}.css_vars.${k} 值「${v}」应为 CSS 变量名（-- 开头）`);
-          }
-        }
-
-        // anchors（ §3.2）：条目可承载的全部通道，含落点层级 layer
-        if (entry.anchors !== undefined) {
-          if (!Array.isArray(entry.anchors)) {
-            errors.push(`[${file}] ${id}.anchors 必须为数组`);
-          }
-          else {
-            let hasClassAnchor = false;
-            for (const [i, a] of entry.anchors.entries()) {
-              const at = `${id}.anchors[${i}]`;
-              if (!a || typeof a !== "object") {
-                errors.push(`[${file}] ${at} 必须为对象`);
-                continue;
-              }
-              if (!ANCHOR_KINDS.includes(a.kind))
-                errors.push(`[${file}] ${at}.kind「${a.kind}」不在枚举 ${ANCHOR_KINDS.join("/")} 内`);
-              if (a.kind === "class")
-                hasClassAnchor = true;
-              if (a.layer !== undefined && !LAYER_ENUM.includes(a.layer))
-                errors.push(`[${file}] ${at}.layer「${a.layer}」不在枚举 ${LAYER_ENUM.join("/")} 内`);
-              if (typeof a.target !== "string" || a.target.trim() === "")
-                errors.push(`[${file}] ${at}.target 必填且为非空字符串`);
-              else if (a.kind === "css_var" && !a.target.trim().startsWith("--"))
-                errors.push(`[${file}] ${at}.target「${a.target}」为 css_var 锚点时应为 CSS 变量名（-- 开头）`);
-            }
-            if (entry.anchors.length > 0 && !hasClassAnchor)
-              warnings.push(`[${file}] ${id}.anchors 无 class 锚点，样式类字段可能找不到落点选择器`);
-          }
-        }
-
-        // preconditions（ §3.2）：几何 / 取值成立的宿主前提，非空字符串数组
-        if (entry.preconditions !== undefined) {
-          if (!Array.isArray(entry.preconditions) || entry.preconditions.length === 0) {
-            errors.push(`[${file}] ${id}.preconditions 必须为非空字符串数组`);
-          }
-          else {
-            for (const [i, p] of entry.preconditions.entries()) {
-              if (typeof p !== "string" || p.trim() === "")
-                errors.push(`[${file}] ${id}.preconditions[${i}] 必须为非空字符串`);
-            }
-          }
-        }
-
-        // priority（ §4.6.4）：覆写优先级策略
-        if (entry.priority !== undefined) {
-          if (typeof entry.priority !== "object" || entry.priority === null) {
-            errors.push(`[${file}] ${id}.priority 必须为对象`);
-          }
-          else {
-            if (!PRIORITY_ENUM.includes(entry.priority.strategy))
-              errors.push(`[${file}] ${id}.priority.strategy「${entry.priority.strategy}」不在枚举 ${PRIORITY_ENUM.join("/")} 内`);
-            if (entry.priority.reason !== undefined && typeof entry.priority.reason !== "string")
-              errors.push(`[${file}] ${id}.priority.reason 必须为字符串`);
-          }
-        }
-      }
-    }
-  }
-
-  // 跨文件一致性：children 引用必须可解析（同场景合并字典内查找）
-  const mergedIndex = buildMergedIndex(dataset);
-  for (const [file, data] of Object.entries(dataset.files)) {
-    if (!data.mappings)
-      continue;
-    for (const [id, entry] of Object.entries(data.mappings)) {
-      if (id.startsWith("$") || !Array.isArray(entry.children))
-        continue;
-      for (const childId of entry.children) {
-        if (!mergedIndex[childId])
-          warnings.push(`[${file}] ${id}.children 引用的「${childId}」未在当前映射集中定义（可能是待补点位）`);
-      }
-    }
-  }
-
-  return { errors, warnings };
-}
-
-/** 合并全部 mappings 形成扁平索引（跨文件） */
-export function buildMergedIndex(dataset) {
-  const index = {};
-  for (const data of Object.values(dataset.files)) {
-    if (!data.mappings)
-      continue;
-    // 同 ID 后加载覆盖先加载（scenes 覆盖 component 全局定义，属预期扩展机制）
-    Object.assign(index, data.mappings);
-  }
-  return index;
-}
-
-// ---- CLI 独立执行 ----
-if (process.argv[1] && process.argv[1].endsWith("validator.js")) {
-  const dataset = buildMappingDataset();
-  const { errors, warnings } = validateMappingDataset(dataset);
-  for (const w of warnings)
-    console.warn(`  ⚠ ${w}`);
-  if (errors.length > 0) {
-    console.error(`\n✖ 映射表校验失败（${errors.length} 项）：`);
-    for (const e of errors)
-      console.error(`  ✘ ${e}`);
-    process.exit(1);
-  }
-  const count = Object.keys(buildMergedIndex(dataset)).length;
-  console.log(`✔ 映射表校验通过：${dataset.fileCount} 个文件，${count} 条语义映射，${warnings.length} 条警告`);
-}
+/**
+ * validator.js — 映射规则校验器
+ *
+ * 对 mapping/ 目录合并后的映射数据集做全量校验：
+ *   1. 字段完整性（必须字段存在且类型正确）
+ *   2. 枚举合法性（type/forms 值域）
+ *   3. 层级一致性（children 引用的 ID 必须存在于同级或同场景映射集）
+ *   4.  三字段结构：anchors（kind/layer 枚举 + target 必填）、
+ *      preconditions（非空字符串数组）、priority（strategy 枚举）
+ *
+ * 说明：selector / anchors.target 的「挂载点存在性」需要在**目标项目源码**里查证，
+ * 本文件只做映射数据的自洽校验；存在性检查由 index.js 的 audit 子命令完成。
+ *
+ * 校验不通过：抛出带文件定位的错误并 exit 1（阻断构建）。
+ *
+ * 用法（由 index.js 调用，也可独立执行）：
+ *   node parser/validator.js          # 校验 mapping/ 全目录
+ */
+
+import { buildMappingDataset } from "./loader.js";
+
+/** 映射条目允许的 type 枚举 */
+const TYPE_ENUM = ["module", "component", "element", "global_component", "global_token"];
+
+/** 必须字段及其类型 */
+const REQUIRED_FIELDS = {
+  type: "string",
+  style_scope: "string",
+};
+
+/** 语义 ID 格式：小写字母数字 + 下划线 + 点分层级，最多 4 段 */
+const ID_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*){1,3}$/;
+
+/** anchors 承载通道类型枚举（class = 选择器锚点 / css_var = CSS 变量锚点 / attr = 属性锚点） */
+const ANCHOR_KINDS = ["class", "css_var", "attr"];
+
+/** 落点层级枚举：host = 宿主盒；inner = 内层文本盒（专治「值对了、位置不对」） */
+const LAYER_ENUM = ["host", "inner"];
+
+/** 覆写优先级策略枚举（design-apply 提权依据） */
+const PRIORITY_ENUM = ["scope_qualified", "self_plus_important", "deep_qualified"];
+
+export function validateMappingDataset(dataset) {
+  const errors = [];
+  const warnings = [];
+
+  for (const [file, data] of Object.entries(dataset.files)) {
+    // meta 校验
+    if (!data.meta) {
+      errors.push(`[${file}] 缺少 meta 节点`);
+      continue;
+    }
+    for (const key of ["layer", "version", "tech_stack"]) {
+      if (!data.meta[key])
+        errors.push(`[${file}] meta 缺少 ${key}`);
+    }
+
+    // tokens 型文件（basic/layout 域）：token 值必须是非空对象
+    if (data.tokens) {
+      for (const [field, def] of Object.entries(data.tokens)) {
+        if (field.startsWith("$"))
+          continue;
+        if (typeof def !== "object" || def === null)
+          errors.push(`[${file}] tokens.${field} 必须为对象`);
+        else if (!def.token && !def.value && !def.hook)
+          errors.push(`[${file}] tokens.${field} 缺少 token/value 定义`);
+      }
+    }
+
+    // mappings 型文件（component/scenes 域）：条目字段校验
+    if (data.mappings) {
+      for (const [id, entry] of Object.entries(data.mappings)) {
+        if (id.startsWith("$"))
+          continue;
+
+        // ID 命名规范
+        if (!ID_PATTERN.test(id))
+          errors.push(`[${file}] 语义 ID「${id}」不符合命名规范（小写下划线、2~4 段点分层级）`);
+
+        // 必须字段
+        for (const [field, kind] of Object.entries(REQUIRED_FIELDS)) {
+          if (typeof entry[field] !== kind)
+            errors.push(`[${file}] ${id} 缺少 ${field} 或类型非 ${kind}`);
+        }
+
+        // type 枚举
+        if (entry.type && !TYPE_ENUM.includes(entry.type))
+          errors.push(`[${file}] ${id}.type「${entry.type}」不在枚举 ${TYPE_ENUM.join("/")} 内`);
+
+        // css_vars / custom_style_map 必须为对象（可空对象）
+        for (const field of ["css_vars", "custom_style_map"]) {
+          if (entry[field] !== undefined && typeof entry[field] !== "object")
+            errors.push(`[${file}] ${id}.${field} 必须为对象`);
+        }
+
+        // css_vars 值必须以 -- 开头（EP/项目 CSS 变量约定）
+        if (entry.css_vars) {
+          for (const [k, v] of Object.entries(entry.css_vars)) {
+            if (typeof v === "string" && !v.trim().startsWith("--"))
+              errors.push(`[${file}] ${id}.css_vars.${k} 值「${v}」应为 CSS 变量名（-- 开头）`);
+          }
+        }
+
+        // anchors（ §3.2）：条目可承载的全部通道，含落点层级 layer
+        if (entry.anchors !== undefined) {
+          if (!Array.isArray(entry.anchors)) {
+            errors.push(`[${file}] ${id}.anchors 必须为数组`);
+          }
+          else {
+            let hasClassAnchor = false;
+            for (const [i, a] of entry.anchors.entries()) {
+              const at = `${id}.anchors[${i}]`;
+              if (!a || typeof a !== "object") {
+                errors.push(`[${file}] ${at} 必须为对象`);
+                continue;
+              }
+              if (!ANCHOR_KINDS.includes(a.kind))
+                errors.push(`[${file}] ${at}.kind「${a.kind}」不在枚举 ${ANCHOR_KINDS.join("/")} 内`);
+              if (a.kind === "class")
+                hasClassAnchor = true;
+              if (a.layer !== undefined && !LAYER_ENUM.includes(a.layer))
+                errors.push(`[${file}] ${at}.layer「${a.layer}」不在枚举 ${LAYER_ENUM.join("/")} 内`);
+              if (typeof a.target !== "string" || a.target.trim() === "")
+                errors.push(`[${file}] ${at}.target 必填且为非空字符串`);
+              else if (a.kind === "css_var" && !a.target.trim().startsWith("--"))
+                errors.push(`[${file}] ${at}.target「${a.target}」为 css_var 锚点时应为 CSS 变量名（-- 开头）`);
+            }
+            if (entry.anchors.length > 0 && !hasClassAnchor)
+              warnings.push(`[${file}] ${id}.anchors 无 class 锚点，样式类字段可能找不到落点选择器`);
+          }
+        }
+
+        // preconditions（ §3.2）：几何 / 取值成立的宿主前提，非空字符串数组
+        if (entry.preconditions !== undefined) {
+          if (!Array.isArray(entry.preconditions) || entry.preconditions.length === 0) {
+            errors.push(`[${file}] ${id}.preconditions 必须为非空字符串数组`);
+          }
+          else {
+            for (const [i, p] of entry.preconditions.entries()) {
+              if (typeof p !== "string" || p.trim() === "")
+                errors.push(`[${file}] ${id}.preconditions[${i}] 必须为非空字符串`);
+            }
+          }
+        }
+
+        // priority（ §4.6.4）：覆写优先级策略
+        if (entry.priority !== undefined) {
+          if (typeof entry.priority !== "object" || entry.priority === null) {
+            errors.push(`[${file}] ${id}.priority 必须为对象`);
+          }
+          else {
+            if (!PRIORITY_ENUM.includes(entry.priority.strategy))
+              errors.push(`[${file}] ${id}.priority.strategy「${entry.priority.strategy}」不在枚举 ${PRIORITY_ENUM.join("/")} 内`);
+            if (entry.priority.reason !== undefined && typeof entry.priority.reason !== "string")
+              errors.push(`[${file}] ${id}.priority.reason 必须为字符串`);
+          }
+        }
+      }
+    }
+  }
+
+  // 跨文件一致性：children 引用必须可解析（同场景合并字典内查找）
+  const mergedIndex = buildMergedIndex(dataset);
+  for (const [file, data] of Object.entries(dataset.files)) {
+    if (!data.mappings)
+      continue;
+    for (const [id, entry] of Object.entries(data.mappings)) {
+      if (id.startsWith("$") || !Array.isArray(entry.children))
+        continue;
+      for (const childId of entry.children) {
+        if (!mergedIndex[childId])
+          warnings.push(`[${file}] ${id}.children 引用的「${childId}」未在当前映射集中定义（可能是待补点位）`);
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+/** 合并全部 mappings 形成扁平索引（跨文件） */
+export function buildMergedIndex(dataset) {
+  const index = {};
+  for (const data of Object.values(dataset.files)) {
+    if (!data.mappings)
+      continue;
+    // 同 ID 后加载覆盖先加载（scenes 覆盖 component 全局定义，属预期扩展机制）
+    Object.assign(index, data.mappings);
+  }
+  return index;
+}
+
+// ---- CLI 独立执行 ----
+if (process.argv[1] && process.argv[1].endsWith("validator.js")) {
+  const dataset = buildMappingDataset();
+  const { errors, warnings } = validateMappingDataset(dataset);
+  for (const w of warnings)
+    console.warn(`  ⚠ ${w}`);
+  if (errors.length > 0) {
+    console.error(`\n✖ 映射表校验失败（${errors.length} 项）：`);
+    for (const e of errors)
+      console.error(`  ✘ ${e}`);
+    process.exit(1);
+  }
+  const count = Object.keys(buildMergedIndex(dataset)).length;
+  console.log(`✔ 映射表校验通过：${dataset.fileCount} 个文件，${count} 条语义映射，${warnings.length} 条警告`);
+}