@query-key-gen/generator/lib/index.cjs

Generated for [Vite](https://vitejs.dev)

"use strict";
var __create = Object.create;
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 __getProtoOf = Object.getPrototypeOf;
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 __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);
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/index.ts
var index_exports = {};
__export(index_exports, {
  default: () => QueryKeyPlugin
});
module.exports = __toCommonJS(index_exports);
var import_path3 = __toESM(require("path"), 1);

// ../common/src/core/Programmer.ts
var import_fast_glob = __toESM(require("fast-glob"), 1);
var import_path = __toESM(require("path"), 1);
var import_typescript = __toESM(require("typescript"), 1);
var Programmer = class {
  constructor(config) {
    // getCompilerOptions = () => {
    //     const { options: compilerOptions } = ts.parseJsonConfigFileContent(
    //         ts.readConfigFile('tsconfig.node.json', ts.sys.readFile).config,
    //         {
    //             fileExists: ts.sys.fileExists,
    //             readFile: ts.sys.readFile,
    //             readDirectory: ts.sys.readDirectory,
    //             useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
    //         },
    //         path.dirname('.')
    //     );
    //     return compilerOptions;
    // };
    this.findFiles = (program) => __async(this, null, function* () {
      const config = this.config;
      const sourceFiles = program.getSourceFiles().filter((item) => {
        return !item.isDeclarationFile;
      });
      const outputFile = import_typescript.default.createSourceFile(config.output, "", this.compilerOptions.target);
      const projectFiles = sourceFiles.filter((item) => {
        const relativePath = import_path.default.relative(process.cwd(), item.fileName);
        const outputPath = import_path.default.relative(process.cwd(), config.output);
        return !relativePath.includes(outputPath);
      });
      return {
        outputFile,
        projectFiles
      };
    });
    this.config = config;
    this.compilerOptions = {
      module: import_typescript.default.ModuleKind.ESNext,
      target: import_typescript.default.ScriptTarget.ESNext
    };
  }
  // Getter로 createProgram 정의
  get create() {
    return () => __async(this, null, function* () {
      const files = yield (0, import_fast_glob.default)(this.config.path, {
        onlyFiles: true
      });
      const builder = import_typescript.default.createIncrementalProgram({
        rootNames: files,
        options: this.compilerOptions
      });
      const program = builder.getProgram();
      return {
        program,
        checker: program.getTypeChecker()
      };
    });
  }
};

// ../common/src/core/GenericRunner.ts
var GenericRunner = class {
  constructor(programmer, config) {
    this.programmer = programmer;
    this.config = config;
  }
  process() {
    return __async(this, null, function* () {
      console.log("\u{1F527} Base process logic");
    });
  }
  execute() {
    return this.process();
  }
};

// src/core/QueryKeyGenerator.ts
var import_typescript13 = __toESM(require("typescript"), 1);

// src/factories/ExportSpecifierFactory.ts
var import_typescript2 = __toESM(require("typescript"), 1);
var ExportSpecifierFactory;
((ExportSpecifierFactory2) => {
  const factory2 = import_typescript2.default.factory;
  const exportDeclaration = (exportSpecifier) => {
    return factory2.createExportDeclaration(
      void 0,
      false,
      exportSpecifier,
      void 0,
      void 0
    );
  };
  ExportSpecifierFactory2.named = (name) => {
    return exportDeclaration(
      factory2.createNamedExports([
        factory2.createExportSpecifier(false, void 0, factory2.createIdentifier(name))
      ])
    );
  };
})(ExportSpecifierFactory || (ExportSpecifierFactory = {}));

// src/factories/ObjectLiteralExpressionFactory.ts
var import_typescript3 = __toESM(require("typescript"), 1);
var ObjectLiteralExpressionFactory;
((ObjectLiteralExpressionFactory2) => {
  const factory2 = import_typescript3.default.factory;
  const objectLiteralExpression = (properties) => {
    return factory2.createObjectLiteralExpression(properties, true);
  };
  ObjectLiteralExpressionFactory2.write = (properties) => {
    return objectLiteralExpression(properties);
  };
})(ObjectLiteralExpressionFactory || (ObjectLiteralExpressionFactory = {}));

// src/factories/QueryKeyStructureFactory.ts
var import_typescript6 = __toESM(require("typescript"), 1);

// src/types/QueryNodeType.ts
var QueryNodeKind = {
  StringLiteral: "StringLiteral",
  Symbol: "Symbol",
  EnumMember: "EnumMember",
  TypeOfKeyword: "TypeOfKeyword",
  Tuple: "Tuple"
};

