openapi-ts-mock-generator/dist/cli.mjs

typescript mock data generator based openapi

#!/usr/bin/env node
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
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 __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/core/types.ts
var HttpMethods, isNotNullish;
var init_types = __esm({
  "src/core/types.ts"() {
    "use strict";
    HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
      HttpMethods2["GET"] = "get";
      HttpMethods2["PUT"] = "put";
      HttpMethods2["POST"] = "post";
      HttpMethods2["DELETE"] = "delete";
      HttpMethods2["OPTIONS"] = "options";
      HttpMethods2["HEAD"] = "head";
      HttpMethods2["PATCH"] = "patch";
      HttpMethods2["TRACE"] = "trace";
      return HttpMethods2;
    })(HttpMethods || {});
    isNotNullish = (value) => {
      return value !== null && value !== void 0;
    };
  }
});

// src/core/config.ts
import { Faker, ko } from "@faker-js/faker";
var defaultOptions, ARRAY_MIN_LENGTH, ARRAY_MAX_LENGTH, MIN_STRING_LENGTH, MAX_STRING_LENGTH, MIN_INTEGER, MAX_INTEGER, MIN_NUMBER, MAX_NUMBER, MIN_WORD_LENGTH, MAX_WORD_LENGTH, FAKER_SEED, faker, GEN_COMMENT;
var init_config = __esm({
  "src/core/config.ts"() {
    "use strict";
    defaultOptions = {
      path: "",
      arrayMinLength: 1,
      arrayMaxLength: 3,
      includeCodes: void 0,
      baseDir: "./",
      specialPath: void 0,
      handlerUrl: "*",
      fakerLocale: "ko",
      generateTarget: "api,schema",
      clear: false,
      // TypeScriptCodeOptions
      isStatic: false,
      isOptional: false
    };
    ARRAY_MIN_LENGTH = 1;
    ARRAY_MAX_LENGTH = 3;
    MIN_STRING_LENGTH = 3;
    MAX_STRING_LENGTH = 20;
    MIN_INTEGER = 1;
    MAX_INTEGER = 1e5;
    MIN_NUMBER = 0;
    MAX_NUMBER = 100;
    MIN_WORD_LENGTH = 0;
    MAX_WORD_LENGTH = 3;
    FAKER_SEED = 1;
    faker = new Faker({
      locale: [ko]
    });
    faker.seed(FAKER_SEED);
    GEN_COMMENT = "/* Do not edit this file. */\n/* This file generated by openapi-ts-mock-generator. */\n\n";
  }
});

// src/core/options.ts
var mergeOptions, transformCliOptions, validateOptions;
var init_options = __esm({
  "src/core/options.ts"() {
    "use strict";
    init_config();
    mergeOptions = (userOptions) => {
      return __spreadValues(__spreadValues({}, defaultOptions), userOptions);
    };
    transformCliOptions = (rawOptions) => {
      return {
        path: rawOptions.path || defaultOptions.path,
        baseDir: rawOptions.baseDir || defaultOptions.baseDir,
        arrayMinLength: parseInt(rawOptions.arrayMinLength) || defaultOptions.arrayMinLength,
        arrayMaxLength: parseInt(rawOptions.arrayMaxLength) || defaultOptions.arrayMaxLength,
        handlerUrl: rawOptions.handlerUrl || defaultOptions.handlerUrl,
        fakerLocale: rawOptions.locales || defaultOptions.fakerLocale,
        generateTarget: rawOptions.generateTarget || defaultOptions.generateTarget,
        specialPath: rawOptions.specialPath || defaultOptions.specialPath,
        clear: rawOptions.clear || defaultOptions.clear,
        includeCodes: rawOptions.includeCodes ? rawOptions.includeCodes.toString().split(",").map((code) => parseInt(code)) : void 0,
        // TypeScriptCodeOptions
        isStatic: rawOptions.static || defaultOptions.isStatic,
        isOptional: rawOptions.optional || defaultOptions.isOptional
      };
    };
    validateOptions = (options) => {
      const errors = [];
      if (!options.path) {
        errors.push("path is required");
      }
      if (options.arrayMinLength && options.arrayMaxLength && options.arrayMinLength > options.arrayMaxLength) {
        errors.push("arrayMinLength should not be greater than arrayMaxLength");
      }
      if (options.generateTarget && !options.generateTarget.split(",").every((target) => ["api", "schema"].includes(target.trim()))) {
        errors.push("generateTarget should contain only 'api' and/or 'schema'");
      }
      return errors;
    };
  }
});

// src/core/index.ts
var core_exports = {};
__export(core_exports, {
  ARRAY_MAX_LENGTH: () => ARRAY_MAX_LENGTH,
  ARRAY_MIN_LENGTH: () => ARRAY_MIN_LENGTH,
  GEN_COMMENT: () => GEN_COMMENT,
  HttpMethods: () => HttpMethods,
  MAX_INTEGER: () => MAX_INTEGER,
  MAX_NUMBER: () => MAX_NUMBER,
  MAX_STRING_LENGTH: () => MAX_STRING_LENGTH,
  MAX_WORD_LENGTH: () => MAX_WORD_LENGTH,
  MIN_INTEGER: () => MIN_INTEGER,
  MIN_NUMBER: () => MIN_NUMBER,
  MIN_STRING_LENGTH: () => MIN_STRING_LENGTH,
  MIN_WORD_LENGTH: () => MIN_WORD_LENGTH,
  defaultOptions: () => defaultOptions,
  faker: () => faker,
  isNotNullish: () => isNotNullish,
  mergeOptions: () => mergeOptions,
  transformCliOptions: () => transformCliOptions,
  validateOptions: () => validateOptions
});
var init_core = __esm({
  "src/core/index.ts"() {
    "use strict";
    init_types();
    init_config();
    init_options();
  }
});

