swagger-typescript-api 13.7.2 → 13.8.0

package/dist/{src-UwNroIF-.cjs → src-NUsiu5_Q.cjs}

@@ -208,7 +208,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.7.2";
+var version = "13.8.0";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 //#endregion
 //#region src/constants.ts
@@ -2616,6 +2616,129 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 	stripHash(urlOrPath) {
 		return urlOrPath.split("#")[0] || urlOrPath;
 	}
+	/**
+	* GitLab REST "get raw file from repository" URLs encode the whole repo-relative
+	* file path as a single path segment, so resolving `./other.yaml` must rebuild
+	* that segment instead of relying on URL resolution rules.
+	*
+	* We only apply this when the base URL matches GitLab's documented API shape
+	* (`/api/v…/projects/…/repository/files/…/raw`), not for arbitrary hosts that
+	* happen to contain similar path fragments.
+	*
+	* @see https://docs.gitlab.com/ee/api/repository_files.html#get-raw-file-from-repository
+	*/
+	createGitlabRepositoryFileUrl(relativePath, baseUrl) {
+		if (!relativePath || this.isHttpUrl(relativePath) || relativePath.startsWith("/")) return null;
+		try {
+			const parsedBaseUrl = new URL(baseUrl);
+			const [, beforeApi, apiRepoFilesPrefix, encodedFilePath, suffix] = parsedBaseUrl.pathname.match(/^(.*?)(\/api\/v\d+\/projects\/[^/]+\/repository\/files\/)(.+)(\/raw)$/) || [];
+			if (!apiRepoFilesPrefix || !encodedFilePath || !suffix) return null;
+			const prefix = `${beforeApi ?? ""}${apiRepoFilesPrefix}`;
+			const currentFilePath = decodeURIComponent(encodedFilePath);
+			const nextFilePath = node_path.default.posix.normalize(node_path.default.posix.join(node_path.default.posix.dirname(currentFilePath), relativePath));
+			parsedBaseUrl.pathname = `${prefix}${encodeURIComponent(nextFilePath)}${suffix}`;
+			parsedBaseUrl.hash = "";
+			return parsedBaseUrl.toString();
+		} catch (e) {
+			consola.default.debug(e);
+			return null;
+		}
+	}
+	splitGithubRefAndFilePath(rest) {
+		const segments = rest.split("/").filter(Boolean);
+		if (segments.length < 2) return null;
+		if (segments[0] === "refs" && segments[1] === "heads" && segments.length >= 4) return {
+			ref: `${segments[0]}/${segments[1]}/${segments[2]}`,
+			pathSegments: segments.slice(3)
+		};
+		if (segments[0] === "refs" && segments[1] === "tags" && segments.length >= 4) return {
+			ref: `${segments[0]}/${segments[1]}/${segments[2]}`,
+			pathSegments: segments.slice(3)
+		};
+		const first = segments[0];
+		if (!first) return null;
+		if (first && first.length === 40 && /^[0-9a-f]+$/i.test(first)) return {
+			ref: first,
+			pathSegments: segments.slice(1)
+		};
+		return {
+			ref: first,
+			pathSegments: segments.slice(1)
+		};
+	}
+	buildRawGithubusercontentUrl({ owner, repo, ref, repoRelativeFilePath }) {
+		const refSegments = ref.split("/").filter(Boolean);
+		const fileSegments = repoRelativeFilePath.split("/").filter(Boolean);
+		return `https://raw.githubusercontent.com${[
+			"",
+			owner,
+			repo,
+			...refSegments,
+			...fileSegments
+		].join("/")}`;
+	}
+	resolveGithubRepositoryRelativeFilePath(relativePath, tail) {
+		const split = this.splitGithubRefAndFilePath(tail);
+		if (!split || split.pathSegments.length === 0) return null;
+		const currentFilePath = split.pathSegments.join("/");
+		const nextFilePath = node_path.default.posix.normalize(node_path.default.posix.join(node_path.default.posix.dirname(currentFilePath), relativePath));
+		if (nextFilePath.startsWith("..")) return null;
+		return {
+			ref: split.ref,
+			repoRelativeFilePath: nextFilePath
+		};
+	}
+	createGithubRepositoryFileUrl(relativePath, baseUrl) {
+		if (!relativePath || this.isHttpUrl(relativePath) || relativePath.startsWith("/")) return null;
+		try {
+			const parsed = new URL(baseUrl);
+			const host = parsed.hostname.toLowerCase();
+			if (host === "raw.githubusercontent.com") {
+				const [, owner, repo, tail] = parsed.pathname.match(/^\/([^/]+)\/([^/]+)\/(.+)$/) || [];
+				if (!owner || !repo || !tail) return null;
+				const resolved = this.resolveGithubRepositoryRelativeFilePath(relativePath, tail);
+				if (!resolved) return null;
+				const out = new URL(this.buildRawGithubusercontentUrl({
+					owner,
+					repo,
+					ref: resolved.ref,
+					repoRelativeFilePath: resolved.repoRelativeFilePath
+				}));
+				out.search = parsed.search;
+				out.hash = "";
+				return out.toString();
+			}
+			if (host === "github.com" || host === "www.github.com") {
+				const blob = parsed.pathname.match(/^\/([^/]+)\/([^/]+)\/blob\/(.+)$/);
+				const raw = parsed.pathname.match(/^\/([^/]+)\/([^/]+)\/raw\/(.+)$/);
+				const [, owner, repo, tail] = blob || raw || [];
+				if (!owner || !repo || !tail) return null;
+				const resolved = this.resolveGithubRepositoryRelativeFilePath(relativePath, tail);
+				if (!resolved) return null;
+				return this.buildRawGithubusercontentUrl({
+					owner,
+					repo,
+					ref: resolved.ref,
+					repoRelativeFilePath: resolved.repoRelativeFilePath
+				});
+			}
+			return null;
+		} catch (e) {
+			consola.default.debug(e);
+			return null;
+		}
+	}
+	resolveAbsoluteUrl(pathOrUrl, baseUrl) {
+		try {
+			if (this.isHttpUrl(pathOrUrl)) return this.stripHash(pathOrUrl);
+			const gitlabUrl = this.createGitlabRepositoryFileUrl(pathOrUrl, baseUrl);
+			const githubUrl = this.createGithubRepositoryFileUrl(pathOrUrl, baseUrl);
+			return this.stripHash(gitlabUrl ?? githubUrl ?? new URL(pathOrUrl, baseUrl).toString());
+		} catch (e) {
+			consola.default.debug("failed to resolve absolute url", e);
+			return pathOrUrl;
+		}
+	}
 	extractRefsFromSchema(schema) {
 		const refs = /* @__PURE__ */ new Set();
 		const walk = (node) => {
@@ -2664,12 +2787,7 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 				if (normalizedRef.startsWith("#")) continue;
 				const [externalPath = ""] = normalizedRef.split("#");
 				if (!externalPath) continue;
-				let absoluteUrl = "";
-				try {
-					absoluteUrl = this.isHttpUrl(externalPath) ? this.stripHash(externalPath) : this.stripHash(new URL(externalPath, currentUrl).toString());
-				} catch (e) {
-					consola.default.debug(e);
-				}
+				const absoluteUrl = this.resolveAbsoluteUrl(externalPath, currentUrl);
 				if (absoluteUrl && !visited.has(absoluteUrl)) queue.push(absoluteUrl);
 			}
 		}
@@ -2689,11 +2807,9 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 			consola.default.debug(e);
 		}
 		const results = /* @__PURE__ */ new Set();
-		for (const base of bases) try {
-			const absolutePath = new URL(relativePath, base).toString();
-			results.add(pointer ? `${absolutePath}#${pointer}` : absolutePath);
-		} catch (e) {
-			consola.default.debug(e);
+		for (const base of bases) {
+			const absolutePath = this.resolveAbsoluteUrl(relativePath, base);
+			if (absolutePath) results.add(pointer ? `${absolutePath}#${pointer}` : absolutePath);
 		}
 		return [...results];
 	}
@@ -3903,4 +4019,4 @@ Object.defineProperty(exports, "version", {
 	}
 });
 
-//# sourceMappingURL=src-UwNroIF-.cjs.map
+//# sourceMappingURL=src-NUsiu5_Q.cjs.map