@dimina-kit/compiler 0.0.2-dev.20260728080958 → 0.0.2-dev.20260728110120

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

@@ -1,33 +1,3 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  try {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  } catch (e) {
-    throw mod = 0, e;
-  }
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
 // src/shims/fs.js
 var current = null;
 function setFs(impl) {
@@ -89,39 +59,8 @@ var fs = {
 };
 var fs_default = fs;
 
-// ../../dimina/fe/packages/compiler/src/common/path-utils.js
-import path from "node:path";
-var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
-function isWindowsFsPath(targetPath) {
-  return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
-}
-function getFsPathApi(targetPath) {
-  return isWindowsFsPath(targetPath) ? path.win32 : path.posix;
-}
-function normalizeToPosixPath(targetPath) {
-  return targetPath.replace(/\\/g, "/");
-}
-function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
-  const pathApi = getFsPathApi(importerPath || workPath);
-  return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
-}
-function toMiniProgramModuleId(resolvedPath, workPath) {
-  const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
-  const normalizedWorkPath = normalizeToPosixPath(workPath);
-  let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
-  moduleId = moduleId.replace(/\/+/g, "/");
-  if (!moduleId.startsWith("/")) {
-    moduleId = `/${moduleId}`;
-  }
-  return moduleId;
-}
-function getRelativePosixPath(targetPath, rootPath) {
-  return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
-}
-
 // ../../dimina/fe/packages/compiler/src/common/utils.js