// src/utils/string-utils.ts
var uuidToB64;
var init_string_utils = __esm({
  "src/utils/string-utils.ts"() {
    "use strict";
    uuidToB64 = (uuid) => {
      const uuidBuffer = Buffer.from(uuid.replace(/-/g, ""), "hex");
      const base64Uuid = uuidBuffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
      return base64Uuid;
    };
  }
});

// src/utils/code-utils.ts
var toTypeScriptCode, shouldApplyNullableExtension, generateObjectProperty, compressCode;
var init_code_utils = __esm({
  "src/utils/code-utils.ts"() {
    "use strict";
    toTypeScriptCode = (param, options) => {
      const { depth = 0, isStatic } = options;
      const prefixSpace = " ".repeat(depth * 2);
      if (param === null) {
        return "null";
      }
      if (Array.isArray(param)) {
        const results = param.map((elem) => toTypeScriptCode(elem, __spreadProps(__spreadValues({}, options), { depth: depth + 1 }))).join(",\n" + prefixSpace);
        return ["[", results, "]"].join("\n" + prefixSpace);
      }
      if (typeof param === "object") {
        const results = Object.entries(param).map(([key, value]) => {
          return generateObjectProperty(key, value, options, prefixSpace);
        }).join("\n" + prefixSpace);
        return ["{", `${results}`, "}"].join("\n" + prefixSpace);
      }
      if (typeof param === "string") {
        if (isStatic === false && (param.startsWith("faker") || param.startsWith("Buffer.from(faker"))) {
          return param;
        }
        if (param.endsWith(" as const")) {
          return `"${param.slice(0, -" as const".length)}" as const`;
        }
      }
      return JSON.stringify(param);
    };
    shouldApplyNullableExtension = (value, isOptional) => {
      if (!isOptional)
        return false;
      if (value === null)
        return true;
      if (typeof value === "string" && value.includes(",null")) {
        return true;
      }
      return false;
    };
    generateObjectProperty = (key, value, options, prefixSpace) => {
      const { isOptional, depth = 0 } = options;
      const shouldApplyNullable = shouldApplyNullableExtension(value, isOptional);
      const nullableTypeExtensionStart = shouldApplyNullable ? `...(faker.datatype.boolean() ? {
${prefixSpace}` : "";
      const nullableTypeExtensionEnd = shouldApplyNullable ? `
${prefixSpace}} : {})` : "";
      const propertyValue = toTypeScriptCode(value, __spreadProps(__spreadValues({}, options), {
        depth: depth + 1
      }));
      return `${nullableTypeExtensionStart}${prefixSpace}${key}: ${propertyValue}${nullableTypeExtensionEnd},`;
    };
    compressCode = (code) => {
      return code.replace(/\n/g, " ").replace(/\s+/g, " ").replace(/\s\./g, ".").trim();
    };
  }
});

// src/utils/array-utils.ts
var getRandomLengthArray;
var init_array_utils = __esm({
  "src/utils/array-utils.ts"() {
    "use strict";
    init_core();
    getRandomLengthArray = (min = 1, max = 3) => {
      const length = faker.number.int({ min, max });
      return Array.from({ length }, (_, i) => i);
    };
  }
});

// src/utils/file-utils.ts
import { existsSync, mkdirSync, writeFileSync, rmSync, readdirSync, readFileSync } from "fs";
import * as path from "path";
var ensureDir, clearDirectory, safeWriteFile, readJsonFile, resolveFilePath;
var init_file_utils = __esm({
  "src/utils/file-utils.ts"() {
    "use strict";
    ensureDir = (dirPath) => {
      if (!existsSync(dirPath)) {
        mkdirSync(dirPath, { recursive: true });
      }
    };
    clearDirectory = (dirPath) => {
      if (existsSync(dirPath)) {
        readdirSync(dirPath).forEach((file) => {
          rmSync(path.join(dirPath, file));
        });
      }
    };
    safeWriteFile = (filePath, content) => {
      const dir = path.dirname(filePath);
      ensureDir(dir);
      writeFileSync(filePath, content);
    };
    readJsonFile = (filePath, defaultValue) => {
      if (!existsSync(filePath)) {
        return defaultValue;
      }
      try {
        const content = readFileSync(filePath, "utf-8");
        return JSON.parse(content);
      } catch (error) {
        console.warn(`Failed to read JSON file ${filePath}:`, error);
        return defaultValue;
      }
    };
    resolveFilePath = (inputPath, baseDir) => {
      if (inputPath.startsWith("http")) {
        return inputPath;
      }
      if (baseDir) {
        return path.join(baseDir, inputPath);
      }
      return inputPath;
    };
  }
});

// src/utils/validation.ts
var init_validation = __esm({
  "src/utils/validation.ts"() {
    "use strict";
  }
});

// src/utils/index.ts
var init_utils = __esm({
  "src/utils/index.ts"() {
    "use strict";
    init_string_utils();
    init_code_utils();
    init_array_utils();
    init_file_utils();
    init_validation();
  }
});

// src/parsers/openapi-parser.ts
import SwaggerParser from "@apidevtools/swagger-parser";
var getOpenAPIDocsDeref, getOpenAPIDocsBundle;
var init_openapi_parser = __esm({
  "src/parsers/openapi-parser.ts"() {
    "use strict";
    getOpenAPIDocsDeref = (path5) => __async(void 0, null, function* () {
      const doc = yield SwaggerParser.dereference(path5);
      const isOpenApiV3 = "openapi" in doc && doc.openapi.startsWith("3");
      if (isOpenApiV3)
        return doc;
      return void 0;
    });
    getOpenAPIDocsBundle = (path5) => __async(void 0, null, function* () {
      const doc = yield SwaggerParser.bundle(path5);
      const isOpenApiV3 = "openapi" in doc && doc.openapi.startsWith("3");
      if (isOpenApiV3)
        return doc;
      return void 0;
    });
  }
});

