@kubb/swagger-ts 1.15.0-canary.20231026T132100 → 1.15.0-canary.20231026T182535

package/dist/index.cjs

@@ -34,17 +34,25 @@ function _interopNamespace(e) {
 var path__default = /*#__PURE__*/_interopDefault(path);
 var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
 
-// src/plugin.ts
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _usedAliasNames, _caseOptions, _getTypeFromSchema, getTypeFromSchema_fn, _getTypeFromProperties, getTypeFromProperties_fn, _getRefAlias, getRefAlias_fn, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn;
 var TypeGenerator = class extends core.SchemaGenerator {
-  refs = {};
-  extraNodes = [];
-  aliases = [];
-  // Keep track of already used type aliases
-  #usedAliasNames = {};
-  #caseOptions = {
-    delimiter: "",
-    stripRegexp: /[^A-Z0-9$]/gi
-  };
   constructor(options = {
     usedEnumNames: {},
     withJSDocs: true,
@@ -54,6 +62,34 @@ var TypeGenerator = class extends core.SchemaGenerator {
     optionalType: "questionToken"
   }) {
     super(options);
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    __privateAdd(this, _getTypeFromSchema);
+    /**
+     * Recursively creates a type literal with the given props.
+     */
+    __privateAdd(this, _getTypeFromProperties);
+    /**
+     * Create a type alias for the schema referenced by the given ReferenceObject
+     */
+    __privateAdd(this, _getRefAlias);
+    /**
+     * This is the very core of the OpenAPI to TS conversion - it takes a
+     * schema and returns the appropriate type.
+     */
+    __privateAdd(this, _getBaseTypeFromSchema);
+    this.refs = {};
+    this.extraNodes = [];
+    this.aliases = [];
+    // Keep track of already used type aliases
+    __privateAdd(this, _usedAliasNames, {});
+    __privateAdd(this, _caseOptions, {
+      delimiter: "",
+      stripRegexp: /[^A-Z0-9$]/gi
+    });
     return this;
   }
   build({
@@ -63,7 +99,7 @@ var TypeGenerator = class extends core.SchemaGenerator {
     keysToOmit
   }) {
     const nodes = [];
-    const type = this.#getTypeFromSchema(schema, baseName);
+    const type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, baseName);
     if (!type) {
       return this.extraNodes;
     }
@@ -89,217 +125,205 @@ var TypeGenerator = class extends core.SchemaGenerator {
     );
     return [...this.extraNodes, ...filterdNodes];
   }
-  /**
-   * Creates a type node from a given schema.
-   * Delegates to getBaseTypeFromSchema internally and
-   * optionally adds a union with null.
-   */
-  #getTypeFromSchema(schema, name) {
-    const type = this.#getBaseTypeFromSchema(schema, name);
+};
+_usedAliasNames = new WeakMap();
+_caseOptions = new WeakMap();
+_getTypeFromSchema = new WeakSet();
+getTypeFromSchema_fn = function(schema, name) {
+  const type = __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schema, name);
+  if (!type) {
+    return null;
+  }
+  if (schema && !schema.nullable) {
+    return type;
+  }
+  return factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.null] });
+};
+_getTypeFromProperties = new WeakSet();
+getTypeFromProperties_fn = function(baseSchema, baseName) {
+  const { optionalType } = this.options;
+  const properties = baseSchema?.properties || {};
+  const required = baseSchema?.required;
+  const additionalProperties = baseSchema?.additionalProperties;
+  const members = Object.keys(properties).map((name) => {
+    const schema = properties[name];
+    const isRequired = required && required.includes(name);
+    let type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, this.options.resolveName({ name: `${baseName || ""} ${name}` }));
     if (!type) {
       return null;
     }
-    if (schema && !schema.nullable) {
-      return type;
+    if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+      type = factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.undefined] });
     }
