@tego/devkit 1.3.14

package/lib/constants.mjs

@@ -0,0 +1,13 @@
+// src/constants.ts
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var STATIC_PATH = join(__dirname, "../assets");
+var DEFAULT_DEV_HOST = "0.0.0.0";
+export {
+  DEFAULT_DEV_HOST,
+  STATIC_PATH,
+  __dirname,
+  __filename
+};

package/lib/index.mjs

@@ -0,0 +1,8 @@
+// src/index.ts
+export * from "./plugin-generator.mjs";
+import { initEnv } from "./util.mjs";
+export * from "./builder/build/index.mjs";
+export * from "./package-map-generator.mjs";
+export {
+  initEnv
+};

package/lib/notify-updates.mjs

@@ -0,0 +1,5 @@
+// src/notify-updates.ts
+import { createRequire } from "node:module";
+import updateNotifier from "update-notifier";
+var require2 = createRequire(import.meta.url);
+updateNotifier({ pkg: require2("../package.json") }).notify({ defer: true });

package/lib/open.mjs

@@ -0,0 +1,92 @@
+// src/open.ts
+import { logger } from "@rsbuild/core";
+import chalk from "chalk";
+import open, { apps } from "open";
+import { STATIC_PATH } from "./constants.mjs";
+var supportedChromiumBrowsers = [
+  "Google Chrome Canary",
+  "Google Chrome Dev",
+  "Google Chrome Beta",
+  "Google Chrome",
+  "Microsoft Edge",
+  "Brave Browser",
+  "Vivaldi",
+  "Chromium"
+];
+var mapChromiumBrowserName = (browser) => {
+  if (browser === "chrome" || browser === "google chrome") {
+    return "Google Chrome";
+  }
+  return browser;
+};
+var shouldTryAppleScript = (browser, browserArgs) => {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  if (browser && browserArgs) {
+    return false;
+  }
+  if (!browser) {
+    return true;
+  }
+  return supportedChromiumBrowsers.includes(mapChromiumBrowserName(browser));
+};
+async function openBrowser(url) {
+  const browser = process.env.BROWSER;
+  const browserArgs = process.env.BROWSER_ARGS;
+  if (shouldTryAppleScript(browser, browserArgs)) {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    const getDefaultBrowserForAppleScript = async () => {
+      const { stdout: ps } = await execAsync("ps cax");
+      return supportedChromiumBrowsers.find((b) => ps.includes(b));
+    };
+    try {
+      const chromiumBrowser = browser ? mapChromiumBrowserName(browser) : await getDefaultBrowserForAppleScript();
+      if (chromiumBrowser) {
+        await execAsync(`osascript openChrome.applescript "${encodeURI(url)}" "${chromiumBrowser}"`, {
+          cwd: STATIC_PATH
+        });
+        return true;
+      }
+      logger.debug("failed to find the target browser.");
+    } catch (err) {
+      logger.debug("failed to open start URL with apple script.");
+      logger.debug(err);
+    }
+  }
+  try {
+    const options = browser ? {
+      app: {
+        name: apps[browser] ?? browser,
+        arguments: browserArgs?.split(" ")
+      }
+    } : {};
+    await open(url, options);
+    return true;
+  } catch (err) {
+    logger.error("Failed to open start URL.");
+    logger.error(err);
+    return false;
+  }
+}
+var replacePortPlaceholder = (url, port) => url.replace(/<port>/g, String(port));
+function resolveUrl(str, base) {
+  if (URL.canParse(str)) {
+    return str;
+  }
+  try {
+    const url = new URL(str, base);
+    return url.href;
+  } catch {
+    throw new Error(
+      `${chalk.dim("[rsbuild:open]")} Invalid input: ${chalk.yellow(str)} is not a valid URL or pathname`
+    );
+  }
+}
+export {
+  openBrowser,
+  replacePortPlaceholder,
+  resolveUrl
+};

package/lib/package-map-generator.mjs

