@umijs/utils 4.2.6-alpha.6 → 4.2.6

package/dist/BaseGenerator/BaseGenerator.d.ts

@@ -0,0 +1,18 @@
+import prompts from '../../compiled/prompts';
+import Generator, { type IGeneratorOpts } from '../Generator/Generator';
+interface IBaseGeneratorOpts extends Partial<Omit<IGeneratorOpts, 'args'>> {
+    path: string;
+    target: string;
+    data?: any;
+    questions?: prompts.PromptObject[];
+}
+export default class BaseGenerator extends Generator {
+    path: string;
+    target: string;
+    data: any;
+    questions: prompts.PromptObject[];
+    constructor({ path, target, data, questions, baseDir, slient, }: IBaseGeneratorOpts);
+    prompting(): prompts.PromptObject<string>[];
+    writing(): Promise<void>;
+}
+export {};

package/dist/BaseGenerator/BaseGenerator.js

@@ -0,0 +1,82 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BaseGenerator/BaseGenerator.ts
+var BaseGenerator_exports = {};
+__export(BaseGenerator_exports, {
+  default: () => BaseGenerator
+});
+module.exports = __toCommonJS(BaseGenerator_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_fs_extra = __toESM(require("../../compiled/fs-extra"));
+var import_Generator = __toESM(require("../Generator/Generator"));
+var BaseGenerator = class extends import_Generator.default {
+  constructor({
+    path,
+    target,
+    data,
+    questions,
+    baseDir,
+    slient
+  }) {
+    super({ baseDir: baseDir || target, args: data, slient });
+    this.path = path;
+    this.target = target;
+    this.data = data;
+    this.questions = questions || [];
+  }
+  prompting() {
+    return this.questions;
+  }
+  async writing() {
+    const context = {
+      ...this.data,
+      ...this.prompts
+    };
+    if ((0, import_fs.statSync)(this.path).isDirectory()) {
+      this.copyDirectory({
+        context,
+        path: this.path,
+        target: this.target
+      });
+    } else {
+      if (this.path.endsWith(".tpl")) {
+        this.copyTpl({
+          templatePath: this.path,
+          target: this.target,
+          context
+        });
+      } else {
+        const absTarget = this.target;
+        import_fs_extra.default.mkdirpSync((0, import_path.dirname)(absTarget));
+        (0, import_fs.copyFileSync)(this.path, absTarget);
+      }
+    }
+  }
+};

package/dist/BaseGenerator/generateFile.d.ts

@@ -0,0 +1,9 @@
+import prompts from '../../compiled/prompts';
+declare const generateFile: ({ path, target, baseDir, data, questions, }: {
+    path: string;
+    target: string;
+    baseDir?: string | undefined;
+    data?: any;
+    questions?: prompts.PromptObject<string>[] | undefined;
+}) => Promise<void>;
+export default generateFile;

package/dist/BaseGenerator/generateFile.js

@@ -0,0 +1,52 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BaseGenerator/generateFile.ts
+var generateFile_exports = {};
+__export(generateFile_exports, {
+  default: () => generateFile_default
+});
+module.exports = __toCommonJS(generateFile_exports);
+var import_BaseGenerator = __toESM(require("./BaseGenerator"));
+var generateFile = async ({
+  path,
+  target,
+  baseDir,
+  data,
+  questions
+}) => {
+  const generator = new import_BaseGenerator.default({
+    path,
+    target,
+    baseDir,
+    data,
+    questions
+  });
+  await generator.run();
+};
+var generateFile_default = generateFile;

package/dist/Generator/Generator.d.ts

@@ -0,0 +1,29 @@
+import yParser from '../../compiled/yargs-parser';
+export interface IGeneratorOpts {
+    baseDir: string;
+    args: yParser.Arguments;
+    slient?: boolean;
+}
+interface IGeneratorBaseOpts {
+    context: Record<string, any>;
+    target: string;
+}
+interface IGeneratorCopyTplOpts extends IGeneratorBaseOpts {
+    templatePath: string;
+}
+interface IGeneratorCopyDirectoryOpts extends IGeneratorBaseOpts {
+    path: string;
+}
+declare class Generator {
+    baseDir: string;
+    args: yParser.Arguments;
+    slient: boolean;
+    prompts: any;
+    constructor({ baseDir, args, slient }: IGeneratorOpts);
+    run(): Promise<void>;
+    prompting(): any;
+    writing(): Promise<void>;
+    copyTpl(opts: IGeneratorCopyTplOpts): void;
+    copyDirectory(opts: IGeneratorCopyDirectoryOpts): void;
+}
+export default Generator;

package/dist/Generator/Generator.js

@@ -0,0 +1,101 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Generator/Generator.ts
+var Generator_exports = {};
+__export(Generator_exports, {
+  default: () => Generator_default
+});
+module.exports = __toCommonJS(Generator_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_chalk = __toESM(require("../../compiled/chalk"));
+var import_fs_extra = __toESM(require("../../compiled/fs-extra"));
+var import_glob = __toESM(require("../../compiled/glob"));
+var import_mustache = __toESM(require("../../compiled/mustache"));
+var import_prompts = __toESM(require("../../compiled/prompts"));
+var Generator = class {
+  constructor({ baseDir, args, slient }) {
+    this.baseDir = baseDir;
+    this.args = args;
+    this.slient = !!slient;
+    this.prompts = {};
+  }
+  async run() {
+    const questions = this.prompting();
+    this.prompts = await (0, import_prompts.default)(questions, {
+      onCancel() {
+        process.exit(1);
+      }
+    });
+    await this.writing();
+  }
+  prompting() {
+    return [];
+  }
+  async writing() {
+  }
+  copyTpl(opts) {
+    const tpl = (0, import_fs.readFileSync)(opts.templatePath, "utf-8");
+    const content = import_mustache.default.render(tpl, opts.context);
+    import_fs_extra.default.mkdirpSync((0, import_path.dirname)(opts.target));
+    if (!this.slient) {
+      console.log(
+        `${import_chalk.default.green("Write:")} ${(0, import_path.relative)(this.baseDir, opts.target)}`
+      );
+    }
+    (0, import_fs.writeFileSync)(opts.target, content, "utf-8");
+  }
+  copyDirectory(opts) {
+    const files = import_glob.default.sync("**/*", {
+      cwd: opts.path,
+      dot: true,
+      ignore: ["**/node_modules/**"]
+    });
+    files.forEach((file) => {
+      const absFile = (0, import_path.join)(opts.path, file);
+      if ((0, import_fs.statSync)(absFile).isDirectory())
+        return;
+      if (file.endsWith(".tpl")) {
+        this.copyTpl({
+          templatePath: absFile,
+          target: (0, import_path.join)(opts.target, file.replace(/\.tpl$/, "")),
+          context: opts.context
+        });
+      } else {
+        if (!this.slient) {
+          console.log(`${import_chalk.default.green("Copy: ")} ${file}`);
+        }
+        const absTarget = (0, import_path.join)(opts.target, file);
+        import_fs_extra.default.mkdirpSync((0, import_path.dirname)(absTarget));
+        (0, import_fs.copyFileSync)(absFile, absTarget);
+      }
+    });
+  }
+};
+var Generator_default = Generator;

package/dist/aliasUtils/getAliasValue.d.ts

@@ -0,0 +1,4 @@
+export declare function getAliasValue(opts: {
+    imported: string;
+    alias: Record<string, string>;
+}): string | undefined;

package/dist/aliasUtils/getAliasValue.js

@@ -0,0 +1,66 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aliasUtils/getAliasValue.ts
+var getAliasValue_exports = {};
+__export(getAliasValue_exports, {
+  getAliasValue: () => getAliasValue
+});
+module.exports = __toCommonJS(getAliasValue_exports);
+var import_path = __toESM(require("path"));
+function getAliasValue(opts) {
+  const { imported, alias } = opts;
+  if (alias[imported]) {
+    return alias[imported];
+  }
+  for (const key of Object.keys(alias)) {
+    const value = alias[key];
+    if (key.endsWith("$")) {
+      if (imported === key.slice(0, -1)) {
+        return value;
+      } else {
+        continue;
+      }
+    }
+    const keyWithLastSlash = addLastSlash(key);
+    if (imported.startsWith(keyWithLastSlash)) {
+      const isWinPath = process.platform === "win32" && value.includes(import_path.default.sep);
+      if (isWinPath) {
+        return import_path.default.join(value, imported.slice(keyWithLastSlash.length));
+      }
+      return imported.replace(keyWithLastSlash, addLastSlash(value));
+    }
+  }
+}
+function addLastSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAliasValue
+});

