@dimina-kit/compiler 0.0.2-dev.20260718095333 → 0.0.2-dev.20260728063215

package/dist/compile-core.node.js

@@ -16,15 +16,18 @@ import {
   resetStoreInfo,
   setFs,
   storeInfo
-} from "./compile-core.node-chunks/chunk-QVEZ34FP.js";
+} from "./compile-core.node-chunks/chunk-M62ZDT7T.js";
 
 // ../../dimina/fe/packages/compiler/src/common/publish.js
-function createDist() {
+function createDist(seedPath) {
   const distPath = getTargetPath();
   if (fs_default.existsSync(distPath)) {
     fs_default.rmSync(distPath, { recursive: true, force: true });
   }
   fs_default.mkdirSync(distPath, { recursive: true });
+  if (seedPath && fs_default.existsSync(seedPath)) {
+    fs_default.cpSync(seedPath, distPath, { recursive: true });
+  }
 }
 
 // ../../dimina/fe/packages/compiler/src/core/config-compiler.js
@@ -65,9 +68,10 @@ var config_compiler_default = compileConfig;
 // ../../dimina/fe/packages/compiler/src/common/npm-builder.js
 import path from "node:path";
 var NpmBuilder = class {
-  constructor(workPath, targetPath) {
+  constructor(workPath, targetPath, dependencyGraph = null) {
     this.workPath = workPath;
     this.targetPath = targetPath;
+    this.dependencyGraph = dependencyGraph;
     this.builtPackages = /* @__PURE__ */ new Set();
     this.packageDependencies = /* @__PURE__ */ new Map();
   }
@@ -160,6 +164,7 @@ var NpmBuilder = class {
         await this.copyPackageFiles(sourceItemPath, targetItemPath);
       } else {
         if (this.isMiniprogramFile(item.name)) {
+          this.dependencyGraph?.addFile("app", sourceItemPath, "config");
           fs_default.copyFileSync(sourceItemPath, targetItemPath);
         }
       }
@@ -254,9 +259,9 @@ var NpmBuilder = class {
 
 // src/compile-core.js
 var STAGE_IMPORTERS = {
-  logic: () => import("./compile-core.node-chunks/logic-compiler-VJWEQMXZ.js"),
-  view: () => import("./compile-core.node-chunks/view-compiler-3OUFRVZF.js"),
-  style: () => import("./compile-core.node-chunks/style-compiler-YWVITCJW.js")
+  logic: () => import("./compile-core.node-chunks/logic-compiler-AEZPY2MO.js"),
+  view: () => import("./compile-core.node-chunks/view-compiler-2SMUHAPD.js"),
+  style: () => import("./compile-core.node-chunks/style-compiler-4PHMBQIC.js")
 };
 var stageLoads = /* @__PURE__ */ new Map();
 var stageModules = /* @__PURE__ */ new Map();

package/dist/pool.node-chunks/{chunk-7F3E2G42.js → chunk-CKQISGZS.js}

@@ -226,7 +226,7 @@ function __resetAssets() {
 // ../../dimina/fe/packages/compiler/src/env.js
 import fs3 from "node:fs";
 import os from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import process2 from "node:process";
 import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
@@ -431,11 +431,164 @@ var NpmResolver = class {
   }
 };
 
+// ../../dimina/fe/packages/compiler/src/common/dependency-graph.js
+import path4 from "node:path";
+function normalizeFilePath(filePath) {
+  return path4.resolve(filePath);
+}
+function normalizeKinds(kinds) {
+  if (!kinds) return null;
+  return new Set(Array.isArray(kinds) ? kinds : [kinds]);
+}
+var DependencyGraph = class _DependencyGraph {
+  constructor(snapshot) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.dependencies = /* @__PURE__ */ new Map();
+    this.dependents = /* @__PURE__ */ new Map();
+    this.fileOwners = /* @__PURE__ */ new Map();
+    this.fileKinds = /* @__PURE__ */ new Map();
+    if (snapshot) {
+      this.merge(snapshot);
+    }
+  }
+  addNode(id, metadata = {}) {
+    if (!id) return null;
+    const current = this.nodes.get(id) || {
+      id,
+      type: "module",
+      entry: false,
+      packageRoot: null,
+      files: /* @__PURE__ */ new Set()
+    };
+    if (metadata.type) current.type = metadata.type;
+    if (metadata.entry === true) current.entry = true;
+    if (metadata.packageRoot !== void 0) current.packageRoot = metadata.packageRoot;
+    this.nodes.set(id, current);
+    for (const filePath of metadata.files || []) {
+      this.addFile(id, filePath);
+    }
+    return current;
+  }
+  addFile(id, filePath, kind = "module") {
+    if (!id || !filePath) return;
+    const node = this.addNode(id);
+    const normalizedPath = normalizeFilePath(filePath);
+    node.files.add(normalizedPath);
+    const owners = this.fileOwners.get(normalizedPath) || /* @__PURE__ */ new Set();
+    owners.add(id);
+    this.fileOwners.set(normalizedPath, owners);
+    const ownerKinds = this.fileKinds.get(normalizedPath) || /* @__PURE__ */ new Map();
+    const kinds = ownerKinds.get(id) || /* @__PURE__ */ new Set();
+    kinds.add(kind);
+    ownerKinds.set(id, kinds);
+    this.fileKinds.set(normalizedPath, ownerKinds);
+  }
+  addDependency(from, to, kind = "module") {
+    if (!from || !to) return;
+    this.addNode(from);
+    this.addNode(to);
+    const outgoing = this.dependencies.get(from) || /* @__PURE__ */ new Map();
+    const kinds = outgoing.get(to) || /* @__PURE__ */ new Set();
+    kinds.add(kind);
+    outgoing.set(to, kinds);
+    this.dependencies.set(from, outgoing);
+    const incoming = this.dependents.get(to) || /* @__PURE__ */ new Map();
+    const reverseKinds = incoming.get(from) || /* @__PURE__ */ new Set();
+    reverseKinds.add(kind);
+    incoming.set(from, reverseKinds);
+    this.dependents.set(to, incoming);
+  }
+  getDirectDependencies(id, kinds) {
+    return this.#filterEdges(this.dependencies.get(id), kinds);
+  }
+  getDirectDependents(id, kinds) {
+    return this.#filterEdges(this.dependents.get(id), kinds);
+  }
+  getAffectedEntries(filePath) {
+    const owners = this.fileOwners.get(normalizeFilePath(filePath)) || /* @__PURE__ */ new Set();
+    const pending = [...owners];
+    const visited = /* @__PURE__ */ new Set();
+    const entries = /* @__PURE__ */ new Set();
+    while (pending.length > 0) {
+      const id = pending.pop();
+      if (visited.has(id)) continue;
+      visited.add(id);
+      const node = this.nodes.get(id);
+      if (node?.entry) entries.add(id);
+      for (const dependent of this.getDirectDependents(id)) {
+        pending.push(dependent);
+      }
+    }
+    return [...entries].sort();
+  }
+  hasFile(filePath) {
+    return this.fileOwners.has(normalizeFilePath(filePath));
+  }
+  getFileKinds(filePath) {
+    const ownerKinds = this.fileKinds.get(normalizeFilePath(filePath));
+    if (!ownerKinds) return [];
+    return [...new Set(
+      [...ownerKinds.values()].flatMap((kinds) => [...kinds])
+    )].sort();
+  }
+  merge(snapshotOrGraph) {
+    const snapshot = snapshotOrGraph instanceof _DependencyGraph ? snapshotOrGraph.toJSON() : snapshotOrGraph;
+    const fileEdges = snapshot?.fileEdges || [];
+    for (const node of snapshot?.nodes || []) {
+      this.addNode(node.id, { ...node, files: [] });
+      if (fileEdges.length === 0) {
+        for (const filePath of node.files || []) {
+          this.addFile(node.id, filePath);
+        }
+      }
+    }
+    for (const fileEdge of fileEdges) {
+      for (const kind of fileEdge.kinds || ["module"]) {
+        this.addFile(fileEdge.owner, fileEdge.file, kind);
+      }
+    }
+    for (const edge of snapshot?.edges || []) {
+      for (const kind of edge.kinds || ["module"]) {
+        this.addDependency(edge.from, edge.to, kind);
+      }
+    }
+    return this;
+  }
+  toJSON() {
+    return {
+      nodes: [...this.nodes.values()].map((node) => ({
+        id: node.id,
+        type: node.type,
+        entry: node.entry,
+        packageRoot: node.packageRoot,
+        files: [...node.files].sort()
+      })).sort((a, b) => a.id.localeCompare(b.id)),
+      edges: [...this.dependencies.entries()].flatMap(([from, targets]) => [...targets.entries()].map(([to, kinds]) => ({
+        from,
+        to,
+        kinds: [...kinds].sort()
+      }))).sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to)),
+      fileEdges: [...this.fileKinds.entries()].flatMap(([file, owners]) => [...owners.entries()].map(([owner, kinds]) => ({
+        file,
+        owner,
+        kinds: [...kinds].sort()
+      }))).sort((a, b) => a.file.localeCompare(b.file) || a.owner.localeCompare(b.owner))
+    };
+  }
+  #filterEdges(edges, kinds) {
+    if (!edges) return [];
+    const acceptedKinds = normalizeKinds(kinds);
+    return [...edges.entries()].filter(([, edgeKinds]) => !acceptedKinds || [...edgeKinds].some((kind) => acceptedKinds.has(kind))).map(([id]) => id);
+  }
+};
+
 // ../../dimina/fe/packages/compiler/src/env.js
 var pathInfo = {};
 var configInfo = {};
 var npmResolver = null;
