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

package/dist/pool.node-chunks/chunk-C7GEIDCP.js

@@ -0,0 +1,211 @@
+import {
+  getViewScriptTags
+} from "./chunk-7FGOYOXU.js";
+
+// ../../dimina/fe/packages/compiler/src/common/compatibility.js
+import { Parser } from "htmlparser2";
+
+// ../../dimina/fe/packages/compiler/src/common/compatibility-reference.js
+var supportedBuiltinComponents = [
+  "block",
+  "button",
+  "canvas",
+  "checkbox",
+  "checkbox-group",
+  "cover-image",
+  "cover-view",
+  "form",
+  "icon",
+  "image",
+  "input",
+  "label",
+  "movable-area",
+  "movable-view",
+  "navigation-bar",
+  "navigator",
+  "picker",
+  "picker-view",
+  "picker-view-column",
+  "progress",
+  "radio",
+  "radio-group",
+  "rich-text",
+  "scroll-view",
+  "slider",
+  "slot",
+  "swiper",
+  "swiper-item",
+  "switch",
+  "template",
+  "text",
+  "textarea",
+  "video",
+  "view",
+  "web-view",
+  "wxs",
+  "include",
+  "import"
+];
+var supportedWxApis = [
+  "env",
+  "canIUse",
+  "getUpdateManager",
+  "openSystemBluetoothSetting",
+  "getWindowInfo",
+  "getSystemSetting",
+  "getSystemInfoSync",
+  "getSystemInfoAsync",
+  "getSystemInfo",
+  "reLaunch",
+  "redirectTo",
+  "navigateTo",
+  "navigateBack",
+  "showToast",
+  "showModal",
+  "showLoading",
+  "showActionSheet",
+  "hideToast",
+  "hideLoading",
+  "setNavigationBarTitle",
+  "setNavigationBarColor",
+  "pageScrollTo",
+  "getMenuButtonBoundingClientRect",
+  "createAnimation",
+  "createCanvasContext",
+  "createOffscreenCanvas",
+  "canvasToTempFilePath",
+  "createSelectorQuery",
+  "createIntersectionObserver",
+  "request",
+  "downloadFile",
+  "uploadFile",
+  "setStorageSync",
+  "getStorageSync",
+  "removeStorageSync",
+  "clearStorageSync",
+  "setStorage",
+  "getStorage",
+  "removeStorage",
+  "clearStorage",
+  "getStorageInfoSync",
+  "getStorageInfo",
+  "saveImageToPhotosAlbum",
+  "previewImage",
+  "compressImage",
+  "chooseImage",
+  "chooseMedia",
+  "chooseContact",
+  "addPhoneContact",
+  "setClipboardData",
+  "getClipboardData",
+  "vibrateShort",
+  "vibrateLong",
+  "hideKeyboard",
+  "getNetworkType",
+  "makePhoneCall",
+  "extBridge",
+  "extOnBridge",
+  "extOffBridge"
+];
+
+// ../../dimina/fe/packages/compiler/src/common/compatibility.js
+var cachedReference = null;
+var warnedItems = /* @__PURE__ */ new Set();
+function loadReference() {
+  if (cachedReference) {
+    return cachedReference;
+  }
+  cachedReference = {
+    supportedBuiltinComponents: new Set(supportedBuiltinComponents),
+    supportedWxApis: new Set(supportedWxApis)
+  };
+  return cachedReference;
+}
+function getWxMemberName(node) {
+  if (node?.type !== "MemberExpression") {
+    return null;
+  }
+  if (node.object?.type !== "Identifier" || node.object.name !== "wx") {
+    return null;
+  }
+  if (!node.computed && node.property?.type === "Identifier") {
+    return node.property.name;
+  }
+  if (node.computed && (node.property?.type === "StringLiteral" || node.property?.type === "Literal") && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return null;
+}
+function warnUnsupportedWxApi(apiName, filePath, line) {
+  const { supportedWxApis: supportedWxApis2 } = loadReference();
+  if (!apiName || supportedWxApis2.has(apiName)) {
+    return;
+  }
+  const location = formatLocation(filePath, line);
+  warnOnce("api", apiName, location, `[compat] Unsupported wx API: wx.${apiName}${location}`);
+}
+function warnUnsupportedComponent(tagName, filePath, line) {
+  const { supportedBuiltinComponents: supportedBuiltinComponents2 } = loadReference();
+  if (!tagName || supportedBuiltinComponents2.has(tagName) || getViewScriptTags().includes(tagName)) {
+    return;
+  }
+  const location = formatLocation(filePath, line);
+  warnOnce("component", tagName, location, `[compat] Unsupported or undeclared component: <${tagName}>${location}`);
+}
+function checkTemplateCompatibility(content, filePath, components = {}) {
+  let parser;
+  parser = new Parser(
+    {
+      onopentag(tagName) {
+        if (components?.[tagName]) {
+          return;
+        }
+        const line = getLineByIndex(content, parser.startIndex);
+        warnUnsupportedComponent(tagName, filePath, line);
+      },
+      onerror(error) {
+        console.warn("[compat]", `Failed to parse template for compatibility diagnostics: ${filePath}`, error.message);
+      }
+    },
+    {
+      xmlMode: true,
+      lowerCaseTags: false,
+      lowerCaseAttributeNames: false,
+      withStartIndices: true
+    }
+  );
+  parser.write(content);
+  parser.end();
+}
+function getLineByIndex(content, index) {
+  if (typeof index !== "number" || index < 0) {
+    return null;
+  }
+  let line = 1;
+  for (let i = 0; i < index; i++) {
+    if (content.charCodeAt(i) === 10) {
+      line++;
+    }
+  }
+  return line;
+}
+function formatLocation(filePath, line) {
+  if (!filePath) {
+    return "";
+  }
+  return line ? ` (${filePath}:${line})` : ` (${filePath})`;
+}
+function warnOnce(type, name, location, message) {
+  const key = `${type}:${name}:${location}`;
+  if (warnedItems.has(key)) {
+    return;
+  }
+  warnedItems.add(key);
+  console.warn(message);
+}
+
+export {
+  getWxMemberName,
+  warnUnsupportedWxApi,
+  checkTemplateCompatibility
+};

package/dist/pool.node-chunks/chunk-KLXXOLDF.js

@@ -0,0 +1,8 @@
+// src/shims/worker_threads.js
+var isMainThread = true;
+var parentPort = null;
+
+export {
+  isMainThread,
+  parentPort
+};

package/dist/pool.node-chunks/{chunk-WX4462A5.js → chunk-PDHO4Y56.js}

@@ -12,21 +12,18 @@ import {
   getViewScriptExts,
   getWorkPath,
   storeInfo
-} from "./chunk-CKQISGZS.js";
+} from "./chunk-7FGOYOXU.js";
 
 // ../../dimina/fe/packages/compiler/src/common/publish.js
 import path from "node:path";
 import process from "node:process";
 import fs from "node:fs";
