@biuxiu/codegen 0.1.1

package/dist/format/dto.js

@@ -0,0 +1,116 @@
+"use strict";
+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);
+var dto_exports = {};
+__export(dto_exports, {
+  DTOFromat: () => DTOFromat
+});
+module.exports = __toCommonJS(dto_exports);
+var import_base = require("./base");
+class DTOFromat extends import_base.BaseFormat {
+  constructor(dto) {
+    super(dto);
+  }
+  #formatType() {
+    const curSchema = this.getCurSchema();
+    this.content += `readonly ${curSchema.key}:${curSchema.type}
+
+`;
+  }
+  #setSimpleRule(key, val) {
+    if (!this.importInfo.includes(`${key},`)) {
+      this.importInfo += `${key},`;
+    }
+    this.content += val ? `@${key}({ message: '${val}' })
+` : `@${key}()
+`;
+  }
+  #max(max, msg, type) {
+    if (type === "number") {
+      if (!this.importInfo.includes("Max,")) {
+        this.importInfo += "Max,";
+      }
+      this.content += `@Max(${max}, { message: '${msg}' })
+`;
+    } else if (type === "string") {
+      if (!this.importInfo.includes("MaxLength,")) {
+        this.importInfo += "MaxLength,";
+      }
+      this.content += `@MaxLength(${max}, { message: '${msg}' })
+`;
+    }
+  }
+  #min(min, msg, type) {
+    if (type === "number") {
+      if (!this.importInfo.includes("Min,")) {
+        this.importInfo += "Min,";
+      }
+      this.content += `@Min(${min}, { message: '${msg}' })
+`;
+    } else if (type === "string") {
+      if (!this.importInfo.includes("MinLength,")) {
+        this.importInfo += "MinLength,";
+      }
+      this.content += `@MinLength(${min}, { message: '${msg}' })
+`;
+    }
+  }
+  #limit(max, min, msg, type) {
+    if (type === "number") {
+      this.#max(max, msg, type);
+      this.#min(min, msg, type);
+    } else if (type === "string") {
+      if (!this.importInfo.includes("Length,")) {
+        this.importInfo += "Length,";
+      }
+      this.content += `@Length(${min}, ${max}, { message: '${msg}' })
+`;
+    }
+  }
+  #formatRule() {
+    const { type, isInt, isOptional, isNumber, notEmpty, limit } = this.getCurSchema();
+    if (isOptional) this.#setSimpleRule("IsOptional");
+    if (notEmpty) this.#setSimpleRule("IsNotEmpty", notEmpty);
+    if (isInt) this.#setSimpleRule("IsInt", isInt);
+    if (isNumber) this.#setSimpleRule("IsNumber", isNumber);
+    if (limit) {
+      const { max, min, msg } = limit;
+      if (max !== void 0 && min !== void 0) {
+        this.#limit(max, min, msg, type);
+      } else if (max !== void 0) {
+        this.#max(max, msg, type);
+      } else if (min !== void 0) {
+        this.#min(min, msg, type);
+      }
+    }
+  }
+  formatOnceStep() {
+    this.#formatRule();
+    this.#formatType();
+  }
+  formatEnd() {
+    if (this.importInfo) {
+      this.importInfo = `import { ${this.importInfo.slice(0, this.importInfo.length - 1)} } from 'class-validator'
+`;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DTOFromat
+});

package/dist/format/entity.d.ts

@@ -0,0 +1,7 @@
+import { EntityField } from '@/types';
+import { BaseFormat } from './base';
+export declare class EntityFormat extends BaseFormat<EntityField> {
+    #private;
+    constructor(entity: EntityField[]);
+    protected formatOnceStep(): void;
+}

package/dist/format/entity.js

