swagger-typescript-api 13.6.10 → 13.7.0

package/dist/{src-DsH2wrQK.cjs → src-DTdmNLxQ.cjs}

@@ -208,7 +208,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.6.10";
+var version = "13.7.0";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 //#endregion
 //#region src/constants.ts
@@ -373,13 +373,19 @@ var CodeGenConfig = class {
 	httpClientType = HTTP_CLIENT.FETCH;
 	unwrapResponseData = false;
 	disableThrowOnError = false;
+	disableFormatTypeNames = false;
 	sortTypes = false;
 	sortRoutes = false;
 	templatePaths = {
+		/** `templates/base` */
 		base: "",
+		/** `templates/default` */
 		default: "",
+		/** `templates/modular` */
 		modular: "",
+		/** usage path if `--templates` option is not set */
 		original: "",
+		/** custom path to templates (`--templates`) */
 		custom: ""
 	};
 	/** Record<templateName, templateContent> */
@@ -400,6 +406,7 @@ var CodeGenConfig = class {
 	silent = false;
 	typePrefix = "";
 	typeSuffix = "";
+	typeNameSeparator = "_";
 	enumKeyPrefix = "";
 	enumKeySuffix = "";
 	patch = false;
@@ -479,18 +486,48 @@ var CodeGenConfig = class {
 	Ts = {
 		Keyword: structuredClone(TsKeyword),
 		CodeGenKeyword: structuredClone(TsCodeGenKeyword),
+		/**
+		* $A[] or Array<$A>
+		*/
 		ArrayType: (content) => {
 			if (this.anotherArrayType) return this.Ts.TypeWithGeneric(this.Ts.Keyword.Array, [content]);
 			return `${this.Ts.ExpressionGroup(content)}[]`;
 		},
+		/**
+		* "$A"
+		*/
 		StringValue: (content) => `"${content}"`,
+		/**
+		* $A
+		*/
 		BooleanValue: (content) => `${content}`,
+		/**
+		* $A
+		*/
 		NumberValue: (content) => `${content}`,
+		/**
+		* $A
+		*/
 		NullValue: () => "null",
+		/**
+		* $A1 | $A2
+		*/
 		UnionType: (contents) => (0, es_toolkit.uniq)(contents).join(` ${this.Ts.Keyword.Union} `),
+		/**
+		* ($A1)
+		*/
 		ExpressionGroup: (content) => content ? `(${content})` : "",
+		/**
+		* $A1 & $A2
+		*/
 		IntersectionType: (contents) => (0, es_toolkit.uniq)(contents).join(` ${this.Ts.Keyword.Intersection} `),
+		/**
+		* Record<$A1, $A2>
+		*/
 		RecordType: (key, value) => this.Ts.TypeWithGeneric(this.Ts.Keyword.Record, [key, value]),
+		/**
+		* readonly $key?:$value
+		*/
 		TypeField: ({ readonly, key, optional, value }) => (0, es_toolkit.compact)([
 			readonly && "readonly ",
 			key,
@@ -498,25 +535,57 @@ var CodeGenConfig = class {
 			": ",
 			value
 		]).join(""),
+		/**
+		* [key: $A1]: $A2
+		*/
 		InterfaceDynamicField: (key, value) => `[key: ${key}]: ${value}`,
+		/**
+		* EnumName.EnumKey
+		*/
 		EnumUsageKey: (enumStruct, key) => `${enumStruct}.${key}`,
+		/**
+		* $A1 = $A2
+		*/
 		EnumField: (key, value) => `${key} = ${value}`,
+		/**
+		* /\** description \*\/
+		*/
 		EnumFieldDescription: (description) => {
 			if (description) return `  /** ${description} */`;
 			else return "";
 		},
+		/**
+		* /\** $A0.description \*\/
+		* $A0.key = $A0.value,
+		* /\** $A1.description \*\/
+		* $A1.key = $A1.value,
+		* /\** $AN.description \*\/
+		* $AN.key = $AN.value,
+		*/
 		EnumFieldsWrapper: (contents) => contents.map(({ key, value, description }) => {
 			return (0, es_toolkit.compact)([this.Ts.EnumFieldDescription(description), `  ${this.Ts.EnumField(key, value)}`]).join("\n");
 		}).join(",\n"),
+		/**
+		* {\n $A \n}
+		*/
 		ObjectWrapper: (content) => `{\n${content}\n}`,
+		/**
+		* /** $A *\/
+		*/
 		MultilineComment: (contents, formatFn) => [...contents.length === 1 ? [`/** ${contents[0]} */`] : [
 			"/**",
 			...contents.map((content) => ` * ${content}`),
 			" */"
 		]].map((part) => `${formatFn ? formatFn(part) : part}\n`),
+		/**
+		* $A1<...$A2.join(,)>
+		*/
 		TypeWithGeneric: (typeName, genericArgs) => {
 			return `${typeName}${genericArgs.length ? `<${genericArgs.join(",")}>` : ""}`;
 		},
+		/**
+		* [$A1, $A2, ...$AN]
+		*/
 		Tuple: (values) => {
 			return `[${values.join(", ")}]`;
 		}
@@ -533,6 +602,7 @@ var CodeGenConfig = class {
 		file: () => this.Ts.Keyword.File,
 		string: {
 			$default: this.Ts.Keyword.String,
+			/** formats */
 			binary: () => this.Ts.Keyword.File,
 			byte: () => this.Ts.Keyword.Blob,
 			file: () => this.Ts.Keyword.File,
@@ -656,6 +726,7 @@ var SchemaComponentsMap = class {
 			typeName,
 			rawTypeData,
 			componentName: rawComponentName === "definitions" ? "schemas" : rawComponentName,
+			/** result from schema parser */
 			typeData: null
 		};
 	}
@@ -1195,10 +1266,11 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 			const rawTypeData = (0, es_toolkit_compat.get)(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
 			const nullable = !!(rawTypeData.nullable || property.nullable);
 			const fieldName = this.typeNameFormatter.isValidName(name) ? name : this.config.Ts.StringValue(name);
-			const fieldValue = this.schemaParserFabric.createSchemaParser({
+			const rawFieldValue = this.schemaParserFabric.createSchemaParser({
 				schema: property,
 				schemaPath: [...this.schemaPath, name]
 			}).getInlineParseContent();
+			const fieldValue = nullable ? this.schemaUtils.safeAddNullToType(property, rawFieldValue) : rawFieldValue;
 			const readOnly = property.readOnly;
 			const complexType = this.schemaUtils.getComplexType(property);
 			const rawDataComplexType = this.schemaUtils.getComplexType(rawTypeData);
@@ -1493,7 +1565,10 @@ var SchemaUtils = class {
 	};
 	isNullMissingInType = (schema, type) => {
 		const { nullable, type: schemaType } = schema || {};
-		return (nullable || !!(0, es_toolkit_compat.get)(schema, "x-nullable") || schemaType === this.config.Ts.Keyword.Null) && typeof type === "string" && !type.includes(` ${this.config.Ts.Keyword.Null}`) && !type.includes(`${this.config.Ts.Keyword.Null} `);
+		if (!(nullable || !!(0, es_toolkit_compat.get)(schema, "x-nullable") || schemaType === this.config.Ts.Keyword.Null) || typeof type !== "string") return false;
+		const nullKeyword = this.config.Ts.Keyword.Null;
+		const lastLine = type.trimEnd().split("\n").pop() ?? type;
+		return !lastLine.includes(` ${nullKeyword}`) && !lastLine.includes(`${nullKeyword} `);
 	};
 	safeAddNullToType = (schema, type) => {
 		if (this.isNullMissingInType(schema, type)) return this.config.Ts.UnionType([type, this.config.Ts.Keyword.Null]);
@@ -3002,10 +3077,15 @@ var TemplatesWorker = class {
 		const defaultTemplatesPath = node_path.resolve(__dirname, "../templates/default");
 		const modularTemplatesPath = node_path.resolve(__dirname, "../templates/modular");
 		return {
+			/** `templates/base` */
 			base: baseTemplatesPath,
+			/** `templates/default` */
 			default: defaultTemplatesPath,
+			/** `templates/modular` */
 			modular: modularTemplatesPath,
+			/** usage path if `--templates` option is not set */
 			original: config.modular ? modularTemplatesPath : defaultTemplatesPath,
+			/** custom path to templates (`--templates`) */
 			custom: config.templates && node_path.resolve(process.cwd(), config.templates)
 		};
 	};
@@ -3125,39 +3205,119 @@ var JavascriptTranslator = class extends Translator {
 //#region src/type-name-formatter.ts
 var TypeNameFormatter = class {
 	formattedModelNamesMap = /* @__PURE__ */ new Map();
+	usedFormattedTypeNames = /* @__PURE__ */ new Map();
 	config;
 	constructor(config) {
 		this.config = config;
 	}
+	/**
+	* Return the TypeScript identifier for a raw OpenAPI name. Fast path is a
+	* cache hit on names resolved by `precommit`. The fallback (for names
+	* discovered after precommit, e.g. enum keys inside schemas or types added
+	* dynamically by `extractEnums`/`extractResponses`) computes the identifier
+	* inline WITHOUT collision handling — collision resolution is the sole
+	* responsibility of `precommit`. Callers expecting collision safety must
+	* list every raw name in the precommit input.
+	*/
 	format = (name, options = {}) => {
 		const schemaType = options.type ?? "type-name";
-		const typePrefix = schemaType === "enum-key" ? this.config.enumKeyPrefix : this.config.typePrefix;
-		const typeSuffix = schemaType === "enum-key" ? this.config.enumKeySuffix : this.config.typeSuffix;
+		const { typePrefix, typeSuffix } = this.getAffixes(schemaType);
 		const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
+		const cached = this.formattedModelNamesMap.get(hashKey);
+		if (cached !== void 0) return cached;
 		if (typeof name !== "string") {
 			consola.consola.warn("wrong model name", name);
 			return name;
 		}
-		if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(name)) return (0, es_toolkit.compact)([
-			typePrefix,
-			name,
-			typeSuffix
-		]).join("_");
-		if (this.formattedModelNamesMap.has(hashKey)) return this.formattedModelNamesMap.get(hashKey);
-		const formattedName = (0, es_toolkit_compat.startCase)(`${typePrefix}_${this.fixModelName(name, { type: schemaType })}_${typeSuffix}`).replace(/\s/g, "");
-		const formattedResultName = this.config.hooks.onFormatTypeName?.(formattedName, name, schemaType) || formattedName;
-		this.formattedModelNamesMap.set(hashKey, formattedResultName);
-		return formattedResultName;
+		const result = this.computeFormattedName(name, schemaType, typePrefix, typeSuffix);
+		this.formattedModelNamesMap.set(hashKey, result);
+		return result;
+	};
+	/**
+	* Resolve the TypeScript identifier for every raw schema name passed in,
+	* populating `formattedModelNamesMap` and `usedFormattedTypeNames`. Must be
+	* called once, before any `format()` call from the schema parser, so that
+	* every subsequent `format()` for these names is a cache hit and returns
+	* the collision-resolved identifier.
+	*
+	* Two passes:
+	*   1. Claim every raw name whose formatted output equals the raw name
+	*      itself ("canonical"). User-declared identifiers like `FooBar` or
+	*      `FooBar1` are preserved regardless of the source order in which
+	*      the generator later visits them.
+	*   2. For non-canonical names (e.g. `Foo_Bar` → `FooBar`), suffix with
+	*      the smallest integer not already claimed, so collisions produce
+	*      `FooBar`, `FooBar1`, `FooBar2`, … deterministically.
+	*
+	* Only type-names go through collision resolution here. Enum keys use the
+	* fallback path in `format()` and are handled per-enum by the template.
+	*/
+	precommit = (rawNames) => {
+		const schemaType = "type-name";
+		const { typePrefix, typeSuffix } = this.getAffixes(schemaType);
+		const seen = /* @__PURE__ */ new Set();
+		const names = [];
+		for (const name of rawNames) {
+			if (typeof name !== "string") continue;
+			if (seen.has(name)) continue;
+			seen.add(name);
+			names.push(name);
+		}
+		for (const name of names) {
+			const formatted = this.computeFormattedName(name, schemaType, typePrefix, typeSuffix);
+			if (name !== formatted) continue;
+			if (this.usedFormattedTypeNames.has(formatted)) continue;
+			this.usedFormattedTypeNames.set(formatted, name);
+			const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
+			this.formattedModelNamesMap.set(hashKey, formatted);
+		}
+		for (const name of names) {
+			const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
+			if (this.formattedModelNamesMap.has(hashKey)) continue;
+			const formatted = this.computeFormattedName(name, schemaType, typePrefix, typeSuffix);
+			let final = formatted;
+			if (this.usedFormattedTypeNames.has(final)) {
+				let suffix = 1;
+				while (this.usedFormattedTypeNames.has(`${formatted}${suffix}`)) suffix += 1;
+				final = `${formatted}${suffix}`;
+			}
+			this.usedFormattedTypeNames.set(final, name);
+			this.formattedModelNamesMap.set(hashKey, final);
+		}
 	};
 	isValidName = (name) => /^([A-Za-z$_]{1,})$/g.test(name);
 	fixModelName = (name, options) => {
 		if (!this.isValidName(name)) {
 			if (!/^[a-zA-Z_$]/g.test(name)) return `${options.type === "enum-key" ? this.config.fixInvalidEnumKeyPrefix : this.config.fixInvalidTypeNamePrefix} ${name}`;
 			if (name.includes(".")) return name.replace(/Exclude_keyof[A-Za-z]+/g, () => "ExcludeKeys").replace(/%22~AND~%22/g, "And").replace(/%22~OR~%22/g, "Or").replace(/(\.?%22)|\./g, "_").replace(/__+$/, "");
-			if (name.includes("-")) return (0, es_toolkit_compat.startCase)(name).replace(/ /g, "");
+			if (name.includes("-")) return this.config.disableFormatTypeNames ? name.replace(/-/g, "_") : (0, es_toolkit_compat.startCase)(name).replace(/ /g, "");
 		}
 		return name;
 	};
+	getAffixes = (schemaType) => ({
+		typePrefix: schemaType === "enum-key" ? this.config.enumKeyPrefix : this.config.typePrefix,
+		typeSuffix: schemaType === "enum-key" ? this.config.enumKeySuffix : this.config.typeSuffix
+	});
+	computeFormattedName = (name, schemaType, typePrefix, typeSuffix) => {
+		const typeNameSeparator = this.config.typeNameSeparator;
+		let resultName = name;
+		if (this.config.disableFormatTypeNames) resultName = (0, es_toolkit.compact)([
+			typePrefix,
+			resultName,
+			typeSuffix
+		]).join(typeNameSeparator);
+		else if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(resultName)) resultName = (0, es_toolkit.compact)([
+			typePrefix,
+			resultName,
+			typeSuffix
+		]).join(typeNameSeparator);
+		else resultName = (0, es_toolkit_compat.startCase)((0, es_toolkit.compact)([
+			typePrefix,
+			this.fixModelName(resultName, { type: schemaType }),
+			typeSuffix
+		]).join(typeNameSeparator)).replace(/\s/g, "");
+		return this.config.hooks.onFormatTypeName?.(resultName, name, schemaType) || resultName;
+	};
 };
 //#endregion
 //#region src/util/file-system.ts
@@ -3276,7 +3436,9 @@ var CodeGenProcess = class {
 		]), rawTypeData);
 		this.schemaComponentsMap.discriminatorsFirst();
 		this.schemaComponentsMap.enumsFirst();
-		const parsedSchemas = this.schemaComponentsMap.filter((0, es_toolkit.compact)(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
+		const componentsToParse = this.schemaComponentsMap.filter((0, es_toolkit.compact)(["schemas", this.config.extractResponses && "responses"]));
+		this.typeNameFormatter.precommit(componentsToParse.map((c) => c.typeName));
+		const parsedSchemas = componentsToParse.map((schemaComponent) => {
 			const parsed = this.schemaParserFabric.parseSchema(schemaComponent.rawTypeData, schemaComponent.typeName);
 			schemaComponent.typeData = parsed;
 			return parsed;
@@ -3739,4 +3901,4 @@ Object.defineProperty(exports, "version", {
 	}
 });
 
-//# sourceMappingURL=src-DsH2wrQK.cjs.map
+//# sourceMappingURL=src-DTdmNLxQ.cjs.map