// src/parsers/schema-parser.ts
import { pascalCase } from "change-case-all";
import { isReference } from "oazapfts/generate";
var parseSchema, refSchemaParser, valueGenerator;
var init_schema_parser = __esm({
  "src/parsers/schema-parser.ts"() {
    "use strict";
    init_core();
    init_utils();
    parseSchema = (schemaValue, specialSchema, options, outputSchema = {}) => {
      if (isReference(schemaValue)) {
        console.warn("can't parse reference schema", schemaValue, schemaValue.$ref);
        return;
      }
      if (schemaValue.type === "object") {
        if (schemaValue.properties === void 0)
          return {};
        return Object.entries(schemaValue.properties).reduce((acc, [key, field]) => {
          acc[key] = parseSchema(field, specialSchema, options, outputSchema);
          return acc;
        }, {});
      } else if (schemaValue.enum !== void 0) {
        const enumValue = options.isStatic ? faker.helpers.arrayElement(schemaValue.enum) : `faker.helpers.arrayElement<${schemaValue.enum.map((item) => `"${item}"`).join(" | ")}>(${toTypeScriptCode(schemaValue.enum, __spreadValues({
          depth: 0
        }, options))})`;
        if (options.isStatic && typeof enumValue === "string")
          return enumValue + " as const";
        return enumValue;
      } else if (schemaValue.allOf !== void 0) {
        const allOfValue = schemaValue.allOf;
        return faker.helpers.arrayElement(
          allOfValue.map((field) => {
            return parseSchema(field, specialSchema, options, outputSchema);
          })
        );
      } else if (schemaValue.anyOf !== void 0) {
        const anyOfValue = schemaValue.anyOf;
        return options.isStatic ? faker.helpers.arrayElement(
          anyOfValue.map((field) => {
            return parseSchema(field, specialSchema, options, outputSchema);
          })
        ) : compressCode(
          `
          faker.helpers.arrayElement([
            ${anyOfValue.map(
            (field) => toTypeScriptCode(parseSchema(field, specialSchema, options, {}), __spreadValues({
              depth: 0
            }, options))
          )}
          ])
        `
        );
      } else if (schemaValue.oneOf !== void 0) {
        const oneOfValue = schemaValue.oneOf;
        return options.isStatic ? faker.helpers.arrayElement(
          oneOfValue.map((field) => {
            return parseSchema(field, specialSchema, options, outputSchema);
          })
        ) : compressCode(
          `
          faker.helpers.arrayElement([
            ${oneOfValue.map(
            (field) => toTypeScriptCode(parseSchema(field, specialSchema, options, {}), __spreadValues({
              depth: 0
            }, options))
          )}
          ])
        `
        );
      } else if (schemaValue.type === "array") {
        if ("prefixItems" in schemaValue) {
          const length = faker.number.int({
            min: schemaValue.minItems,
            max: schemaValue.maxItems
          });
          return schemaValue.prefixItems.slice(0, length).map((field) => parseSchema(field, specialSchema, options, outputSchema));
        }
        const arrayValue = schemaValue.items;
        return getRandomLengthArray(options.arrayMinLength, options.arrayMaxLength).map(
          () => parseSchema(arrayValue, specialSchema, options, outputSchema)
        );
      }
      return valueGenerator(schemaValue, specialSchema, options);
    };
    refSchemaParser = (ref, refs) => {
      const schemaName = pascalCase(ref.replace("#/components/schemas/", ""));
      const schemaValue = refs.get(ref);
      return { name: schemaName, value: schemaValue };
    };
    valueGenerator = (schemaValue, specialSchema, options) => {
      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
      const { isStatic } = options;
      const { titleSpecial, descriptionSpecial } = specialSchema;
      if (schemaValue.title && titleSpecial[schemaValue.title]) {
        return titleSpecial[schemaValue.title];
      } else if (schemaValue.description && descriptionSpecial[schemaValue.description]) {
        return descriptionSpecial[schemaValue.description];
      }
      if (schemaValue.type === "string" && schemaValue.format === "date-time") {
        return isStatic ? faker.date.between({
          from: "2020-01-01T00:00:00.000Z",
          to: "2030-12-31T23:59:59.999Z"
        }).toISOString() : compressCode(
          `
          faker.date.between({
            from: "2020-01-01T00:00:00.000Z",
            to: "2030-12-31T23:59:59.999Z",
          })
          .toISOString()
        `
        );
      } else if (schemaValue.type === "string" && schemaValue.format === "date") {
        return isStatic ? faker.date.between({
          from: "2020-01-01T00:00:00.000Z",
          to: "2030-12-31T23:59:59.999Z"
        }).toISOString().split("T")[0] : compressCode(
          `
          faker.date.between({
            from: "2020-01-01T00:00:00.000Z",
            to: "2030-12-31T23:59:59.999Z",
          })
          .toISOString()
          .split("T")[0]
        `
        );
      } else if (schemaValue.type === "string" && schemaValue.pattern) {
        return isStatic ? faker.helpers.fromRegExp(schemaValue.pattern) : `faker.helpers.fromRegExp(/${schemaValue.pattern}/)`;
      } else if (schemaValue.type === "string" && ((_a = schemaValue.title) == null ? void 0 : _a.toLowerCase()) === "b64uuid") {
        const baseUuid = faker.string.uuid();
        return isStatic ? uuidToB64(baseUuid) : compressCode(
          `
          Buffer.from(faker.string.uuid().replace(/-/g, ""), "hex")
          .toString("base64")
          .replace(/\\+/g, "-")
          .replace(/\\//g, "_")
          .replace(/=/g, "")
        `
        );
      } else if (schemaValue.type === "string") {
        const minLength = (_c = schemaValue.minLength) != null ? _c : Math.min(MIN_STRING_LENGTH, (_b = schemaValue.maxLength) != null ? _b : MAX_STRING_LENGTH);
        const maxLength = (_e = schemaValue.maxLength) != null ? _e : Math.max(MAX_STRING_LENGTH, (_d = schemaValue.minLength) != null ? _d : MIN_STRING_LENGTH);
        return isStatic ? faker.string.alphanumeric({
          length: { min: minLength, max: maxLength }
        }) : compressCode(
          `
          faker.string.alphanumeric({
            length: { min: ${minLength}, max: ${maxLength} },
          })
        `
        );
      } else if (schemaValue.type === "integer") {
        return isStatic ? faker.number.int({ min: MIN_INTEGER, max: MAX_INTEGER }) : compressCode(
          `
          faker.number.int({ min: ${MIN_INTEGER}, max: ${MAX_INTEGER} })
        `
        );
      } else if (schemaValue.type === "number") {
        const minNumber = (_g = schemaValue.minimum) != null ? _g : Math.min(MIN_NUMBER, (_f = schemaValue.maximum) != null ? _f : MAX_NUMBER);
        const maxNumber = (_i = schemaValue.maximum) != null ? _i : Math.max(MAX_NUMBER, (_h = schemaValue.minimum) != null ? _h : MIN_NUMBER);
        return isStatic ? faker.number.float({
          min: minNumber,
          max: maxNumber,
          fractionDigits: 2
        }) : compressCode(
          `
          faker.number.float({
            min: ${minNumber},
            max: ${maxNumber},
            fractionDigits: 2,
          })
        `
        );
      } else if (schemaValue.type === "boolean") {
        return isStatic ? faker.datatype.boolean() : "faker.datatype.boolean()";
      } else if (schemaValue.type === "null") {
        return null;
      } else if (Object.keys(schemaValue).length === 0) {
        return isStatic ? faker.word.words({
          count: {
            min: MIN_WORD_LENGTH,
            max: MAX_WORD_LENGTH
          }
        }) : compressCode(
          `
          faker.word.words({
            count: {
              min: ${MIN_WORD_LENGTH},
              max: ${MAX_WORD_LENGTH},
            },
          })
        `
        );
      }
      return isStatic ? faker.word.adjective() : "faker.word.adjective()";
    };
  }
});