@@ -0,0 +1,219 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/package-map-generator.ts
+import { existsSync as _existsSync, existsSync, mkdirSync, readFileSync, rmSync, watch, writeFileSync } from "node:fs";
+import { dirname as _dirname, sep as _sep, join, relative, resolve, sep } from "node:path";
+import { sync } from "fast-glob";
+import { version } from "../package.json";
+var ProjectRoot = process.cwd();
+function getUmiConfig() {
+  const { APP_PORT, API_BASE_URL, APP_PUBLIC_PATH } = process.env;
+  const API_BASE_PATH = process.env.API_BASE_PATH || "/api/";
+  const EXTENSION_UI_BASE_PATH = process.env.EXTENSION_UI_BASE_PATH || "/adapters/";
+  const PROXY_TARGET_URL = process.env.PROXY_TARGET_URL || `http://127.0.0.1:${APP_PORT}`;
+  const LOCAL_STORAGE_BASE_URL = "storage/uploads/";
+  const STATIC_PATH = "static/";
+  function getLocalStorageProxy() {
+    if (LOCAL_STORAGE_BASE_URL.startsWith("http")) {
+      return {};
+    }
+    return {
+      [APP_PUBLIC_PATH + LOCAL_STORAGE_BASE_URL]: {
+        target: PROXY_TARGET_URL,
+        changeOrigin: true
+      },
+      [APP_PUBLIC_PATH + STATIC_PATH]: {
+        target: PROXY_TARGET_URL,
+        changeOrigin: true
+      }
+    };
+  }
+  return {
+    alias: getPackagePaths().reduce((memo, item) => {
+      memo[item[0]] = item[1];
+      return memo;
+    }, {}),
+    define: {
+      "process.env.APP_PUBLIC_PATH": process.env.APP_PUBLIC_PATH,
+      "process.env.WS_PATH": process.env.WS_PATH,
+      "process.env.API_BASE_URL": API_BASE_URL || API_BASE_PATH,
+      "process.env.APP_ENV": process.env.APP_ENV,
+      "process.env.VERSION": version,
+      "process.env.WEBSOCKET_URL": process.env.WEBSOCKET_URL,
+      "process.env.__E2E__": process.env.__E2E__
+    },
+    // only proxy when using `umi dev`
+    // if the assets are built, will not proxy
+    proxy: {
+      [API_BASE_PATH]: {
+        target: PROXY_TARGET_URL,
+        changeOrigin: true,
+        pathRewrite: { [`^${API_BASE_PATH}`]: API_BASE_PATH }
+      },
+      [EXTENSION_UI_BASE_PATH]: {
+        target: PROXY_TARGET_URL,
+        changeOrigin: true,
+        pathRewrite: { [`^${EXTENSION_UI_BASE_PATH}`]: EXTENSION_UI_BASE_PATH }
+      },
+      // for local storage
+      ...getLocalStorageProxy()
+    }
+  };
+}
+function getTsconfigPaths() {
+  const content = readFileSync(resolve(ProjectRoot, "tsconfig.paths.json"), "utf-8");
+  const json = JSON.parse(content);
+  return json.compilerOptions.paths;
+}
+function getPackagePaths() {
+  const paths = getTsconfigPaths();
+  const pkgs = [];
+  for (const key in paths) {
+    if (Object.hasOwnProperty.call(paths, key)) {
+      for (let dir of paths[key]) {
+        if (dir.includes("*")) {
+          const files = sync(dir, { cwd: ProjectRoot, onlyDirectories: true });
+          for (const file of files) {
+            const dirname = resolve(ProjectRoot, file);
+            if (existsSync(dirname)) {
+              const re = new RegExp(dir.replace("*", "(.+)"));
+              const p = dirname.substring(ProjectRoot.length + 1).split(sep).join("/");
+              const match = re.exec(p);
+              pkgs.push([key.replace("*", match?.[1]), dirname]);
+            }
+          }
+        } else {
+          const dirname = resolve(ProjectRoot, dir);
+          pkgs.push([key, dirname]);
+        }
+      }
+    }
+  }
+  return pkgs;
+}
+function resolveTachybasePackagesAlias(config) {
+  const pkgs = getPackagePaths();
+  for (const [pkg, dir] of pkgs) {
+    config.module.rules.get("ts-in-node_modules").include.add(dir);
+    config.resolve.alias.set(pkg, dir);
+  }
+}
+function getNodeModulesPath(packageDir) {
+  const node_modules_dir = join(ProjectRoot, "node_modules");
+  return join(node_modules_dir, packageDir);
+}
+var IndexGenerator = class {
+  tachybaseDir = getNodeModulesPath("@tachybase");
+  constructor(outputPath, pluginsPath) {
+    this.outputPath = outputPath;
+    this.pluginsPath = pluginsPath;
+  }
+  get indexPath() {
+    return join(this.outputPath, "index.ts");
+  }
+  get packageMapPath() {
+    return join(this.outputPath, "packageMap.json");
+  }
+  get packagesPath() {
+    return join(this.outputPath, "packages");
+  }
+  generate() {
+    this.generatePluginContent();
+    if (process.env.NODE_ENV === "production") return;
+    this.pluginsPath.forEach((pluginPath) => {
+      if (!_existsSync(pluginPath)) {
+        return;
+      }
+      watch(pluginPath, { recursive: false }, () => {
+        this.generatePluginContent();
+      });
+    });
+  }
+  get indexContent() {
+    return `// @ts-nocheck
+import packageMap from './packageMap.json';
+
+function devDynamicImport(packageName: string): Promise<any> {
+  const fileName = packageMap[packageName];
+  if (!fileName) {
+    return Promise.resolve(null);
+  }
+  return import(\`./packages/\${fileName}\`)
+}
+export default devDynamicImport;`;
+  }
+  get emptyIndexContent() {
+    return `
+export default function devDynamicImport(packageName: string): Promise<any> {
+  return Promise.resolve(null);
+}`;
+  }
+  generatePluginContent() {
+    if (_existsSync(this.outputPath)) {
+      rmSync(this.outputPath, { recursive: true, force: true });
+    }
+    mkdirSync(this.outputPath);
+    const validPluginPaths = this.pluginsPath.filter((pluginsPath) => {
+      return _existsSync(pluginsPath);
+    });
+    if (process.env.NODE_ENV === "production") {
+      writeFileSync(this.indexPath, this.emptyIndexContent);
+      return;
+    }
+    const pluginInfos = validPluginPaths.map((pluginsPath) => this.getContent(pluginsPath)).flat();
+    writeFileSync(this.indexPath, this.indexContent);
+    const packageMapContent = pluginInfos.reduce((memo, item) => {
+      memo[item.packageJsonName] = item.pluginFileName + ".ts";
+      return memo;
+    }, {});
+    writeFileSync(this.packageMapPath, JSON.stringify(packageMapContent, null, 2));
+    mkdirSync(this.packagesPath, { recursive: true });
+    pluginInfos.forEach((item) => {
+      const pluginPackagePath = join(this.packagesPath, item.pluginFileName + ".ts");
+      writeFileSync(pluginPackagePath, item.exportStatement);
+    });
+  }
+  getContent(pluginsPath) {
+    const pluginFolders = sync(["plugin-*/package.json", "module-*/package.json"], {
+      cwd: pluginsPath,
+      onlyFiles: true,
+      absolute: true
+    });
+    const pluginInfos = Array.from(new Set(pluginFolders)).filter((item) => {
+      const dirname = _dirname(item);
+      const clientJs = join(dirname, "client.js");
+      return _existsSync(clientJs);
+    }).map((pluginPackageJsonPath) => {
+      const pluginPackageJson = __require(pluginPackageJsonPath);
+      const pluginPathArr = pluginPackageJsonPath.replaceAll(_sep, "/").split("/");
+      const hasNamespace = pluginPathArr[pluginPathArr.length - 3].startsWith("@");
+      const pluginFileName = (hasNamespace ? `${pluginPathArr[pluginPathArr.length - 3].replace("@", "")}_${pluginPathArr[pluginPathArr.length - 2]}` : pluginPathArr[pluginPathArr.length - 2]).replaceAll("-", "_");
+      let exportStatement = "";
+      if (pluginPackageJsonPath.includes("packages")) {
+        const pluginSrcClientPath = relative(
+          this.packagesPath,
+          join(_dirname(pluginPackageJsonPath), "src", "client")
+        ).replaceAll(_sep, "/");
+        exportStatement = `export { default } from '${pluginSrcClientPath}';`;
+        exportStatement += "\n";
+        exportStatement += `export * from '${pluginSrcClientPath}';`;
+      } else {
+        exportStatement = `export { default } from '${pluginPackageJson.name}/client';`;
+        exportStatement += "\n";
+        exportStatement += `export * from '${pluginPackageJson.name}/client';`;
+      }
+      return { exportStatement, pluginFileName, packageJsonName: pluginPackageJson.name };
+    });
+    return pluginInfos;
+  }
+};
+export {
+  IndexGenerator,
+  getUmiConfig,
+  resolveTachybasePackagesAlias
+};