-    return factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.null] });
-  }
-  /**
-   * Recursively creates a type literal with the given props.
-   */
-  #getTypeFromProperties(baseSchema, baseName) {
-    const { optionalType } = this.options;
-    const properties = baseSchema?.properties || {};
-    const required = baseSchema?.required;
-    const additionalProperties = baseSchema?.additionalProperties;
-    const members = Object.keys(properties).map((name) => {
-      const schema = properties[name];
-      const isRequired = required && required.includes(name);
-      let type = this.#getTypeFromSchema(schema, this.options.resolveName({ name: `${baseName || ""} ${name}` }));
-      if (!type) {
-        return null;
-      }
-      if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-        type = factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.undefined] });
-      }
-      const propertySignature = factory__namespace.createPropertySignature({
-        questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
-        name,
-        type,
-        readOnly: schema.readOnly
-      });
-      if (this.options.withJSDocs) {
-        return factory__namespace.appendJSDocToNode({
-          node: propertySignature,
-          comments: [
-            schema.description ? `@description ${schema.description}` : void 0,
-            schema.type ? `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
-            schema.example ? `@example ${schema.example}` : void 0,
-            schema.deprecated ? `@deprecated` : void 0,
-            schema.default !== void 0 && typeof schema.default === "string" ? `@default '${schema.default}'` : void 0,
-            schema.default !== void 0 && typeof schema.default !== "string" ? `@default ${schema.default}` : void 0
-          ].filter(Boolean)
-        });
-      }
-      return propertySignature;
+    const propertySignature = factory__namespace.createPropertySignature({
+      questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
+      name,
+      type,
+      readOnly: schema.readOnly
     });
-    if (additionalProperties) {
-      const type = additionalProperties === true ? factory__namespace.keywordTypeNodes.any : this.#getTypeFromSchema(additionalProperties);
-      if (type) {
-        members.push(factory__namespace.createIndexSignature(type));
-      }
+    if (this.options.withJSDocs) {
+      return factory__namespace.appendJSDocToNode({
+        node: propertySignature,
+        comments: [
+          schema.description ? `@description ${schema.description}` : void 0,
+          schema.type ? `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
+          schema.example ? `@example ${schema.example}` : void 0,
+          schema.deprecated ? `@deprecated` : void 0,
+          schema.default !== void 0 && typeof schema.default === "string" ? `@default '${schema.default}'` : void 0,
+          schema.default !== void 0 && typeof schema.default !== "string" ? `@default ${schema.default}` : void 0
+        ].filter(Boolean)
+      });
     }
-    return factory__namespace.createTypeLiteralNode(members.filter(Boolean));
-  }
-  /**
-   * Create a type alias for the schema referenced by the given ReferenceObject
-   */
-  #getRefAlias(obj, _baseName) {
-    const { $ref } = obj;
-    let ref = this.refs[$ref];
-    if (ref) {
-      return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+    return propertySignature;
+  });
+  if (additionalProperties) {
+    const type = additionalProperties === true ? factory__namespace.keywordTypeNodes.any : __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, additionalProperties);
+    if (type) {
+      members.push(factory__namespace.createIndexSignature(type));
     }
