swagger-typescript-api 13.6.11 → 13.7.1

package/dist/{src-D7B_7nSd.cjs → src-pyGddI9m.cjs}

@@ -208,7 +208,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.6.11";
+var version = "13.7.1";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 //#endregion
 //#region src/constants.ts
@@ -373,6 +373,7 @@ var CodeGenConfig = class {
 	httpClientType = HTTP_CLIENT.FETCH;
 	unwrapResponseData = false;
 	disableThrowOnError = false;
+	disableFormatTypeNames = false;
 	sortTypes = false;
 	sortRoutes = false;
 	templatePaths = {
@@ -405,6 +406,7 @@ var CodeGenConfig = class {
 	silent = false;
 	typePrefix = "";
 	typeSuffix = "";
+	typeNameSeparator = "_";
 	enumKeyPrefix = "";
 	enumKeySuffix = "";
 	patch = false;
@@ -2845,16 +2847,18 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 	}
 	collectExternalRefCandidates(externalPath) {
 		const candidates = /* @__PURE__ */ new Set();
-		if (/^https?:\/\//i.test(externalPath)) return [];
+		const isRemote = /^https?:\/\//i.test(externalPath);
+		const normalizedExternalPath = externalPath.startsWith("/") ? externalPath.replace(/^\/+/, "") : externalPath;
+		if (isRemote) return [];
 		if (node_path.default.isAbsolute(externalPath)) candidates.add(externalPath);
 		const inputPath = this.config.input;
-		if (typeof inputPath === "string" && inputPath) candidates.add(node_path.default.resolve(node_path.default.dirname(inputPath), externalPath));
+		if (typeof inputPath === "string" && inputPath) candidates.add(node_path.default.resolve(node_path.default.dirname(inputPath), normalizedExternalPath));
 		for (const resolver of this.resolvers) try {
 			const resolverPaths = typeof resolver.paths === "function" ? resolver.paths() : [];
 			for (const resolverPath of resolverPaths) {
 				if (typeof resolverPath !== "string") continue;
 				if (/^https?:\/\//i.test(resolverPath)) continue;
-				candidates.add(node_path.default.resolve(node_path.default.dirname(resolverPath), externalPath));
+				candidates.add(node_path.default.resolve(node_path.default.dirname(resolverPath), normalizedExternalPath));
 			}
 		} catch (e) {
 			consola.default.debug(e);
@@ -3203,39 +3207,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
@@ -3354,7 +3438,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;
@@ -3817,4 +3903,4 @@ Object.defineProperty(exports, "version", {
 	}
 });
 
-//# sourceMappingURL=src-D7B_7nSd.cjs.map
+//# sourceMappingURL=src-pyGddI9m.cjs.map