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

package/dist/compile-core.node-chunks/chunk-23PCGQQU.js

@@ -0,0 +1,141 @@
+// src/shims/worker_threads.js
+var isMainThread = true;
+var parentPort = null;
+
+// ../../dimina/fe/packages/compiler/src/core/sourcemap.js
+import { SourceMapConsumer, SourceMapGenerator } from "source-map-js";
+function wrapModDefine(module) {
+  const code = module.code.endsWith("\n") ? module.code : module.code + "\n";
+  const extraLine = module.extraInfoCode || "";
+  const header = `modDefine('${module.path}', function(require, module, exports) {
+${extraLine}`;
+  const footer = "});\n";
+  return { header, code, footer };
+}
+function appendSourceMap(smg, map, lineOffset, columnOffset) {
+  const mapObject = typeof map === "string" ? JSON.parse(map) : map;
+  const consumer = new SourceMapConsumer(mapObject);
+  consumer.eachMapping((mapping) => {
+    if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {
+      return;
+    }
+    smg.addMapping({
+      generated: {
+        line: mapping.generatedLine + lineOffset,
+        column: mapping.generatedColumn + (mapping.generatedLine === 1 ? columnOffset : 0)
+      },
+      original: {
+        line: mapping.originalLine,
+        column: mapping.originalColumn
+      },
+      source: mapping.source,
+      name: mapping.name
+    });
+  });
+  if (mapObject.sourcesContent) {
+    mapObject.sources.forEach((source, index) => {
+      smg.setSourceContent(source, mapObject.sourcesContent[index]);
+    });
+  }
+}
+function advanceGeneratedPosition(position, code) {
+  const lines = code.split("\n");
+  if (lines.length === 1) {
+    position.column += code.length;
+    return;
+  }
+  position.line += lines.length - 1;
+  position.column = lines.at(-1).length;
+}
+function concatSourcemap(chunks, file = "") {
+  const smg = new SourceMapGenerator({ file });
+  const position = { line: 1, column: 0 };
+  let code = "";
+  for (const chunk of chunks) {
+    const chunkCode = typeof chunk === "string" ? chunk : chunk.code;
+    if (typeof chunk !== "string" && chunk.map) {
+      appendSourceMap(smg, chunk.map, position.line - 1, position.column);
+    }
+    code += chunkCode;
+    advanceGeneratedPosition(position, chunkCode);
+  }
+  return { code, sourcemap: smg.toString() };
+}
+function createLineSourcemap(generatedCode, source, sourceContent, startLine = 1) {
+  const smg = new SourceMapGenerator({ file: source });
+  const generatedLineCount = generatedCode.split("\n").length;
+  const sourceLineCount = Math.max(1, sourceContent.split("\n").length);
+  for (let line = 1; line <= generatedLineCount; line++) {
+    smg.addMapping({
+      generated: { line, column: 0 },
+      original: {
+        line: Math.min(sourceLineCount, startLine + line - 1),
+        column: 0
+      },
+      source
+    });
+  }
+  smg.setSourceContent(source, sourceContent);
+  return JSON.parse(smg.toString());
+}
+function mergeSourcemap(compileRes, file = "logic.js") {
+  const chunks = [];
+  for (const module of compileRes) {
+    const { header, code, footer } = wrapModDefine(module);
+    chunks.push(header, { code, map: module.map }, footer);
+  }
+  const { code: bundleCode, sourcemap } = concatSourcemap(chunks, file);
+  return { bundleCode, sourcemap };
+}
+function remapSourcemap(nextMap, prevMap) {
+  if (!nextMap) {
+    return prevMap;
+  }
+  if (!prevMap) {
+    return nextMap;
+  }
+  const nextMapObj = typeof nextMap === "string" ? JSON.parse(nextMap) : nextMap;
+  const prevMapObj = typeof prevMap === "string" ? JSON.parse(prevMap) : prevMap;
+  const smg = new SourceMapGenerator({ file: nextMapObj.file || prevMapObj.file || "" });
+  const prevSmc = new SourceMapConsumer(prevMapObj);
+  const nextSmc = new SourceMapConsumer(nextMapObj);
+  nextSmc.eachMapping((mapping) => {
+    if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {
+      return;
+    }
+    const original = prevSmc.originalPositionFor({
+      line: mapping.originalLine,
+      column: mapping.originalColumn
+    });
+    if (original.source == null || original.line == null || original.column == null) {
+      return;
+    }
+    smg.addMapping({
+      generated: {
+        line: mapping.generatedLine,
+        column: mapping.generatedColumn
+      },
+      original: {
+        line: original.line,
+        column: original.column
+      },
+      source: original.source,
+      name: original.name || mapping.name
+    });
+  });
+  if (prevMapObj.sourcesContent) {
+    prevMapObj.sources.forEach((src, i) => {
+      smg.setSourceContent(src, prevMapObj.sourcesContent[i]);
+    });
+  }
+  return smg.toString();
+}
+
+export {
+  isMainThread,
+  parentPort,
+  concatSourcemap,
+  createLineSourcemap,
+  mergeSourcemap,
+  remapSourcemap
+};