+var dependencyGraph = new DependencyGraph();
 var DEFAULT_TEMPLATE_EXTS = [".wxml", ".ddml"];
+var DEFAULT_TEMPLATE_DIRECTIVE_PREFIXES = ["wx", "dd", "a"];
 var DEFAULT_STYLE_EXTS = [".wxss", ".ddss", ".less", ".scss", ".sass"];
 var DEFAULT_VIEW_SCRIPT_EXTS = [".wxs"];
 var DEFAULT_VIEW_SCRIPT_TAGS = ["wxs", "dds"];
@@ -490,29 +643,38 @@ function mergeUnique(builtins, custom, normalizer, reserved) {
 }
 function normalizeFileTypes(fileTypes = {}) {
   const ft = fileTypes || {};
+  const templateExts = mergeUnique(DEFAULT_TEMPLATE_EXTS, ft.template, normalizeExt, RESERVED_EXTS);
   return {
-    templateExts: mergeUnique(DEFAULT_TEMPLATE_EXTS, ft.template, normalizeExt, RESERVED_EXTS),
+    templateExts,
+    templateDirectivePrefixes: [.../* @__PURE__ */ new Set([...DEFAULT_TEMPLATE_DIRECTIVE_PREFIXES, ...templateExts.map((extension) => {
+      const name = extension.slice(1);
+      return name.endsWith("ml") ? name.slice(0, -2) : name;
+    }).filter(Boolean)])],
     styleExts: mergeUnique(DEFAULT_STYLE_EXTS, ft.style, normalizeExt, RESERVED_EXTS),
     viewScriptExts: mergeUnique(DEFAULT_VIEW_SCRIPT_EXTS, ft.viewScript, normalizeExt, RESERVED_EXTS),
     viewScriptTags: mergeUnique(DEFAULT_VIEW_SCRIPT_TAGS, ft.viewScript, normalizeTag)
   };
 }
 function storeInfo(workPath, options = {}) {
+  compilerOptions = normalizeFileTypes(options.fileTypes);
   storePathInfo(workPath);
   storeProjectConfig();
   storeAppConfig();
   storePageConfig();
-  compilerOptions = normalizeFileTypes(options.fileTypes);
+  dependencyGraph = createInitialDependencyGraph();
+  dependencyGraph.merge(options.dependencyGraph);
   return {
     pathInfo,
     configInfo,
-    compilerOptions
+    compilerOptions,
+    dependencyGraph: dependencyGraph.toJSON()
   };
 }
 function resetStoreInfo(opts) {
   pathInfo = opts.pathInfo;
   configInfo = opts.configInfo;
   compilerOptions = opts.compilerOptions || normalizeFileTypes();
+  dependencyGraph = new DependencyGraph(opts.dependencyGraph);
   if (pathInfo.workPath) {
     npmResolver = new NpmResolver(pathInfo.workPath);
   }
@@ -520,6 +682,9 @@ function resetStoreInfo(opts) {
 function getTemplateExts() {
   return compilerOptions.templateExts;
 }
+function getTemplateDirectivePrefixes() {
+  return compilerOptions.templateDirectivePrefixes || normalizeFileTypes({ template: compilerOptions.templateExts }).templateDirectivePrefixes;
+}
 function getStyleExts() {
   return compilerOptions.styleExts;
 }
@@ -529,13 +694,16 @@ function getViewScriptExts() {
 function getViewScriptTags() {
   return compilerOptions.viewScriptTags;
 }
+function getDependencyGraph() {
+  return dependencyGraph;
+}
 function storePathInfo(workPath) {
   pathInfo.workPath = workPath;
   if (process2.env.TARGET_PATH) {
     pathInfo.targetPath = process2.env.TARGET_PATH;
   } else {
     const tempDir = process2.env.GITHUB_WORKSPACE || os.tmpdir();
-    const targetDir = path4.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+    const targetDir = path5.join(tempDir, `dimina-fe-dist-${Date.now()}`);
     if (!fs3.existsSync(targetDir)) {
       fs3.mkdirSync(targetDir, { recursive: true });
     }
@@ -579,11 +747,11 @@ function storeAppConfig() {
   }
   configInfo.appInfo = newObj;
 }
-function getContentByPath(path5) {
-  return fs3.readFileSync(path5, { encoding: "utf-8" });
+function getContentByPath(path6) {
+  return fs3.readFileSync(path6, { encoding: "utf-8" });
 }
-function parseContentByPath(path5) {
-  return JSON.parse(getContentByPath(path5));
+function parseContentByPath(path6) {
+  return JSON.parse(getContentByPath(path6));
 }
 function storePageConfig() {
   const { pages, subPackages } = configInfo.appInfo;
@@ -606,7 +774,7 @@ function storeCustomTabBarConfig() {
   if (tabBar?.custom !== true || !Array.isArray(tabBar.list)) {
     return;
   }
-  const componentJsonPath = path4.join(pathInfo.workPath, "custom-tab-bar/index.json");
+  const componentJsonPath = path5.join(pathInfo.workPath, "custom-tab-bar/index.json");
   if (!fs3.existsSync(componentJsonPath)) {
     console.warn("[env] tabBar.custom \u5DF2\u542F\u7528\uFF0C\u4F46\u627E\u4E0D\u5230 custom-tab-bar/index.json");
     return;
@@ -617,7 +785,7 @@ function storeCustomTabBarConfig() {
       [dependencyName]: CUSTOM_TAB_BAR_COMPONENT_PATH
     }
   };
-  storeComponentConfig(internalConfig, path4.join(pathInfo.workPath, "app.json"));
+  storeComponentConfig(internalConfig, path5.join(pathInfo.workPath, "app.json"));
   const componentConfig = configInfo.componentInfo[CUSTOM_TAB_BAR_COMPONENT_PATH];
   if (componentConfig) {
     componentConfig.customTabBar = true;
@@ -674,12 +842,12 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
     if (configInfo.componentInfo[moduleId]) {
       continue;
     }
-    let componentFilePath = path4.resolve(getWorkPath(), `./${moduleId}.json`);
+    let componentFilePath = path5.resolve(getWorkPath(), `./${moduleId}.json`);
     let cContent = null;
     if (fs3.existsSync(componentFilePath)) {
       cContent = parseContentByPath(componentFilePath);
     } else {
-      const indexJsonPath = path4.resolve(getWorkPath(), `./${moduleId}/index.json`);
+      const indexJsonPath = path5.resolve(getWorkPath(), `./${moduleId}/index.json`);
       if (fs3.existsSync(indexJsonPath)) {
         componentFilePath = indexJsonPath;
         cContent = parseContentByPath(componentFilePath);
@@ -708,7 +876,8 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
       path: moduleId,
       component: isComponent,
       styleIsolation,
-      usingComponents: cComponents
+      usingComponents: cComponents,
+      componentPlaceholder: { ...cContent.componentPlaceholder || {} }
     };
     if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) {
       storeComponentConfig(configInfo.componentInfo[moduleId], componentFilePath);
@@ -839,16 +1008,17 @@ function transSubDir(name) {
 function getPages() {
   const { pages, subPackages = [], usingComponents: globalComponents = {} } = getAppConfigInfo();
   const pageInfo = getPageConfigInfo();
-  const mainPages = pages.map((path5) => {
-    const pageComponents = pageInfo[path5]?.usingComponents || {};
+  const mainPages = pages.map((path6) => {
+    const pageComponents = pageInfo[path6]?.usingComponents || {};
     const mergedComponents = { ...globalComponents, ...pageComponents };
     return {
-      id: uuid(path5),
-      path: path5,
+      id: uuid(path6),
+      path: path6,
       appStyleScopeId: getAppStyleScopeId(),
       sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
       usingComponents: mergedComponents,
-      customTabBar: pageInfo[path5]?.customTabBar
+      componentPlaceholder: { ...pageInfo[path6]?.componentPlaceholder || {} },
+      customTabBar: pageInfo[path6]?.customTabBar
     };
   });
   const subPages = {};
@@ -857,8 +1027,8 @@ function getPages() {
     const independent = subPkg.independent ? subPkg.independent : false;
     subPages[transSubDir(rootPath)] = {
       independent,
-      info: subPkg.pages.map((path5) => {
-        const fullPath = rootPath + path5;
+      info: subPkg.pages.map((path6) => {
+        const fullPath = rootPath + path6;
         const pageComponents = pageInfo[fullPath]?.usingComponents || {};
         const mergedComponents = { ...globalComponents, ...pageComponents };
         return {
@@ -867,6 +1037,7 @@ function getPages() {
           appStyleScopeId: getAppStyleScopeId(),
           sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
           usingComponents: mergedComponents,
+          componentPlaceholder: { ...pageInfo[fullPath]?.componentPlaceholder || {} },
           customTabBar: pageInfo[fullPath]?.customTabBar
         };
       })
@@ -877,6 +1048,92 @@ function getPages() {
     subPages
   };
 }
+function addExistingModuleFiles(graph, moduleId) {
+  const relativeId = moduleId.replace(/^\/+/, "");
+  const basePath = path5.resolve(getWorkPath(), relativeId);
+  const baseCandidates = [basePath, path5.join(basePath, "index")];
+  const extensions = [
+    ".json",
+    ".js",
+    ".ts",
+    ...getTemplateExts(),
+    ...getStyleExts(),
+    ...getViewScriptExts()
+  ];
+  for (const candidateBase of baseCandidates) {
+    for (const extension of extensions) {
+      const filePath = `${candidateBase}${extension}`;
+      if (fs3.existsSync(filePath)) {
+        graph.addFile(moduleId, filePath, getFileDependencyKind(filePath));
+      }
+    }
+  }
+}
+function getFileDependencyKind(filePath) {
+  const extension = path5.extname(filePath).toLowerCase();
+  if (extension === ".json") return "config";
+  if (extension === ".js" || extension === ".ts") return "logic";
+  if (getTemplateExts().includes(extension) || getViewScriptExts().includes(extension)) return "view";
+  if (getStyleExts().includes(extension)) return "style";
+  return "module";
+}
+function createInitialDependencyGraph() {
+  const graph = new DependencyGraph();
+  graph.addNode("app", { type: "app" });
+  for (const fileName of [
+    "app.json",
+    "app.js",
+    "app.ts",
+    "project.config.json",
+    "project.private.config.json"
+  ]) {
+    const filePath = path5.resolve(getWorkPath(), fileName);
+    if (fs3.existsSync(filePath)) {
+      graph.addFile("app", filePath, getFileDependencyKind(filePath));
+    }
+  }
+  addExistingModuleFiles(graph, "app");
+  for (const item of getAppConfigInfo().tabBar?.list || []) {
+    for (const field of ["iconPath", "selectedIconPath"]) {
+      if (!item[field]) continue;
+      const assetPath = resolveAssetSourcePath(getWorkPath(), "", item[field]);
+      if (fs3.existsSync(assetPath)) {
+        graph.addFile("app", assetPath, "config");
+      }
+    }
+  }
+  for (const component of Object.values(configInfo.componentInfo || {})) {
+    graph.addNode(component.path, { type: "component" });
+    addExistingModuleFiles(graph, component.path);
+  }
+  for (const component of Object.values(configInfo.componentInfo || {})) {
+    for (const dependencyPath of Object.values(component.usingComponents || {})) {
+      graph.addDependency(component.path, dependencyPath, "component");
+    }
+  }
+  const pages = getPages();
+  const addEntry = (page, packageRoot) => {
+    graph.addNode(page.path, {
+      type: "page",
+      entry: true,
+      packageRoot
+    });
+    addExistingModuleFiles(graph, page.path);
+    graph.addDependency(page.path, "app", "app");
+    for (const dependencyPath of Object.values(page.usingComponents || {})) {
+      graph.addDependency(page.path, dependencyPath, "component");
+    }
+  };
+  for (const page of pages.mainPages) {
+    addEntry(page, null);
+  }
+  for (const [packageRoot, subPackage] of Object.entries(pages.subPages)) {
+    for (const page of subPackage.info) {
+      addEntry(page, packageRoot);
+    }
+  }
+  return graph;
+}
 function collectSharedStyleScopeIds(usingComponents) {
   const result = [];
   const visited = /* @__PURE__ */ new Set();
@@ -911,6 +1168,7 @@ export {
   toMiniProgramModuleId,
   hasCompileInfo,
   getAbsolutePath,
+  resolveAssetSourcePath,
   collectAssets,
   transformRpx,
   tagWhiteList,
@@ -919,9 +1177,11 @@ export {
   storeInfo,
   resetStoreInfo,
   getTemplateExts,
+  getTemplateDirectivePrefixes,
   getStyleExts,
   getViewScriptExts,
   getViewScriptTags,
+  getDependencyGraph,
   getContentByPath,
   resolveAppAlias,
   getTargetPath,

package/dist/pool.node-chunks/{chunk-DQNLDQGT.js → chunk-LGB3AH5C.js}

@@ -1,13 +1,14 @@
 import {
   isMainThread
-} from "./chunk-KLXXOLDF.js";
+} from "./chunk-VHWKAXDL.js";
 import {
   __commonJS,
   __toESM,
+  getTemplateDirectivePrefixes,
   getViewScriptTags,
   miniProgramBuiltinTags,
   tagWhiteList
-} from "./chunk-7F3E2G42.js";
+} from "./chunk-CKQISGZS.js";
 
 // ../../dimina/fe/node_modules/.pnpm/@vue+shared@3.5.40/node_modules/@vue/shared/dist/shared.cjs.prod.js
 var require_shared_cjs_prod = __commonJS({
@@ -1395,6 +1396,8 @@ var supportedWxApis = [
   "hideKeyboard",
   "getNetworkType",
   "makePhoneCall",
+  "onUserCaptureScreen",
+  "offUserCaptureScreen",
   "extBridge",
   "extOnBridge",
   "extOffBridge"
@@ -1404,6 +1407,61 @@ var supportedWxApis = [
 var cachedReference = null;
 var warnedItems = /* @__PURE__ */ new Set();
 var pendingWarnings = [];
+var TEMPLATE_DIRECTIVE_NAMES = /* @__PURE__ */ new Set([
+  "if",
+  "elif",
+  "else",
+  "for",
+  "for-items",
+  "for-item",
+  "for-index",
+  "key"
+]);
+var KNOWN_NON_TEMPLATE_PREFIXES = /* @__PURE__ */ new Set([
+  "model",
+  "change",
+  "worklet",
+  "data",
+  "class",
+  "style",
+  "bind",
+  "mut-bind",
+  "catch",
+  "capture-bind",
+  "capture-mut-bind",
+  "capture-catch",
+  "mark",
+  "generic",
+  "extra-attr",
+  "slot",
+  "let"
+]);
+function splitAttributePrefix(attributeName) {
+  const segments = attributeName.split(":");
+  if (segments.length !== 2 || !segments[0] || !segments[1]) {
+    return null;
+  }
+  return { prefix: segments[0], name: segments[1] };
+}
+function getTemplateDirectiveName(attributeName) {
+  const attribute = splitAttributePrefix(attributeName);
+  if (!attribute || !getTemplateDirectivePrefixes().includes(attribute.prefix)) {
+    return null;
+  }
+  return TEMPLATE_DIRECTIVE_NAMES.has(attribute.name) ? attribute.name : null;
+}
+function getInvalidAttributePrefix(attributeName) {
+  const attribute = splitAttributePrefix(attributeName);
+  if (!attribute) return null;
+  const templatePrefixes = getTemplateDirectivePrefixes();
+  if (templatePrefixes.includes(attribute.prefix)) {
+    return TEMPLATE_DIRECTIVE_NAMES.has(attribute.name) ? null : attribute.prefix;
+  }
+  if (KNOWN_NON_TEMPLATE_PREFIXES.has(attribute.prefix)) {
+    return null;
+  }
+  return attribute.prefix;
+}
 function loadReference() {
   if (cachedReference) {
     return cachedReference;
@@ -1452,11 +1510,23 @@ function checkTemplateCompatibility(content, filePath, components = {}) {
   let parser;
   parser = new Parser(
     {
-      onopentag(tagName) {
+      onopentag(tagName, attrs) {
+        const line = getLineByIndex(content, parser.startIndex);
+        for (const attributeName of Object.keys(attrs)) {
+          const invalidPrefix = getInvalidAttributePrefix(attributeName);
+          if (invalidPrefix) {
+            const location = formatLocation(filePath, line);
+            warnOnce(
+              "template-prefix",
+              attributeName,
+              location,
+              `[compat] Invalid template attribute prefix: ${invalidPrefix}: (${attributeName})${location}`
+            );
+          }
+        }
         if (components?.[tagName]) {
           return;
         }
-        const line = getLineByIndex(content, parser.startIndex);
         warnUnsupportedComponent(tagName, filePath, line);
       },
       onerror(error) {
@@ -1513,6 +1583,7 @@ function takeCompatibilityWarnings() {
 }
 
 export {
+  getTemplateDirectiveName,
   getWxMemberName,
   warnUnsupportedWxApi,
   checkTemplateCompatibility,