// src/parsers/faker-parser.ts
import { join as join2 } from "path";
var specialFakerParser, getFakerValue;
var init_faker_parser = __esm({
  "src/parsers/faker-parser.ts"() {
    "use strict";
    init_core();
    init_utils();
    specialFakerParser = (options) => {
      var _a, _b;
      if (options.specialPath === void 0)
        return {
          titleSpecial: {},
          descriptionSpecial: {}
        };
      const titlePath = join2((_a = options.baseDir) != null ? _a : "", options.specialPath, "titles.json");
      const descPath = join2((_b = options.baseDir) != null ? _b : "", options.specialPath, "descriptions.json");
      const titleSpecialKey = readJsonFile(titlePath, {});
      const descriptionSpecialKey = readJsonFile(descPath, {});
      const titleSpecial = Object.entries(titleSpecialKey).reduce((acc, [key, value]) => {
        const fakerValue = getFakerValue(value, options);
        acc[key] = fakerValue;
        return acc;
      }, {});
      const descriptionSpecial = Object.entries(descriptionSpecialKey).reduce((acc, [key, value]) => {
        const fakerValue = getFakerValue(value, options);
        acc[key] = fakerValue;
        return acc;
      }, {});
      return { titleSpecial, descriptionSpecial };
    };
    getFakerValue = (value, options) => {
      if ("value" in value) {
        return value.value;
      }
      if ("module" in value && "type" in value) {
        if (options.isStatic === false) {
          const fakerOption = "options" in value ? toTypeScriptCode(value.options, __spreadValues({
            depth: 0
          }, options)) : "";
          return `faker.${value.module}.${value.type}(${fakerOption})`;
        }
        const fakerModule = faker[value.module];
        if (fakerModule === void 0) {
          console.warn("can't find faker module", fakerModule);
          return void 0;
        }
        const fakerFunc = fakerModule[value.type];
        if (fakerFunc === void 0 || typeof fakerFunc !== "function") {
          console.warn("can't find faker function", fakerFunc);
          return void 0;
        }
        return "options" in value ? fakerFunc(value.options) : fakerFunc();
      }
      return void 0;
    };
  }
});

// src/parsers/index.ts
var init_parsers = __esm({
  "src/parsers/index.ts"() {
    "use strict";
    init_openapi_parser();
    init_schema_parser();
    init_faker_parser();
  }
});

// src/generators/api-generator.ts
import { isReference as isReference2 } from "oazapfts/generate";
var generateAPI, createCompositeSchema;
var init_api_generator = __esm({
  "src/generators/api-generator.ts"() {
    "use strict";
    init_core();
    init_utils();
    init_parsers();
    generateAPI = (options) => __async(void 0, null, function* () {
      const openapiPath = resolveFilePath(options.path, options.baseDir);
      const doc = yield getOpenAPIDocsBundle(openapiPath);
      const samplePaths = doc == null ? void 0 : doc.paths;
      if (samplePaths === void 0) {
        console.warn("No paths found");
        return void 0;
      }
      const specialFakers = specialFakerParser(options);
      const normalizedPaths = Object.entries(samplePaths).reduce((acc, [apiName, api]) => {
        if (api === void 0)
          return acc;
        const paths = Object.values(HttpMethods).map((method) => {
          var _a, _b, _c, _d, _e, _f, _g, _h;
          if (api[method] === void 0)
            return void 0;
          const responses = Object.entries((_b = (_a = api[method]) == null ? void 0 : _a.responses) != null ? _b : []).map(([statusCode, response]) => {
            var _a2, _b2, _c2;
            if (isReference2(response))
              return void 0;
            if (options.includeCodes && !options.includeCodes.includes(parseInt(statusCode)))
              return void 0;
            const schema = (_c2 = (_b2 = (_a2 = response.content) == null ? void 0 : _a2["application/json"]) == null ? void 0 : _b2.schema) != null ? _c2 : {};
            const compositeSchema = createCompositeSchema(schema, specialFakers, options);
            return {
              statusCode: parseInt(statusCode),
              description: response.description,
              schema: compositeSchema
            };
          }).filter(isNotNullish);
          return {
            pathname: apiName.replace(/{/g, ":").replace(/}/g, ""),
            operationId: (_d = (_c = api[method]) == null ? void 0 : _c.operationId) != null ? _d : "",
            summary: (_f = (_e = api[method]) == null ? void 0 : _e.summary) != null ? _f : "",
            tags: (_h = (_g = api[method]) == null ? void 0 : _g.tags) != null ? _h : ["default"],
            method,
            responses
          };
        }).filter(isNotNullish);
        return [...acc, ...paths];
      }, []);
      return normalizedPaths;
    });
    createCompositeSchema = (schema, specialFakers, options) => {
      if ("oneOf" in schema) {
        return {
          type: "oneOf",
          value: schema
        };
      }
      if ("anyOf" in schema) {
        return {
          type: "anyOf",
          value: schema
        };
      }
      if ("type" in schema && "items" in schema && schema.type === "array") {
        return {
          type: "array",
          value: schema.items
        };
      }
      if (isReference2(schema)) {
        return { type: "ref", value: schema };
      }
      if (Object.keys(schema).length === 0) {
        return void 0;
      }
      return parseSchema(schema != null ? schema : {}, specialFakers, options, {});
    };
  }
});