package/lib/plugin-generator.mjs

@@ -0,0 +1,63 @@
+// src/plugin-generator.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { URL } from "node:url";
+import { Generator } from "@umijs/utils";
+import chalk from "chalk";
+import { execa } from "execa";
+import { genTsConfigPaths } from "./util.mjs";
+var __dirname = new URL(".", import.meta.url).pathname;
+function camelize(str) {
+  return str.trim().replace(/[-_\s]+(.)?/g, (match, c) => c.toUpperCase());
+}
+function capitalize(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+async function getProjectVersion() {
+  const content = await readFile(resolve(process.cwd(), "package.json"), "utf-8");
+  const json = JSON.parse(content);
+  return json.version || "0.1.0";
+}
+var PluginGenerator = class extends Generator {
+  context;
+  log;
+  constructor(options) {
+    const { log, context = {}, ...opts } = options;
+    super(opts);
+    this.context = context;
+    this.log = log || console.log;
+  }
+  async getContext() {
+    const { name } = this.context;
+    const packageVersion = await getProjectVersion();
+    return {
+      ...this.context,
+      packageName: name,
+      packageVersion,
+      tachybaseVersion: "0.0.1",
+      pascalCaseName: capitalize(camelize(name.split("/").pop()))
+    };
+  }
+  async writing() {
+    const name = this.context.name.split("/").pop();
+    const target = resolve(process.cwd(), "packages/", name);
+    if (existsSync(target)) {
+      this.log(chalk.red(`[${name}] plugin already exists.`));
+      return;
+    }
+    this.log("Creating plugin");
+    this.copyDirectory({
+      target,
+      context: await this.getContext(),
+      path: join(__dirname, "../templates/plugin")
+    });
+    this.log("");
+    genTsConfigPaths();
+    execa("pnpm", ["postinstall"], { shell: true, stdio: "inherit" });
+    this.log(`The plugin folder is in ${chalk.green(`packages/${name}`)}`);
+  }
+};
+export {
+  PluginGenerator
+};