package/dist/aliasUtils/index.d.ts

@@ -0,0 +1,2 @@
+export { getAliasValue } from './getAliasValue';
+export { parseCircleAlias } from './parseCircleAlias';

package/dist/aliasUtils/index.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aliasUtils/index.ts
+var aliasUtils_exports = {};
+__export(aliasUtils_exports, {
+  getAliasValue: () => import_getAliasValue.getAliasValue,
+  parseCircleAlias: () => import_parseCircleAlias.parseCircleAlias
+});
+module.exports = __toCommonJS(aliasUtils_exports);
+var import_getAliasValue = require("./getAliasValue");
+var import_parseCircleAlias = require("./parseCircleAlias");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAliasValue,
+  parseCircleAlias
+});

package/dist/aliasUtils/parseCircleAlias.d.ts

@@ -0,0 +1,4 @@
+export declare const parseCircleAlias: (opts: {
+    alias: Record<string, string>;
+    maxDepth?: number;
+}) => Record<string, any>;

package/dist/aliasUtils/parseCircleAlias.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aliasUtils/parseCircleAlias.ts
+var parseCircleAlias_exports = {};
+__export(parseCircleAlias_exports, {
+  parseCircleAlias: () => parseCircleAlias
+});
+module.exports = __toCommonJS(parseCircleAlias_exports);
+var import_path = require("path");
+var import_fs_extra = require("../../compiled/fs-extra");
+var import_getAliasValue = require("./getAliasValue");
+var DEFAULT_MAX_DEPTH = 5;
+var parseCircleAlias = (opts) => {
+  const { alias, maxDepth = DEFAULT_MAX_DEPTH } = opts;
+  const isExist = (value) => {
+    return value.startsWith(".") || (0, import_path.isAbsolute)(value) || (0, import_fs_extra.existsSync)(value);
+  };
+  const parsed = {};
+  Object.entries(alias).forEach(([key, value]) => {
+    if (isExist(value)) {
+      parsed[key] = value;
+    } else {
+      let realPath = value;
+      for (let i = 0; i < maxDepth; i++) {
+        const deeperPath = (0, import_getAliasValue.getAliasValue)({ imported: realPath, alias });
+        if (!deeperPath) {
+          parsed[key] = realPath;
+          break;
+        } else {
+          if (isExist(deeperPath)) {
+            parsed[key] = deeperPath;
+            break;
+          } else {
+            realPath = deeperPath;
+          }
+        }
+        if (i === maxDepth - 1) {
+          throw Error(
+            `endless loop detected in resolve alias for '${key}': '${value}', please check your alias config.`
+          );
+        }
+      }
+    }
+  });
+  return parsed;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCircleAlias
+});