// src/generators/schema-generator.ts
var generateSchema;
var init_schema_generator = __esm({
  "src/generators/schema-generator.ts"() {
    "use strict";
    init_utils();
    init_parsers();
    generateSchema = (options) => __async(void 0, null, function* () {
      var _a;
      const openapiPath = resolveFilePath(options.path, options.baseDir);
      const doc = yield getOpenAPIDocsDeref(openapiPath);
      const sampleSchemas = (_a = doc == null ? void 0 : doc.components) == null ? void 0 : _a.schemas;
      if (sampleSchemas === void 0) {
        console.warn("No schemas found");
        return void 0;
      }
      const specialFakers = specialFakerParser(options);
      return Object.entries(sampleSchemas).reduce((acc, [schemaName, schema]) => {
        acc[schemaName] = parseSchema(schema, specialFakers, options, {});
        return acc;
      }, {});
    });
  }
});

// src/generators/response-generator.ts
import SwaggerParser2 from "@apidevtools/swagger-parser";
import { pascalCase as pascalCase2 } from "change-case-all";
import * as path2 from "path";
import { isReference as isReference3 } from "oazapfts/generate";
var generateResponses, generateSingleResponse, writeResponseFiles, generateResponseFileContent, generateResponseIndexFile;
var init_response_generator = __esm({
  "src/generators/response-generator.ts"() {
    "use strict";
    init_utils();
    init_parsers();
    generateResponses = (paths, options) => __async(void 0, null, function* () {
      const parser = new SwaggerParser2();
      const openapiPath = resolveFilePath(options.path, options.baseDir);
      yield parser.dereference(openapiPath);
      const refs = parser.$refs;
      const firstTags = Array.from(new Set(paths.map((path5) => path5.tags[0])));
      const codeBasePerTag = firstTags.reduce((acc, tag) => {
        acc[tag] = [];
        return acc;
      }, {});
      const specialFakers = specialFakerParser(options);
      paths.forEach((path5) => {
        const pathResponses = path5.responses.map((res) => {
          return generateSingleResponse(path5, res, refs, specialFakers, options);
        });
        const pathResponsesWithComment = `// ${path5.operationId}
` + pathResponses.join("\n\n");
        codeBasePerTag[path5.tags[0]].push(pathResponsesWithComment);
      });
      yield writeResponseFiles(codeBasePerTag, options);
    });
    generateSingleResponse = (path5, res, refs, specialFakers, options) => {
      var _a, _b, _c, _d, _e;
      const codeBaseArray = [
        `export const get${pascalCase2(path5.operationId)}${res.statusCode} = () => {`
      ];
      if (((_a = res.schema) == null ? void 0 : _a.type) === "ref") {
        const { name, value } = refSchemaParser(res.schema.value.$ref, refs);
        const outputSchema = parseSchema(value, specialFakers, options);
        codeBaseArray.push(`  // Schema is ${name}`);
        codeBaseArray.push(
          `  return ${toTypeScriptCode(outputSchema, __spreadValues({
            depth: 1
          }, options))}`
        );
      } else if (((_b = res.schema) == null ? void 0 : _b.type) === "array") {
        if (isReference3(res.schema.value)) {
          const { name, value } = refSchemaParser(res.schema.value.$ref, refs);
          const outputSchema = getRandomLengthArray(options.arrayMinLength, options.arrayMaxLength).map(
            () => parseSchema(value, specialFakers, options)
          );
          codeBaseArray.push(`  // Schema is ${name} array`);
          codeBaseArray.push(
            `  return ${toTypeScriptCode(outputSchema, __spreadValues({
              depth: 1
            }, options))}`
          );
        } else {
          const outputSchema = getRandomLengthArray(options.arrayMinLength, options.arrayMaxLength).map(
            () => res.schema && parseSchema(res.schema.value, specialFakers, options)
          );
          codeBaseArray.push(
            `  return ${toTypeScriptCode(outputSchema, __spreadValues({
              depth: 1
            }, options))}`
          );
        }
      } else if (((_c = res.schema) == null ? void 0 : _c.type) === "anyOf") {
        const firstSchema = (_d = res.schema.value.anyOf) == null ? void 0 : _d[0];
        if (isReference3(firstSchema)) {
          const { name, value } = refSchemaParser(firstSchema.$ref, refs);
          const outputSchema = parseSchema(value, specialFakers, options);
          codeBaseArray.push(`  // Schema is ${name}`);
          codeBaseArray.push(
            `  return ${toTypeScriptCode(outputSchema, __spreadValues({
              depth: 1
            }, options))}`
          );
        } else {
          codeBaseArray.push(`  return ${res.schema.value}`);
        }
      } else {
        codeBaseArray.push(`  return ${(_e = res.schema) == null ? void 0 : _e.value}`);
      }
      return [...codeBaseArray, `}`].join("\n");
    };
    writeResponseFiles = (codeBasePerTag, options) => __async(void 0, null, function* () {
      const directory = path2.join(options.baseDir, "response");
      ensureDir(directory);
      if (options.clear) {
        clearDirectory(directory);
      }
      Object.entries(codeBasePerTag).forEach(([tag, responses]) => {
        const needImportFaker = responses.some((res) => res.includes("faker."));
        const importFaker = options.isStatic || !needImportFaker ? "" : 'import { faker } from "../fakers"\n\n';
        const fileName = `${directory}/${tag}.ts`;
        const content = generateResponseFileContent(importFaker, responses);
        safeWriteFile(fileName, content);
        console.log(`Generated ${fileName}`);
      });
      const indexContent = generateResponseIndexFile(codeBasePerTag);
      const indexFileName = `${directory}/index.ts`;
      safeWriteFile(indexFileName, indexContent);
      console.log(`Generated ${indexFileName}`);
    });
    generateResponseFileContent = (importFaker, responses) => {
      const { GEN_COMMENT: GEN_COMMENT2 } = (init_core(), __toCommonJS(core_exports));
      return GEN_COMMENT2 + importFaker + responses.join("\n\n");
    };
    generateResponseIndexFile = (codeBasePerTag) => {
      const { GEN_COMMENT: GEN_COMMENT2 } = (init_core(), __toCommonJS(core_exports));
      const importResponses = Object.entries(codeBasePerTag).map(([tag, responses]) => {
        const responseNames = responses.reduce((acc, handler) => {
          const matched = handler.match(/get[A-Z]\w+/g);
          if (matched === null)
            return acc;
          return [...acc, ...matched];
        }, []).join(",\n  ");
        return ["export {", "  " + responseNames, '} from "./' + tag + '"'].join("\n");
      });
      return GEN_COMMENT2 + importResponses.join("\n");
    };
  }
});