// src/utils/index.ts
var import_child_process = require("child_process");
var import_fs = __toESM(require("fs"), 1);
var import_path2 = __toESM(require("path"), 1);
var import_typescript4 = __toESM(require("typescript"), 1);
var TypeGuard = {
  symbol: (node) => {
    return typeof node === "object" && "escapedName" in node;
  },
  stringLiteral: (node) => {
    return import_typescript4.default.isStringLiteral(node);
  },
  tsType: (node) => {
    return typeof node === "object" && "symbol" in node;
  },
  tuple: (node) => {
    return import_typescript4.default.isTupleTypeNode(node);
  }
};
var nodeByName = {
  identifier: (name) => {
    return import_typescript4.factory.createIdentifier(name);
  },
  stringLiteral: (name) => {
    return import_typescript4.factory.createStringLiteral(name.replace(/'/g, ""));
  }
};
var toCamelCase = (str) => {
  return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, letter) => letter.toUpperCase());
};
var makeQueryKeyName = (literal, separator) => {
  return literal.map((node) => {
    const name = node.name;
    if (node.kind !== QueryNodeKind.StringLiteral) {
      return `{${name}}`;
    }
    return name;
  }).join(separator);
};
var groupByFirstName = (data) => {
  return data.reduce(
    (acc, group) => {
      if (group.length > 0) {
        const firstItem = group[0];
        const firstItemName = firstItem == null ? void 0 : firstItem.name;
        if (!firstItemName) {
          return acc;
        }
        const camelCaseName = toCamelCase(firstItemName);
        if (!acc[camelCaseName]) {
          acc[camelCaseName] = [];
        }
        acc[camelCaseName].push(group);
      }
      return acc;
    },
    {}
  );
};
var prettify = (output) => {
  const prettier = import_path2.default.resolve("./node_modules/.bin/prettier");
  if (import_fs.default.existsSync(prettier)) (0, import_child_process.execSync)(`${prettier} --write --cache ${output}`);
};
var logger = (() => {
  const prefix = "[QUERY-KEY-GENERATOR]: ";
  const log = () => {
    return {
      warn: (msg) => {
        console.warn(`[WARN]${prefix}${msg}`);
      },
      error: (msg) => {
        console.error(`[ERROR]${prefix}${msg}`);
      },
      info: (msg) => {
        console.log(`[INFO]${prefix}${msg}`);
      }
    };
  };
  return log();
})();

