every-plugin 0.4.3 → 0.4.5

package/dist/fetch-KLktuWuM.mjs

@@ -0,0 +1,335 @@
+import { _ as tryDecodeURIComponent, a as toHttpPath, h as stringifyJSON, i as standardizeHTTPPath, l as isORPCErrorStatus, n as StandardOpenAPISerializer, o as StandardBracketNotationSerializer, p as isObject, t as StandardOpenAPIJsonSerializer, v as value } from "./standard-DaxKTFui.mjs";
+import { createContractedProcedure, getLazyMeta, getRouter, isProcedure, traverseContractProcedures, unlazy } from "@orpc/server";
+import { fallbackContractConfig } from "@orpc/contract";
+import { FetchHandler } from "@orpc/server/fetch";
+import { StandardHandler } from "@orpc/server/standard";
+
+//#region ../../node_modules/.bun/rou3@0.7.10/node_modules/rou3/dist/index.mjs
+const NullProtoObj = /* @__PURE__ */ (() => {
+	const e = function() {};
+	return e.prototype = Object.create(null), Object.freeze(e.prototype), e;
+})();
+/**
+* Create a new router context.
+*/
+function createRouter() {
+	return {
+		root: { key: "" },
+		static: new NullProtoObj()
+	};
+}
+function splitPath(path) {
+	const [_, ...s] = path.split("/");
+	return s[s.length - 1] === "" ? s.slice(0, -1) : s;
+}
+function getMatchParams(segments, paramsMap) {
+	const params = new NullProtoObj();
+	for (const [index, name] of paramsMap) {
+		const segment = index < 0 ? segments.slice(-1 * index).join("/") : segments[index];
+		if (typeof name === "string") params[name] = segment;
+		else {
+			const match = segment.match(name);
+			if (match) for (const key in match.groups) params[key] = match.groups[key];
+		}
+	}
+	return params;
+}
+/**
+* Add a route to the router context.
+*/
+function addRoute(ctx, method = "", path, data) {
+	method = method.toUpperCase();
+	if (path.charCodeAt(0) !== 47) path = `/${path}`;
+	const segments = splitPath(path);
+	let node = ctx.root;
+	let _unnamedParamIndex = 0;
+	const paramsMap = [];
+	const paramsRegexp = [];
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		if (segment.startsWith("**")) {
+			if (!node.wildcard) node.wildcard = { key: "**" };
+			node = node.wildcard;
+			paramsMap.push([
+				-i,
+				segment.split(":")[1] || "_",
+				segment.length === 2
+			]);
+			break;
+		}
+		if (segment === "*" || segment.includes(":")) {
+			if (!node.param) node.param = { key: "*" };
+			node = node.param;
+			if (segment === "*") paramsMap.push([
+				i,
+				`_${_unnamedParamIndex++}`,
+				true
+			]);
+			else if (segment.includes(":", 1)) {
+				const regexp = getParamRegexp(segment);
+				paramsRegexp[i] = regexp;
+				node.hasRegexParam = true;
+				paramsMap.push([
+					i,
+					regexp,
+					false
+				]);
+			} else paramsMap.push([
+				i,
+				segment.slice(1),
+				false
+			]);
+			continue;
+		}
+		const child = node.static?.[segment];
+		if (child) node = child;
+		else {
+			const staticNode = { key: segment };
+			if (!node.static) node.static = new NullProtoObj();
+			node.static[segment] = staticNode;
+			node = staticNode;
+		}
+	}
+	const hasParams = paramsMap.length > 0;
+	if (!node.methods) node.methods = new NullProtoObj();
+	node.methods[method] ??= [];
+	node.methods[method].push({
+		data: data || null,
+		paramsRegexp,
+		paramsMap: hasParams ? paramsMap : void 0
+	});
+	if (!hasParams) ctx.static[path] = node;
+}
+function getParamRegexp(segment) {
+	const regex = segment.replace(/:(\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\./g, "\\.");
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+}
+/**
+* Find a route by path.
+*/
+function findRoute(ctx, method = "", path, opts) {
+	if (path.charCodeAt(path.length - 1) === 47) path = path.slice(0, -1);
+	const staticNode = ctx.static[path];
+	if (staticNode && staticNode.methods) {
+		const staticMatch = staticNode.methods[method] || staticNode.methods[""];
+		if (staticMatch !== void 0) return staticMatch[0];
+	}
+	const segments = splitPath(path);
+	const match = _lookupTree(ctx, ctx.root, method, segments, 0)?.[0];
+	if (match === void 0) return;
+	if (opts?.params === false) return match;
+	return {
+		data: match.data,
+		params: match.paramsMap ? getMatchParams(segments, match.paramsMap) : void 0
+	};
+}
+function _lookupTree(ctx, node, method, segments, index) {
+	if (index === segments.length) {
+		if (node.methods) {
+			const match = node.methods[method] || node.methods[""];
+			if (match) return match;
+		}
+		if (node.param && node.param.methods) {
+			const match = node.param.methods[method] || node.param.methods[""];
+			if (match) {
+				const pMap = match[0].paramsMap;
+				if (pMap?.[pMap?.length - 1]?.[2]) return match;
+			}
+		}
+		if (node.wildcard && node.wildcard.methods) {
+			const match = node.wildcard.methods[method] || node.wildcard.methods[""];
+			if (match) {
+				const pMap = match[0].paramsMap;
+				if (pMap?.[pMap?.length - 1]?.[2]) return match;
+			}
+		}
+		return;
+	}
+	const segment = segments[index];
+	if (node.static) {
+		const staticChild = node.static[segment];
+		if (staticChild) {
+			const match = _lookupTree(ctx, staticChild, method, segments, index + 1);
+			if (match) return match;
+		}
+	}
+	if (node.param) {
+		const match = _lookupTree(ctx, node.param, method, segments, index + 1);
+		if (match) {
+			if (node.param.hasRegexParam) {
+				const exactMatch = match.find((m) => m.paramsRegexp[index]?.test(segment)) || match.find((m) => !m.paramsRegexp[index]);
+				return exactMatch ? [exactMatch] : void 0;
+			}
+			return match;
+		}
+	}
+	if (node.wildcard && node.wildcard.methods) return node.wildcard.methods[method] || node.wildcard.methods[""];
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/shared/openapi.DIt-Z9W1.mjs
+var StandardOpenAPICodec = class {
+	constructor(serializer, options = {}) {
+		this.serializer = serializer;
+		this.customErrorResponseBodyEncoder = options.customErrorResponseBodyEncoder;
+	}
+	customErrorResponseBodyEncoder;
+	async decode(request, params, procedure) {
+		if (fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure) === "compact") {
+			const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
+			if (data === void 0) return params;
+			if (isObject(data)) return {
+				...params,
+				...data
+			};
+			return data;
+		}
+		const deserializeSearchParams = () => {
+			return this.serializer.deserialize(request.url.searchParams);
+		};
+		return {
+			params,
+			get query() {
+				const value$1 = deserializeSearchParams();
+				Object.defineProperty(this, "query", {
+					value: value$1,
+					writable: true
+				});
+				return value$1;
+			},
+			set query(value$1) {
+				Object.defineProperty(this, "query", {
+					value: value$1,
+					writable: true
+				});
+			},
+			headers: request.headers,
+			body: this.serializer.deserialize(await request.body())
+		};
+	}
+	encode(output, procedure) {
+		const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+		if (fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure) === "compact") return {
+			status: successStatus,
+			headers: {},
+			body: this.serializer.serialize(output)
+		};
+		if (!this.#isDetailedOutput(output)) throw new Error(`
+        Invalid "detailed" output structure:
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[]>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
+		return {
+			status: output.status ?? successStatus,
+			headers: output.headers ?? {},
+			body: this.serializer.serialize(output.body)
+		};
+	}
+	encodeError(error) {
+		const body = this.customErrorResponseBodyEncoder?.(error) ?? error.toJSON();
+		return {
+			status: error.status,
+			headers: {},
+			body: this.serializer.serialize(body, { outputFormat: "plain" })
+		};
+	}
+	#isDetailedOutput(output) {
+		if (!isObject(output)) return false;
+		if (output.headers && !isObject(output.headers)) return false;
+		if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) return false;
+		return true;
+	}
+};
+function toRou3Pattern(path) {
+	return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
+}
+function decodeParams(params) {
+	return Object.fromEntries(Object.entries(params).map(([key, value$1]) => [key, tryDecodeURIComponent(value$1)]));
+}
+var StandardOpenAPIMatcher = class {
+	filter;
+	tree = createRouter();
+	pendingRouters = [];
+	constructor(options = {}) {
+		this.filter = options.filter ?? true;
+	}
+	init(router, path = []) {
+		const laziedOptions = traverseContractProcedures({
+			router,
+			path
+		}, (traverseOptions) => {
+			if (!value(this.filter, traverseOptions)) return;
+			const { path: path2, contract } = traverseOptions;
+			const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+			const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
+			if (isProcedure(contract)) addRoute(this.tree, method, httpPath, {
+				path: path2,
+				contract,
+				procedure: contract,
+				router
+			});
+			else addRoute(this.tree, method, httpPath, {
+				path: path2,
+				contract,
+				procedure: void 0,
+				router
+			});
+		});
+		this.pendingRouters.push(...laziedOptions.map((option) => ({
+			...option,
+			httpPathPrefix: toHttpPath(option.path),
+			laziedPrefix: getLazyMeta(option.router).prefix
+		})));
+	}
+	async match(method, pathname) {
+		if (this.pendingRouters.length) {
+			const newPendingRouters = [];
+			for (const pendingRouter of this.pendingRouters) if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
+				const { default: router } = await unlazy(pendingRouter.router);
+				this.init(router, pendingRouter.path);
+			} else newPendingRouters.push(pendingRouter);
+			this.pendingRouters = newPendingRouters;
+		}
+		const match = findRoute(this.tree, method, pathname);
+		if (!match) return;
+		if (!match.data.procedure) {
+			const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
+			if (!isProcedure(maybeProcedure)) throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+			match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
+		}
+		return {
+			path: match.data.path,
+			procedure: match.data.procedure,
+			params: match.params ? decodeParams(match.params) : void 0
+		};
+	}
+};
+var StandardOpenAPIHandler = class extends StandardHandler {
+	constructor(router, options) {
+		const serializer = new StandardOpenAPISerializer(new StandardOpenAPIJsonSerializer(options), new StandardBracketNotationSerializer(options));
+		const matcher = new StandardOpenAPIMatcher(options);
+		const codec = new StandardOpenAPICodec(serializer, options);
+		super(router, matcher, codec, options);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/adapters/fetch/index.mjs
+var OpenAPIHandler = class extends FetchHandler {
+	constructor(router, options = {}) {
+		super(new StandardOpenAPIHandler(router, options), options);
+	}
+};
+
+//#endregion
+export { OpenAPIHandler };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetch-KLktuWuM.mjs","names":["value","#isDetailedOutput"],"sources":["../../../node_modules/.bun/rou3@0.7.10/node_modules/rou3/dist/index.mjs","../../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/shared/openapi.DIt-Z9W1.mjs","../../../node_modules/.bun/@orpc+openapi@1.10.4/node_modules/@orpc/openapi/dist/adapters/fetch/index.mjs"],"sourcesContent":["const NullProtoObj = /* @__PURE__ */ (() => {\n\tconst e = function() {};\n\treturn e.prototype = Object.create(null), Object.freeze(e.prototype), e;\n})();\n\n/**\n* Create a new router context.\n*/\nfunction createRouter() {\n\treturn {\n\t\troot: { key: \"\" },\n\t\tstatic: new NullProtoObj()\n\t};\n}\n\nfunction splitPath(path) {\n\tconst [_, ...s] = path.split(\"/\");\n\treturn s[s.length - 1] === \"\" ? s.slice(0, -1) : s;\n}\nfunction getMatchParams(segments, paramsMap) {\n\tconst params = new NullProtoObj();\n\tfor (const [index, name] of paramsMap) {\n\t\tconst segment = index < 0 ? segments.slice(-1 * index).join(\"/\") : segments[index];\n\t\tif (typeof name === \"string\") params[name] = segment;\n\t\telse {\n\t\t\tconst match = segment.match(name);\n\t\t\tif (match) for (const key in match.groups) params[key] = match.groups[key];\n\t\t}\n\t}\n\treturn params;\n}\n\n/**\n* Add a route to the router context.\n*/\nfunction addRoute(ctx, method = \"\", path, data) {\n\tmethod = method.toUpperCase();\n\tif (path.charCodeAt(0) !== 47) path = `/${path}`;\n\tconst segments = splitPath(path);\n\tlet node = ctx.root;\n\tlet _unnamedParamIndex = 0;\n\tconst paramsMap = [];\n\tconst paramsRegexp = [];\n\tfor (let i = 0; i < segments.length; i++) {\n\t\tconst segment = segments[i];\n\t\tif (segment.startsWith(\"**\")) {\n\t\t\tif (!node.wildcard) node.wildcard = { key: \"**\" };\n\t\t\tnode = node.wildcard;\n\t\t\tparamsMap.push([\n\t\t\t\t-i,\n\t\t\t\tsegment.split(\":\")[1] || \"_\",\n\t\t\t\tsegment.length === 2\n\t\t\t]);\n\t\t\tbreak;\n\t\t}\n\t\tif (segment === \"*\" || segment.includes(\":\")) {\n\t\t\tif (!node.param) node.param = { key: \"*\" };\n\t\t\tnode = node.param;\n\t\t\tif (segment === \"*\") paramsMap.push([\n\t\t\t\ti,\n\t\t\t\t`_${_unnamedParamIndex++}`,\n\t\t\t\ttrue\n\t\t\t]);\n\t\t\telse if (segment.includes(\":\", 1)) {\n\t\t\t\tconst regexp = getParamRegexp(segment);\n\t\t\t\tparamsRegexp[i] = regexp;\n\t\t\t\tnode.hasRegexParam = true;\n\t\t\t\tparamsMap.push([\n\t\t\t\t\ti,\n\t\t\t\t\tregexp,\n\t\t\t\t\tfalse\n\t\t\t\t]);\n\t\t\t} else paramsMap.push([\n\t\t\t\ti,\n\t\t\t\tsegment.slice(1),\n\t\t\t\tfalse\n\t\t\t]);\n\t\t\tcontinue;\n\t\t}\n\t\tconst child = node.static?.[segment];\n\t\tif (child) node = child;\n\t\telse {\n\t\t\tconst staticNode = { key: segment };\n\t\t\tif (!node.static) node.static = new NullProtoObj();\n\t\t\tnode.static[segment] = staticNode;\n\t\t\tnode = staticNode;\n\t\t}\n\t}\n\tconst hasParams = paramsMap.length > 0;\n\tif (!node.methods) node.methods = new NullProtoObj();\n\tnode.methods[method] ??= [];\n\tnode.methods[method].push({\n\t\tdata: data || null,\n\t\tparamsRegexp,\n\t\tparamsMap: hasParams ? paramsMap : void 0\n\t});\n\tif (!hasParams) ctx.static[path] = node;\n}\nfunction getParamRegexp(segment) {\n\tconst regex = segment.replace(/:(\\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\\./g, \"\\\\.\");\n\treturn /* @__PURE__ */ new RegExp(`^${regex}$`);\n}\n\n/**\n* Find a route by path.\n*/\nfunction findRoute(ctx, method = \"\", path, opts) {\n\tif (path.charCodeAt(path.length - 1) === 47) path = path.slice(0, -1);\n\tconst staticNode = ctx.static[path];\n\tif (staticNode && staticNode.methods) {\n\t\tconst staticMatch = staticNode.methods[method] || staticNode.methods[\"\"];\n\t\tif (staticMatch !== void 0) return staticMatch[0];\n\t}\n\tconst segments = splitPath(path);\n\tconst match = _lookupTree(ctx, ctx.root, method, segments, 0)?.[0];\n\tif (match === void 0) return;\n\tif (opts?.params === false) return match;\n\treturn {\n\t\tdata: match.data,\n\t\tparams: match.paramsMap ? getMatchParams(segments, match.paramsMap) : void 0\n\t};\n}\nfunction _lookupTree(ctx, node, method, segments, index) {\n\tif (index === segments.length) {\n\t\tif (node.methods) {\n\t\t\tconst match = node.methods[method] || node.methods[\"\"];\n\t\t\tif (match) return match;\n\t\t}\n\t\tif (node.param && node.param.methods) {\n\t\t\tconst match = node.param.methods[method] || node.param.methods[\"\"];\n\t\t\tif (match) {\n\t\t\t\tconst pMap = match[0].paramsMap;\n\t\t\t\tif (pMap?.[pMap?.length - 1]?.[2]) return match;\n\t\t\t}\n\t\t}\n\t\tif (node.wildcard && node.wildcard.methods) {\n\t\t\tconst match = node.wildcard.methods[method] || node.wildcard.methods[\"\"];\n\t\t\tif (match) {\n\t\t\t\tconst pMap = match[0].paramsMap;\n\t\t\t\tif (pMap?.[pMap?.length - 1]?.[2]) return match;\n\t\t\t}\n\t\t}\n\t\treturn;\n\t}\n\tconst segment = segments[index];\n\tif (node.static) {\n\t\tconst staticChild = node.static[segment];\n\t\tif (staticChild) {\n\t\t\tconst match = _lookupTree(ctx, staticChild, method, segments, index + 1);\n\t\t\tif (match) return match;\n\t\t}\n\t}\n\tif (node.param) {\n\t\tconst match = _lookupTree(ctx, node.param, method, segments, index + 1);\n\t\tif (match) {\n\t\t\tif (node.param.hasRegexParam) {\n\t\t\t\tconst exactMatch = match.find((m) => m.paramsRegexp[index]?.test(segment)) || match.find((m) => !m.paramsRegexp[index]);\n\t\t\t\treturn exactMatch ? [exactMatch] : void 0;\n\t\t\t}\n\t\t\treturn match;\n\t\t}\n\t}\n\tif (node.wildcard && node.wildcard.methods) return node.wildcard.methods[method] || node.wildcard.methods[\"\"];\n}\n\n/**\n* Remove a route from the router context.\n*/\nfunction removeRoute(ctx, method, path) {\n\tconst segments = splitPath(path);\n\treturn _remove(ctx.root, method || \"\", segments, 0);\n}\nfunction _remove(node, method, segments, index) {\n\tif (index === segments.length) {\n\t\tif (node.methods && method in node.methods) {\n\t\t\tdelete node.methods[method];\n\t\t\tif (Object.keys(node.methods).length === 0) node.methods = void 0;\n\t\t}\n\t\treturn;\n\t}\n\tconst segment = segments[index];\n\tif (segment === \"*\") {\n\t\tif (node.param) {\n\t\t\t_remove(node.param, method, segments, index + 1);\n\t\t\tif (_isEmptyNode(node.param)) node.param = void 0;\n\t\t}\n\t\treturn;\n\t}\n\tif (segment.startsWith(\"**\")) {\n\t\tif (node.wildcard) {\n\t\t\t_remove(node.wildcard, method, segments, index + 1);\n\t\t\tif (_isEmptyNode(node.wildcard)) node.wildcard = void 0;\n\t\t}\n\t\treturn;\n\t}\n\tconst childNode = node.static?.[segment];\n\tif (childNode) {\n\t\t_remove(childNode, method, segments, index + 1);\n\t\tif (_isEmptyNode(childNode)) {\n\t\t\tdelete node.static[segment];\n\t\t\tif (Object.keys(node.static).length === 0) node.static = void 0;\n\t\t}\n\t}\n}\nfunction _isEmptyNode(node) {\n\treturn node.methods === void 0 && node.static === void 0 && node.param === void 0 && node.wildcard === void 0;\n}\n\n/**\n* Find all route patterns that match the given path.\n*/\nfunction findAllRoutes(ctx, method = \"\", path, opts) {\n\tif (path.charCodeAt(path.length - 1) === 47) path = path.slice(0, -1);\n\tconst segments = splitPath(path);\n\tconst matches = _findAll(ctx, ctx.root, method, segments, 0);\n\tif (opts?.params === false) return matches;\n\treturn matches.map((m) => {\n\t\treturn {\n\t\t\tdata: m.data,\n\t\t\tparams: m.paramsMap ? getMatchParams(segments, m.paramsMap) : void 0\n\t\t};\n\t});\n}\nfunction _findAll(ctx, node, method, segments, index, matches = []) {\n\tconst segment = segments[index];\n\tif (node.wildcard && node.wildcard.methods) {\n\t\tconst match = node.wildcard.methods[method] || node.wildcard.methods[\"\"];\n\t\tif (match) matches.push(...match);\n\t}\n\tif (node.param) {\n\t\t_findAll(ctx, node.param, method, segments, index + 1, matches);\n\t\tif (index === segments.length && node.param.methods) {\n\t\t\tconst match = node.param.methods[method] || node.param.methods[\"\"];\n\t\t\tif (match) {\n\t\t\t\tconst pMap = match[0].paramsMap;\n\t\t\t\tif (pMap?.[pMap?.length - 1]?.[2]) matches.push(...match);\n\t\t\t}\n\t\t}\n\t}\n\tconst staticChild = node.static?.[segment];\n\tif (staticChild) _findAll(ctx, staticChild, method, segments, index + 1, matches);\n\tif (index === segments.length && node.methods) {\n\t\tconst match = node.methods[method] || node.methods[\"\"];\n\t\tif (match) matches.push(...match);\n\t}\n\treturn matches;\n}\n\nfunction routeToRegExp(route = \"/\") {\n\tconst reSegments = [];\n\tlet idCtr = 0;\n\tfor (const segment of route.split(\"/\")) {\n\t\tif (!segment) continue;\n\t\tif (segment === \"*\") reSegments.push(`(?<_${idCtr++}>[^/]*)`);\n\t\telse if (segment.startsWith(\"**\")) reSegments.push(segment === \"**\" ? \"?(?<_>.*)\" : `?(?<${segment.slice(3)}>.+)`);\n\t\telse if (segment.includes(\":\")) reSegments.push(segment.replace(/:(\\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\\./g, \"\\\\.\"));\n\t\telse reSegments.push(segment);\n\t}\n\treturn /* @__PURE__ */ new RegExp(`^/${reSegments.join(\"/\")}/?$`);\n}\n\nexport { NullProtoObj, addRoute, createRouter, findAllRoutes, findRoute, removeRoute, routeToRegExp };","import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, StandardBracketNotationSerializer, StandardOpenAPISerializer } from '@orpc/openapi-client/standard';\nimport { StandardHandler } from '@orpc/server/standard';\nimport { isORPCErrorStatus } from '@orpc/client';\nimport { fallbackContractConfig } from '@orpc/contract';\nimport { isObject, stringifyJSON, tryDecodeURIComponent, value } from '@orpc/shared';\nimport { toHttpPath } from '@orpc/client/standard';\nimport { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@orpc/server';\nimport { createRouter, addRoute, findRoute } from 'rou3';\n\nclass StandardOpenAPICodec {\n  constructor(serializer, options = {}) {\n    this.serializer = serializer;\n    this.customErrorResponseBodyEncoder = options.customErrorResponseBodyEncoder;\n  }\n  customErrorResponseBodyEncoder;\n  async decode(request, params, procedure) {\n    const inputStructure = fallbackContractConfig(\"defaultInputStructure\", procedure[\"~orpc\"].route.inputStructure);\n    if (inputStructure === \"compact\") {\n      const data = request.method === \"GET\" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());\n      if (data === void 0) {\n        return params;\n      }\n      if (isObject(data)) {\n        return {\n          ...params,\n          ...data\n        };\n      }\n      return data;\n    }\n    const deserializeSearchParams = () => {\n      return this.serializer.deserialize(request.url.searchParams);\n    };\n    return {\n      params,\n      get query() {\n        const value = deserializeSearchParams();\n        Object.defineProperty(this, \"query\", { value, writable: true });\n        return value;\n      },\n      set query(value) {\n        Object.defineProperty(this, \"query\", { value, writable: true });\n      },\n      headers: request.headers,\n      body: this.serializer.deserialize(await request.body())\n    };\n  }\n  encode(output, procedure) {\n    const successStatus = fallbackContractConfig(\"defaultSuccessStatus\", procedure[\"~orpc\"].route.successStatus);\n    const outputStructure = fallbackContractConfig(\"defaultOutputStructure\", procedure[\"~orpc\"].route.outputStructure);\n    if (outputStructure === \"compact\") {\n      return {\n        status: successStatus,\n        headers: {},\n        body: this.serializer.serialize(output)\n      };\n    }\n    if (!this.#isDetailedOutput(output)) {\n      throw new Error(`\n        Invalid \"detailed\" output structure:\n        \\u2022 Expected an object with optional properties:\n          - status (number 200-399)\n          - headers (Record<string, string | string[]>)\n          - body (any)\n        \\u2022 No extra keys allowed.\n\n        Actual value:\n          ${stringifyJSON(output)}\n      `);\n    }\n    return {\n      status: output.status ?? successStatus,\n      headers: output.headers ?? {},\n      body: this.serializer.serialize(output.body)\n    };\n  }\n  encodeError(error) {\n    const body = this.customErrorResponseBodyEncoder?.(error) ?? error.toJSON();\n    return {\n      status: error.status,\n      headers: {},\n      body: this.serializer.serialize(body, { outputFormat: \"plain\" })\n    };\n  }\n  #isDetailedOutput(output) {\n    if (!isObject(output)) {\n      return false;\n    }\n    if (output.headers && !isObject(output.headers)) {\n      return false;\n    }\n    if (output.status !== void 0 && (typeof output.status !== \"number\" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {\n      return false;\n    }\n    return true;\n  }\n}\n\nfunction toRou3Pattern(path) {\n  return standardizeHTTPPath(path).replace(/\\/\\{\\+([^}]+)\\}/g, \"/**:$1\").replace(/\\/\\{([^}]+)\\}/g, \"/:$1\");\n}\nfunction decodeParams(params) {\n  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, tryDecodeURIComponent(value)]));\n}\n\nclass StandardOpenAPIMatcher {\n  filter;\n  tree = createRouter();\n  pendingRouters = [];\n  constructor(options = {}) {\n    this.filter = options.filter ?? true;\n  }\n  init(router, path = []) {\n    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {\n      if (!value(this.filter, traverseOptions)) {\n        return;\n      }\n      const { path: path2, contract } = traverseOptions;\n      const method = fallbackContractConfig(\"defaultMethod\", contract[\"~orpc\"].route.method);\n      const httpPath = toRou3Pattern(contract[\"~orpc\"].route.path ?? toHttpPath(path2));\n      if (isProcedure(contract)) {\n        addRoute(this.tree, method, httpPath, {\n          path: path2,\n          contract,\n          procedure: contract,\n          // this mean dev not used contract-first so we can used contract as procedure directly\n          router\n        });\n      } else {\n        addRoute(this.tree, method, httpPath, {\n          path: path2,\n          contract,\n          procedure: void 0,\n          router\n        });\n      }\n    });\n    this.pendingRouters.push(...laziedOptions.map((option) => ({\n      ...option,\n      httpPathPrefix: toHttpPath(option.path),\n      laziedPrefix: getLazyMeta(option.router).prefix\n    })));\n  }\n  async match(method, pathname) {\n    if (this.pendingRouters.length) {\n      const newPendingRouters = [];\n      for (const pendingRouter of this.pendingRouters) {\n        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {\n          const { default: router } = await unlazy(pendingRouter.router);\n          this.init(router, pendingRouter.path);\n        } else {\n          newPendingRouters.push(pendingRouter);\n        }\n      }\n      this.pendingRouters = newPendingRouters;\n    }\n    const match = findRoute(this.tree, method, pathname);\n    if (!match) {\n      return void 0;\n    }\n    if (!match.data.procedure) {\n      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));\n      if (!isProcedure(maybeProcedure)) {\n        throw new Error(`\n          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.\n          Ensure that the procedure is correctly defined and matches the expected contract.\n        `);\n      }\n      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);\n    }\n    return {\n      path: match.data.path,\n      procedure: match.data.procedure,\n      params: match.params ? decodeParams(match.params) : void 0\n    };\n  }\n}\n\nclass StandardOpenAPIHandler extends StandardHandler {\n  constructor(router, options) {\n    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);\n    const bracketNotationSerializer = new StandardBracketNotationSerializer(options);\n    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);\n    const matcher = new StandardOpenAPIMatcher(options);\n    const codec = new StandardOpenAPICodec(serializer, options);\n    super(router, matcher, codec, options);\n  }\n}\n\nexport { StandardOpenAPICodec as S, StandardOpenAPIHandler as a, StandardOpenAPIMatcher as b, decodeParams as d, toRou3Pattern as t };\n","import { FetchHandler } from '@orpc/server/fetch';\nimport '@orpc/client';\nimport '@orpc/contract';\nimport '@orpc/shared';\nimport { a as StandardOpenAPIHandler } from '../../shared/openapi.DIt-Z9W1.mjs';\nimport '@orpc/client/standard';\nimport '@orpc/server';\nimport 'rou3';\nimport '@orpc/openapi-client/standard';\nimport '@orpc/server/standard';\n\nclass OpenAPIHandler extends FetchHandler {\n  constructor(router, options = {}) {\n    super(new StandardOpenAPIHandler(router, options), options);\n  }\n}\n\nexport { OpenAPIHandler };\n"],"x_google_ignoreList":[0,1,2],"mappings":"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"}