// src/generators/handler-generator.ts
import { camelCase, pascalCase as pascalCase3 } from "change-case-all";
import * as path3 from "path";
var generateHandlers, generateSingleHandler, writeHandlerFiles, generateHandlerFileContent, generateMockHandlersFile;
var init_handler_generator = __esm({
  "src/generators/handler-generator.ts"() {
    "use strict";
    init_core();
    init_utils();
    generateHandlers = (paths, options) => {
      const firstTags = Array.from(new Set(paths.map((path5) => path5.tags[0])));
      const handlersPerTag = firstTags.reduce((acc, tag) => {
        acc[tag] = [];
        return acc;
      }, {});
      paths.forEach((path5) => {
        const handler = generateSingleHandler(path5, options);
        handlersPerTag[path5.tags[0]].push(handler);
      });
      writeHandlerFiles(handlersPerTag, options);
    };
    generateSingleHandler = (path5, options) => {
      var _a;
      const codeBaseArray = [`  http.${path5.method}(\`\${handlerUrl}${path5.pathname}\`, () => {`];
      if (path5.responses.length === 1) {
        const res = path5.responses[0];
        if (((_a = res.schema) == null ? void 0 : _a.type) === "ref") {
          const schemaName = pascalCase3(res.schema.value.$ref.replace("#/components/schemas/", ""));
          codeBaseArray.push(`    // Schema is ${schemaName}`);
        }
        const outputResName = `get${pascalCase3(path5.operationId)}${res.statusCode}`;
        codeBaseArray.push(`    return HttpResponse.json(${outputResName}(), {`);
        codeBaseArray.push(`      status: ${res.statusCode},`);
        codeBaseArray.push(`    })`);
      } else if (path5.responses.length > 1) {
        codeBaseArray.push(`    const responses = [`);
        path5.responses.forEach((res) => {
          var _a2;
          const schemaName = ((_a2 = res.schema) == null ? void 0 : _a2.type) === "ref" ? pascalCase3(res.schema.value.$ref.replace("#/components/schemas/", "")) : "";
          const schemaComment = schemaName ? ` // Schema is ${schemaName}` : "";
          const outputResName = `get${pascalCase3(path5.operationId)}${res.statusCode}`;
          codeBaseArray.push(
            `      [${outputResName}(), { status: ${res.statusCode} }],${schemaComment}`
          );
        });
        codeBaseArray.push(`    ]`);
        codeBaseArray.push(`    const randomIndex = Math.floor(Math.random() * responses.length)`);
        codeBaseArray.push(`    return HttpResponse.json(...responses[randomIndex])`);
      } else {
        codeBaseArray.push(`    return HttpResponse.json()`);
      }
      codeBaseArray.push(`  }),`);
      return codeBaseArray.join("\n");
    };
    writeHandlerFiles = (handlersPerTag, options) => {
      var _a;
      const directory = path3.join(options.baseDir, "handlers");
      ensureDir(directory);
      if (options.clear) {
        clearDirectory(directory);
      }
      Object.entries(handlersPerTag).forEach(([tag, handlers]) => {
        const content = generateHandlerFileContent(tag, handlers, options);
        const fileName2 = path3.join(directory, `${tag}.ts`);
        safeWriteFile(fileName2, content);
        console.log(`Generated Handler ${fileName2}`);
      });
      const mockHandlersContent = generateMockHandlersFile(handlersPerTag, options);
      const fileName = path3.join((_a = options.baseDir) != null ? _a : "", "mockHandlers.ts");
      safeWriteFile(fileName, mockHandlersContent);
      console.log(`Generated mock handlers ${fileName}`);
    };
    generateHandlerFileContent = (tag, handlers, options) => {
      const importMSW = `import { http, HttpResponse } from 'msw'`;
      const responseNames = handlers.reduce((acc, handler) => {
        const matched = handler.match(/get[A-Z]\w+/g);
        if (matched === null)
          return acc;
        return [...acc, ...matched];
      }, []).join(", ");
      const importResponses = responseNames.length > 0 ? `import { ${responseNames} } from "../response"
` : "";
      const handlerUrl = `const handlerUrl = "${options.handlerUrl}"`;
      const handlerName = camelCase(tag);
      const mockHandlers = [
        `${importMSW}`,
        `${importResponses}`,
        `${handlerUrl}`,
        ``,
        `export const ${handlerName}Handlers = [`,
        `${handlers.join("\n\n")}`,
        `]`
      ].join("\n");
      return GEN_COMMENT + mockHandlers;
    };
    generateMockHandlersFile = (handlersPerTag, options) => {
      const handlersImport = Object.keys(handlersPerTag).map((tag) => {
        const handlerName = `${camelCase(tag)}Handlers`;
        return `import { ${handlerName} } from "./handlers/${tag}"`;
      }).join("\n");
      const handlersArrayItem = Object.keys(handlersPerTag).map((tag) => {
        const handlerName = `${camelCase(tag)}Handlers`;
        return `  ...${handlerName},`;
      }).join("\n");
      const mockHandlers = [
        `${handlersImport}`,
        ``,
        `export const handlers = [`,
        `${handlersArrayItem}`,
        `]`
      ].join("\n");
      return GEN_COMMENT + mockHandlers;
    };
  }
});

