@dimina/compiler 1.0.7 → 1.0.8

package/dist/env-Cmen1qwy.cjs

@@ -0,0 +1,543 @@
+"use strict";
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const process = require("node:process");
+function hasCompileInfo(modulePath, list, preList) {
+  const mergeList = Array.isArray(preList) ? [...preList, ...list] : list;
+  for (const element of mergeList) {
+    if (element.path === modulePath) {
+      return true;
+    }
+  }
+  return false;
+}
+function getAbsolutePath(workPath, pagePath, src) {
+  if (src.startsWith("/")) {
+    return path.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);
+  }
+  const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
+  return path.resolve(workPath, relativePath, src);
+}
+const assetsMap = {};
+function collectAssets(workPath, pagePath, src, targetPath, appId) {
+  if (src.startsWith("http") || src.startsWith("//")) {
+    return src;
+  }
+  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);
+  if (assetsMap[absolutePath]) {
+    return assetsMap[absolutePath];
+  }
+  try {
+    const ext = `.${src.split(".").pop()}`;
+    const dirPath = absolutePath.split(path.sep).slice(0, -1).join("/");
+    const prefix = uuid();
+    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}`);
+    });
+    const filename = src.split("/").pop();
+    const pathPrefix = process.env.ASSETS_PATH_PREFIX ? "" : "/";
+    assetsMap[absolutePath] = `${pathPrefix}${appId}/main/static/${prefix}_${filename}`;
+  } catch (error) {
+    console.log(error);
+  }
+  return assetsMap[absolutePath] || src;
+}
+function getFilesWithExtension(directory, extension) {
+  const files = fs.readdirSync(directory);
+  const filteredFiles = files.filter((file) => path.extname(file) === extension);
+  return filteredFiles;
+}
+function isObjectEmpty(objectName) {
+  if (!objectName) {
+    return true;
+  }
+  return Object.keys(objectName).length === 0 && objectName.constructor === Object;
+}
+function isString(o) {
+  return Object.prototype.toString.call(o) === "[object String]";
+}
+function transformRpx(styleText) {
+  if (!isString(styleText)) {
+    return styleText;
+  }
+  return styleText.replace(/([+-]?\d+(?:\.\d+)?)rpx/g, (_, pixel) => {
+    return `${Number(pixel)}rem`;
+  });
+}
+function uuid() {
+  return Math.random().toString(36).slice(2, 7);
+}
+const tagWhiteList = [
+  "page",
+  "wrapper",
+  "block",
+  "button",
+  "camera",
+  "checkbox-group",
+  "checkbox",
+  "cover-image",
+  "cover-view",
+  "form",
+  "icon",
+  "image",
+  "input",
+  "keyboard-accessory",
+  "label",
+  "map",
+  "movable-area",
+  "movable-view",
+  "navigation-bar",
+  "navigator",
+  "open-data",
+  "page-meta",
+  "picker-view-column",
+  "picker-view",
+  "picker",
+  "progress",
+  "radio-group",
+  "radio",
+  "rich-text",
+  "root-portal",
+  "scroll-view",
+  "slider",
+  "swiper-item",
+  "swiper",
+  "switch",
+  "template",
+  "text",
+  "textarea",
+  "video",
+  "view",
+  "web-view"
+];
+class NpmResolver {
+  constructor(workPath) {
+    this.workPath = workPath;
+    this.miniprogramNpmCache = /* @__PURE__ */ new Map();
+    this.packageCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 解析组件路径，支持 npm 包组件
+   * @param {string} componentPath 组件路径
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string} 解析后的组件路径
+   */
+  resolveComponentPath(componentPath, pageFilePath) {
+    if (componentPath.startsWith("./") || componentPath.startsWith("../") || componentPath.startsWith("/")) {
+      return this.resolveRelativePath(componentPath, pageFilePath);
+    }
+    const npmPath = this.resolveNpmComponent(componentPath, pageFilePath);
+    if (npmPath) {
+      return npmPath;
+    }
+    return this.resolveRelativePath(componentPath, pageFilePath);
+  }
+  /**
+   * 解析相对路径组件
+   * @param {string} componentPath 组件路径
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string} 解析后的路径
+   */
+  resolveRelativePath(componentPath, pageFilePath) {
+    const lastIndex = pageFilePath.lastIndexOf("/");
+    const newPath = pageFilePath.slice(0, lastIndex);
+    const res = path.resolve(newPath, componentPath);
+    return res.replace(this.workPath, "");
+  }
+  /**
+   * 解析 npm 组件
+   * @param {string} componentName 组件名称
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string|null} 解析后的组件路径，如果找不到返回 null
+   */
+  resolveNpmComponent(componentName, pageFilePath) {
+    const searchPaths = this.generateSearchPaths(pageFilePath);
+    for (const searchPath of searchPaths) {
+      const componentPath = this.findComponentInMiniprogramNpm(componentName, searchPath);
+      if (componentPath) {
+        return componentPath;
+      }
+    }
+    return null;
+  }
+  /**
+   * 生成 miniprogram_npm 搜索路径
+   * 按照微信小程序的寻址顺序生成搜索路径
+   * @param {string} pageFilePath 页面文件路径
+   * @returns {string[]} 搜索路径数组
+   */
+  generateSearchPaths(pageFilePath) {
+    const relativePath = pageFilePath.replace(this.workPath, "").replace(/^\//, "");
+    const pathParts = relativePath.split("/").slice(0, -1);
+    const searchPaths = [];
+    for (let i = pathParts.length; i >= 0; i--) {
+      const currentPath = pathParts.slice(0, i).join("/");
+      const miniprogramNpmPath = currentPath ? `${currentPath}/miniprogram_npm` : "miniprogram_npm";
+      searchPaths.push(miniprogramNpmPath);
+    }
+    return searchPaths;
+  }
+  /**
+   * 在指定的 miniprogram_npm 目录中查找组件
+   * @param {string} componentName 组件名称
+   * @param {string} miniprogramNpmPath miniprogram_npm 路径
+   * @returns {string|null} 组件路径，如果找不到返回 null
+   */
+  findComponentInMiniprogramNpm(componentName, miniprogramNpmPath) {
+    const fullMiniprogramNpmPath = path.join(this.workPath, miniprogramNpmPath);
+    if (!fs.existsSync(fullMiniprogramNpmPath)) {
+      return null;
+    }
+    const cacheKey = `${miniprogramNpmPath}/${componentName}`;
+    if (this.miniprogramNpmCache.has(cacheKey)) {
+      return this.miniprogramNpmCache.get(cacheKey);
+    }
+    const candidatePaths = [
+      componentName,
+      `${componentName}/index`
+    ];
+    for (const candidatePath of candidatePaths) {
+      const componentDir = path.join(fullMiniprogramNpmPath, candidatePath);
+      if (this.isValidComponent(componentDir)) {
+        const resolvedPath = `/${miniprogramNpmPath}/${candidatePath}`.replace(/\/+/g, "/");
+        this.miniprogramNpmCache.set(cacheKey, resolvedPath);
+        return resolvedPath;
+      }
+    }
+    this.miniprogramNpmCache.set(cacheKey, null);
+    return null;
+  }
+  /**
+   * 检查是否为有效的组件
+   * @param {string} componentPath 组件路径
+   * @returns {boolean} 是否为有效组件
+   */
+  isValidComponent(componentPath) {
+    const requiredFiles = [".json", ".js"];
+    const hasRequiredFiles = requiredFiles.some((ext) => {
+      return fs.existsSync(`${componentPath}${ext}`);
+    });
+    if (!hasRequiredFiles) {
+      const indexFiles = requiredFiles.some((ext) => {
+        return fs.existsSync(path.join(componentPath, `index${ext}`));
+      });
+      if (!indexFiles) {
+        return false;
+      }
+      const indexJsonFile = path.join(componentPath, "index.json");
+      if (fs.existsSync(indexJsonFile)) {
+        try {
+          const config = JSON.parse(fs.readFileSync(indexJsonFile, "utf-8"));
+          return config.component === true;
+        } catch (e) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const jsonFile = `${componentPath}.json`;
+    if (fs.existsSync(jsonFile)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(jsonFile, "utf-8"));
+        return config.component === true;
+      } catch (e) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * 获取 npm 包信息
+   * @param {string} packageName 包名
+   * @param {string} searchPath 搜索路径
+   * @returns {object|null} 包信息，如果找不到返回 null
+   */
+  getPackageInfo(packageName, searchPath) {
+    const cacheKey = `${searchPath}/${packageName}`;
+    if (this.packageCache.has(cacheKey)) {
+      return this.packageCache.get(cacheKey);
+    }
+    const packageJsonPath = path.join(this.workPath, searchPath, packageName, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+      this.packageCache.set(cacheKey, null);
+      return null;
+    }
+    try {
+      const packageInfo = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      this.packageCache.set(cacheKey, packageInfo);
+      return packageInfo;
+    } catch (e) {
+      this.packageCache.set(cacheKey, null);
+      return null;
+    }
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.miniprogramNpmCache.clear();
+    this.packageCache.clear();
+  }
+}
+let pathInfo = {};
+let configInfo = {};
+let npmResolver = null;
+function storeInfo(workPath) {
+  storePathInfo(workPath);
+  storeProjectConfig();
+  storeAppConfig();
+  storePageConfig();
+  return {
+    pathInfo,
+    configInfo
+  };
+}
+function resetStoreInfo(opts) {
+  pathInfo = opts.pathInfo;
+  configInfo = opts.configInfo;
+  if (pathInfo.workPath) {
+    npmResolver = new NpmResolver(pathInfo.workPath);
+  }
+}
+function storePathInfo(workPath) {
+  pathInfo.workPath = workPath;
+  if (process.env.TARGET_PATH) {
+    pathInfo.targetPath = process.env.TARGET_PATH;
+  } else {
+    const tempDir = process.env.GITHUB_WORKSPACE || os.tmpdir();
+    const targetDir = path.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    pathInfo.targetPath = targetDir;
+  }
+  npmResolver = new NpmResolver(workPath);
+}
+function storeProjectConfig() {
+  const privateConfigPath = `${pathInfo.workPath}/project.private.config.json`;
+  const defaultConfigPath = `${pathInfo.workPath}/project.config.json`;
+  let privateConfig = {};
+  let defaultConfig = {};
+  if (fs.existsSync(defaultConfigPath)) {
+    try {
+      defaultConfig = parseContentByPath(defaultConfigPath);
+    } catch (e) {
+      console.warn("Failed to parse project.config.json:", e.message);
+    }
+  }
+  if (fs.existsSync(privateConfigPath)) {
+    try {
+      privateConfig = parseContentByPath(privateConfigPath);
+    } catch (e) {
+      console.warn("Failed to parse project.private.config.json:", e.message);
+    }
+  }
+  configInfo.projectInfo = { ...defaultConfig, ...privateConfig };
+}
+function storeAppConfig() {
+  const filePath = `${pathInfo.workPath}/app.json`;
+  const content = parseContentByPath(filePath);
+  const newObj = {};
+  for (const key in content) {
+    if (Object.hasOwn(content, key)) {
+      if (key === "subpackages") {
+        newObj.subPackages = content[key];
+      } else {
+        newObj[key] = content[key];
+      }
+    }
+  }
+  configInfo.appInfo = newObj;
+}
+function getContentByPath(path2) {
+  return fs.readFileSync(path2, { encoding: "utf-8" });
+}
+function parseContentByPath(path2) {
+  return JSON.parse(getContentByPath(path2));
+}
+function storePageConfig() {
+  const { pages, subPackages } = configInfo.appInfo;
+  configInfo.pageInfo = {};
+  configInfo.componentInfo = {};
+  if (configInfo.appInfo.usingComponents) {
+    const appFilePath = `${pathInfo.workPath}/app.json`;
+    storeComponentConfig(configInfo.appInfo, appFilePath);
+  }
+  collectionPageJson(pages);
+  if (subPackages) {
+    subPackages.forEach((subPkg) => {
+      collectionPageJson(subPkg.pages, subPkg.root);
+    });
+  }
+}
+function collectionPageJson(pages, root) {
+  pages.forEach((pagePath) => {
+    let np = pagePath;
+    if (root) {
+      if (!root.endsWith("/")) {
+        root += "/";
+      }
+      np = root + np;
+    }
+    const pageFilePath = `${pathInfo.workPath}/${np}.json`;
+    if (fs.existsSync(pageFilePath)) {
+      const pageJsonContent = parseContentByPath(pageFilePath);
+      if (root) {
+        pageJsonContent.root = transSubDir(root);
+      }
+      configInfo.pageInfo[np] = pageJsonContent;
+      storeComponentConfig(pageJsonContent, pageFilePath);
+    }
+  });
+}
+function storeComponentConfig(pageJsonContent, pageFilePath) {
+  if (isObjectEmpty(pageJsonContent.usingComponents)) {
+    return;
+  }
+  for (const [componentName, componentPath] of Object.entries(pageJsonContent.usingComponents)) {
+    const moduleId = getModuleId(componentPath, pageFilePath);
+    pageJsonContent.usingComponents[componentName] = moduleId;
+    if (configInfo.componentInfo[moduleId]) {
+      continue;
+    }
+    let componentFilePath = path.resolve(getWorkPath(), `./${moduleId}.json`);
+    let cContent = null;
+    if (fs.existsSync(componentFilePath)) {
+      cContent = parseContentByPath(componentFilePath);
+    } else {
+      const indexJsonPath = path.resolve(getWorkPath(), `./${moduleId}/index.json`);
+      if (fs.existsSync(indexJsonPath)) {
+        componentFilePath = indexJsonPath;
+        cContent = parseContentByPath(componentFilePath);
+      } else {
+        if (moduleId.includes("/miniprogram_npm/")) {
+          console.log(`[env] 为 npm 组件创建默认配置: ${moduleId}`);
+          cContent = {
+            component: true,
+            usingComponents: {}
+          };
+        } else {
+          console.warn(`[env] 组件配置文件不存在: ${componentFilePath}`);
+          continue;
+        }
+      }
+    }
+    const cUsing = cContent.usingComponents || {};
+    const isComponent = cContent.component || false;
+    const cComponents = Object.keys(cUsing).reduce((acc, key) => {
+      acc[key] = getModuleId(cUsing[key], componentFilePath);
+      return acc;
+    }, {});
+    configInfo.componentInfo[moduleId] = {
+      id: uuid(),
+      path: moduleId,
+      component: isComponent,
+      usingComponents: cComponents
+    };
+    if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) {
+      storeComponentConfig(configInfo.componentInfo[moduleId], componentFilePath);
+    }
+  }
+}
+function getModuleId(src, pageFilePath) {
+  if (!npmResolver) {
+    const lastIndex = pageFilePath.lastIndexOf("/");
+    const newPath = pageFilePath.slice(0, lastIndex);
+    const workPath = getWorkPath();
+    const res = path.resolve(newPath, src);
+    return res.replace(workPath, "");
+  }
+  return npmResolver.resolveComponentPath(src, pageFilePath);
+}
+function getTargetPath() {
+  return pathInfo.targetPath;
+}
+function getComponent(src) {
+  return configInfo.componentInfo[src];
+}
+function getPageConfigInfo() {
+  return configInfo.pageInfo;
+}
+function getAppConfigInfo() {
+  return configInfo.appInfo;
+}
+function getWorkPath() {
+  return pathInfo.workPath;
+}
+function getAppId() {
+  return configInfo.projectInfo.appid;
+}
+function getAppName() {
+  if (configInfo.projectInfo.projectname) {
+    return decodeURIComponent(configInfo.projectInfo.projectname);
+  }
+  return getAppId();
+}
+function transSubDir(name) {
+  return `sub_${name.replace(/\/$/, "")}`;
+}
+function getPages() {
+  const { pages, subPackages = [], usingComponents: globalComponents = {} } = getAppConfigInfo();
+  const pageInfo = getPageConfigInfo();
+  const mainPages = pages.map((path2) => {
+    const pageComponents = pageInfo[path2]?.usingComponents || {};
+    const mergedComponents = { ...globalComponents, ...pageComponents };
+    return {
+      id: uuid(),
+      path: path2,
+      usingComponents: mergedComponents
+    };
+  });
+  const subPages = {};
+  subPackages.forEach((subPkg) => {
+    const rootPath = subPkg.root.endsWith("/") ? subPkg.root : `${subPkg.root}/`;
+    const independent = subPkg.independent ? subPkg.independent : false;
+    subPages[transSubDir(rootPath)] = {
+      independent,
+      info: subPkg.pages.map((path2) => {
+        const fullPath = rootPath + path2;
+        const pageComponents = pageInfo[fullPath]?.usingComponents || {};
+        const mergedComponents = { ...globalComponents, ...pageComponents };
+        return {
+          id: uuid(),
+          path: fullPath,
+          usingComponents: mergedComponents
+        };
+      })
+    };
+  });
+  return {
+    mainPages,
+    subPages
+  };
+}
+exports.collectAssets = collectAssets;
+exports.getAbsolutePath = getAbsolutePath;
+exports.getAppConfigInfo = getAppConfigInfo;
+exports.getAppId = getAppId;
+exports.getAppName = getAppName;
+exports.getComponent = getComponent;
+exports.getContentByPath = getContentByPath;
+exports.getPageConfigInfo = getPageConfigInfo;
+exports.getPages = getPages;
+exports.getTargetPath = getTargetPath;
+exports.getWorkPath = getWorkPath;
+exports.hasCompileInfo = hasCompileInfo;
+exports.resetStoreInfo = resetStoreInfo;
+exports.storeInfo = storeInfo;
+exports.tagWhiteList = tagWhiteList;
+exports.transformRpx = transformRpx;