package/dist/compile-core.node-chunks/{chunk-QVEZ34FP.js → chunk-M62ZDT7T.js}

@@ -285,7 +285,7 @@ function __resetAssets() {
 
 // ../../dimina/fe/packages/compiler/src/env.js
 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";
@@ -489,11 +489,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 current2 = this.nodes.get(id) || {
+      id,
+      type: "module",
+      entry: false,
+      packageRoot: null,
+      files: /* @__PURE__ */ new Set()
+    };
+    if (metadata.type) current2.type = metadata.type;
+    if (metadata.entry === true) current2.entry = true;
+    if (metadata.packageRoot !== void 0) current2.packageRoot = metadata.packageRoot;
+    this.nodes.set(id, current2);
+    for (const filePath of metadata.files || []) {
+      this.addFile(id, filePath);
+    }
+    return current2;
+  }
+  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"];
@@ -548,29 +701,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);
   }
@@ -578,6 +740,9 @@ function resetStoreInfo(opts) {
 function getTemplateExts() {
   return compilerOptions.templateExts;
 }
+function getTemplateDirectivePrefixes() {
+  return compilerOptions.templateDirectivePrefixes || normalizeFileTypes({ template: compilerOptions.templateExts }).templateDirectivePrefixes;
+}
 function getStyleExts() {
   return compilerOptions.styleExts;
 }
@@ -587,13 +752,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 (!fs_default.existsSync(targetDir)) {
       fs_default.mkdirSync(targetDir, { recursive: true });
     }
@@ -637,11 +805,11 @@ function storeAppConfig() {
   }
   configInfo.appInfo = newObj;
 }
-function getContentByPath(path5) {
-  return fs_default.readFileSync(path5, { encoding: "utf-8" });
+function getContentByPath(path6) {
+  return fs_default.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;
@@ -664,7 +832,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 (!fs_default.existsSync(componentJsonPath)) {
     console.warn("[env] tabBar.custom \u5DF2\u542F\u7528\uFF0C\u4F46\u627E\u4E0D\u5230 custom-tab-bar/index.json");
     return;
@@ -675,7 +843,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;
@@ -732,12 +900,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 (fs_default.existsSync(componentFilePath)) {
       cContent = parseContentByPath(componentFilePath);
     } else {
-      const indexJsonPath = path4.resolve(getWorkPath(), `./${moduleId}/index.json`);
+      const indexJsonPath = path5.resolve(getWorkPath(), `./${moduleId}/index.json`);
       if (fs_default.existsSync(indexJsonPath)) {
         componentFilePath = indexJsonPath;
         cContent = parseContentByPath(componentFilePath);
@@ -766,7 +934,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);
@@ -897,16 +1066,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 = {};
@@ -915,8 +1085,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 {
@@ -925,6 +1095,7 @@ function getPages() {
           appStyleScopeId: getAppStyleScopeId(),
           sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
           usingComponents: mergedComponents,
+          componentPlaceholder: { ...pageInfo[fullPath]?.componentPlaceholder || {} },
           customTabBar: pageInfo[fullPath]?.customTabBar
         };
       })
@@ -935,6 +1106,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 (fs_default.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 (fs_default.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 (fs_default.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();
@@ -972,6 +1229,7 @@ export {
   toMiniProgramModuleId,
   hasCompileInfo,
   getAbsolutePath,
+  resolveAssetSourcePath,
   collectAssets,
   transformRpx,
   tagWhiteList,
@@ -980,9 +1238,11 @@ export {
   storeInfo,
   resetStoreInfo,
   getTemplateExts,
+  getTemplateDirectivePrefixes,
   getStyleExts,
   getViewScriptExts,
   getViewScriptTags,
+  getDependencyGraph,
   getContentByPath,
   resolveAppAlias,
   getTargetPath,