// src/generators/faker-generator.ts
import * as path4 from "path";
var generateFaker, generateFakerFileContent, generateSchemaFile;
var init_faker_generator = __esm({
  "src/generators/faker-generator.ts"() {
    "use strict";
    init_core();
    init_utils();
    generateFaker = (options) => {
      var _a, _b;
      const directory = path4.join((_a = options.baseDir) != null ? _a : "");
      ensureDir(directory);
      const content = generateFakerFileContent(options);
      const outputFileName = path4.join((_b = options.baseDir) != null ? _b : "", "fakers.ts");
      safeWriteFile(outputFileName, content);
      console.log(`Generated fakers ${outputFileName}`);
    };
    generateFakerFileContent = (options) => {
      const { GEN_COMMENT: GEN_COMMENT2 } = (init_core(), __toCommonJS(core_exports));
      const localeOption = options.fakerLocale.replace(",", ", ");
      const importFaker = `import { Faker, ${localeOption} } from "@faker-js/faker"

`;
      const fakerDeclare = [
        "export const faker = new Faker({",
        `  locale: [${localeOption}]`,
        "})"
      ].join("\n");
      return GEN_COMMENT2 + importFaker + fakerDeclare;
    };
    generateSchemaFile = (schemas, options) => {
      var _a;
      const generatedVars = Object.entries(schemas).map(([varName, varValue]) => {
        return `export const ${varName}Mock = ${toTypeScriptCode(varValue, __spreadValues({
          depth: 0
        }, options))}`;
      }).join("\n\n");
      const importFaker = options.isStatic ? "" : 'import { faker } from "./fakers"\n\n';
      const content = GEN_COMMENT + importFaker + generatedVars;
      const outputFileName = path4.join((_a = options.baseDir) != null ? _a : "", "schemas.ts");
      safeWriteFile(outputFileName, content);
      console.log(`Generated schema ${outputFileName}`);
    };
  }
});

// src/generators/index.ts
var init_generators = __esm({
  "src/generators/index.ts"() {
    "use strict";
    init_api_generator();
    init_schema_generator();
    init_response_generator();
    init_handler_generator();
    init_faker_generator();
  }
});

// src/index.ts
import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
var main;
var init_src = __esm({
  "src/index.ts"() {
    "use strict";
    init_generators();
    init_generators();
    main = (options) => __async(void 0, null, function* () {
      if (options.baseDir && !existsSync2(options.baseDir)) {
        mkdirSync2(options.baseDir, { recursive: true });
      }
      if (options.generateTarget.includes("api")) {
        const generatedAPI = yield generateAPI(options);
        if (generatedAPI === void 0) {
          console.warn("generate api fail");
          return;
        }
        generateHandlers(generatedAPI, options);
        yield generateResponses(generatedAPI, options);
      }
      if (options.generateTarget.includes("schema")) {
        const generatedSchema = yield generateSchema(options);
        if (generatedSchema === void 0) {
          console.warn("generate schema fail");
          return;
        }
        generateSchemaFile(generatedSchema, options);
      }
      if (options.isStatic === false)
        generateFaker(options);
    });
  }
});