// src/factories/TypeConverterFactory.ts
var import_typescript5 = __toESM(require("typescript"), 1);
var TypeConverterFactory;
((TypeConverterFactory2) => {
  const factory2 = import_typescript5.default.factory;
  const typeCache = /* @__PURE__ */ new WeakMap();
  TypeConverterFactory2.transform = (symbol, checker, isTypeReference) => {
    const type = checker.getTypeOfSymbol(symbol);
    const declaration = symbol.declarations;
    const valueDeclaration = symbol.valueDeclaration;
    if (valueDeclaration && import_typescript5.default.isParameter(valueDeclaration)) {
      const type2 = valueDeclaration.type;
      if (type2) {
        if (import_typescript5.default.isTupleTypeNode(type2)) {
          return (0, TypeConverterFactory2.tuple)(type2, checker);
        }
        if (import_typescript5.default.isArrayTypeNode(type2)) {
          return array(type2, checker);
        }
        if (import_typescript5.default.isUnionTypeNode(type2)) {
          return unionOrIntersection(type2, checker, true);
        }
        if (import_typescript5.default.isTypeLiteralNode(type2)) {
          return typeLiteral(type2, checker);
        }
        if (import_typescript5.default.isIntersectionTypeNode(type2)) {
          return unionOrIntersection(type2, checker, false);
        }
        if (import_typescript5.default.isTypeReferenceNode(type2)) {
          const symbol2 = checker.getSymbolAtLocation(type2.typeName);
          if (symbol2) {
            return (0, TypeConverterFactory2.transform)(symbol2, checker, true);
          }
        }
      }
    }
    if (valueDeclaration && import_typescript5.default.isEnumDeclaration(valueDeclaration)) {
      return (0, TypeConverterFactory2.enumToUnionFromEnumDeclaration)(valueDeclaration, checker);
    }
    if (declaration && isTypeReference) {
      const typeNode2 = typeDeclaration(declaration, checker);
      if (typeNode2) {
        return typeNode2;
      }
    }
    const typeName = checker.typeToString(type);
    const isKeywordTypeNode = keywordTypeNode(typeName);
    if (isKeywordTypeNode) {
      return isKeywordTypeNode;
    }
    if (type.isIntersection()) {
      return intersection(type, checker);
    }
    if (type.isNumberLiteral()) {
      return factory2.createLiteralTypeNode(factory2.createNumericLiteral(typeName));
    }
    if (type.isStringLiteral()) {
      const name = typeName.replace(/"/g, "");
      return factory2.createLiteralTypeNode(factory2.createStringLiteral(name));
    }
    if (typeCache.has(type)) {
      return typeCache.get(type);
    }
    const typeNode = literal(type, checker);
    typeCache.set(type, typeNode);
    return typeNode;
  };
  const keywordTypeNode = (name) => {
    switch (name) {
      case "string":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.StringKeyword);
      case "number":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.NumberKeyword);
      case "boolean":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.BooleanKeyword);
      case "any":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.AnyKeyword);
      case "undefined":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.UndefinedKeyword);
      case "null":
        return factory2.createLiteralTypeNode(factory2.createNull());
      case "unknown":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.UnknownKeyword);
      case "never":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.NeverKeyword);
      case "object":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.ObjectKeyword);
      case "void":
        return factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.VoidKeyword);
    }
    return void 0;
  };
  const literalKindToKeyword = (element) => {
    const literal2 = element.literal;
    switch (literal2.kind) {
      case import_typescript5.default.SyntaxKind.NullKeyword:
        return keywordTypeNode("null");
      case import_typescript5.default.SyntaxKind.TrueKeyword:
        return factory2.createLiteralTypeNode(factory2.createTrue());
      case import_typescript5.default.SyntaxKind.FalseKeyword:
        return factory2.createLiteralTypeNode(factory2.createFalse());
      case import_typescript5.default.SyntaxKind.NumericLiteral:
        return factory2.createLiteralTypeNode(
          factory2.createNumericLiteral(literal2.text)
        );
      case import_typescript5.default.SyntaxKind.StringLiteral:
        return factory2.createLiteralTypeNode(
          factory2.createStringLiteral(literal2.text)
        );
      case import_typescript5.default.SyntaxKind.BigIntLiteral:
        return factory2.createLiteralTypeNode(
          factory2.createBigIntLiteral(literal2.text)
        );
    }
    return void 0;
  };
  const literal = (type, checker) => {
    const properties = type.getProperties().map((prop) => {
      const isOptional = TypeConverterFactoryGuard.isOptional(prop);
      return factory2.createPropertySignature(
        void 0,
        prop.getName(),
        isOptional ? factory2.createToken(import_typescript5.default.SyntaxKind.QuestionToken) : void 0,
        (0, TypeConverterFactory2.transform)(prop, checker)
      );
    });
    return factory2.createTypeLiteralNode(properties);
  };
  const generateProperties = (type, checker, isReadonly) => {
    const properties = type.getProperties();
    const propertyNames = /* @__PURE__ */ new Set();
    properties.forEach((prop) => {
      propertyNames.add(prop.getName());
    });
    return properties.map((prop) => {
      return factory2.createPropertySignature(
        isReadonly ? [factory2.createToken(import_typescript5.default.SyntaxKind.ReadonlyKeyword)] : void 0,
        prop.getName(),
        void 0,
        (0, TypeConverterFactory2.transform)(prop, checker)
      );
    });
  };
  const unionOrIntersection = (typeNode, checker, isUnion) => {
    const types = typeNode.types;
    const node = types.map((element) => {
      const kind = element.kind;
      if (kind === import_typescript5.default.SyntaxKind.StringKeyword) {
        return keywordTypeNode("string");
      }
      if (kind === import_typescript5.default.SyntaxKind.NumberKeyword) {
        return keywordTypeNode("number");
      }
      if (kind === import_typescript5.default.SyntaxKind.BooleanKeyword) {
        return keywordTypeNode("boolean");
      }
      if (kind === import_typescript5.default.SyntaxKind.UndefinedKeyword) {
        return keywordTypeNode("undefined");
      }
      if (kind === import_typescript5.default.SyntaxKind.ObjectKeyword) {
        return keywordTypeNode("object");
      }
      if (kind === import_typescript5.default.SyntaxKind.AnyKeyword) {
        return keywordTypeNode("any");
      }
      if (import_typescript5.default.isLiteralTypeNode(element)) {
        const keyword = literalKindToKeyword(element);
        if (keyword) {
          return keyword;
        }
      }
      if (import_typescript5.default.isTypeLiteralNode(element)) {
        return typeLiteral(element, checker);
      }
      if (import_typescript5.default.isTypeReferenceNode(element)) {
        const symbol = checker.getSymbolAtLocation(element.typeName);
        if (symbol) {
          return (0, TypeConverterFactory2.transform)(symbol, checker, true);
        }
      }
      return void 0;
    }).filter(Boolean);
    return isUnion ? factory2.createUnionTypeNode(node) : factory2.createIntersectionTypeNode(node);
  };
  const intersection = (intersection2, checker) => {
    const types = intersection2.types;
    const intersectionNode = types.map((t) => {
      const typeName = checker.typeToString(t);
      if (TypeConverterFactoryGuard.isObjectType(t)) {
        const properties = generateProperties(t, checker);
        return factory2.createTypeLiteralNode(properties);
      }
      if (TypeConverterFactoryGuard.isLiteralType(t)) {
        return factory2.createLiteralTypeNode(
          factory2.createStringLiteral(typeName.replace(/"/g, ""))
        );
      }
      return keywordTypeNode(typeName);
    }).filter(Boolean);
    return factory2.createIntersectionTypeNode(intersectionNode);
  };
  TypeConverterFactory2.enumToUnion = (type, checker) => {
    var _a, _b, _c;
    const enumValues = Array.from((_c = (_b = (_a = type.symbol) == null ? void 0 : _a.exports) == null ? void 0 : _b.values()) != null ? _c : []);
    const unionType = enumValues.map((value) => {
      const declaration = value.valueDeclaration;
      if (declaration && import_typescript5.default.isEnumMember(declaration)) {
        const name = value.getName();
        const enumValue = checker.getConstantValue(declaration);
        if (typeof enumValue === "string") {
          return import_typescript5.default.factory.createLiteralTypeNode(
            import_typescript5.default.factory.createStringLiteral(enumValue)
          );
        } else if (typeof enumValue === "number") {
          return import_typescript5.default.factory.createLiteralTypeNode(
            import_typescript5.default.factory.createNumericLiteral(enumValue.toString())
          );
        } else {
          return import_typescript5.default.factory.createTypeReferenceNode(name, void 0);
        }
      }
      return void 0;
    }).filter(Boolean);
    return factory2.createUnionTypeNode(unionType);
  };
  TypeConverterFactory2.enumToUnionFromEnumDeclaration = (type, checker) => {
    const members = type.members;
    const unionType = members.map((member) => {
      const initial = member.initializer;
      if (!initial) return void 0;
      if (import_typescript5.default.isStringLiteral(initial)) {
        return factory2.createLiteralTypeNode(factory2.createStringLiteral(initial.text));
      }
      if (import_typescript5.default.isNumericLiteral(initial)) {
        return factory2.createLiteralTypeNode(
          factory2.createNumericLiteral(initial.text)
        );
      }
      if (import_typescript5.default.isPropertyAccessExpression(initial)) {
        const symbol = checker.getSymbolAtLocation(initial.name);
        if (symbol) {
          return (0, TypeConverterFactory2.transform)(symbol, checker);
        }
      }
      return void 0;
    }).filter(Boolean);
    return factory2.createUnionTypeNode(unionType);
  };
  TypeConverterFactory2.typeofKeyword = (type, checker) => {
    const properties = generateProperties(type, checker, true);
    return factory2.createTypeLiteralNode(properties);
  };
  TypeConverterFactory2.tuple = (type, checker) => {
    const elements = type.elements;
    const node = elements.map((element) => {
      const kind = element.kind;
      if (kind === import_typescript5.default.SyntaxKind.StringKeyword) {
        return keywordTypeNode("string");
      }
      if (kind === import_typescript5.default.SyntaxKind.NumberKeyword) {
        return keywordTypeNode("number");
      }
      if (kind === import_typescript5.default.SyntaxKind.BooleanKeyword) {
        return keywordTypeNode("boolean");
      }
      if (kind === import_typescript5.default.SyntaxKind.UndefinedKeyword) {
        return keywordTypeNode("undefined");
      }
      if (kind === import_typescript5.default.SyntaxKind.ObjectKeyword) {
        return keywordTypeNode("object");
      }
      if (kind === import_typescript5.default.SyntaxKind.AnyKeyword) {
        return keywordTypeNode("any");
      }
      if (kind === import_typescript5.default.SyntaxKind.UnknownKeyword) {
        return keywordTypeNode("unknown");
      }
      if (kind === import_typescript5.default.SyntaxKind.NeverKeyword) {
        return keywordTypeNode("never");
      }
      if (kind === import_typescript5.default.SyntaxKind.VoidKeyword) {
        return keywordTypeNode("void");
      }
      if (import_typescript5.default.isLiteralTypeNode(element)) {
        const keyword = literalKindToKeyword(element);
        if (keyword) {
          return keyword;
        }
      }
      if (import_typescript5.default.isTypeLiteralNode(element)) {
        return typeLiteral(element, checker);
      }
      if (import_typescript5.default.isTypeReferenceNode(element)) {
        const symbol = checker.getSymbolAtLocation(element.typeName);
        if (symbol) {
          return (0, TypeConverterFactory2.transform)(symbol, checker);
        }
      }
      return void 0;
    }).filter(Boolean);
    return factory2.createTupleTypeNode(node);
  };
  const array = (type, checker) => {
    const element = type.elementType;
    if (element.kind === import_typescript5.default.SyntaxKind.StringKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.StringKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.NumberKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.NumberKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.BooleanKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.BooleanKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.UndefinedKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.UndefinedKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.NullKeyword) {
      return factory2.createArrayTypeNode(factory2.createLiteralTypeNode(factory2.createNull()));
    }
    if (element.kind === import_typescript5.default.SyntaxKind.AnyKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.AnyKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.ObjectKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.ObjectKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.UnknownKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.UnknownKeyword)
      );
    }
    if (element.kind === import_typescript5.default.SyntaxKind.NeverKeyword) {
      return factory2.createArrayTypeNode(
        factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.NeverKeyword)
      );
    }
    if (import_typescript5.default.isTypeLiteralNode(element)) {
      return factory2.createArrayTypeNode(typeLiteral(element, checker));
    }
    if (import_typescript5.default.isParenthesizedTypeNode(element)) {
      const type2 = element.type;
      if (import_typescript5.default.isUnionTypeNode(type2)) {
        return factory2.createArrayTypeNode(unionOrIntersection(type2, checker, true));
      }
      if (import_typescript5.default.isIntersectionTypeNode(type2)) {
        return factory2.createArrayTypeNode(unionOrIntersection(type2, checker, false));
      }
    }
    return void 0;
  };
  const typeLiteral = (type, checker) => {
    const properties = type.members.map((member) => {
      const name = member.name;
      if (import_typescript5.default.isPropertySignature(member) && member.type && name) {
        const type2 = member.type;
        if (type2.kind === import_typescript5.default.SyntaxKind.StringKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.StringKeyword)
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.NumberKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.NumberKeyword)
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.BooleanKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.BooleanKeyword)
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.NullKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createLiteralTypeNode(factory2.createNull())
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.AnyKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.AnyKeyword)
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.UndefinedKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createKeywordTypeNode(import_typescript5.default.SyntaxKind.UndefinedKeyword)
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.LiteralType && import_typescript5.default.isLiteralTypeNode(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            literalKindToKeyword(type2)
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.UnknownKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            keywordTypeNode("unknown")
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.NeverKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            keywordTypeNode("never")
          );
        }
        if (type2.kind === import_typescript5.default.SyntaxKind.VoidKeyword) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            keywordTypeNode("void")
          );
        }
        if (import_typescript5.default.isUnionTypeNode(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            unionOrIntersection(type2, checker, true)
          );
        }
        if (import_typescript5.default.isIntersectionTypeNode(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            unionOrIntersection(type2, checker, false)
          );
        }
        if (import_typescript5.default.isStringLiteral(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createLiteralTypeNode(factory2.createStringLiteral(type2.text))
          );
        }
        if (import_typescript5.default.isNumericLiteral(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            factory2.createLiteralTypeNode(factory2.createNumericLiteral(type2.text))
          );
        }
        if (import_typescript5.default.isTypeLiteralNode(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            typeLiteral(type2, checker)
          );
        }
        if (import_typescript5.default.isTypeReferenceNode(type2)) {
          const symbol = checker.getSymbolAtLocation(type2.typeName);
          const typeArgument = type2.typeArguments;
          if (symbol && !typeArgument) {
            return factory2.createPropertySignature(
              void 0,
              name,
              void 0,
              (0, TypeConverterFactory2.transform)(symbol, checker, true)
            );
          }
          if (symbol && typeArgument) {
            const node = typeArgument.map((t) => {
              if (import_typescript5.default.isTypeReferenceNode(t)) {
                const symbol2 = checker.getSymbolAtLocation(t.typeName);
                if (symbol2) {
                  return (0, TypeConverterFactory2.transform)(symbol2, checker, true);
                }
              }
              if (import_typescript5.default.isLiteralTypeNode(t)) {
                return literalKindToKeyword(t);
              }
              if (import_typescript5.default.isTypeLiteralNode(t)) {
                return typeLiteral(t, checker);
              }
              if (import_typescript5.default.isUnionTypeNode(t)) {
                return unionOrIntersection(t, checker, true);
              }
              if (import_typescript5.default.isIntersectionTypeNode(t)) {
                return unionOrIntersection(t, checker, false);
              }
              return t;
            }).filter(Boolean);
            return factory2.createPropertySignature(
              void 0,
              name,
              void 0,
              factory2.createTypeReferenceNode(
                factory2.createIdentifier("Record"),
                node
              )
            );
          }
        }
        if (import_typescript5.default.isTupleTypeNode(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            (0, TypeConverterFactory2.tuple)(type2, checker)
          );
        }
        if (import_typescript5.default.isArrayTypeNode(type2)) {
          return factory2.createPropertySignature(
            void 0,
            name,
            void 0,
            array(type2, checker)
          );
        }
      }
      return void 0;
    }).filter(Boolean);
    return factory2.createTypeLiteralNode(properties);
  };
  const typeDeclaration = (type, checker) => {
    return type.map((declaration) => {
      if (import_typescript5.default.isTypeAliasDeclaration(declaration)) {
        const type2 = declaration.type;
        if (import_typescript5.default.isTypeLiteralNode(type2)) {
          return typeLiteral(type2, checker);
        }
      }
      if (import_typescript5.default.isInterfaceDeclaration(declaration)) {
        return void 0;
      }
      return void 0;
    }).filter(Boolean)[0];
  };
})(TypeConverterFactory || (TypeConverterFactory = {}));
var TypeConverterFactoryGuard = {
  isObjectType: (type) => {
    return !!(type.flags & import_typescript5.default.TypeFlags.Object);
  },
  isLiteralType: (type) => {
    return !!(type.flags & import_typescript5.default.TypeFlags.StringLiteral) || !!(type.flags & import_typescript5.default.TypeFlags.NumberLiteral) || !!(type.flags & import_typescript5.default.TypeFlags.BooleanLiteral);
  },
  isOptional: (symbol) => {
    return symbol.valueDeclaration && (import_typescript5.default.isParameter(symbol.valueDeclaration) || import_typescript5.default.isPropertySignature(symbol.valueDeclaration)) ? !!symbol.valueDeclaration.questionToken : !!(symbol.getFlags() & import_typescript5.default.SymbolFlags.Optional);
  }
};

