@infly/libs 2.0.36 → 2.0.37

package/module/cjs/page-config.cjs

@@ -0,0 +1,119 @@
+const sameValue = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+
+const hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+
+function mergePageConfig(...sources) {
+  const pageConfig = {};
+
+  sources.forEach((source) => {
+    Object.keys(source || {}).forEach((key) => {
+      const value = source[key];
+
+      if (hasOwn(pageConfig, key) && !sameValue(pageConfig[key], value)) {
+        console.warn(
+          `[page-config] duplicate pageConfig key "${key}" has different values.`
+        );
+      }
+
+      pageConfig[key] = value;
+    });
+  });
+
+  return pageConfig;
+}
+
+function normalizePlatforms(platforms = [], platformGroups = {}) {
+  return platforms.reduce((result, platform) => {
+    if (platformGroups[platform]) {
+      result.push(...platformGroups[platform]);
+      return result;
+    }
+    result.push(platform);
+    return result;
+  }, []);
+}
+
+function normalizePlatformKey(key, platformGroups) {
+  return normalizePlatforms(
+    key.split(",").map((platform) => platform.trim()),
+    platformGroups
+  );
+}
+
+function getPlatformChain(platform, platformExtends = {}) {
+  const chain = [];
+  let current = platform;
+
+  while (current && !chain.includes(current)) {
+    chain.push(current);
+    current = platformExtends[current];
+  }
+
+  return chain;
+}
+
+function resolvePageConfigValue(config, platform, options = {}) {
+  const { platformGroups = {}, platformExtends = {} } = options;
+  const platformChain = getPlatformChain(platform, platformExtends);
+
+  if (Array.isArray(config)) {
+    const platforms = normalizePlatforms(config, platformGroups);
+    return platformChain.some((item) => platforms.includes(item))
+      ? true
+      : undefined;
+  }
+
+  if (!config || typeof config !== "object") {
+    return config;
+  }
+
+  const exactPlatform = platformChain.find((item) => hasOwn(config, item));
+
+  if (exactPlatform) {
+    return config[exactPlatform];
+  }
+
+  const matchedKey = Object.keys(config).find((key) => {
+    if (key === "DEFAULT") {
+      return false;
+    }
+    const platforms = normalizePlatformKey(key, platformGroups);
+    return platformChain.some((item) => platforms.includes(item));
+  });
+
+  if (matchedKey) {
+    return config[matchedKey];
+  }
+
+  return config.DEFAULT;
+}
+
+function resolvePlatformPageConfig(pageConfig = {}, platform = "DEFAULT", options = {}) {
+  const resolvedConfig = {};
+  const keys = Object.keys(pageConfig);
+  const normalKeys = keys.filter((key) => !key.startsWith("!"));
+  const negatedKeys = keys.filter((key) => key.startsWith("!"));
+
+  normalKeys.forEach((key) => {
+    const value = resolvePageConfigValue(pageConfig[key], platform, options);
+    if (value !== undefined) {
+      resolvedConfig[key] = value;
+    }
+  });
+
+  // "!showXxx": ["PARTNER"] → 命中平台时解析为 showXxx: false
+  negatedKeys.forEach((key) => {
+    const configKey = key.slice(1);
+    const value = resolvePageConfigValue(pageConfig[key], platform, options);
+    if (value === true) {
+      resolvedConfig[configKey] = false;
+    }
+  });
+
+  return resolvedConfig;
+}
+
+module.exports = {
+  mergePageConfig,
+  resolvePlatformPageConfig
+};

package/module/cjs/request-url-rules.cjs