// node_modules/cac/dist/index.mjs
import { EventEmitter } from "events";
function toArr(any) {
  return any == null ? [] : Array.isArray(any) ? any : [any];
}
function toVal(out, key, val, opts) {
  var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
}
function mri2(args, opts) {
  args = args || [];
  opts = opts || {};
  var k, arr, arg, name, val, out = { _: [] };
  var i = 0, j = 0, idx = 0, len = args.length;
  const alibi = opts.alias !== void 0;
  const strict = opts.unknown !== void 0;
  const defaults = opts.default !== void 0;
  opts.alias = opts.alias || {};
  opts.string = toArr(opts.string);
  opts.boolean = toArr(opts.boolean);
  if (alibi) {
    for (k in opts.alias) {
      arr = opts.alias[k] = toArr(opts.alias[k]);
      for (i = 0; i < arr.length; i++) {
        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
      }
    }
  }
  for (i = opts.boolean.length; i-- > 0; ) {
    arr = opts.alias[opts.boolean[i]] || [];
    for (j = arr.length; j-- > 0; )
      opts.boolean.push(arr[j]);
  }
  for (i = opts.string.length; i-- > 0; ) {
    arr = opts.alias[opts.string[i]] || [];
    for (j = arr.length; j-- > 0; )
      opts.string.push(arr[j]);
  }
  if (defaults) {
    for (k in opts.default) {
      name = typeof opts.default[k];
      arr = opts.alias[k] = opts.alias[k] || [];
      if (opts[name] !== void 0) {
        opts[name].push(k);
        for (i = 0; i < arr.length; i++) {
          opts[name].push(arr[i]);
        }
      }
    }
  }
  const keys = strict ? Object.keys(opts.alias) : [];
  for (i = 0; i < len; i++) {
    arg = args[i];
    if (arg === "--") {
      out._ = out._.concat(args.slice(++i));
      break;
    }
    for (j = 0; j < arg.length; j++) {
      if (arg.charCodeAt(j) !== 45)
        break;
    }
    if (j === 0) {
      out._.push(arg);
    } else if (arg.substring(j, j + 3) === "no-") {
      name = arg.substring(j + 3);
      if (strict && !~keys.indexOf(name)) {
        return opts.unknown(arg);
      }
      out[name] = false;
    } else {
      for (idx = j + 1; idx < arg.length; idx++) {
        if (arg.charCodeAt(idx) === 61)
          break;
      }
      name = arg.substring(j, idx);
      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
      arr = j === 2 ? [name] : name;
      for (idx = 0; idx < arr.length; idx++) {
        name = arr[idx];
        if (strict && !~keys.indexOf(name))
          return opts.unknown("-".repeat(j) + name);
        toVal(out, name, idx + 1 < arr.length || val, opts);
      }
    }
  }
  if (defaults) {
    for (k in opts.default) {
      if (out[k] === void 0) {
        out[k] = opts.default[k];
      }
    }
  }
  if (alibi) {
    for (k in out) {
      arr = opts.alias[k] || [];
      while (arr.length > 0) {
        out[arr.shift()] = out[k];
      }
    }
  }
  return out;
}
var removeBrackets, findAllBrackets, getMriOptions, findLongest, padRight, camelcase, setDotProp, setByType, getFileName, camelcaseOptionName, CACError, Option, processArgs, platformInfo, Command, GlobalCommand, __assign, CAC, cac, dist_default;
var init_dist = __esm({
  "node_modules/cac/dist/index.mjs"() {
    "use strict";
    removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
    findAllBrackets = (v) => {
      const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
      const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
      const res = [];
      const parse = (match) => {
        let variadic = false;
        let value = match[1];
        if (value.startsWith("...")) {
          value = value.slice(3);
          variadic = true;
        }
        return {
          required: match[0].startsWith("<"),
          value,
          variadic
        };
      };
      let angledMatch;
      while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
        res.push(parse(angledMatch));
      }
      let squareMatch;
      while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
        res.push(parse(squareMatch));
      }
      return res;
    };
    getMriOptions = (options) => {
      const result = { alias: {}, boolean: [] };
      for (const [index, option] of options.entries()) {
        if (option.names.length > 1) {
          result.alias[option.names[0]] = option.names.slice(1);
        }
        if (option.isBoolean) {
          if (option.negated) {
            const hasStringTypeOption = options.some((o, i) => {
              return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
            });
            if (!hasStringTypeOption) {
              result.boolean.push(option.names[0]);
            }
          } else {
            result.boolean.push(option.names[0]);
          }
        }
      }
      return result;
    };
    findLongest = (arr) => {
      return arr.sort((a, b) => {
        return a.length > b.length ? -1 : 1;
      })[0];
    };
    padRight = (str, length) => {
      return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
    };
    camelcase = (input) => {
      return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
        return p1 + p2.toUpperCase();
      });
    };
    setDotProp = (obj, keys, val) => {
      let i = 0;
      let length = keys.length;
      let t = obj;
      let x;
      for (; i < length; ++i) {
        x = t[keys[i]];
        t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
      }
    };
    setByType = (obj, transforms) => {
      for (const key of Object.keys(transforms)) {
        const transform = transforms[key];
        if (transform.shouldTransform) {
          obj[key] = Array.prototype.concat.call([], obj[key]);
          if (typeof transform.transformFunction === "function") {
            obj[key] = obj[key].map(transform.transformFunction);
          }
        }
      }
    };
    getFileName = (input) => {
      const m = /([^\\\/]+)$/.exec(input);
      return m ? m[1] : "";
    };
    camelcaseOptionName = (name) => {
      return name.split(".").map((v, i) => {
        return i === 0 ? camelcase(v) : v;
      }).join(".");
    };
    CACError = class extends Error {
      constructor(message) {
        super(message);
        this.name = this.constructor.name;
        if (typeof Error.captureStackTrace === "function") {
          Error.captureStackTrace(this, this.constructor);
        } else {
          this.stack = new Error(message).stack;
        }
      }
    };
    Option = class {
      constructor(rawName, description, config) {
        this.rawName = rawName;
        this.description = description;
        this.config = Object.assign({}, config);
        rawName = rawName.replace(/\.\*/g, "");
        this.negated = false;
        this.names = removeBrackets(rawName).split(",").map((v) => {
          let name = v.trim().replace(/^-{1,2}/, "");
          if (name.startsWith("no-")) {
            this.negated = true;
            name = name.replace(/^no-/, "");
          }
          return camelcaseOptionName(name);
        }).sort((a, b) => a.length > b.length ? 1 : -1);
        this.name = this.names[this.names.length - 1];
        if (this.negated && this.config.default == null) {
          this.config.default = true;
        }
        if (rawName.includes("<")) {
          this.required = true;
        } else if (rawName.includes("[")) {
          this.required = false;
        } else {
          this.isBoolean = true;
        }
      }
    };
    processArgs = process.argv;
    platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
    Command = class {
      constructor(rawName, description, config = {}, cli) {
        this.rawName = rawName;
        this.description = description;
        this.config = config;
        this.cli = cli;
        this.options = [];
        this.aliasNames = [];
        this.name = removeBrackets(rawName);
        this.args = findAllBrackets(rawName);
        this.examples = [];
      }
      usage(text) {
        this.usageText = text;
        return this;
      }
      allowUnknownOptions() {
        this.config.allowUnknownOptions = true;
        return this;
      }
      ignoreOptionDefaultValue() {
        this.config.ignoreOptionDefaultValue = true;
        return this;
      }
      version(version, customFlags = "-v, --version") {
        this.vers