@dimina/compiler 1.0.12-beta.9 → 1.0.13

package/dist/index.js

@@ -1,462 +1,2 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { Worker } from "node:worker_threads";
-import { Listr } from "listr2";
-import process from "node:process";
-import fs from "node:fs";
-import { g as getTargetPath, f as getAppId, k as getAppName, l as getPageConfigInfo, j as getAppConfigInfo, s as storeInfo, d as getWorkPath, m as getPages } from "./env-Csj3AHY4.js";
-import os from "node:os";
-const artCode = `
-██████╗ ██╗███╗   ███╗██╗███╗   ██╗ █████╗
-██╔══██╗██║████╗ ████║██║████╗  ██║██╔══██╗
-██║  ██║██║██╔████╔██║██║██╔██╗ ██║███████║
-██║  ██║██║██║╚██╔╝██║██║██║╚██╗██║██╔══██║
-██████╔╝██║██║ ╚═╝ ██║██║██║ ╚████║██║  ██║
-╚═════╝ ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝
-`;
-function artCode$1() {
-  console.log(artCode);
-}
-function createDist() {
-  const distPath = getTargetPath();
-  if (fs.existsSync(distPath)) {
-    fs.rmSync(distPath, { recursive: true, force: true });
-  }
-  fs.mkdirSync(distPath, { recursive: true });
-}
-function publishToDist(dist, useAppIdDir = true) {
-  const distPath = getTargetPath();
-  const appId = getAppId();
-  const absolutePath = useAppIdDir ? `${path.resolve(process.cwd(), dist)}${path.sep}${appId}` : `${path.resolve(process.cwd(), dist)}`;
-  if (fs.existsSync(absolutePath)) {
-    fs.rmSync(absolutePath, { recursive: true, force: true });
-  }
-  fs.mkdirSync(absolutePath, { recursive: true });
-  function copyDir(src, dest) {
-    fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-      if (entry.isDirectory()) {
-        copyDir(srcPath, destPath);
-      } else {
-        fs.copyFileSync(srcPath, destPath);
-      }
-    }
-  }
-  copyDir(distPath, absolutePath);
-}
-function getCGroupCPUCount() {
-  try {
-    const quotaPath = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
-    const periodPath = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
-    if (fs.existsSync(quotaPath) && fs.existsSync(periodPath)) {
-      const quota = Number.parseInt(fs.readFileSync(quotaPath, "utf8"));
-      const period = Number.parseInt(fs.readFileSync(periodPath, "utf8"));
-      if (quota > 0) {
-        return Math.max(1, Math.floor(quota / period));
-      }
-    }
-  } catch (e) {
-    console.warn("Failed to read CPU limits from cgroup:", e.message);
-  }
-  return os.cpus().length;
-}
-function getCGroupMemoryLimit() {
-  try {
-    const memLimitPath = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
-    if (fs.existsSync(memLimitPath)) {
-      const memLimit = Number.parseInt(fs.readFileSync(memLimitPath, "utf8"));
-      if (memLimit < Number.Infinity && memLimit > 0) {
-        return memLimit;
-      }
-    }
-  } catch (e) {
-    console.warn("Failed to read memory limits from cgroup:", e.message);
-  }
-  return os.totalmem();
-}
-const MAX_WORKERS = Math.max(1, Math.min(4, Math.floor(getCGroupCPUCount() / 4)));
-class WorkerPool {
-  constructor(maxWorkers = MAX_WORKERS) {
-    this.maxWorkers = maxWorkers;
-    this.activeWorkers = 0;
-    this.queue = [];
-    this.memoryLimit = Math.floor(getCGroupMemoryLimit() * 0.6 / maxWorkers);
-  }
-  async runWorker(workerCreator) {
-    if (this.activeWorkers >= this.maxWorkers) {
-      await new Promise((resolve) => this.queue.push(resolve));
-    }
-    this.activeWorkers++;
-    try {
-      return await workerCreator();
-    } finally {
-      this.activeWorkers--;
-      if (this.queue.length > 0) {
-        const next = this.queue.shift();
-        next();
-      }
-    }
-  }
-  getWorkerOptions() {
-    const memoryMb = Math.floor(this.memoryLimit / (1024 * 1024));
-    return {
-      resourceLimits: {
-        maxOldGenerationSizeMb: Math.max(256, memoryMb),
-        // 最少 256MB
-        maxYoungGenerationSizeMb: Math.max(64, Math.floor(memoryMb / 4)),
-        // 最少 64MB
-        codeRangeSizeMb: 64
-        // 减少代码范围大小从 128MB 到 64MB
-      }
-    };
-  }
-}
-const workerPool = new WorkerPool();
-class NpmBuilder {
-  constructor(workPath, targetPath) {
-    this.workPath = workPath;
-    this.targetPath = targetPath;
-    this.builtPackages = /* @__PURE__ */ new Set();
-    this.packageDependencies = /* @__PURE__ */ new Map();
-  }
-  /**
-   * 构建 npm 包
-   * 扫描 miniprogram_npm 目录并构建相关包
-   */
-  async buildNpmPackages() {
-    const miniprogramNpmPaths = this.findMiniprogramNpmDirs();
-    for (const npmPath of miniprogramNpmPaths) {
-      await this.buildNpmDir(npmPath);
-    }
-  }
-  /**
-   * 查找所有 miniprogram_npm 目录
-   * @returns {string[]} miniprogram_npm 目录路径数组
-   */
-  findMiniprogramNpmDirs() {
-    const npmDirs = [];
-    const scanDir = (dir, relativePath = "") => {
-      if (!fs.existsSync(dir)) {
-        return;
-      }
-      const items = fs.readdirSync(dir, { withFileTypes: true });
-      for (const item of items) {
-        if (item.isDirectory()) {
-          const itemPath = path.join(dir, item.name);
-          const itemRelativePath = relativePath ? `${relativePath}/${item.name}` : item.name;
-          if (item.name === "miniprogram_npm") {
-            npmDirs.push(itemRelativePath);
-          } else {
-            scanDir(itemPath, itemRelativePath);
-          }
-        }
-      }
-    };
-    scanDir(this.workPath);
-    return npmDirs;
-  }
-  /**
-   * 构建指定的 miniprogram_npm 目录
-   * @param {string} npmDirPath miniprogram_npm 目录路径
-   */
-  async buildNpmDir(npmDirPath) {
-    const fullNpmPath = path.join(this.workPath, npmDirPath);
-    if (!fs.existsSync(fullNpmPath)) {
-      return;
-    }
-    const packages = fs.readdirSync(fullNpmPath, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name);
-    for (const packageName of packages) {
-      await this.buildPackage(packageName, npmDirPath);
-    }
-  }
-  /**
-   * 构建单个 npm 包
-   * @param {string} packageName 包名
-   * @param {string} npmDirPath miniprogram_npm 目录路径
-   */
-  async buildPackage(packageName, npmDirPath) {
-    const packageKey = `${npmDirPath}/${packageName}`;
-    if (this.builtPackages.has(packageKey)) {
-      return;
-    }
-    const packagePath = path.join(this.workPath, npmDirPath, packageName);
-    const targetPackagePath = path.join(this.targetPath, npmDirPath, packageName);
-    if (!fs.existsSync(path.dirname(targetPackagePath))) {
-      fs.mkdirSync(path.dirname(targetPackagePath), { recursive: true });
-    }
-    await this.copyPackageFiles(packagePath, targetPackagePath);
-    await this.processDependencies(packageName, packagePath, npmDirPath);
-    this.builtPackages.add(packageKey);
-  }
-  /**
-   * 复制包文件
-   * @param {string} sourcePath 源路径
-   * @param {string} targetPath 目标路径
-   */
-  async copyPackageFiles(sourcePath, targetPath) {
-    if (!fs.existsSync(sourcePath)) {
-      return;
-    }
-    if (!fs.existsSync(targetPath)) {
-      fs.mkdirSync(targetPath, { recursive: true });
-    }
-    const items = fs.readdirSync(sourcePath, { withFileTypes: true });
-    for (const item of items) {
-      const sourceItemPath = path.join(sourcePath, item.name);
-      const targetItemPath = path.join(targetPath, item.name);
-      if (item.isDirectory()) {
-        await this.copyPackageFiles(sourceItemPath, targetItemPath);
-      } else {
-        if (this.isMiniprogramFile(item.name)) {
-          fs.copyFileSync(sourceItemPath, targetItemPath);
-        }
-      }
-    }
-  }
-  /**
-   * 检查是否为小程序相关文件
-   * @param {string} filename 文件名
-   * @returns {boolean} 是否为小程序文件
-   */
-  isMiniprogramFile(filename) {
-    const miniprogramExts = [".js", ".json", ".wxml", ".wxss", ".wxs", ".ts", ".less", ".scss", ".styl"];
-    const ext = path.extname(filename).toLowerCase();
-    return miniprogramExts.includes(ext) || filename === "package.json" || filename === "README.md" || filename.startsWith(".");
-  }
-  /**
-   * 处理包依赖
-   * @param {string} packageName 包名
-   * @param {string} packagePath 包路径
-   * @param {string} npmDirPath npm 目录路径
-   */
-  async processDependencies(packageName, packagePath, npmDirPath) {
-    const packageJsonPath = path.join(packagePath, "package.json");
-    if (!fs.existsSync(packageJsonPath)) {
-      return;
-    }
-    try {
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-      const dependencies = {
-        ...packageJson.dependencies,
-        ...packageJson.peerDependencies
-      };
-      if (dependencies && Object.keys(dependencies).length > 0) {
-        this.packageDependencies.set(packageName, dependencies);
-        for (const depName of Object.keys(dependencies)) {
-          await this.buildPackage(depName, npmDirPath);
-        }
-      }
-    } catch (e) {
-      console.warn(`[npm-builder] 解析 package.json 失败: ${packageJsonPath}`, e.message);
-    }
-  }
-  /**
-   * 验证 npm 包的完整性
-   * @param {string} packageName 包名
-   * @param {string} packagePath 包路径
-   * @returns {boolean} 是否有效
-   */
-  validatePackage(packageName, packagePath) {
-    const requiredFiles = ["package.json"];
-    for (const file of requiredFiles) {
-      if (!fs.existsSync(path.join(packagePath, file))) {
-        console.warn(`[npm-builder] 包 ${packageName} 缺少必要文件: ${file}`);
-        return false;
-      }
-    }
-    try {
-      const packageJsonPath = path.join(packagePath, "package.json");
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-      if (!packageJson.name || !packageJson.version) {
-        console.warn(`[npm-builder] 包 ${packageName} 的 package.json 格式不正确`);
-        return false;
-      }
-    } catch (e) {
-      console.warn(`[npm-builder] 包 ${packageName} 的 package.json 解析失败:`, e.message);
-      return false;
-    }
-    return true;
-  }
-  /**
-   * 获取已构建的包列表
-   * @returns {string[]} 已构建的包列表
-   */
-  getBuiltPackages() {
-    return Array.from(this.builtPackages);
-  }
-  /**
-   * 获取包依赖关系
-   * @returns {Map} 包依赖关系映射
-   */
-  getPackageDependencies() {
-    return this.packageDependencies;
-  }
-  /**
-   * 清理构建缓存
-   */
-  clearCache() {
-    this.builtPackages.clear();
-    this.packageDependencies.clear();
-  }
-}
-function compileConfig() {
-  const compileResInfo = {
-    app: getAppConfigInfo(),
-    modules: getPageConfigInfo(),
-    projectName: getAppName()
-  };
-  const json = JSON.stringify(compileResInfo, null, 4);
-  const mainDir = `${getTargetPath()}/main`;
-  if (!fs.existsSync(mainDir)) {
-    fs.mkdirSync(mainDir, { recursive: true });
-  }
-  fs.writeFileSync(`${mainDir}/app-config.json`, json);
-}
-let isPrinted = false;
-async function build(targetPath, workPath, useAppIdDir = true) {
-  if (!isPrinted) {
-    artCode$1();
-    isPrinted = true;
-  }
-  const tasks = new Listr(
-    [
-      {
-        title: "准备项目编译环境",
-        task: (_, task) => task.newListr(
-          [
-            {
-              title: "收集配置信息",
-              task: (ctx) => {
-                ctx.storeInfo = storeInfo(workPath);
-              }
-            },
-            {
-              title: "准备产物目录",
-              task: () => {
-                createDist();
-              }
-            },
-            {
-              title: "编译配置信息",
-              task: () => {
-                compileConfig();
-              }
-            },
-            {
-              title: "构建 npm 包",
-              task: async () => {
-                const npmBuilder = new NpmBuilder(getWorkPath(), getTargetPath());
-                await npmBuilder.buildNpmPackages();
-              }
-            }
-          ],
-          { concurrent: false }
-        )
-      },
-      {
-        title: `开始编译:${workPath.split("/").pop()}`,
-        task: (ctx, task) => {
-          const pages = getPages();
-          ctx.pages = pages;
-          return task.newListr(
-            [
-              {
-                title: "编译页面文件",
-                task: async (ctx2, task2) => {
-                  return runCompileInWorker("view", ctx2, task2);
-                }
-              },
-              {
-                title: "编译页面逻辑",
-                task: async (ctx2, task2) => {
-                  return runCompileInWorker("logic", ctx2, task2);
-                }
-              },
-              {
-                title: "编译样式文件",
-                task: async (ctx2, task2) => {
-                  pages.mainPages.unshift({
-                    path: "app",
-                    id: ""
-                  });
-                  return runCompileInWorker("style", ctx2, task2);
-                }
-              }
-            ],
-            { concurrent: true }
-          );
-        }
-      },
-      {
-        title: "输出编译产物",
-        task: () => {
-          publishToDist(targetPath, useAppIdDir);
-        }
-      }
-    ],
-    { concurrent: false }
-  );
-  try {
-    const context = await tasks.run();
-    return {
-      appId: getAppId(),
-      name: getAppName(),
-      path: getAppConfigInfo().entryPagePath || context.pages.mainPages[1].path
-    };
-  } catch (e) {
-    console.error(`${workPath} 编译出错: ${e.message}
-${e.stack}`);
-  }
-}
-function runCompileInWorker(script, ctx, task) {
-  return workerPool.runWorker(() => new Promise((resolve, reject) => {
-    const worker = new Worker(
-      path.join(path.dirname(fileURLToPath(import.meta.url)), `core/${script}-compiler.js`),
-      workerPool.getWorkerOptions()
-    );
-    const totalTasks = Object.keys(ctx.pages.mainPages).length + Object.values(ctx.pages.subPages).reduce((sum, item) => sum + item.info.length, 0);
-    worker.postMessage({ pages: ctx.pages, storeInfo: ctx.storeInfo });
-    worker.on("message", (message) => {
-      try {
-        if (message.completedTasks) {
-          const progress = message.completedTasks / totalTasks;
-          const percentage = progress * 100;
-          const barLength = 30;
-          const filledLength = Math.ceil(barLength * progress);
-          const bar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
-          task.output = `[${bar}] ${percentage.toFixed(2)}%`;
-        }
-        if (message.success) {
-          resolve();
-          worker.terminate();
-        } else if (message.error) {
-          const error = new Error(message.error.message || message.error);
-          if (message.error.stack)
-            error.stack = message.error.stack;
-          if (message.error.file)
-            error.file = message.error.file;
-          if (message.error.line)
-            error.line = message.error.line;
-          reject(error);
-          worker.terminate();
-        }
-      } catch (err) {
-        reject(new Error(`Error processing worker message: ${err.message}
-${err.stack}`));
-        worker.terminate();
-      }
-    });
-    worker.on("error", reject);
-    worker.on("exit", (code) => {
-      if (code !== 0) {
-        reject(new Error(`Worker stopped with exit code ${code}`));
-      }
-    });
-  }));
-}
-export {
-  build as default
-};
+import { t as build } from "./src-D9P-SZeX.js";
+export { build as default };