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

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

@@ -1,3 +1,33 @@
+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) {
@@ -59,9 +89,39 @@ 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 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;
@@ -74,17 +134,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;
@@ -92,21 +169,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_default.existsSync(targetStatic)) {
       fs_default.mkdirSync(targetStatic, { recursive: true });
     }
     getFilesWithExtension(dirPath, ext).forEach((file) => {
-      fs_default.copyFileSync(path.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+      fs_default.copyFileSync(path2.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
     });
     const filename = src.split("/").pop();
     const pathPrefix = process.env.ASSETS_PATH_PREFIX ? "" : "/";
@@ -118,7 +194,7 @@ function collectAssets(workPath, pagePath, src, targetPath, appId) {
 }
 function getFilesWithExtension(directory, extension) {
   const files = fs_default.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) {
@@ -135,7 +211,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) {
@@ -143,7 +220,7 @@ function uuid(str) {
 }
 var tagWhiteList = [
   "page",
-  "wrapper",
+  "component-host",
   "block",
   "button",
   "camera",
@@ -184,6 +261,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];
 }
@@ -192,36 +287,8 @@ function __resetAssets() {
 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 path3 from "node:path";
@@ -430,6 +497,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,
@@ -584,6 +657,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 (!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, 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) => {
@@ -639,6 +756,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;
@@ -647,6 +765,7 @@ function storeComponentConfig(pageJsonContent, pageFilePath) {
       id: uuid(moduleId),
       path: moduleId,
       component: isComponent,
+      styleIsolation,
       usingComponents: cComponents
     };
     if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) {
@@ -654,6 +773,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) => 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) {
@@ -725,7 +903,10 @@ function getPages() {
     return {
       id: uuid(path5),
       path: path5,
-      usingComponents: mergedComponents
+      appStyleScopeId: getAppStyleScopeId(),
+      sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
+      usingComponents: mergedComponents,
+      customTabBar: pageInfo[path5]?.customTabBar
     };
   });
   const subPages = {};
@@ -741,7 +922,10 @@ function getPages() {
         return {
           id: uuid(fullPath),
           path: fullPath,
-          usingComponents: mergedComponents
+          appStyleScopeId: getAppStyleScopeId(),
+          sharedStyleScopeIds: collectSharedStyleScopeIds(mergedComponents),
+          usingComponents: mergedComponents,
+          customTabBar: pageInfo[fullPath]?.customTabBar
         };
       })
     };
@@ -751,16 +935,47 @@ 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,
   setFs,
   resetFs,
   fs_default,
+  toMiniProgramModuleId,
   hasCompileInfo,
   getAbsolutePath,
   collectAssets,
   transformRpx,
   tagWhiteList,
+  miniProgramBuiltinTags,
   __resetAssets,
   storeInfo,
   resetStoreInfo,

package/dist/compile-core.node-chunks/{logic-compiler-4BUMLGSW.js → logic-compiler-VJWEQMXZ.js}

@@ -1,7 +1,8 @@
 import {
   getWxMemberName,
+  takeCompatibilityWarnings,
   warnUnsupportedWxApi
-} from "./chunk-3MOLMQLJ.js";
+} from "./chunk-6734LXNU.js";
 import {
   isMainThread,
   parentPort
@@ -19,7 +20,7 @@ import {
   hasCompileInfo,
   resetStoreInfo,
   resolveAppAlias
-} from "./chunk-O5CWW2ZX.js";
+} from "./chunk-QVEZ34FP.js";
 
 // ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
 import { resolve, sep } from "node:path";
@@ -157,7 +158,10 @@ ${error.stack}`);
       }
       await writeCompileRes(mainCompileRes, null);
       processedModules.clear();
-      parentPort.postMessage({ success: true });
+      parentPort.postMessage({
+        success: true,
+        compatibilityWarnings: takeCompatibilityWarnings()
+      });
     } catch (error) {
       processedModules.clear();
       parentPort.postMessage({
@@ -210,18 +214,12 @@ async function compileJS(pages, root, mainCompileRes, progress) {
   }
   return compileRes;
 }
-async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, depthChain = [], putMain = false) {
+async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, activePaths = /* @__PURE__ */ new Set(), putMain = false) {
   const currentPath = module.path;
-  if (depthChain.includes(currentPath)) {
-    console.warn("[logic]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
-    return;
-  }
-  if (depthChain.length > 20) {
-    console.warn("[logic]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+  if (!currentPath) {
     return;
   }
-  depthChain = [...depthChain, currentPath];
-  if (!module.path) {
+  if (activePaths.has(currentPath)) {
     return;
   }
   if (hasCompileInfo(module.path, compileRes, mainCompileRes)) {
@@ -258,6 +256,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
   const extraInfo = {
     path: module.path
   };
+  activePaths.add(currentPath);
   if (module.component) {
     extraInfo.component = true;
   }
@@ -281,7 +280,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
       if (!componentModule) {
         continue;
       }
-      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, putMain || toMainSubPackage);
+      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, activePaths, putMain || toMainSubPackage);
       componentsObj[name] = path;
     }
     extraInfo.usingComponents = componentsObj;
@@ -392,7 +391,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     }
   });
   for (const depId of dependenciesToProcess) {
-    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, depthChain, putMain);
+    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, activePaths, putMain);
   }
   for (const replacement of pathReplacements.reverse()) {
     s.overwrite(replacement.start, replacement.end, `'${replacement.newValue}'`);
@@ -433,6 +432,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     compileInfo.code = modifiedCode;
   }
   processedModules.add(packageName + currentPath);
+  activePaths.delete(currentPath);
 }
 function isLocalAssetString(value) {
   return typeof value === "string" && !value.startsWith("http") && !value.startsWith("//") && (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) && /\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(value);