dilswer/dist/cjs/ts-type-generator/file-scope.cjs

Blazingly fast data validation library with TypeScript integration.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// src/ts-type-generator/file-scope.ts
var file_scope_exports = {};
__export(file_scope_exports, {
  TsFileScope: () => TsFileScope
});
module.exports = __toCommonJS(file_scope_exports);
var import_name_generator = require("./name-generator.cjs");
var import_type_reference = require("./type-builders/type-reference.cjs");
var TsFileScope = class {
  constructor(options) {
    this.options = options;
    __publicField(this, "imports", /* @__PURE__ */ new Map());
    __publicField(this, "typeDefinitions", /* @__PURE__ */ new Map());
    __publicField(this, "exportedNames", /* @__PURE__ */ new Set());
    __publicField(this, "definedTypes", /* @__PURE__ */ new Set());
  }
  exportTypeFor(builder, isRoot = false) {
    if (this.options.declaration) {
      if (this.options.exports === "none") return "declare";
      if (this.options.exports === "main" && !isRoot) return "declare";
      if (this.options.exports === "named" && !builder.isTitled) {
        return "declare";
      }
      return "export/declare";
    }
    if (this.options.exports === "none") return null;
    if (this.options.exports === "main" && !isRoot) return null;
    if (this.options.exports === "named" && !builder.isTitled) return null;
    return "export";
  }
  addTypeImport(ext) {
    if (ext.path) {
      let imports = this.imports.get(ext.path);
      if (!imports) {
        imports = /* @__PURE__ */ new Set();
        this.imports.set(ext.path, imports);
      }
      imports.add(ext.importName);
    }
  }
  appendDef(builder, name, declarationStatement) {
    if (this.options.exports === "none" || this.options.exports === "main") {
      declarationStatement = declarationStatement.replace(/^export /, "");
    }
    this.definedTypes.add(name);
    this.typeDefinitions.set(builder, declarationStatement);
    if (declarationStatement.match(/^\s*export/)) {
      this.exportedNames.add(name);
    }
  }
  changeReferenceName(ref, newName) {
    const currentName = ref.getName();
    if (currentName === newName) return;
    if (this.definedTypes.has(newName)) {
      throw new Error(`Duplicate type name: ${newName}`);
    }
    const referencedBuilder = import_type_reference.TsTypeReference.resolveReference(ref);
    if (currentName) {
      this.definedTypes.delete(currentName);
      this.typeDefinitions.delete(referencedBuilder);
      this.exportedNames.delete(currentName);
    }
    referencedBuilder.setName(newName);
    ref.name = newName;
    const declarationStatement = referencedBuilder.buildExport(
      this.exportTypeFor(referencedBuilder)
    );
    if (declarationStatement) {
      this.appendDef(referencedBuilder, newName, declarationStatement);
    }
  }
  addTypeExport(builder, forceName) {
    let declarationStatement = builder.buildExport(this.exportTypeFor(builder));
    let name = forceName != null ? forceName : builder.getName();
    if (!name) {
      throw new Error(
        "Type name is undefined after definition generation. Impossible situation."
      );
    }
    if (!forceName) {
      if (this.definedTypes.has(name)) {
        switch (this.options.onDuplicateName) {
          case "error":
            throw new Error(`Duplicate type name: ${name}`);
          case "rename": {
            name = import_name_generator.NameGenerator.generate(name);
            builder.setName(name);
            declarationStatement = builder.buildExport(
              this.exportTypeFor(builder)
            );
          }
        }
      }
      if (declarationStatement) {
        this.appendDef(builder, name, declarationStatement);
      }
    } else if (declarationStatement && !this.definedTypes.has(name)) {
      this.appendDef(builder, name, declarationStatement);
    }
    builder.isAddedToScope = true;
    return new import_type_reference.TsTypeReference(this, builder, name);
  }
  addRootType(builder) {
    const referencedBuilder = import_type_reference.TsTypeReference.resolveReference(builder);
    if (!referencedBuilder.isAddedToScope) {
      this.addTypeExport(referencedBuilder);
    }
    const exportType = this.exportTypeFor(builder, true);
    const def = builder.buildExport(exportType);
    const name = builder.getName();
    if (name && this.exportedNames.has(name)) {
      return;
    }
    if (def) {
      this.typeDefinitions.set(builder, def);
    } else {
      if (name) {
        switch (exportType) {
          case "export":
          case "export/declare":
            this.typeDefinitions.set(builder, `export type { ${name} };`);
            break;
        }
      }
    }
  }
  build() {
    let imports = "";
    for (const [from, types] of this.imports) {
      const typesList = Array.from(types).join(", ");
      imports += `import type { ${typesList} } from "${from}";
`;
    }
    const content = [...this.typeDefinitions.values()].join("\n\n");
    return (imports + content).trim() + "\n";
  }
};