-function createDist(seedPath) {
+function createDist() {
   const distPath = getTargetPath();
   if (fs.existsSync(distPath)) {
     fs.rmSync(distPath, { recursive: true, force: true });
   }
   fs.mkdirSync(distPath, { recursive: true });
-  if (seedPath && fs.existsSync(seedPath)) {
-    fs.cpSync(seedPath, distPath, { recursive: true });
-  }
 }
 function publishToDist(dist, useAppIdDir = true) {
   const distPath = getTargetPath();
@@ -132,10 +129,9 @@ var config_compiler_default = compileConfig;
 import fs3 from "node:fs";
 import path2 from "node:path";
 var NpmBuilder = class {
-  constructor(workPath, targetPath, dependencyGraph = null) {
+  constructor(workPath, targetPath) {
     this.workPath = workPath;
     this.targetPath = targetPath;
-    this.dependencyGraph = dependencyGraph;
     this.builtPackages = /* @__PURE__ */ new Set();
     this.packageDependencies = /* @__PURE__ */ new Map();
   }
@@ -228,7 +224,6 @@ var NpmBuilder = class {
         await this.copyPackageFiles(sourceItemPath, targetItemPath);
       } else {
         if (this.isMiniprogramFile(item.name)) {
-          this.dependencyGraph?.addFile("app", sourceItemPath, "config");
           fs3.copyFileSync(sourceItemPath, targetItemPath);
         }
       }
@@ -323,9 +318,9 @@ var NpmBuilder = class {
 
 // src/compile-core.js
 var STAGE_IMPORTERS = {
-  logic: () => import("./logic-compiler-P4T4OMTG.js"),
-  view: () => import("./view-compiler-2D7HPYIN.js"),
-  style: () => import("./style-compiler-W7EA2Y7R.js")
+  logic: () => import("./logic-compiler-BODAINZQ.js"),
+  view: () => import("./view-compiler-HOFFL63K.js"),
+  style: () => import("./style-compiler-TUNDVSR5.js")
 };
 var stageLoads = /* @__PURE__ */ new Map();
 var stageModules = /* @__PURE__ */ new Map();

package/dist/pool.node-chunks/{logic-compiler-P4T4OMTG.js → logic-compiler-BODAINZQ.js}

@@ -1,29 +1,24 @@
 import {
   getWxMemberName,
-  takeCompatibilityWarnings,
   warnUnsupportedWxApi
-} from "./chunk-LGB3AH5C.js";
+} from "./chunk-C7GEIDCP.js";
 import {
   isMainThread,
-  mergeSourcemap,
-  parentPort,
-  remapSourcemap
-} from "./chunk-VHWKAXDL.js";
+  parentPort
+} from "./chunk-KLXXOLDF.js";
 import {
   collectAssets,
   getAppConfigInfo,
   getAppId,
   getComponent,
   getContentByPath,
-  getDependencyGraph,
   getNpmResolver,
   getTargetPath,
   getWorkPath,
   hasCompileInfo,
   resetStoreInfo,
-  resolveAppAlias,
-  resolveAssetSourcePath
-} from "./chunk-CKQISGZS.js";
+  resolveAppAlias
+} from "./chunk-7FGOYOXU.js";
 
 // ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
 import fs from "node:fs";
@@ -32,6 +27,102 @@ import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
 import MagicString from "magic-string";
 import { transform } from "esbuild";
+
+// ../../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 mergeSourcemap(compileRes) {
+  const smg = new SourceMapGenerator({ file: "logic.js" });
+  let bundleCode = "";
+  let lineOffset = 0;
+  for (const module of compileRes) {
+    const { header, code, footer } = wrapModDefine(module);
+    bundleCode += header;
+    const headerLineCount = header.split("\n").length - 1;
+    lineOffset += headerLineCount;
+    if (module.map) {
+      const moduleMap = JSON.parse(module.map);
+      const smc = new SourceMapConsumer(moduleMap);
+      smc.eachMapping((mapping) => {
+        if (mapping.source == null) return;
+        smg.addMapping({
+          generated: {
+            line: mapping.generatedLine + lineOffset,
+            column: mapping.generatedColumn
+          },
+          original: {
+            line: mapping.originalLine,
+            column: mapping.originalColumn
+          },
+          source: mapping.source,
+          name: mapping.name
+        });
+      });
+      if (moduleMap.sourcesContent) {
+        moduleMap.sources.forEach((src, i) => {
+          smg.setSourceContent(src, moduleMap.sourcesContent[i]);
+        });
+      }
+    }
+    bundleCode += code;
+    lineOffset += code.split("\n").length - 1;
+    bundleCode += footer;
+    lineOffset += footer.split("\n").length - 1;
+  }
+  return { bundleCode, sourcemap: smg.toString() };
+}
+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();
+}
+
+// ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
 var processedModules = /* @__PURE__ */ new Set();
 var enableSourcemap = false;
 if (!isMainThread) {
@@ -66,11 +157,7 @@ ${error.stack}`);
       }
       await writeCompileRes(mainCompileRes, null);
       processedModules.clear();
-      parentPort.postMessage({
-        success: true,
-        compatibilityWarnings: takeCompatibilityWarnings(),
-        dependencyGraph: getDependencyGraph().toJSON()
-      });
+      parentPort.postMessage({ success: true });
     } catch (error) {
       processedModules.clear();
       parentPort.postMessage({
@@ -123,12 +210,18 @@ async function compileJS(pages, root, mainCompileRes, progress) {
   }
   return compileRes;
 }
-async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, activePaths = /* @__PURE__ */ new Set(), putMain = false) {
+async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, depthChain = [], putMain = false) {
   const currentPath = module.path;
-  if (!currentPath) {
+  if (depthChain.includes(currentPath)) {
+    console.warn("[logic]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
     return;
   }
-  if (activePaths.has(currentPath)) {
+  if (depthChain.length > 20) {
+    console.warn("[logic]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return;
+  }
+  depthChain = [...depthChain, currentPath];
+  if (!module.path) {
     return;
   }
   if (hasCompileInfo(module.path, compileRes, mainCompileRes)) {
@@ -145,7 +238,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     console.warn("[logic]", `\u627E\u4E0D\u5230\u6A21\u5757\u6587\u4EF6: ${src}`);
     return;
   }
-  getDependencyGraph().addFile(currentPath, modulePath, "logic");
   const diagnosticSource = modulePath.startsWith(getWorkPath()) ? modulePath.slice(getWorkPath().length) : src;
   const sourceCode = getContentByPath(modulePath);
   if (!sourceCode) {
@@ -166,19 +258,13 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
   const extraInfo = {
     path: module.path
   };
-  activePaths.add(currentPath);
   if (module.component) {
     extraInfo.component = true;
   }
   if (module.usingComponents) {
     const componentsObj = {};
     const allSubPackages = getAppConfigInfo().subPackages;
-    const graphDependencies = getDependencyGraph().getDirectDependencies(module.path, "component");
-    const componentDependencies = graphDependencies.length > 0 ? new Set(graphDependencies) : null;
     for (const [name, path] of Object.entries(module.usingComponents)) {
-      if (componentDependencies && !componentDependencies.has(path)) {
-        continue;
-      }
       let toMainSubPackage = true;
       if (packageName) {
         const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
@@ -195,7 +281,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
       if (!componentModule) {
         continue;
       }
-      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, activePaths, putMain || toMainSubPackage);
+      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, putMain || toMainSubPackage);
       componentsObj[name] = path;
     }
     extraInfo.usingComponents = componentsObj;
@@ -227,11 +313,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         );
       }
       if ((node.type === "StringLiteral" || node.type === "Literal") && isLocalAssetString(node.value)) {
-        getDependencyGraph().addFile(
-          currentPath,
-          resolveAssetSourcePath(getWorkPath(), modulePath, node.value),
-          "logic"
-        );
         pathReplacements.push({
           start: node.start,
           end: node.end,
@@ -247,7 +328,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
           if (requirePath) {
             const { id, shouldProcess } = resolveDependencyId(requirePath, modulePath, false);
             if (shouldProcess) {
-              getDependencyGraph().addDependency(currentPath, id, "logic");
               pathReplacements.push({
                 start: arg.start,
                 end: arg.end,
@@ -265,7 +345,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         if (importPath) {
           const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, true);
           if (shouldProcess) {
-            getDependencyGraph().addDependency(currentPath, id, "logic");
             pathReplacements.push({
               start: node.source.start,
               end: node.source.end,
@@ -283,7 +362,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         if (importPath) {
           const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, false);
           if (shouldProcess) {
-            getDependencyGraph().addDependency(currentPath, id, "logic");
             pathReplacements.push({
               start: importPathNode.start,
               end: importPathNode.end,
@@ -300,7 +378,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         if (exportPath) {
           const { id, shouldProcess } = resolveDependencyId(exportPath, modulePath, true);
           if (shouldProcess) {
-            getDependencyGraph().addDependency(currentPath, id, "logic");
             pathReplacements.push({
               start: node.source.start,
               end: node.source.end,
@@ -315,7 +392,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     }
   });
   for (const depId of dependenciesToProcess) {
-    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, activePaths, putMain);
+    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, depthChain, putMain);
   }
   for (const replacement of pathReplacements.reverse()) {
     s.overwrite(replacement.start, replacement.end, `'${replacement.newValue}'`);
@@ -356,7 +433,6 @@ 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);