// src/factories/QueryKeyStructureFactory.ts
var QueryKeyStructureFactory;
((QueryKeyStructureFactory2) => {
  const factory2 = import_typescript6.default.factory;
  QueryKeyStructureFactory2.write = ({
    identifierName,
    node,
    checker
  }) => {
    const isStringLiteral = node.every((item) => TypeGuard.stringLiteral(item.type));
    const arrayLiteralExpression = arrayLiteral(node);
    if (isStringLiteral) {
      return factory2.createPropertyAssignment(
        factory2.createIdentifier(identifierName),
        arrayLiteralExpression
      );
    }
    const parameterDeclarations = parameter(
      node.filter((item) => !TypeGuard.stringLiteral(item.type)),
      checker
    );
    return factory2.createPropertyAssignment(
      factory2.createIdentifier(identifierName),
      factory2.createArrowFunction(
        void 0,
        void 0,
        [...parameterDeclarations],
        void 0,
        factory2.createToken(import_typescript6.default.SyntaxKind.EqualsGreaterThanToken),
        arrayLiteralExpression
      )
    );
  };
  const arrayLiteral = (node) => {
    const literal = node.map((item) => {
      if (TypeGuard.stringLiteral(item.type)) {
        return nodeByName.stringLiteral(item.name);
      }
      if (TypeGuard.symbol(item.type)) {
        return nodeByName.identifier(item.name);
      }
      if (TypeGuard.tsType(item.type)) {
        return nodeByName.identifier(item.name);
      }
      return nodeByName.identifier(item.name);
    }).filter(Boolean);
    const arrayLiteralExpression = factory2.createArrayLiteralExpression(literal, false);
    return arrayLiteralExpression;
  };
  const parameter = (node, checker) => {
    return node.map((item) => {
      if (TypeGuard.symbol(item.type)) {
        const isOptional = TypeConverterFactoryGuard.isOptional(item.type);
        return factory2.createParameterDeclaration(
          void 0,
          void 0,
          nodeByName.identifier(item.name),
          isOptional ? factory2.createToken(import_typescript6.default.SyntaxKind.QuestionToken) : void 0,
          TypeConverterFactory.transform(item.type, checker),
          void 0
        );
      }
      if (TypeGuard.tsType(item.type) && item.kind === QueryNodeKind.EnumMember) {
        const isOptional = TypeConverterFactoryGuard.isOptional(item.symbol);
        return factory2.createParameterDeclaration(
          void 0,
          void 0,
          nodeByName.identifier(item.name),
          isOptional ? factory2.createToken(import_typescript6.default.SyntaxKind.QuestionToken) : void 0,
          TypeConverterFactory.enumToUnion(item.type, checker),
          void 0
        );
      }
      if (TypeGuard.tsType(item.type) && item.kind === QueryNodeKind.TypeOfKeyword) {
        const isOptional = TypeConverterFactoryGuard.isOptional(item.symbol);
        const typeOfNode = TypeConverterFactory.typeofKeyword(item.type, checker);
        return factory2.createParameterDeclaration(
          void 0,
          void 0,
          nodeByName.identifier(item.name),
          isOptional ? factory2.createToken(import_typescript6.default.SyntaxKind.QuestionToken) : void 0,
          typeOfNode,
          void 0
        );
      }
      if (TypeGuard.tuple(item.type) && item.kind === QueryNodeKind.Tuple) {
        const isOptional = TypeConverterFactoryGuard.isOptional(item.symbol);
        const tupleNode = TypeConverterFactory.tuple(item.type, checker);
        return factory2.createParameterDeclaration(
          void 0,
          void 0,
          nodeByName.identifier(item.name),
          isOptional ? factory2.createToken(import_typescript6.default.SyntaxKind.QuestionToken) : void 0,
          tupleNode,
          void 0
        );
      }
      return void 0;
    }).filter(Boolean);
  };
})(QueryKeyStructureFactory || (QueryKeyStructureFactory = {}));