@@ -0,0 +1,55 @@
+function normalizeRuleDomains(domains) {
+  if (!Array.isArray(domains)) {
+    return [];
+  }
+
+  return domains
+    .filter(Boolean)
+    .map((domain) => String(domain).trim().replace(/\/+$/, ""));
+}
+
+function normalizePathIncludes(pathIncludes) {
+  if (!Array.isArray(pathIncludes)) {
+    return [];
+  }
+
+  return pathIncludes.filter(Boolean).map((path) => String(path));
+}
+
+function resolveInternalServiceURL(url, rules = []) {
+  if (!url || !Array.isArray(rules) || rules.length === 0) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    return null;
+  }
+
+  const requestOrigin = parsed.origin.replace(/\/+$/, "");
+  const requestPath = parsed.pathname || "/";
+
+  for (const rule of rules) {
+    const domains = normalizeRuleDomains(rule.domains);
+    const pathIncludes = normalizePathIncludes(rule.pathIncludes);
+    const domainMatched = domains.includes(requestOrigin);
+    const pathMatched =
+      pathIncludes.length === 0 ||
+      pathIncludes.some((path) => requestPath.includes(path));
+
+    if (domainMatched && pathMatched) {
+      return {
+        url: `${requestPath}${parsed.search || ""}`,
+        baseURL: rule.baseURL || "/"
+      };
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  resolveInternalServiceURL
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infly/libs",
-  "version": "2.0.36",
+  "version": "2.0.37",
   "description": "工具组件库",
   "main": "index.js",
   "scripts": {
@@ -35,12 +35,12 @@
   "author": "Kahal",
   "license": "ISC",
   "dependencies": {},
-  "devDependencies-仅在需要webpack时候删除": {
-    "@babel/core": "^7.27.3",
-    "@babel/preset-env": "^7.27.2",
+  "devDependencies": {
+    "@babel/core": "^7.23.3",
+    "@babel/preset-env": "^7.23.3",
     "babel-loader": "^10.0.0",
-    "webpack": "^5.99.9",
-    "webpack-cli": "^6.0.1",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4",
     "webpack-node-externals": "^3.0.0"
   },
   "peerDependencies": {

package/script/build/command.js

@@ -0,0 +1,48 @@
+const { spawn } = require("child_process");
+
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd || process.cwd(),
+      env: {
+        ...process.env,
+        ...(options.env || {})
+      },
+      stdio: options.stdio || "inherit",
+      shell: process.platform === "win32"
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
+      }
+    });
+
+    child.on("error", reject);
+  });
+}
+
+function spawnBackground(command, args, options = {}) {
+  const child = spawn(command, args, {
+    cwd: options.cwd || process.cwd(),
+    env: {
+      ...process.env,
+      ...(options.env || {})
+    },
+    stdio: options.stdio || "inherit",
+    shell: process.platform === "win32"
+  });
+
+  child.on("error", (error) => {
+    console.error(error.message);
+  });
+
+  return child;
+}
+
+module.exports = {
+  run,
+  spawnBackground
+};

package/script/build/env.js

@@ -0,0 +1,28 @@
+const ENV = {
+  buildContext: "INFLY_BUILD_CONTEXT",
+  batchWebhookFile: "INFLY_BATCH_WEBHOOK_FILE",
+  batchPreview: "INFLY_BATCH_PREVIEW",
+  skipPreview: "INFLY_SKIP_PREVIEW",
+  skipPackagesUpdate: "INFLY_SKIP_PACKAGES_UPDATE",
+  skipBranchUpdate: "INFLY_SKIP_BRANCH_UPDATE"
+};
+
+function parseBuildContext() {
+  try {
+    return JSON.parse(process.env[ENV.buildContext] || "{}");
+  } catch {
+    return {};
+  }
+}
+
+function createBuildContext(value) {
+  return {
+    [ENV.buildContext]: JSON.stringify(value || {})
+  };
+}
+
+module.exports = {
+  ENV,
+  parseBuildContext,
+  createBuildContext
+};

package/script/build/git.js

