longmo-unplugin-info 1.0.0

package/dist/shared/longmo-unplugin-info.D5mpeSYM.cjs

@@ -0,0 +1,619 @@
+'use strict';
+
+const path = require('node:path');
+const process$1 = require('node:process');
+const unplugin = require('unplugin');
+const ci = require('ci-info');
+const simpleGit = require('simple-git');
+const parseGitUrl = require('git-url-parse');
+const node_child_process = require('node:child_process');
+const node_util = require('node:util');
+const fs = require('node:fs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process$1);
+const ci__default = /*#__PURE__*/_interopDefaultCompat(ci);
+const parseGitUrl__default = /*#__PURE__*/_interopDefaultCompat(parseGitUrl);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+class BuildInfoModule {
+  name;
+  root;
+  options;
+  constructor(name, root, options) {
+    this.name = `${options?.prefix ?? "~build"}/${name}`;
+    this.root = root;
+    this.options = options;
+  }
+  buildStart(ctx) {
+  }
+  buildEnd(ctx) {
+  }
+}
+
+class BuildTimeModule extends BuildInfoModule {
+  now;
+  constructor(root, options) {
+    super("time", root, options);
+  }
+  buildStart() {
+    this.now = this.options.time ? this.options.time : /* @__PURE__ */ new Date();
+  }
+  load() {
+    return `const time = new Date(${this.now.getTime()})
+export default time`;
+  }
+}
+
+async function getRepoInfo(root, extra = {}) {
+  const git = simpleGit.simpleGit(root);
+  if (!await git.checkIsRepo()) {
+    return void 0;
+  }
+  const [branch, currentCommit, committer, describe, tags, github, result] = await Promise.all([
+    getBranch(git),
+    getCommit(git),
+    getCommitter(git),
+    getDescribe(git),
+    getTags(git),
+    getGitHubUrl(git),
+    Promise.all(
+      Object.entries(extra).map(async ([key, fn]) => {
+        return [key, await fn(git)];
+      })
+    )
+  ]);
+  return {
+    ...branch,
+    ...currentCommit,
+    ...committer,
+    ...describe,
+    ...tags,
+    ...github,
+    ...Object.fromEntries(result)
+  };
+}
+async function getBranch(git) {
+  try {
+    const branch = (await git.branch([])).current;
+    return { branch };
+  } catch (error) {
+    return { branch: void 0 };
+  }
+}
+async function getCommit(git) {
+  try {
+    const log = await git.log(["-1"]);
+    const sha = log.latest?.hash;
+    const commitMessage = log.latest?.message;
+    const author = log.latest?.author_name;
+    const authorEmail = log.latest?.author_email;
+    const authorDate = log.latest?.date;
+    return {
+      sha,
+      abbreviatedSha: sha?.slice(0, 10),
+      commitMessage,
+      author,
+      authorEmail,
+      authorDate
+    };
+  } catch (error) {
+    return {
+      sha: void 0,
+      abbreviatedSha: void 0,
+      commitMessage: void 0,
+      author: void 0,
+      authorEmail: void 0,
+      authorDate: void 0
+    };
+  }
+}
+function removeLineBreak(str) {
+  return str.replace(/[\s\r\n]+$/, "");
+}
+async function getCommitter(git) {
+  try {
+    const [committer, committerEmail, committerDate] = await Promise.all([
+      git.show(["-s", "--format=%cn"]),
+      git.show(["-s", "--format=%ce"]),
+      git.show(["-s", "--format=%cd"])
+    ]);
+    return {
+      committer: removeLineBreak(committer),
+      committerEmail: removeLineBreak(committerEmail),
+      committerDate: removeLineBreak(committerDate)
+    };
+  } catch (error) {
+    return {
+      committer: void 0,
+      committerEmail: void 0,
+      committerDate: void 0
+    };
+  }
+}
+async function getTags(git) {
+  try {
+    const hash = await git.revparse(["HEAD"]);
+    const tags = await git.tags(["--points-at", hash]);
+    const all = await git.tags();
+    return { tag: tags.all[tags.all.length - 1], tags: tags.all, lastTag: all.latest };
+  } catch (error) {
+    return { tags: void 0, lastTag: void 0 };
+  }
+}
+async function getDescribe(git) {
+  try {
+    const output = await git.raw(["describe", "--always"]);
+    return {
+      describe: removeLineBreak(output)
+    };
+  } catch (error) {
+    return {
+      describe: void 0
+    };
+  }
+}
+async function getGitHubUrl(git) {
+  const remotes = await git.getRemotes(true);
+  const origin = remotes.find((remote) => remote.name === "origin");
+  const url = origin?.refs.fetch;
+  if (url) {
+    const parsed = parseGitUrl__default(url);
+    if (parsed.resource === "github.com" && parsed.full_name) {
+      return { github: `https://github.com/${parsed.full_name}` };
+    }
+  }
+  return { github: void 0 };
+}
+
+class BuildGitModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("git", root, options);
+  }
+  async load(ctx, id) {
+    const { root, options } = this;
+    const info = await getRepoInfo(root, options?.git);
+    if (info && options?.github) {
+      info.github = options.github;
+    }
+    if (!info) {
+      ctx.warn("This may not be a git repo");
+    }
+    const keys = [
+      .../* @__PURE__ */ new Set([
+        "github",
+        "sha",
+        "abbreviatedSha",
+        "branch",
+        "tag",
+        "tags",
+        "lastTag",
+        "describe",
+        "author",
+        "authorEmail",
+        "authorDate",
+        "committer",
+        "committerEmail",
+        "committerDate",
+        "commitMessage",
+        ...Object.keys(options?.git ?? {})
+      ])
+    ];
+    const gen = (key) => {
+      return `export const ${key} = ${info ? JSON.stringify(info[key]) : "null"}`;
+    };
+    return [
+      // Support legacy ~build/info module
+      id.endsWith("info") ? `export const CI = ${ci__default.isCI ? `"${ci__default.name}"` : "null"}` : ``,
+      ...keys.map((key) => gen(key))
+    ].join("\n");
+  }
+}
+
+const execAsync = node_util.promisify(node_child_process.exec);
+async function getSvnInfo(root, extra = {}) {
+  try {
+    const svnDir = await execSync("svn info --show-item wc-root", root);
+    if (!svnDir) {
+      return void 0;
+    }
+    const [info, lastCommit, log, extraResult] = await Promise.all([
+      getSvnBasicInfo(root),
+      getLastCommit(root),
+      getCommitLog(root),
+      Promise.all(
+        Object.entries(extra).map(async ([key, fn]) => {
+          return [key, await fn(null)];
+        })
+      )
+    ]);
+    return {
+      ...info,
+      ...lastCommit,
+      ...log,
+      ...Object.fromEntries(extraResult)
+    };
+  } catch (error) {
+    return void 0;
+  }
+}
+async function getSvnBasicInfo(root) {
+  try {
+    const output = await execSync("svn info", root);
+    const lines = output.split("\n");
+    const info = {};
+    for (const line of lines) {
+      const match = line.match(/^([^:]+):\s*(.+)$/);
+      if (match) {
+        const key = toCamelCase(match[1].trim());
+        info[key] = match[2].trim();
+      }
+    }
+    return {
+      url: info["URL"],
+      repositoryRoot: info["Repository Root"],
+      repositoryUuid: info["Repository UUID"],
+      revision: info["Revision"],
+      nodeKind: info["Node Kind"],
+      lastChangedRev: info["Last Changed Rev"],
+      lastChangedDate: info["Last Changed Date"],
+      lastChangedAuthor: info["Last Changed Author"]
+    };
+  } catch (error) {
+    return {
+      url: void 0,
+      repositoryRoot: void 0,
+      repositoryUuid: void 0,
+      revision: void 0,
+      nodeKind: void 0,
+      lastChangedRev: void 0,
+      lastChangedDate: void 0,
+      lastChangedAuthor: void 0
+    };
+  }
+}
+async function getLastCommit(root) {
+  try {
+    const output = await execSync("svn log -l 1 --xml", root);
+    const logEntry = parseSvnXmlLog(output);
+    return {
+      sha: logEntry?.revision,
+      abbreviatedSha: logEntry?.revision,
+      commitMessage: logEntry?.msg,
+      author: logEntry?.author,
+      authorDate: logEntry?.date,
+      authorEmail: void 0
+      // SVN 不包含邮箱信息
+    };
+  } catch (error) {
+    return {
+      sha: void 0,
+      abbreviatedSha: void 0,
+      commitMessage: void 0,
+      author: void 0,
+      authorDate: void 0,
+      authorEmail: void 0
+    };
+  }
+}
+async function getCommitLog(root) {
+  try {
+    const output = await execSync("svn log -l 10 --xml", root);
+    const logs = parseSvnXmlLogs(output);
+    const lastTag = await getBranchOrTag(root);
+    return {
+      branch: lastTag || void 0,
+      tag: lastTag || void 0,
+      tags: logs.map((log) => log.revision),
+      lastTag: lastTag || void 0,
+      describe: `r${logs[0]?.revision || ""}`
+    };
+  } catch (error) {
+    return {
+      branch: void 0,
+      tag: void 0,
+      tags: [],
+      lastTag: void 0,
+      describe: void 0
+    };
+  }
+}
+async function getBranchOrTag(root) {
+  try {
+    const url = await execSync("svn info --show-item url", root);
+    if (url.includes("/trunk/")) {
+      return "trunk";
+    }
+    if (url.includes("/branches/")) {
+      const match = url.match(/\/branches\/([^\/]+)/);
+      return match ? match[1] : void 0;
+    }
+    if (url.includes("/tags/")) {
+      const match = url.match(/\/tags\/([^\/]+)/);
+      return match ? match[1] : void 0;
+    }
+    return void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+function parseSvnXmlLog(xml) {
+  try {
+    const entryMatch = xml.match(/<logentry[^>]*revision="(\d+)"[^>]*>/);
+    if (!entryMatch) return null;
+    const authorMatch = xml.match(/<author>([^<]+)<\/author>/);
+    const dateMatch = xml.match(/<date>([^<]+)<\/date>/);
+    const msgMatch = xml.match(/<msg>([^<]*)<\/msg>/);
+    return {
+      revision: entryMatch[1],
+      author: authorMatch?.[1] || "",
+      date: dateMatch?.[1] || "",
+      msg: msgMatch?.[1] || ""
+    };
+  } catch (error) {
+    return null;
+  }
+}
+function parseSvnXmlLogs(xml) {
+  try {
+    const entries = [];
+    const regex = /<logentry[^>]*revision="(\d+)"[^>]*>[\s\S]*?<author>([^<]+)<\/author>[\s\S]*?<date>([^<]+)<\/date>[\s\S]*?<msg>([^<]*)<\/msg>[\s\S]*?<\/logentry>/g;
+    let match;
+    while ((match = regex.exec(xml)) !== null) {
+      entries.push({
+        revision: match[1],
+        author: match[2],
+        date: match[3],
+        msg: match[4]
+      });
+    }
+    return entries;
+  } catch (error) {
+    return [];
+  }
+}
+function toCamelCase(str) {
+  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+    return index === 0 ? word.toLowerCase() : word.toUpperCase();
+  }).replace(/\s+/g, "");
+}
+function execSync(command, cwd) {
+  return execAsync(command, { cwd, encoding: "utf-8" }).then((res) => res.stdout.trim()).catch(() => "");
+}
+
+class BuildSvnModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("svn", root, options);
+  }
+  async load(ctx, id) {
+    const { root, options } = this;
+    const info = await getSvnInfo(root, options?.svn);
+    if (!info) {
+      ctx.warn("This may not be a svn repo");
+    }
+    const keys = [
+      .../* @__PURE__ */ new Set([
+        "url",
+        "repositoryRoot",
+        "repositoryUuid",
+        "revision",
+        "nodeKind",
+        "lastChangedRev",
+        "lastChangedDate",
+        "lastChangedAuthor",
+        "sha",
+        "abbreviatedSha",
+        "commitMessage",
+        "author",
+        "authorDate",
+        "authorEmail",
+        "branch",
+        "tag",
+        "tags",
+        "lastTag",
+        "describe",
+        ...Object.keys(options?.svn ?? {})
+      ])
+    ];
+    const gen = (key) => {
+      return `export const ${key} = ${info ? JSON.stringify(info[key]) : "null"}`;
+    };
+    return keys.map((key) => gen(key)).join("\n");
+  }
+}
+
+class LegacyInfoModule extends BuildGitModule {
+  constructor(root, options) {
+    super(root, options);
+    this.name = `${options.prefix ?? "~build"}/info`;
+  }
+}
+
+class BuildConsoleModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("console", root, options);
+  }
+  load() {
+    const { environment = ["development", "production"] } = this.options.console ?? {};
+    return [
+      `import time from '~build/time';`,
+      `import { isCI } from '~build/ci';`,
+      `import { github } from '~build/git';`,
+      `import { name, version } from '~build/package';`,
+      ``,
+      `export const print = () => {`,
+      `  if (!${JSON.stringify(environment)}.includes(process.env.NODE_ENV)) return;`,
+      `  if (typeof import.meta?.env?.SSR !== 'undefined' && import.meta.env.SSR) return;`,
+      `  console.groupCollapsed('~build/console');`,
+      `  console.log('Project:', name);`,
+      `  console.log('Build-at:', time ? time.toLocaleString() : 'Unknown');`,
+      `  console.log('Environment:', \`${process.env.NODE_ENV}\${isCI ? '(ci)' : ''}\`);`,
+      `  console.log('Version:', version);`,
+      `  console.log('GitHub:', github);`,
+      `  console.groupEnd();`,
+      `};`,
+      ``,
+      `print();`
+    ].join("\n");
+  }
+}
+
+class BuildCIModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("ci", root, options);
+  }
+  load() {
+    return [
+      `export const isCI = ${ci__default.isCI !== null ? ci__default.isCI ? "true" : "false" : "null"}`,
+      `export const isPR = ${ci__default.isPR !== null ? ci__default.isPR ? "true" : "false" : "null"}`,
+      `export const name = ${ci__default.name !== null ? `\`${ci__default.name}\`` : "null"}`
+    ].join("\n");
+  }
+}
+
+class BuildMetaModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("meta", root, options);
+  }
+  async load() {
+    const { options } = this;
+    const get = () => {
+      if (!options?.meta) return {};
+      if (typeof options.meta === "function") {
+        return options.meta();
+      }
+      return options.meta;
+    };
+    const meta = await get();
+    const body = Object.entries(meta).map(
+      ([key, value]) => `export const ${key} = ${JSON.stringify(value, null, 2)};`
+    );
+    return body.length > 0 ? body.join("\n") : "export {};";
+  }
+}
+
+class BuildEnvModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("env", root, options);
+  }
+  async load() {
+    const { options } = this;
+    const get = () => {
+      if (!options?.env) return {};
+      if (typeof options.env === "function") {
+        return options.env();
+      }
+      return options.env;
+    };
+    const cloudflare = options.cloudflare === true;
+    const meta = await get();
+    const body = Object.entries(meta).map(
+      ([key, value]) => !cloudflare ? `export const ${key} = (typeof import.meta?.env?.SSR !== 'undefined' && import.meta.env.SSR ? process?.env?.['${key.replace(/'/g, "\\\\")}'] : undefined) ?? ${JSON.stringify(value, null, 2)};` : `export const ${key} = ${JSON.stringify(value, null, 2)};`
+    );
+    return body.length > 0 ? body.join("\n") : "export {};";
+  }
+}
+
+class BuildPackageModule extends BuildInfoModule {
+  constructor(root, options) {
+    super("package", root, options);
+  }
+  load() {
+    const { root, options } = this;
+    const pkg = JSON.parse(fs__default.readFileSync(path__default.join(root, "package.json"), "utf-8"));
+    const defaults = ["name", "version", "description", "keywords", "license", "author"];
+    const keys = new Set(
+      Array.isArray(options?.package) ? [...defaults, ...options.package] : typeof options?.package === "object" ? Object.entries(
+        Object.fromEntries([
+          ...defaults.map((d) => [d, true]),
+          ...Object.entries(options.package)
+        ])
+      ).filter(([k, v]) => !!v).map(([k, v]) => k) : defaults
+    );
+    const resolved = {
+      name: "",
+      version: "0.0.0",
+      description: "",
+      keywords: [],
+      license: "",
+      author: "",
+      ...pkg
+    };
+    const entries = [...keys].map((key) => [key, resolved[key]]);
+    return entries.map(([key, value]) => `export const ${key} = ${JSON.stringify(value, null, 2)};`).join("\n");
+  }
+}
+
+const UnpluginInfo = /* @__PURE__ */ unplugin.createUnplugin(
+  (options = {}, meta) => {
+    const root = path__default.resolve(options?.root ?? process__default.cwd());
+    const modules = {
+      Time: new BuildTimeModule(root, options),
+      Git: new BuildGitModule(root, options),
+      Svn: new BuildSvnModule(root, options),
+      CI: new BuildCIModule(root, options),
+      Info: new LegacyInfoModule(root, options),
+      Console: new BuildConsoleModule(root, options),
+      Meta: new BuildMetaModule(root, options),
+      Env: new BuildEnvModule(root, options),
+      Package: new BuildPackageModule(root, options)
+    };
+    return {
+      name: "unplugin-info",
+      async buildStart() {
+        await Promise.all(Object.values(modules).map((mod) => mod.buildStart(this)));
+      },
+      async buildEnd() {
+        await Promise.all(Object.values(modules).map((mod) => mod.buildEnd(this)));
+      },
+      resolveId(id) {
+        if (Object.values(modules).map((m) => m.name).includes(id)) {
+          return `\0${id}`;
+        }
+      },
+      loadInclude(id) {
+        if (!id.startsWith("\0")) return false;
+        id = id.slice(1);
+        return Object.values(modules).map((m) => m.name).includes(id);
+      },
+      async load(id) {
+        if (!id.startsWith("\0")) return;
+        id = id.slice(1);
+        for (const mod of Object.values(modules)) {
+          if (id === mod.name) {
+            if (id === modules.Info.name) {
+              this.warn(
+                `${modules.Info.name} is deprecated, please migrate to ${modules.Git.name} and ${modules.CI.name}.`
+              );
+            }
+            if (id === modules.Env.name && meta.framework !== "vite") {
+              this.warn(`${modules.Env.name} is only supported in Vite.`);
+              return;
+            }
+            return mod.load(this, id);
+          }
+        }
+      },
+      vite: {
+        handleHotUpdate({ file, server }) {
+          if (file === normalizePath(path__default.resolve(root, "package.json"))) {
+            const module = server.moduleGraph.getModuleById("\0" + modules.Package.name);
+            if (module) {
+              server.moduleGraph.invalidateModule(module);
+              server.ws.send({
+                type: "full-reload"
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+);
+function normalizePath(filename) {
+  return filename.split(path__default.win32.sep).join(path__default.posix.sep);
+}
+
+exports.UnpluginInfo = UnpluginInfo;

package/dist/shared/longmo-unplugin-info.zS6I--Tu.d.cts

@@ -0,0 +1,69 @@
+import { SimpleGit } from 'simple-git';
+
+type Metadata = Record<string | number, any>;
+type Env = Record<string | number, any>;
+type ConsoleField = string;
+interface Options {
+    /**
+     * Git repo root path
+     */
+    root?: string;
+    /**
+     * Github repo url
+     */
+    github?: string;
+    /**
+     * Sepcify build time manually
+     */
+    time?: Date;
+    /**
+     * Custom the exported fields in ~build/git
+     */
+    git?: Record<string, (git: SimpleGit) => Promise<any> | any>;
+    /**
+     * Custom the exported fields in ~build/svn
+     */
+    svn?: Record<string, (info: any) => Promise<any> | any>;
+    /**
+     * Filter exported fields of package.json
+     */
+    package?: string[] | Record<string, boolean | null | undefined>;
+    /**
+     * Pass some meta data to Vite app
+     *
+     * Notice: meta data will be serialized to JSON format
+     */
+    meta?: Metadata | (() => Metadata | Promise<Metadata>);
+    /**
+     * Pass environment variables to Vite SSR app
+     *
+     * For each key / value record
+     * - In the SSR environment, it will read the environment variable (e.g. process.env.<key>)
+     * - In the client environment, it will return the provided default value
+     */
+    env?: Metadata | (() => Env | Promise<Env>);
+    /**
+     * Print help build information
+     */
+    console?: {
+        /**
+         * Enable build info log under these NODE_ENV
+         *
+         * @default ['development','production']
+         */
+        environment?: string[];
+        fields?: ConsoleField[] | Record<string, ConsoleField>;
+    };
+    /**
+     * Custom virtual module prefix
+     *
+     * @default '~build'
+     */
+    prefix?: string;
+    /**
+     * Whether it is bundled for cloudflare worker runtime
+     */
+    cloudflare?: boolean;
+}
+
+export type { Options as O };