package/dist/getCorejsVersion.d.ts

@@ -0,0 +1 @@
+export declare const getCorejsVersion: (pkgPath: string) => any;

package/dist/getCorejsVersion.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/getCorejsVersion.ts
+var getCorejsVersion_exports = {};
+__export(getCorejsVersion_exports, {
+  getCorejsVersion: () => getCorejsVersion
+});
+module.exports = __toCommonJS(getCorejsVersion_exports);
+var import_fs_extra = require("../compiled/fs-extra");
+var getCorejsVersion = (pkgPath) => {
+  var _a;
+  const pkg = (0, import_fs_extra.readJsonSync)(pkgPath, { encoding: "utf-8" });
+  const version = ((_a = pkg.dependencies["core-js"]) == null ? void 0 : _a.split(".").slice(0, 2).join(".")) || "3";
+  return version;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCorejsVersion
+});

package/dist/getDevBanner.d.ts

@@ -0,0 +1,5 @@
+export declare function getDevBanner(protocol: string, host: string | undefined, port: number, offset?: number): {
+    before: string;
+    main: string;
+    after: string;
+};

package/dist/getDevBanner.js

@@ -0,0 +1,81 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/getDevBanner.ts
+var getDevBanner_exports = {};
+__export(getDevBanner_exports, {
+  getDevBanner: () => getDevBanner
+});
+module.exports = __toCommonJS(getDevBanner_exports);
+var import_address = __toESM(require("../compiled/address"));
+var import_chalk = __toESM(require("../compiled/chalk"));
+var import_strip_ansi = __toESM(require("../compiled/strip-ansi"));
+var BORDERS = {
+  TL: import_chalk.default.gray.dim("╔"),
+  TR: import_chalk.default.gray.dim("╗"),
+  BL: import_chalk.default.gray.dim("╚"),
+  BR: import_chalk.default.gray.dim("╝"),
+  V: import_chalk.default.gray.dim("║"),
+  H_PURE: "═"
+};
+function getDevBanner(protocol, host = "0.0.0.0", port, offset = 8) {
+  const header = " App listening at:";
+  const footer = import_chalk.default.bold(
+    " Now you can open browser with the above addresses↑ "
+  );
+  const local = `  ${import_chalk.default.gray(">")}   Local: ${import_chalk.default.green(
+    `${protocol}//${host === "0.0.0.0" ? "localhost" : host}:${port}`
+  )} `;
+  const ip = import_address.default.ip();
+  const network = `  ${import_chalk.default.gray(">")} Network: ${ip ? import_chalk.default.green(`${protocol}//${ip}:${port}`) : import_chalk.default.gray("Not available")} `;
+  const maxLen = Math.max(
+    ...[header, footer, local, network].map((x) => (0, import_strip_ansi.default)(x).length)
+  );
+  const beforeLines = [
+    `${BORDERS.TL}${import_chalk.default.gray.dim("".padStart(maxLen, BORDERS.H_PURE))}${BORDERS.TR}`,
+    `${BORDERS.V}${header}${"".padStart(maxLen - header.length)}${BORDERS.V}`,
+    `${BORDERS.V}${local}${"".padStart(maxLen - (0, import_strip_ansi.default)(local).length)}${BORDERS.V}`
+  ];
+  const mainLine = `${BORDERS.V}${network}${"".padStart(
+    maxLen - (0, import_strip_ansi.default)(network).length
+  )}${BORDERS.V}`;
+  const afterLines = [
+    `${BORDERS.V}${"".padStart(maxLen)}${BORDERS.V}`,
+    `${BORDERS.V}${footer}${"".padStart(maxLen - (0, import_strip_ansi.default)(footer).length)}${BORDERS.V}`,
+    `${BORDERS.BL}${import_chalk.default.gray.dim("".padStart(maxLen, BORDERS.H_PURE))}${BORDERS.BR}`
+  ];
+  return {
+    before: beforeLines.map((l) => l.padStart(l.length + offset)).join("\n"),
+    main: mainLine,
+    after: afterLines.map((l) => l.padStart(l.length + offset)).join("\n")
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDevBanner
+});

package/dist/getFileGitIno.d.ts

@@ -0,0 +1,47 @@
+export interface ICreateInfo {
+    createTime?: string;
+    creator?: string;
+    creatorEmail?: string;
+    createSince?: string;
+}
+export interface IModifyInfo {
+    modifyTime?: string;
+    modifier?: string;
+    modifierEmail?: string;
+    modifySince?: string;
+}
+/**
+ * 获取文件创建信息
+ * @param filePath 文件路径，绝对或相对 .git
+ * @param gitDirPath .git路径
+ * @returns
+ */
+export declare const getFileCreateInfo: (filePath: string, gitDirPath?: string) => Promise<{
+    createTime: string | undefined;
+    creator: string | undefined;
+    creatorEmail: string | undefined;
+    createSince: string | undefined;
+} | {
+    createTime?: undefined;
+    creator?: undefined;
+    creatorEmail?: undefined;
+    createSince?: undefined;
+}>;
+/**
+ * 获取文件最新修改信息
+ * @param filePath 文件路径，绝对或相对 .git
+ * @param gitDirPath .git路径
+ * @returns
+ */
+export declare const getFileLastModifyInfo: (filePath: string, gitDirPath?: string) => Promise<{
+    modifyTime: string | undefined;
+    modifier: string | undefined;
+    modifierEmail: string | undefined;
+    modifySince: string | undefined;
+} | {
+    modifyTime?: undefined;
+    modifier?: undefined;
+    modifierEmail?: undefined;
+    modifySince?: undefined;
+}>;
+export declare const isGitRepo: () => Promise<boolean>;