@@ -0,0 +1,252 @@
+const fs = require("fs");
+const path = require("path");
+const { checkAndUpdatePackages } = require("../git-automation");
+const { gitOutput, findGitRepo, getGitCommonDir } = require("../git-automation/git-utils");
+const { run } = require("./command");
+
+function getTargetBranch(rootPackageJson, mode) {
+  const branchMap = rootPackageJson.projectConfig?.buildBranchMap || {};
+  return branchMap[mode] || (mode === "prod" ? "master" : "develop");
+}
+
+function hasPackageGitRepos(rootDir) {
+  const packagesDir = path.join(rootDir, "packages");
+
+  if (!fs.existsSync(packagesDir)) {
+    return false;
+  }
+
+  return ["infly-libs", "infly-ui"].some((name) => fs.existsSync(path.join(packagesDir, name, ".git")));
+}
+
+async function updatePackageSources(rootDir) {
+  console.log("\x1b[32m%s\x1b[0m", "更新 admin-monorepo / packages 源码");
+
+  if (hasPackageGitRepos(rootDir)) {
+    console.log("  使用 packages/* 独立 git 仓库模式，拉取 master");
+  } else {
+    console.log("  使用 admin-monorepo 根仓库模式，拉取 master");
+  }
+
+  global.logColor = global.logColor || {
+    success: "\n\x1b[32m%s\x1b[0m",
+    error: "\n\x1b[31m%s\x1b[0m",
+    warning: "\n\x1b[33m%s\x1b[0m",
+    link: "\x1b[34m%s\x1b[0m",
+    info: "\n\x1b[36m%s\x1b[0m"
+  };
+
+  const packagesDir = path.join(rootDir, "packages");
+  await checkAndUpdatePackages(fs.existsSync(packagesDir) ? packagesDir : undefined, "master");
+}
+
+function getPackageSourcesKey(rootDir) {
+  if (!hasPackageGitRepos(rootDir)) {
+    return getGitCommonDir(rootDir);
+  }
+
+  return path.join(rootDir, "packages");
+}
+
+function findExistingAncestor(targetDir) {
+  let current = targetDir;
+
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+
+    if (parent === current) {
+      return "";
+    }
+
+    current = parent;
+  }
+
+  return current;
+}
+
+function getDistRepoInfo(rootDir, pkg, targetBranch, options = {}) {
+  const packageRoot = path.join(rootDir, pkg.dir);
+  const vueConfigPath = path.join(packageRoot, "vue.config.js");
+  const nextConfigJs = path.join(packageRoot, "next.config.js");
+  const nextConfigMjs = path.join(packageRoot, "next.config.mjs");
+  const nextConfigTs = path.join(packageRoot, "next.config.ts");
+  const hasVueConfig = fs.existsSync(vueConfigPath);
+  const hasNextConfig = !hasVueConfig && (
+    fs.existsSync(nextConfigJs) ||
+    fs.existsSync(nextConfigMjs) ||
+    fs.existsSync(nextConfigTs)
+  );
+
+  let outputDir;
+
+  if (hasVueConfig) {
+    outputDir = require(vueConfigPath).outputDir;
+  } else if (hasNextConfig) {
+    outputDir = pkg.packageJson.infly?.buildConfigs?.outputPath;
+  } else {
+    return null;
+  }
+
+  if (outputDir && !path.isAbsolute(outputDir)) {
+    outputDir = path.resolve(packageRoot, outputDir);
+  }
+
+  if (!outputDir) {
+    return null;
+  }
+
+  const existingOutputDir = fs.existsSync(outputDir) ? outputDir : findExistingAncestor(outputDir);
+
+  if (!existingOutputDir) {
+    return null;
+  }
+
+  const branchMap = pkg.packageJson.infly?.buildConfigs?.gitAutoPushReposBranchMap || {};
+  const distBranch = branchMap[targetBranch] || targetBranch;
+  let repoRoot = existingOutputDir;
+  let repoKey = existingOutputDir;
+  const repo = findGitRepo(existingOutputDir);
+
+  if (repo) {
+    repoRoot = repo.root;
+    repoKey = repo.commonDir;
+  } else {
+    try {
+      repoRoot = gitOutput(["-C", existingOutputDir, "rev-parse", "--show-toplevel"], rootDir);
+      repoKey = getGitCommonDir(existingOutputDir);
+    } catch (error) {
+      if (!options.allowPathFallback) {
+        throw error;
+      }
+    }
+  }
+
+  return {
+    cwd: repoRoot,
+    branch: distBranch,
+    key: repoKey,
+    label: `dist(${path.relative(rootDir, repoRoot)})`
+  };
+}
+
+function getDistRepoTasks(rootDir, packages, targetBranch, options = {}) {
+  const repos = new Map();
+
+  packages.forEach((pkg) => {
+    const repo = getDistRepoInfo(rootDir, pkg, targetBranch, options);
+
+    if (repo && !repos.has(repo.key)) {
+      repos.set(repo.key, {
+        cwd: repo.cwd,
+        branch: repo.branch,
+        key: repo.key,
+        label: repo.label
+      });
+    }
+  });
+
+  return Array.from(repos.values());
+}
+
+async function pullGitRepo(task) {
+  console.log("\x1b[32m%s\x1b[0m", `更新 ${task.label} -> ${task.branch}`);
+  const status = gitOutput(["status", "--porcelain"], task.cwd);
+
+  if (status) {
+    throw new Error(`${task.label} 存在未提交的更改，无法自动切换并拉取 ${task.branch}\n${status}`);
+  }
+
+  await run("git", ["checkout", task.branch], { cwd: task.cwd });
+  await run("git", ["pull", "origin", task.branch], { cwd: task.cwd });
+}
+
+function getAppAndDistSourceTasks(rootDir, packages, targetBranch) {
+  const appTasks = packages.map((pkg) => {
+    const cwd = path.join(rootDir, pkg.dir);
+
+    return {
+      cwd,
+      branch: targetBranch,
+      label: pkg.name,
+      key: getGitCommonDir(cwd),
+      run: pullGitRepo
+    };
+  });
+  const distTasks = getDistRepoTasks(rootDir, packages, targetBranch).map((task) => ({
+    ...task,
+    run: pullGitRepo
+  }));
+
+  return [...appTasks, ...distTasks];
+}
+
+async function runSourceTasksWithOverlapCheck(tasks) {
+  const groups = new Map();
+
+  tasks.forEach((task) => {
+    const key = task.key || task.cwd || task.label;
+
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+
+    groups.get(key).push(task);
+  });
+
+  await Promise.all(
+    Array.from(groups.values()).map(async (group) => {
+      for (const task of group) {
+        await task.run(task);
+      }
+    })
+  );
+}
+
+async function updateAppAndDistSources(rootDir, packages, targetBranch) {
+  const tasks = getAppAndDistSourceTasks(rootDir, packages, targetBranch);
+
+  console.log("\x1b[32m%s\x1b[0m", "并行更新 app / dist 源码");
+
+  await runSourceTasksWithOverlapCheck(tasks);
+}
+
+async function updateAllSources(rootDir, packages, targetBranch) {
+  const tasks = [
+    {
+      label: "admin-monorepo/packages",
+      key: getPackageSourcesKey(rootDir),
+      run: () => updatePackageSources(rootDir)
+    },
+    ...getAppAndDistSourceTasks(rootDir, packages, targetBranch)
+  ];
+
+  await runSourceTasksWithOverlapCheck(tasks);
+}
+
+function printDryRunSourceUpdatePlan(rootDir, packages, targetBranch) {
+  console.log("并行拉取:");
+  console.log("  1. admin-monorepo/packages -> master");
+  packages.forEach((pkg, index) => {
+    console.log(`  ${index + 2}. ${pkg.name} -> ${targetBranch} (${pkg.dir})`);
+  });
+
+  const distTasks = getDistRepoTasks(rootDir, packages, targetBranch, { allowPathFallback: true });
+
+  if (distTasks.length === 0) {
+    console.log(`  ${packages.length + 2}. dist 仓库 -> 未解析到可拉取仓库`);
+    return;
+  }
+
+  distTasks.forEach((task, index) => {
+    console.log(`  ${packages.length + 2 + index}. ${task.label} -> ${task.branch} (${path.relative(rootDir, task.cwd)})`);
+  });
+}
+
+module.exports = {
+  getTargetBranch,
+  updatePackageSources,
+  updateAppAndDistSources,
+  updateAllSources,
+  getDistRepoTasks,
+  printDryRunSourceUpdatePlan
+};

