@busy-hour/blaze-types/dist/cjs/lib/writer.js

<h1 align='center'>🔥 Blaze Types</h1> <div align='center'> An event driven framework for 🔥 Hono.js </div>

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var writer_exports = {};
__export(writer_exports, {
  writeDefinition: () => writeDefinition
});
module.exports = __toCommonJS(writer_exports);
var import_node_fs = __toESM(require("node:fs"), 1);
var import_node_path = __toESM(require("node:path"), 1);
var import_service_loader = require("./service-loader");
var import_module = require("../utils/module");
var import_constant = require("../utils/constant");
function buildDefinition(info) {
  const action = `
    ActionsExtractor<typeof ${info.fileName}>`;
  const event = `
    EventsExtractor<typeof ${info.fileName}>`;
  const imports = `import ${info.fileName} from '${info.importPath}';`;
  const trpcQuery = `
    TrpcQueryExtractor<typeof ${info.fileName}>`;
  const trpcMutation = `
    TrpcMutationExtractor<typeof ${info.fileName}>`;
  return {
    action,
    event,
    trpcQuery,
    trpcMutation,
    import: imports
  };
}
function generateDefinition(definitions) {
  const isShouldExtend = definitions.length > 0;
  const imports = [...import_constant.IMPORTS];
  const actions = isShouldExtend ? `export interface ActionCallRecord extends ${definitions.map((def) => def.action).join(",")} {}` : `export interface ActionCallRecord {}`;
  const events = isShouldExtend ? `export interface EventCallRecord extends ${definitions.map((def) => def.event).join(",")} {}` : `export interface EventCallRecord {}`;
  const trpcQuery = isShouldExtend ? `export interface TrpcQueryCallRecord extends ${definitions.map((def) => def.trpcQuery).join(",")} {}` : "";
  const trpcMutation = isShouldExtend ? `export interface TrpcMutationCallRecord extends ${definitions.map((def) => def.trpcMutation).join(",")} {}` : "";
  if (isShouldExtend) {
    imports.push(...definitions.map((def) => def.import));
  }
  return `${import_constant.DISCLAIMER}
/* eslint-disable */

${imports.join("\n")}

declare module '@busy-hour/blaze' {
  ${actions}

  ${events}

  ${trpcQuery}

  ${trpcMutation}
}
`;
}
function writeDefinition() {
  const services = (0, import_service_loader.getServicesPaths)().map(import_service_loader.readServiceDir).flat(1);
  const servicesInfo = services.map(import_service_loader.getServiceInformation).filter(Boolean);
  const definitions = servicesInfo.map(buildDefinition);
  const filePath = import_node_path.default.join(import_module.tsModule.getOutputPath(), "blaze.d.ts");
  const content = generateDefinition(definitions);
  if (!import_node_fs.default.existsSync(import_module.tsModule.getOutputPath())) {
    import_node_fs.default.mkdirSync(import_module.tsModule.getOutputPath(), {
      recursive: true
    });
  }
  return import_node_fs.default.writeFileSync(filePath, content, "utf8");
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  writeDefinition
});