-import crypto from "node:crypto";
-import path2 from "node:path";
+import path from "node:path";
 import process from "node:process";
 function hasCompileInfo(modulePath, list, preList) {
   const mergeList = Array.isArray(preList) ? [...preList, ...list] : list;
@@ -134,34 +73,17 @@ function hasCompileInfo(modulePath, list, preList) {
 }
 function getAbsolutePath(workPath, pagePath, src) {
   if (src.startsWith("/")) {
-    return path2.join(workPath, src);
+    return path.join(workPath, src);
   }
   if (pagePath.includes("/miniprogram_npm/")) {
     const componentDir = pagePath.split("/").slice(0, -1).join("/");
     const componentFullPath = workPath + componentDir;
-    return path2.resolve(componentFullPath, src);
+    return path.resolve(componentFullPath, src);
   }
   const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
-  return path2.resolve(workPath, relativePath, src);
+  return path.resolve(workPath, relativePath, src);
 }
 var assetsMap = {};
-function isPathInside(rootPath, targetPath) {
-  const relativePath = path2.relative(rootPath, targetPath);
-  return relativePath === "" || !relativePath.startsWith(`..${path2.sep}`) && relativePath !== ".." && !path2.isAbsolute(relativePath);
-}
-function resolveAssetSourcePath(workPath, pagePath, src) {
-  const projectRoot = path2.resolve(workPath);
-  if (src.startsWith("/")) {
-    return path2.resolve(projectRoot, `.${src}`);
-  }
-  const normalizedPagePath = path2.resolve(pagePath);
-  const pageDirectory = path2.isAbsolute(pagePath) && isPathInside(projectRoot, normalizedPagePath) ? path2.dirname(normalizedPagePath) : path2.resolve(projectRoot, path2.dirname(pagePath.replace(/^[/\\]+/, "")));
-  const resolvedPath = path2.resolve(pageDirectory, src);
-  if (isPathInside(projectRoot, resolvedPath)) {
-    return resolvedPath;
-  }
-  return path2.resolve(projectRoot, src.replace(/^(?:\.\.[/\\])+/, ""));
-}
 function collectAssets(workPath, pagePath, src, targetPath, appId) {
   if (src.startsWith("http") || src.startsWith("//")) {
     return src;
@@ -169,20 +91,21 @@ function collectAssets(workPath, pagePath, src, targetPath, appId) {
   if (!/\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(src)) {
     return src;
   }
-  const absolutePath = resolveAssetSourcePath(workPath, pagePath, src);
+  const relativePath = pagePath.split("/").slice(0, -1).join("/");
+  const absolutePath = src.startsWith("/") ? workPath + src : path.resolve(workPath, relativePath, src);
   if (assetsMap[absolutePath]) {
     return assetsMap[absolutePath];
   }
   try {
     const ext = `.${src.split(".").pop()}`;
-    const dirPath = absolutePath.split(path2.sep).slice(0, -1).join("/");
-    const prefix = uuid(dirPath);
+    const dirPath = absolutePath.split(path.sep).slice(0, -1).join("/");
+    const prefix = uuid();
     const targetStatic = `${targetPath}/main/static`;
     if (!fs_default.existsSync(targetStatic)) {
       fs_default.mkdirSync(targetStatic, { recursive: true });
     }
     getFilesWithExtension(dirPath, ext).forEach((file) => {
-      fs_default.copyFileSync(path2.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+      fs_default.copyFileSync(path.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
     });
     const filename = src.split("/").pop();
     const pathPrefix = process.env.ASSETS_PATH_PREFIX ? "" : "/";
@@ -194,7 +117,7 @@ function collectAssets(workPath, pagePath, src, targetPath, appId) {
 }
 function getFilesWithExtension(directory, extension) {
   const files = fs_default.readdirSync(directory);
-  const filteredFiles = files.filter((file) => path2.extname(file) === extension);
+  const filteredFiles = files.filter((file) => path.extname(file) === extension);
   return filteredFiles;
 }
 function isObjectEmpty(objectName) {
@@ -211,16 +134,15 @@ function transformRpx(styleText) {
     return styleText;
   }
   return styleText.replace(/([+-]?\d+(?:\.\d+)?)rpx/g, (_, pixel) => {
-    const viewportWidth = Number((Number(pixel) / 7.5).toFixed(6));
-    return `${Object.is(viewportWidth, -0) ? 0 : viewportWidth}vw`;
+    return `${Number(pixel)}rem`;
   });
 }
-function uuid(str) {
-  return crypto.createHash("sha256").update(str).digest().readBigUInt64BE(0).toString(36);
+function uuid() {
+  return Math.random().toString(36).slice(2, 7);
 }
 var tagWhiteList = [
   "page",
-  "component-host",
+  "wrapper",
   "block",
   "button",
   "camera",
@@ -261,34 +183,44 @@ var tagWhiteList = [
   "view",
   "web-view"
 ];
-var miniProgramBuiltinTags = /* @__PURE__ */ new Set([
-  ...tagWhiteList,
-  "canvas",
-  "match-media",
-  "page-container",
-  "share-element",
-  "editor",
-  "audio",
-  "channel-live",
-  "channel-video",
-  "live-player",
-  "live-pusher",
-  "voip-room",
-  "ad",
-  "ad-custom",
-  "official-account",
-  "xr-frame"
-]);
 function __resetAssets() {
   for (const k of Object.keys(assetsMap)) delete assetsMap[k];
 }
 
 // ../../dimina/fe/packages/compiler/src/env.js
 import os from "node:os";
-import path5 from "node:path";
+import path4 from "node:path";
 import process2 from "node:process";
-import { parseSync } from "oxc-parser";
-import { walk } from "oxc-walker";
+
+// ../../dimina/fe/packages/compiler/src/common/path-utils.js
+import path2 from "node:path";
+var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
+function isWindowsFsPath(targetPath) {
+  return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
+}
+function getFsPathApi(targetPath) {
+  return isWindowsFsPath(targetPath) ? path2.win32 : path2.posix;
+}
+function normalizeToPosixPath(targetPath) {
+  return targetPath.replace(/\\/g, "/");
+}
+function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
+  const pathApi = getFsPathApi(importerPath || workPath);
+  return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
+}
+function toMiniProgramModuleId(resolvedPath, workPath) {
+  const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
+  const normalizedWorkPath = normalizeToPosixPath(workPath);
+  let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
+  moduleId = moduleId.replace(/\/+/g, "/");
+  if (!moduleId.startsWith("/")) {
+    moduleId = `/${moduleId}`;
+  }
+  return moduleId;
+}
+function getRelativePosixPath(targetPath, rootPath) {
+  return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
+}
 
 // ../../dimina/fe/packages/compiler/src/common/npm-resolver.js
 import path3 from "node:path";
@@ -489,173 +421,14 @@ 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"];
-var CUSTOM_TAB_BAR_COMPONENT_PATH = "/custom-tab-bar/index";
-var STYLE_ISOLATION_VALUES = /* @__PURE__ */ new Set([
-  "isolated",
-  "apply-shared",
-  "shared"
-]);
 var RESERVED_EXTS = /* @__PURE__ */ new Set([
   ...DEFAULT_TEMPLATE_EXTS,
   ...DEFAULT_STYLE_EXTS,
@@ -701,38 +474,29 @@ 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,
-    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)])],
+    templateExts: mergeUnique(DEFAULT_TEMPLATE_EXTS, ft.template, normalizeExt, RESERVED_EXTS),
     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();
-  dependencyGraph = createInitialDependencyGraph();
-  dependencyGraph.merge(options.dependencyGraph);
+  compilerOptions = normalizeFileTypes(options.fileTypes);
   return {
     pathInfo,
     configInfo,
-    compilerOptions,
-    dependencyGraph: dependencyGraph.toJSON()
+    compilerOptions
   };
 }
 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);
   }
@@ -740,9 +504,6 @@ function resetStoreInfo(opts) {
 function getTemplateExts() {
   return compilerOptions.templateExts;
 }
-function getTemplateDirectivePrefixes() {
-  return compilerOptions.templateDirectivePrefixes || normalizeFileTypes({ template: compilerOptions.templateExts }).templateDirectivePrefixes;
-}
 function getStyleExts() {
   return compilerOptions.styleExts;
 }
@@ -752,16 +513,13 @@ 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 = path5.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+    const targetDir = path4.join(tempDir, `dimina-fe-dist-${Date.now()}`);
     if (!fs_default.existsSync(targetDir)) {
       fs_default.mkdirSync(targetDir, { recursive: true });
     }
@@ -805,11 +563,11 @@ function storeAppConfig() {
   }
   configInfo.appInfo = newObj;
 }
-function getContentByPath(path6) {
-  return fs_default.readFileSync(path6, { encoding: "utf-8" });
+function getContentByPath(path5) {
+  return fs_default.readFileSync(path5, { encoding: "utf-8" });
 }
-function parseContentByPath(path6) {
-  return JSON.parse(getContentByPath(path6));
+function parseContentByPath(path5) {
+  return JSON.parse(getContentByPath(path5));
 }
 function storePageConfig() {
   const { pages, subPackages } = configInfo.appInfo;
@@ -825,50 +583,6 @@ function storePageConfig() {
       collectionPageJson(subPkg.pages, subPkg.root);
     });
   }
-  storeCustomTabBarConfig();
-}
-function storeCustomTabBarConfig() {
-  const tabBar = configInfo.appInfo?.tabBar;
-  if (tabBar?.custom !== true || !Array.isArray(tabBar.list)) {
-    return;
-  }
-  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;
-  }
-  const dependencyName = `dimina-${uuid(CUSTOM_TAB_BAR_COMPONENT_PATH)}`;
-  const internalConfig = {
-    usingComponents: {
-      [dependencyName]: CUSTOM_TAB_BAR_COMPONENT_PATH
-    }
-  };
-  storeComponentConfig(internalConfig, path5.join(pathInfo.workPath, "app.json"));
-  const componentConfig = configInfo.componentInfo[CUSTOM_TAB_BAR_COMPONENT_PATH];
-  if (componentConfig) {
-    componentConfig.customTabBar = true;
-  }
-  for (const item of tabBar.list) {
-    const pagePath = typeof item?.pagePath === "string" ? item.pagePath.replace(/^\/+/, "") : "";
-    if (!pagePath || !configInfo.appInfo.pages?.includes(pagePath)) {
-      continue;
-    }
-    const pageConfig = configInfo.pageInfo[pagePath] ||= {};
-    pageConfig.usingComponents ||= {};
-    const declaredComponents = {
-      ...configInfo.appInfo.usingComponents || {},
-      ...pageConfig.usingComponents
-    };
-    const declaredEntry = Object.entries(declaredComponents).find(([, componentPath]) => componentPath === CUSTOM_TAB_BAR_COMPONENT_PATH);
-    let componentName = declaredEntry?.[0] || dependencyName;
-    let suffix = 0;
-    while (declaredComponents[componentName] && declaredComponents[componentName] !== CUSTOM_TAB_BAR_COMPONENT_PATH) {
-      suffix++;
-      componentName = `${dependencyName}-${suffix}`;
-    }
-    pageConfig.usingComponents[componentName] = CUSTOM_TAB_BAR_COMPONENT_PATH;
-    pageConfig.customTabBar = { componentName };
-  }
 }
 function collectionPageJson(pages, root) {
   pages.forEach((pagePath) => {
@@ -900,12 +614,12 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
     if (configInfo.componentInfo[moduleId]) {
       continue;
     }
-    let componentFilePath = path5.resolve(getWorkPath(), `./${moduleId}.json`);
+    let componentFilePath = path4.resolve(getWorkPath(), `./${moduleId}.json`);
     let cContent = null;
     if (fs_default.existsSync(componentFilePath)) {
       cContent = parseContentByPath(componentFilePath);
     } else {
-      const indexJsonPath = path5.resolve(getWorkPath(), `./${moduleId}/index.json`);
+      const indexJsonPath = path4.resolve(getWorkPath(), `./${moduleId}/index.json`);
       if (fs_default.existsSync(indexJsonPath)) {
         componentFilePath = indexJsonPath;
         cContent = parseContentByPath(componentFilePath);
@@ -924,83 +638,21 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
     }
     const cUsing = cContent.usingComponents || {};
     const isComponent = cContent.component || false;
-    const styleIsolation = resolveComponentStyleIsolation(cContent, componentFilePath);
     const cComponents = Object.keys(cUsing).reduce((acc, key) => {
       acc[key] = getModuleId(cUsing[key], componentFilePath);
       return acc;
     }, {});
     configInfo.componentInfo[moduleId] = {
-      id: uuid(moduleId),
+      id: uuid(),
       path: moduleId,
       component: isComponent,
-      styleIsolation,
-      usingComponents: cComponents,
-      componentPlaceholder: { ...cContent.componentPlaceholder || {} }
+      usingComponents: cComponents
     };
     if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) {
       storeComponentConfig(configInfo.componentInfo[moduleId], componentFilePath);
     }
   }
 }
-function getStaticProperty(objectExpression, propertyName) {
-  if (objectExpression?.type !== "ObjectExpression") {
-    return void 0;
-  }
-  return objectExpression.properties?.find((property) => {
-    if (property.type !== "Property" || property.computed) {
-      return false;
-    }
-    return property.key?.name === propertyName || property.key?.value === propertyName;
-  })?.value;
-}
-function normalizeStyleIsolation(value) {
-  return STYLE_ISOLATION_VALUES.has(value) ? value : void 0;
-}
-function resolveComponentStyleIsolation(componentConfig, componentJsonPath) {
-  const jsonValue = normalizeStyleIsolation(componentConfig?.styleIsolation);
-  if (jsonValue) {
-    return jsonValue;
-  }
-  const basePath = componentJsonPath.replace(/\.json$/i, "");
-  const scriptPath = [".js", ".ts"].map((ext) => `${basePath}${ext}`).find((candidate) => fs_default.existsSync(candidate));
-  if (!scriptPath) {
-    return "isolated";
-  }
-  try {
-    const source = getContentByPath(scriptPath);
-    const { program } = parseSync(scriptPath, source, {
-      sourceType: "unambiguous"
-    });
-    let extractedValue;
-    walk(program, {
-      enter(expression) {
-        if (extractedValue) {
-          return;
-        }
-        if (expression?.type !== "CallExpression" || expression.callee?.type !== "Identifier" || expression.callee.name !== "Component") {
-          return;
-        }
-        const definition = expression.arguments?.[0];
-        const options = getStaticProperty(definition, "options");
-        const styleIsolation = getStaticProperty(options, "styleIsolation")?.value;
-        const normalized = normalizeStyleIsolation(styleIsolation);
-        if (normalized) {
-          extractedValue = normalized;
-          return;
-        }
-        if (getStaticProperty(options, "addGlobalClass")?.value === true) {
-          extractedValue = "apply-shared";
-        }
-      }
-    });
-    if (extractedValue) {
-      return extractedValue;
-    }
-  } catch (error) {
-    console.warn(`[env] \u65E0\u6CD5\u89E3\u6790\u7EC4\u4EF6\u6837\u5F0F\u9694\u79BB\u914D\u7F6E ${scriptPath}: ${error.message}`);
-  }
-  return "isolated";
-}
 function getModuleId(src, pageFilePath) {
   const resolvedAlias = resolveAppAlias(src);
   if (resolvedAlias) {
@@ -1066,17 +718,13 @@ function transSubDir(name) {
 function getPages() {
   const { pages, subPackages = [], usingComponents: globalComponents = {} } = getAppConfigInfo();
   const pageInfo = getPageConfigInfo();
-  const mainPages = pages.map((path6) => {
-    const pageComponents = pageInfo[path6]?.usingComponents || {};
+  const mainPages = pages.map((path5) => {
+    const pageComponents = pageInfo[path5]?.usingComponents || {};
     const mergedComponents = { ...globalComponents, ...pageComponents };
     return {
-      id: uuid(path6),
-      path: path6,
-      appStyleScopeId: getAppStyleScopeId(),
-      sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
-      usingComponents: mergedComponents,
-      componentPlaceholder: { ...pageInfo[path6]?.componentPlaceholder || {} },
-      customTabBar: pageInfo[path6]?.customTabBar
+      id: uuid(),
+      path: path5,
+      usingComponents: mergedComponents
     };
   });
   const subPages = {};
@@ -1085,18 +733,14 @@ function getPages() {
     const independent = subPkg.independent ? subPkg.independent : false;
     subPages[transSubDir(rootPath)] = {
       independent,
-      info: subPkg.pages.map((path6) => {
-        const fullPath = rootPath + path6;
+      info: subPkg.pages.map((path5) => {
+        const fullPath = rootPath + path5;
         const pageComponents = pageInfo[fullPath]?.usingComponents || {};
         const mergedComponents = { ...globalComponents, ...pageComponents };
         return {
-          id: uuid(fullPath),
+          id: uuid(),
           path: fullPath,
-          appStyleScopeId: getAppStyleScopeId(),
-          sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
-          usingComponents: mergedComponents,
-          componentPlaceholder: { ...pageInfo[fullPath]?.componentPlaceholder || {} },
-          customTabBar: pageInfo[fullPath]?.customTabBar
+          usingComponents: mergedComponents
         };
       })
     };
@@ -1106,143 +750,23 @@ 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();
-  const visit = (componentPath) => {
-    if (visited.has(componentPath)) {
-      return;
-    }
-    visited.add(componentPath);
-    const component = configInfo.componentInfo[componentPath];
-    if (!component) {
-      return;
-    }
-    if (component.styleIsolation === "shared") {
-      result.push(component.id);
-    }
-    for (const childPath of Object.values(component.usingComponents || {})) {
-      visit(childPath);
-    }
-  };
-  for (const componentPath of Object.values(usingComponents || {})) {
-    visit(componentPath);
-  }
-  return result;
-}
-function getAppStyleScopeId() {
-  return uuid("app");
-}
 
 export {
-  __commonJS,
-  __toESM,
   setFs,
   resetFs,
   fs_default,
-  toMiniProgramModuleId,
   hasCompileInfo,
   getAbsolutePath,
-  resolveAssetSourcePath,
   collectAssets,
   transformRpx,
   tagWhiteList,
-  miniProgramBuiltinTags,
   __resetAssets,
   storeInfo,
   resetStoreInfo,
   getTemplateExts,
-  getTemplateDirectivePrefixes,
   getStyleExts,
   getViewScriptExts,
   getViewScriptTags,
-  getDependencyGraph,
   getContentByPath,
   resolveAppAlias,
   getTargetPath,