package/script/build/preview.js

@@ -0,0 +1,75 @@
+const path = require("path");
+const { spawn } = require("child_process");
+const { spawnBackground } = require("./command");
+const { createBuildContext } = require("./env");
+
+function killPreviewChild(child) {
+  if (!child || child.killed) {
+    return;
+  }
+
+  if (process.platform === "win32") {
+    spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    return;
+  }
+
+  child.kill();
+}
+
+function startBatchPreviews(rootDir, packages) {
+  const previewPackages = packages.filter((pkg) => {
+    return pkg.packageJson.infly?.buildConfigs?.enablePreview !== false;
+  });
+
+  if (previewPackages.length === 0) {
+    return;
+  }
+
+  console.log("\n\x1b[32m%s\x1b[0m", "\x1b[42m\x1b[30m DONE \x1b[0m\x1b[32m  项目构建预览，CTRL + C 结束：");
+
+  const children = previewPackages.map((pkg) => {
+    const child = spawnBackground("infly-libs", ["preview", "--no-build"], {
+      cwd: path.join(rootDir, pkg.dir),
+      env: createBuildContext({
+        batchPreview: true
+      })
+    });
+
+    // console.log(`preview ${pkg.name}: pid ${child.pid}`);
+
+    child.on("close", (code, signal) => {
+      if (code === 0 || signal) {
+        return;
+      }
+
+      console.log(`preview ${pkg.name} 已退出，code=${code}`);
+    });
+
+    child.on("error", (error) => {
+      console.error(`preview ${pkg.name} 启动失败：${error.message}`);
+    });
+
+    return child;
+  });
+
+  const stop = () => {
+    children.forEach(killPreviewChild);
+  };
+
+  process.on("SIGINT", () => {
+    stop();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", () => {
+    stop();
+    process.exit(0);
+  });
+}
+
+module.exports = {
+  startBatchPreviews
+};