// src/factories/QueryKeyStatementFactory.ts
var import_typescript8 = __toESM(require("typescript"), 1);

// src/factories/VariableDeclarationFactory.ts
var import_typescript7 = __toESM(require("typescript"), 1);
var VariableDeclarationFactory;
((VariableDeclarationFactory2) => {
  const factory2 = import_typescript7.default.factory;
  VariableDeclarationFactory2.write = (name, node, isConst = false) => {
    const typeNode = () => {
      if (isConst) {
        return factory2.createAsExpression(
          node,
          factory2.createTypeReferenceNode(factory2.createIdentifier("const"), void 0)
        );
      }
      return node;
    };
    return factory2.createVariableDeclaration(
      factory2.createIdentifier(name),
      void 0,
      void 0,
      typeNode()
    );
  };
})(VariableDeclarationFactory || (VariableDeclarationFactory = {}));
var VariableDeclarationListFactory;
((VariableDeclarationListFactory2) => {
  const factory2 = import_typescript7.default.factory;
  VariableDeclarationListFactory2.write = (variables, flag = import_typescript7.default.NodeFlags.Const) => {
    return factory2.createVariableDeclarationList(variables, flag);
  };
})(VariableDeclarationListFactory || (VariableDeclarationListFactory = {}));

// src/factories/QueryKeyStatementFactory.ts
var QueryKeyStatementFactory;
((QueryKeyStatementFactory2) => {
  const factory2 = import_typescript8.default.factory;
  QueryKeyStatementFactory2.write = (propertyAssignments, keyName, factoryPrefix) => {
    return factory2.createVariableStatement(
      void 0,
      VariableDeclarationListFactory.write(
        [
          VariableDeclarationFactory.write(
            keyName + factoryPrefix,
            ObjectLiteralExpressionFactory.write([...propertyAssignments]),
            true
          )
        ],
        import_typescript8.default.NodeFlags.Const
      )
    );
  };
})(QueryKeyStatementFactory || (QueryKeyStatementFactory = {}));