@@ -0,0 +1,68 @@
+"use strict";
+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);
+var entity_exports = {};
+__export(entity_exports, {
+  EntityFormat: () => EntityFormat
+});
+module.exports = __toCommonJS(entity_exports);
+var import_base = require("./base");
+class EntityFormat extends import_base.BaseFormat {
+  #columnStr = "";
+  constructor(entity) {
+    super(entity);
+  }
+  formatOnceStep() {
+    const {
+      key,
+      type,
+      isExclude,
+      comment,
+      nullable,
+      dataType,
+      name,
+      length
+    } = this.getCurSchema();
+    if (isExclude) {
+      if (!this.importInfo) {
+        this.importInfo += "import { Exclude } from 'class-transformer'\n";
+      }
+      this.content += "@Exclude()\n";
+    }
+    if (name) this.#columnStr += `name: '${name}',`;
+    if (comment) this.#columnStr += `comment: '${comment}',`;
+    if (nullable) this.#columnStr += `nullable: true,`;
+    if (dataType) this.#columnStr += `type: '${dataType}',`;
+    if (length) this.#columnStr += `length: '${length}',`;
+    if (this.#columnStr) {
+      this.content += `@Column({ ${this.#columnStr.slice(0, this.#columnStr.length - 1)} })
+`;
+    } else {
+      this.content += `@Column()
+`;
+    }
+    this.#columnStr = "";
+    this.content += `${key}:${type}
+
+`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EntityFormat
+});

package/dist/format/service.d.ts

@@ -0,0 +1,8 @@
+import { ApiServiceField } from '@/types';
+import { BaseFormat } from './base';
+export declare class ServiceFormat extends BaseFormat<ApiServiceField> {
+    #private;
+    constructor(moduleName: string, apiService: ApiServiceField[]);
+    protected formatOnceStep(): void;
+    protected formatEnd(): void;
+}

package/dist/format/service.js

