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

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

@@ -1,7 +1,67 @@
+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
+));
+
+// ../../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 fs from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 import process from "node:process";
 function hasCompileInfo(modulePath, list, preList) {
   const mergeList = Array.isArray(preList) ? [...preList, ...list] : list;
@@ -14,17 +74,34 @@ function hasCompileInfo(modulePath, list, preList) {
 }
 function getAbsolutePath(workPath, pagePath, src) {
   if (src.startsWith("/")) {
-    return path.join(workPath, src);
+    return path2.join(workPath, src);
   }
   if (pagePath.includes("/miniprogram_npm/")) {
     const componentDir = pagePath.split("/").slice(0, -1).join("/");
     const componentFullPath = workPath + componentDir;
-    return path.resolve(componentFullPath, src);
+    return path2.resolve(componentFullPath, src);
   }
   const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
-  return path.resolve(workPath, relativePath, src);
+  return path2.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;
@@ -32,21 +109,20 @@ function collectAssets(workPath, pagePath, src, targetPath, appId) {
   if (!/\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(src)) {
     return src;
   }
-  const relativePath = pagePath.split("/").slice(0, -1).join("/");
-  const absolutePath = src.startsWith("/") ? workPath + src : path.resolve(workPath, relativePath, src);
+  const absolutePath = resolveAssetSourcePath(workPath, pagePath, src);
   if (assetsMap[absolutePath]) {
     return assetsMap[absolutePath];
   }
   try {
     const ext = `.${src.split(".").pop()}`;
-    const dirPath = absolutePath.split(path.sep).slice(0, -1).join("/");
+    const dirPath = absolutePath.split(path2.sep).slice(0, -1).join("/");
     const prefix = uuid(dirPath);
     const targetStatic = `${targetPath}/main/static`;
     if (!fs.existsSync(targetStatic)) {
       fs.mkdirSync(targetStatic, { recursive: true });
     }
     getFilesWithExtension(dirPath, ext).forEach((file) => {
-      fs.copyFileSync(path.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+      fs.copyFileSync(path2.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
     });
     const filename = src.split("/").pop();
     const pathPrefix = process.env.ASSETS_PATH_PREFIX ? "" : "/";
@@ -58,7 +134,7 @@ function collectAssets(workPath, pagePath, src, targetPath, appId) {
 }
 function getFilesWithExtension(directory, extension) {
   const files = fs.readdirSync(directory);
-  const filteredFiles = files.filter((file) => path.extname(file) === extension);
+  const filteredFiles = files.filter((file) => path2.extname(file) === extension);
   return filteredFiles;
 }
 function isObjectEmpty(objectName) {
@@ -75,7 +151,8 @@ function transformRpx(styleText) {
     return styleText;
   }
   return styleText.replace(/([+-]?\d+(?:\.\d+)?)rpx/g, (_, pixel) => {
-    return `${Number(pixel)}rem`;
+    const viewportWidth = Number((Number(pixel) / 7.5).toFixed(6));
+    return `${Object.is(viewportWidth, -0) ? 0 : viewportWidth}vw`;
   });
 }
 function uuid(str) {
@@ -83,7 +160,7 @@ function uuid(str) {
 }
 var tagWhiteList = [
   "page",
-  "wrapper",
+  "component-host",
   "block",
   "button",
   "camera",
@@ -124,6 +201,24 @@ 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];
 }
@@ -133,36 +228,8 @@ import fs3 from "node:fs";
 import os from "node:os";
 import path4 from "node:path";
 import process2 from "node:process";
-
-// ../../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(/^\//, "");
-}
+import { parseSync } from "oxc-parser";
+import { walk } from "oxc-walker";
 
 // ../../dimina/fe/packages/compiler/src/common/npm-resolver.js
 import fs2 from "node:fs";
@@ -372,6 +439,12 @@ var DEFAULT_TEMPLATE_EXTS = [".wxml", ".ddml"];
 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,
@@ -526,6 +599,50 @@ 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 = path4.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;
+  }
+  const dependencyName = `dimina-${uuid(CUSTOM_TAB_BAR_COMPONENT_PATH)}`;
+  const internalConfig = {
+    usingComponents: {
+      [dependencyName]: CUSTOM_TAB_BAR_COMPONENT_PATH
+    }
+  };
+  storeComponentConfig(internalConfig, path4.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) => {
@@ -581,6 +698,7 @@ 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;
@@ -589,6 +707,7 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
       id: uuid(moduleId),
       path: moduleId,
       component: isComponent,
+      styleIsolation,
       usingComponents: cComponents
     };
     if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) {
@@ -596,6 +715,65 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
     }
   }
 }
+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) => fs3.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) {
@@ -667,7 +845,10 @@ function getPages() {
     return {
       id: uuid(path5),
       path: path5,
-      usingComponents: mergedComponents
+      appStyleScopeId: getAppStyleScopeId(),
+      sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
+      usingComponents: mergedComponents,
+      customTabBar: pageInfo[path5]?.customTabBar
     };
   });
   const subPages = {};
@@ -683,7 +864,10 @@ function getPages() {
         return {
           id: uuid(fullPath),
           path: fullPath,
-          usingComponents: mergedComponents
+          appStyleScopeId: getAppStyleScopeId(),
+          sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
+          usingComponents: mergedComponents,
+          customTabBar: pageInfo[fullPath]?.customTabBar
         };
       })
     };
@@ -693,13 +877,44 @@ function getPages() {
     subPages
   };
 }
+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,
+  toMiniProgramModuleId,
   hasCompileInfo,
   getAbsolutePath,
   collectAssets,
   transformRpx,
   tagWhiteList,
+  miniProgramBuiltinTags,
   __resetAssets,
   storeInfo,
   resetStoreInfo,