-    const originalName = utils.getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
-    const propertyName = this.options.resolveName({ name: originalName }) || originalName;
-    ref = this.refs[$ref] = {
-      propertyName,
-      originalName
-    };
+  }
+  return factory__namespace.createTypeLiteralNode(members.filter(Boolean));
+};
+_getRefAlias = new WeakSet();
+getRefAlias_fn = function(obj, _baseName) {
+  const { $ref } = obj;
+  let ref = this.refs[$ref];
+  if (ref) {
     return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
   }
-  /**
-   * This is the very core of the OpenAPI to TS conversion - it takes a
-   * schema and returns the appropriate type.
-   */
-  #getBaseTypeFromSchema(schema, baseName) {
-    if (!schema) {
-      return factory__namespace.keywordTypeNodes.any;
-    }
-    if (utils$1.isReference(schema)) {
-      return this.#getRefAlias(schema, baseName);
-    }
-    if (schema.oneOf) {
-      const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
-      const union = factory__namespace.createUnionDeclaration({
-        withParentheses: true,
-        nodes: schema.oneOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== factory__namespace.keywordTypeNodes.any;
-        })
+  const originalName = utils.getUniqueName($ref.replace(/.+\//, ""), __privateGet(this, _usedAliasNames));
+  const propertyName = this.options.resolveName({ name: originalName }) || originalName;
+  ref = this.refs[$ref] = {
+    propertyName,
+    originalName
+  };
+  return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+};
+_getBaseTypeFromSchema = new WeakSet();
+getBaseTypeFromSchema_fn = function(schema, baseName) {
+  if (!schema) {
+    return factory__namespace.keywordTypeNodes.any;
+  }
+  if (utils$1.isReference(schema)) {
+    return __privateMethod(this, _getRefAlias, getRefAlias_fn).call(this, schema, baseName);
+  }
+  if (schema.oneOf) {
+    const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+    const union = factory__namespace.createUnionDeclaration({
+      withParentheses: true,
+      nodes: schema.oneOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutOneOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutOneOf, baseName), union].filter(Boolean)
       });
-      if (schemaWithoutOneOf.properties) {
-        return factory__namespace.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
-        });
-      }
-      return union;
     }
-    if (schema.anyOf) {
-      const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-      const union = factory__namespace.createUnionDeclaration({
-        withParentheses: true,
-        nodes: schema.anyOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== factory__namespace.keywordTypeNodes.any;
-        })
+    return union;
+  }
+  if (schema.anyOf) {
+    const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
+    const union = factory__namespace.createUnionDeclaration({
+      withParentheses: true,
+      nodes: schema.anyOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAnyOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAnyOf, baseName), union].filter(Boolean)
       });
-      if (schemaWithoutAnyOf.properties) {
-        return factory__namespace.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean)
-        });
-      }
-      return union;
     }
-    if (schema.allOf) {
-      const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-      const and = factory__namespace.createIntersectionDeclaration({
-        withParentheses: true,
-        nodes: schema.allOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== factory__namespace.keywordTypeNodes.any;
-        })
+    return union;
+  }
+  if (schema.allOf) {
+    const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+    const and = factory__namespace.createIntersectionDeclaration({
+      withParentheses: true,
+      nodes: schema.allOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAllOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAllOf, baseName), and].filter(Boolean)
       });
-      if (schemaWithoutAllOf.properties) {
-        return factory__namespace.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
-        });
-      }
-      return and;
     }