@@ -0,0 +1,93 @@
+"use strict";
+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);
+var service_exports = {};
+__export(service_exports, {
+  ServiceFormat: () => ServiceFormat
+});
+module.exports = __toCommonJS(service_exports);
+var import_base = require("./base");
+class ServiceFormat extends import_base.BaseFormat {
+  #moudleName;
+  #upperName;
+  #serviceMap = {};
+  constructor(moduleName, apiService) {
+    super(apiService);
+    this.#moudleName = moduleName;
+    this.#upperName = moduleName[0].toUpperCase() + moduleName.slice(1);
+  }
+  formatOnceStep() {
+    const { key } = this.getCurSchema();
+    if (this.#serviceMap[key]) {
+      return;
+    }
+    this.#serviceMap[key] = true;
+    if (key === "get") {
+      this.content += `
+            	query(id: number) {
+		            return this.${this.#moudleName}Repository.findOneBy({ id })
+	            }
+`;
+    } else if (key === "all") {
+      this.content += `
+                async table(skip?: number, take?: number, search?: string) {
+                    if (skip === undefined || take === undefined) return this.${this.#moudleName}Repository.find()
+
+                    let queryBuilder = this.${this.#moudleName}Repository.createQueryBuilder('${this.#moudleName}')
+                    if (search) {
+                        queryBuilder = queryBuilder.where('${this.#moudleName}.id like :search', { search: \`%\${search}%\` })
+                    }
+                    const [list, total] = await queryBuilder.skip(skip).take(take).getManyAndCount()
+                    return { list, total }
+                }
+`;
+    } else if (key === "delete") {
+      this.content += `
+                delete(id: number) {
+                    return this.${this.#moudleName}Repository.softDelete(id)
+                }
+`;
+    } else if (key === "update") {
+      this.content += `
+                update(id: number, update${this.#upperName}Dto: Update${this.#upperName}Dto) {
+                    return this.${this.#moudleName}Repository.update(id, update${this.#upperName}Dto)
+                }
+`;
+    } else if (key === "add") {
+      this.content += `
+                create(create${this.#upperName}Dto: Create${this.#upperName}Dto) {
+                    return this.${this.#moudleName}Repository.save(create${this.#upperName}Dto)
+                }
+`;
+    }
+  }
+  formatEnd() {
+    if (this.#serviceMap["add"]) {
+      this.importInfo += `import { Create${this.#upperName}Dto } from './dto/create-${this.#upperName}.dto'
+`;
+    }
+    if (this.#serviceMap["update"]) {
+      this.importInfo += `import { Update${this.#upperName}Dto } from './dto/update-${this.#upperName}.dto'
+`;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceFormat
+});

package/dist/gen-type.d.ts

@@ -0,0 +1 @@
+export declare const genLuaTypes: (path: string) => Promise<void>;

package/dist/gen-type.js

@@ -0,0 +1,66 @@
+"use strict";
+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);
+var gen_type_exports = {};
+__export(gen_type_exports, {
+  genLuaTypes: () => genLuaTypes
+});
+module.exports = __toCommonJS(gen_type_exports);
+var import_path = require("path");
+var import_util = require("./util");
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+const genLuaTypes = async (path) => {
+  const types = ["base", "nest", "vue"];
+  const vscodePath = (0, import_path.join)(path, ".vscode");
+  if (!(0, import_fs.existsSync)(vscodePath)) {
+    (0, import_fs.mkdirSync)(vscodePath);
+  }
+  const moveList = types.map((t) => ({
+    writePath: (0, import_path.join)(vscodePath, `${t}-type.lua`),
+    readPath: (0, import_path.resolve)(__dirname, `../sources/${t}-type.txt`)
+  }));
+  moveList.forEach((m) => {
+    (0, import_promises.readFile)(m.readPath, "utf-8").then((content) => {
+      (0, import_promises.writeFile)(m.writePath, content);
+    });
+  });
+  const settingPath = (0, import_path.join)(vscodePath, "settings.json");
+  if ((0, import_fs.existsSync)(settingPath)) {
+    const content = await (0, import_promises.readFile)(settingPath, "utf-8");
+    if (content.length > 0) {
+      const settionObj = JSON.parse(content);
+      settionObj["Lua.workspace.library"] = types.map(
+        (t) => `./${t}-type.lua`
+      );
+      (0, import_util.writeFormatFile)(settingPath, JSON.stringify(settionObj), true);
+    }
+  } else {
+    (0, import_util.writeFormatFile)(
+      settingPath,
+      JSON.stringify({
+        "Lua.workspace.library": types.map((t) => `./${t}-type.lua`)
+      }),
+      true
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genLuaTypes
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { genLuaTypes } from './gen-type';
+import { ConfigType } from './config';
+declare function startRun(filePath: string, config?: ConfigType): Promise<void>;
+export { startRun, genLuaTypes };

package/dist/index.js

@@ -0,0 +1,48 @@
+require('module-alias/register');require('module-alias').addAliases({'@': require('path').resolve(__dirname)});
+"use strict";
+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);
+var src_exports = {};
+__export(src_exports, {
+  genLuaTypes: () => import_gen_type.genLuaTypes,
+  startRun: () => startRun
+});
+module.exports = __toCommonJS(src_exports);
+var import_compile = require("./compile");
+var import_fs = require("fs");
+var import_lua_codegen = require("../pkg/lua_codegen");
+var import_gen_type = require("./gen-type");
+var import_config = require("./config");
+async function startRun(filePath, config) {
+  if (config) (0, import_config.setConfig)(config);
+  if ((0, import_fs.existsSync)(filePath)) {
+    try {
+      const data = await (0, import_compile.compileToByte)(filePath);
+      (0, import_lua_codegen.run)(new Uint8Array(data), filePath);
+    } catch (error) {
+      console.error(error);
+    }
+  } else {
+    console.error(`${filePath}\u6587\u4EF6\u5B58\u5728`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genLuaTypes,
+  startRun
+});

package/dist/libs/index.d.ts

@@ -0,0 +1 @@
+export declare function printToNode(info: any): void;

package/dist/libs/index.js

@@ -0,0 +1,30 @@
+"use strict";
+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);
+var libs_exports = {};
+__export(libs_exports, {
+  printToNode: () => printToNode
+});
+module.exports = __toCommonJS(libs_exports);
+function printToNode(info) {
+  console.log(info);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  printToNode
+});

package/dist/libs/nest-lib.d.ts

@@ -0,0 +1,5 @@
+import { ApiServiceField, DtoField, EntityField } from '@/types';
+export declare function renderNestCode(config: {
+    name: string;
+    path?: string;
+}, dto: DtoField[], entity: EntityField[], apiService: ApiServiceField[]): void;

package/dist/libs/nest-lib.js

@@ -0,0 +1,41 @@
+"use strict";
+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);
+var nest_lib_exports = {};
+__export(nest_lib_exports, {
+  renderNestCode: () => renderNestCode
+});
+module.exports = __toCommonJS(nest_lib_exports);
+var import_nest = require("@/code/nest");
+var import_config = require("@/config");
+function renderNestCode(config, dto, entity, apiService) {
+  const api = new import_nest.RenderNest(config.name, config.path);
+  if ((0, import_config.isReverse)()) {
+    api.remove();
+    return;
+  }
+  api.editAppModule();
+  api.genModule();
+  api.genDto(dto);
+  api.genEntity(entity);
+  api.genApiService(apiService);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderNestCode
+});