// src/factories/GlobalQueryKeyStatement.ts
var import_typescript9 = __toESM(require("typescript"), 1);
var GlobalQueryKeyStatement;
((GlobalQueryKeyStatement2) => {
  const factory2 = import_typescript9.default.factory;
  GlobalQueryKeyStatement2.write = (keyStatement, keyName, factoryPrefix) => {
    return factory2.createVariableStatement(
      [factory2.createToken(import_typescript9.default.SyntaxKind.ExportKeyword)],
      factory2.createVariableDeclarationList(
        [
          factory2.createVariableDeclaration(
            factory2.createIdentifier(keyName),
            void 0,
            void 0,
            factory2.createAsExpression(
              factory2.createObjectLiteralExpression(
                [
                  ...keyStatement.map((item) => {
                    return factory2.createShorthandPropertyAssignment(
                      factory2.createIdentifier(item.key + factoryPrefix)
                    );
                  })
                ],
                true
              ),
              factory2.createTypeReferenceNode(
                factory2.createIdentifier("const"),
                void 0
              )
            )
          )
        ],
        import_typescript9.default.NodeFlags.Const
      )
    );
  };
})(GlobalQueryKeyStatement || (GlobalQueryKeyStatement = {}));

// src/queryFinder/QueryKeyFinder.ts
var import_typescript10 = __toESM(require("typescript"), 1);
var QueryKeyFinder;
((QueryKeyFinder2) => {
  const PROPERTY_NAME = "queryKey";
  QueryKeyFinder2.findQueryKey = ({
    useQueries,
    checker
  }) => {
    const result = useQueries.map((value) => {
      const arrayLiteral = visitor(value, checker);
      return arrayLiteral;
    }).flat();
    return result;
  };
  const visitor = (value, checker) => {
    const arrayLiteral = [];
    const visit = (node) => {
      if (import_typescript10.default.isCallExpression(node)) {
        const expression = node.expression;
        const args = node.arguments;
        args.forEach((arg) => {
          if (import_typescript10.default.isPropertyAccessExpression(arg)) {
            const symbol = checker.getSymbolAtLocation(arg);
            if (symbol && symbol.valueDeclaration) {
              const valueDeclaration = symbol.valueDeclaration;
              if (import_typescript10.default.isPropertyAssignment(valueDeclaration)) {
                const initializer = valueDeclaration.initializer;
                if (initializer && import_typescript10.default.isCallExpression(initializer)) {
                  visit(initializer);
                }
              }
            }
          }
          if (import_typescript10.default.isCallExpression(arg)) {
            const expression2 = arg.expression;
            visit(expression2);
          }
          if (import_typescript10.default.isIdentifier(arg)) {
            const symbol = checker.getSymbolAtLocation(arg);
            if (symbol && symbol.valueDeclaration) {
              const valueDeclaration = symbol.valueDeclaration;
              if (import_typescript10.default.isVariableDeclaration(valueDeclaration)) {
                const initializer = valueDeclaration.initializer;
                if (initializer) {
                  visit(initializer);
                }
              }
            }
          }
          if (import_typescript10.default.isObjectLiteralExpression(arg)) {
            visit(arg);
          }
        });
        if (import_typescript10.default.isIdentifier(expression)) {
          const symbol = checker.getSymbolAtLocation(expression);
          if (symbol && symbol.valueDeclaration) {
            const valueDeclaration = symbol.valueDeclaration;
            if (import_typescript10.default.isVariableDeclaration(valueDeclaration)) {
              const initializer = valueDeclaration.initializer;
              if (initializer && import_typescript10.default.isCallExpression(initializer)) {
                visit(initializer);
              }
            }
          }
        }
        if (import_typescript10.default.isPropertyAccessExpression(expression)) {
          const symbol = checker.getSymbolAtLocation(expression);
          if (symbol && symbol.valueDeclaration) {
            const valueDeclaration = symbol.valueDeclaration;
            if (import_typescript10.default.isPropertyAssignment(valueDeclaration)) {
              const initializer = valueDeclaration.initializer;
              if (initializer && import_typescript10.default.isArrowFunction(initializer)) {
                const body = initializer.body;
                if (import_typescript10.default.isArrayLiteralExpression(body)) {
                  arrayLiteral.push(makeArrayLiteral(body.elements, checker));
                }
                if (import_typescript10.default.isBlock(body)) {
                  const statements = body.statements;
                  statements.forEach((statement) => {
                    if (import_typescript10.default.isReturnStatement(statement)) {
                      const expression2 = statement.expression;
                      if (expression2 && import_typescript10.default.isCallExpression(expression2)) {
                        const argument = expression2.arguments;
                        const callExpression = expression2.expression;
                        argument.forEach((arg) => {
                          if (import_typescript10.default.isObjectLiteralExpression(arg)) {
                            arrayLiteral.push(
                              objectExpression(arg, checker)
                            );
                          }
                        });
                        visit(callExpression);
                      }
                    }
                  });
                }
                if (import_typescript10.default.isArrowFunction(body)) {
                  visit(body);
                }
                if (import_typescript10.default.isCallExpression(body)) {
                  visit(body);
                }
              }
            }
          }
        }
      }
      if (import_typescript10.default.isIdentifier(node)) {
        const identifierSymbol = checker.getSymbolAtLocation(node);
        if (identifierSymbol) {
          const valueDeclaration = identifierSymbol.valueDeclaration;
          if (valueDeclaration && import_typescript10.default.isVariableDeclaration(valueDeclaration)) {
            const objectInitializer = valueDeclaration.initializer;
            if (objectInitializer && import_typescript10.default.isObjectLiteralExpression(objectInitializer)) {
              const targetProperty = findPropertyByQueryKey(
                objectInitializer.properties
              );
              if (targetProperty && import_typescript10.default.isPropertyAssignment(targetProperty)) {
                const targetInitializer = targetProperty.initializer;
                if (import_typescript10.default.isArrayLiteralExpression(targetInitializer)) {
                  arrayLiteral.push(
                    makeArrayLiteral(targetInitializer.elements, checker)
                  );
                }
                if (import_typescript10.default.isArrowFunction(targetInitializer)) {
                  const body = targetInitializer.body;
                  if (import_typescript10.default.isArrayLiteralExpression(body)) {
                    arrayLiteral.push(makeArrayLiteral(body.elements, checker));
                  }
                  if (import_typescript10.default.isBlock(body)) {
                    const statements = body.statements;
                    statements.forEach((statement) => {
                      visit(statement);
                    });
                  }
                  if (import_typescript10.default.isParenthesizedExpression(body)) {
                    visit(body.expression);
                  }
                }
              }
            }
            if (objectInitializer && import_typescript10.default.isArrowFunction(objectInitializer)) {
              const body = objectInitializer.body;
              if (import_typescript10.default.isCallExpression(body)) {
                visit(body);
              }
              if (import_typescript10.default.isBlock(body)) {
                const statements = body.statements;
                statements.forEach((statement) => {
                  visit(statement);
                });
              }
              if (import_typescript10.default.isParenthesizedExpression(body)) {
                visit(body.expression);
              }
            }
            if (objectInitializer && import_typescript10.default.isCallExpression(objectInitializer)) {
              visit(objectInitializer);
            }
          }
          if (valueDeclaration && import_typescript10.default.isFunctionDeclaration(valueDeclaration)) {
            const body = valueDeclaration.body;
            if (body && import_typescript10.default.isBlock(body)) {
              visit(body);
            }
          }
        }
      }
      if (import_typescript10.default.isObjectLiteralExpression(node)) {
        const properties = node.properties;
        const isQueries = properties.some(
          (property) => import_typescript10.default.isPropertyAssignment(property) && property.name.getText() === "queries"
        );
        if (isQueries) {
          properties.forEach((property) => {
            if (import_typescript10.default.isPropertyAssignment(property) && property.name.getText() === "queries") {
              const initializer = property.initializer;
              visit(initializer);
            }
          });
          return;
        }
        arrayLiteral.push(objectExpression(node, checker));
      }
      import_typescript10.default.forEachChild(node, visit);
    };
    visit(value);
    if (arrayLiteral.flat().length === 0) {
      logger.warn("This function is not provided. : \n" + value.getText());
    }
    return arrayLiteral;
  };
  const objectExpression = (node, checker) => {
    let arrayLiteral = [];
    const properties = node.properties;
    properties.forEach((property) => {
      var _a;
      if (import_typescript10.default.isPropertyAssignment(property) && property.name.getText() === "queryKey") {
        const initializer = property.initializer;
        if (import_typescript10.default.isArrayLiteralExpression(initializer)) {
          arrayLiteral = makeArrayLiteral(initializer.elements, checker);
        }
        if (import_typescript10.default.isCallExpression(initializer)) {
          const expression = initializer.expression;
          if (import_typescript10.default.isIdentifier(expression)) {
            const valueDeclaration = (_a = checker.getSymbolAtLocation(expression)) == null ? void 0 : _a.valueDeclaration;
            if (valueDeclaration && import_typescript10.default.isVariableDeclaration(valueDeclaration)) {
              const initializer2 = valueDeclaration.initializer;
              if (initializer2 && import_typescript10.default.isArrowFunction(initializer2)) {
                const body = initializer2.body;
                if (import_typescript10.default.isArrayLiteralExpression(body)) {
                  const elements = body.elements;
                  arrayLiteral = makeArrayLiteral(elements, checker);
                }
              }
            }
            if (valueDeclaration && impor