-    if (schema.enum && baseName) {
-      const enumName = utils.getUniqueName(baseName, this.options.usedEnumNames);
-      let enums = [...new Set(schema.enum)].map((key) => [key, key]);
-      if ("x-enumNames" in schema) {
-        enums = [...new Set(schema["x-enumNames"])].map((key, index) => {
-          return [key, schema.enum?.[index]];
-        });
-      }
-      this.extraNodes.push(
-        ...factory__namespace.createEnumDeclaration({
-          name: changeCase.camelCase(enumName, this.#caseOptions),
-          typeName: this.options.resolveName({ name: enumName }),
-          enums,
-          type: this.options.enumType
-        })
-      );
-      return factory__namespace.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
-    }
-    if (schema.enum) {
-      return factory__namespace.createUnionDeclaration({
-        nodes: schema.enum.map((name) => {
-          return factory__namespace.createLiteralTypeNode(typeof name === "number" ? factory__namespace.createNumericLiteral(name) : factory__namespace.createStringLiteral(`${name}`));
-        })
+    return and;
+  }
+  if (schema.enum && baseName) {
+    const enumName = utils.getUniqueName(baseName, this.options.usedEnumNames);
+    let enums = [...new Set(schema.enum)].map((key) => [key, key]);
+    if ("x-enumNames" in schema) {
+      enums = [...new Set(schema["x-enumNames"])].map((key, index) => {
+        return [key, schema.enum?.[index]];
       });
     }
-    if ("items" in schema) {
-      const node = this.#getTypeFromSchema(schema.items, baseName);
-      if (node) {
-        return factory__namespace.createArrayTypeNode(node);
-      }
+    this.extraNodes.push(
+      ...factory__namespace.createEnumDeclaration({
+        name: changeCase.camelCase(enumName, __privateGet(this, _caseOptions)),
+        typeName: this.options.resolveName({ name: enumName }),
+        enums,
+        type: this.options.enumType
+      })
+    );
+    return factory__namespace.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
+  }
+  if (schema.enum) {
+    return factory__namespace.createUnionDeclaration({
+      nodes: schema.enum.map((name) => {
+        return factory__namespace.createLiteralTypeNode(typeof name === "number" ? factory__namespace.createNumericLiteral(name) : factory__namespace.createStringLiteral(`${name}`));
+      })
+    });
+  }
+  if ("items" in schema) {
+    const node = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema.items, baseName);
+    if (node) {
+      return factory__namespace.createArrayTypeNode(node);
     }
-    if ("prefixItems" in schema) {
-      const prefixItems = schema.prefixItems;
-      return factory__namespace.createTupleDeclaration({
-        nodes: prefixItems.map((item) => {
-          return this.#getBaseTypeFromSchema(item, void 0);
-        })
+  }
+  if ("prefixItems" in schema) {
+    const prefixItems = schema.prefixItems;
+    return factory__namespace.createTupleDeclaration({
+      nodes: prefixItems.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item, void 0);
+      })
+    });
+  }
+  if (schema.properties || schema.additionalProperties) {
+    return __privateMethod(this, _getTypeFromProperties, getTypeFromProperties_fn).call(this, schema, baseName);
+  }
+  if (schema.type) {
+    if (Array.isArray(schema.type)) {
+      const [type, nullable] = schema.type;
+      return factory__namespace.createUnionDeclaration({
+        nodes: [
+          __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, {
+            ...schema,
+            type
+          }, baseName),
+          nullable ? factory__namespace.createLiteralTypeNode(factory__namespace.createNull()) : void 0
+        ].filter(Boolean)
       });
     }
-    if (schema.properties || schema.additionalProperties) {
-      return this.#getTypeFromProperties(schema, baseName);
-    }
-    if (schema.type) {
-      if (Array.isArray(schema.type)) {
-        const [type, nullable] = schema.type;
-        return factory__namespace.createUnionDeclaration({
-          nodes: [
-            this.#getBaseTypeFromSchema(
-              {
-                ...schema,
-                type
-              },
-              baseName
-            ),
-            nullable ? factory__namespace.createLiteralTypeNode(factory__namespace.createNull()) : void 0
-          ].filter(Boolean)
-        });
-      }
-      if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
-        return factory__namespace.createTypeReferenceNode(factory__namespace.createIdentifier("Date"));
-      }
-      if (schema.type in factory__namespace.keywordTypeNodes) {
-        return factory__namespace.keywordTypeNodes[schema.type];
-      }
+    if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
+      return factory__namespace.createTypeReferenceNode(factory__namespace.createIdentifier("Date"));
     }
-    if (schema.format === "binary") {
-      return factory__namespace.createTypeReferenceNode("Blob", []);
+    if (schema.type in factory__namespace.keywordTypeNodes) {
+      return factory__namespace.keywordTypeNodes[schema.type];
     }
-    return factory__namespace.keywordTypeNodes.any;
   }
+  if (schema.format === "binary") {
+    return factory__namespace.createTypeReferenceNode("Blob", []);
+  }
+  return factory__namespace.keywordTypeNodes.any;
 };
 
 // src/builders/TypeBuilder.ts