package/dist/libs/vue-lib.d.ts

@@ -0,0 +1 @@
+export declare function genWebCode(name: string, val: any): void;

package/dist/libs/vue-lib.js

@@ -0,0 +1,30 @@
+"use strict";
+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);
+var vue_lib_exports = {};
+__export(vue_lib_exports, {
+  genWebCode: () => genWebCode
+});
+module.exports = __toCommonJS(vue_lib_exports);
+function genWebCode(name, val) {
+  console.log("name=", name, ",value=", val);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genWebCode
+});

package/dist/render.d.ts

@@ -0,0 +1,3 @@
+import { XiuTemplate } from '@biuxiu/template';
+declare const xiu: XiuTemplate;
+export default xiu;

package/dist/render.js

@@ -0,0 +1,32 @@
+"use strict";
+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);
+var render_exports = {};
+__export(render_exports, {
+  default: () => render_default
+});
+module.exports = __toCommonJS(render_exports);
+var import_template = require("@biuxiu/template");
+var import_path = require("path");
+const basePath = (0, import_path.resolve)(__dirname, "..");
+const xiu = new import_template.XiuTemplate(basePath);
+xiu.install(() => ({
+  name: "up",
+  fn: (val) => val[0].toUpperCase() + val.slice(1)
+}));
+var render_default = xiu;

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+type FieldSchema = {
+    key: string;
+    type: 'string' | 'number' | 'bool';
+};
+export type DtoField = FieldSchema & {
+    isOptional?: boolean;
+    limit?: {
+        max?: number;
+        min?: number;
+        msg: string;
+    };
+    notEmpty?: string;
+    isInt?: string;
+    isNumber?: string;
+};
+export type EntityField = FieldSchema & {
+    isExclude?: true;
+    comment?: string;
+    length?: number;
+    nullable?: true;
+    name?: string;
+    dataType?: 'int' | 'datetime' | 'varchar' | 'tinyint';
+};
+export type ApiServiceField = {
+    key: 'get' | 'all' | 'delete' | 'update' | 'add';
+    interceptor?: true;
+};
+export {};

package/dist/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare const reFromatFile: (filePath: string) => Promise<void>;
+export declare const writeFormatFile: (filePath: string, content: string, isJson?: boolean) => Promise<void>;

package/dist/util.js

@@ -0,0 +1,48 @@
+"use strict";
+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);
+var util_exports = {};
+__export(util_exports, {
+  reFromatFile: () => reFromatFile,
+  writeFormatFile: () => writeFormatFile
+});
+module.exports = __toCommonJS(util_exports);
+var import_promises = require("fs/promises");
+var import_prettier = require("prettier");
+const reFromatFile = async (filePath) => {
+  const content = await (0, import_promises.readFile)(filePath, "utf-8");
+  await writeFormatFile(filePath, content);
+};
+const writeFormatFile = async (filePath, content, isJson = false) => {
+  try {
+    const file = await (0, import_prettier.resolveConfigFile)(filePath);
+    const config = file ? await (0, import_prettier.resolveConfig)(file) : {};
+    const formatText = await (0, import_prettier.format)(content, {
+      ...config,
+      parser: isJson ? "json" : "typescript"
+    });
+    await (0, import_promises.writeFile)(filePath, formatText);
+  } catch (error) {
+    console.log(error);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reFromatFile,
+  writeFormatFile
+});