@orpc/server 0.0.0-next.c29cb6d → 0.0.0-next.c6c659d
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/chunk-MB74GD7C.js +301 -0
- package/dist/chunk-WUOGVGWG.js +1 -0
- package/dist/{chunk-YAVPFNPF.js → chunk-ZBJYYEII.js} +78 -33
- package/dist/fetch.js +10 -281
- package/dist/hono.js +30 -0
- package/dist/index.js +143 -111
- package/dist/next.js +36 -0
- package/dist/node.js +87 -0
- package/dist/src/{fetch → adapters/fetch}/index.d.ts +1 -1
- package/dist/src/adapters/fetch/orpc-handler.d.ts +20 -0
- package/dist/src/adapters/fetch/orpc-payload-codec.d.ts +16 -0
- package/dist/src/{fetch → adapters/fetch}/orpc-procedure-matcher.d.ts +2 -2
- package/dist/src/adapters/fetch/types.d.ts +21 -0
- package/dist/src/adapters/hono/index.d.ts +3 -0
- package/dist/src/adapters/hono/middleware.d.ts +12 -0
- package/dist/src/adapters/next/index.d.ts +3 -0
- package/dist/src/adapters/next/serve.d.ts +19 -0
- package/dist/src/adapters/node/index.d.ts +5 -0
- package/dist/src/adapters/node/orpc-handler.d.ts +12 -0
- package/dist/src/adapters/node/request-listener.d.ts +28 -0
- package/dist/src/adapters/node/types.d.ts +22 -0
- package/dist/src/builder.d.ts +11 -10
- package/dist/src/error.d.ts +10 -0
- package/dist/src/implementer-chainable.d.ts +2 -2
- package/dist/src/index.d.ts +3 -1
- package/dist/src/lazy-decorated.d.ts +3 -6
- package/dist/src/middleware-decorated.d.ts +6 -5
- package/dist/src/middleware.d.ts +20 -8
- package/dist/src/procedure-builder.d.ts +17 -15
- package/dist/src/procedure-client.d.ts +9 -21
- package/dist/src/procedure-decorated.d.ts +22 -10
- package/dist/src/procedure-implementer.d.ts +13 -12
- package/dist/src/procedure-utils.d.ts +17 -0
- package/dist/src/procedure.d.ts +33 -13
- package/dist/src/router-builder.d.ts +4 -4
- package/dist/src/router-client.d.ts +7 -5
- package/dist/src/router-implementer.d.ts +2 -2
- package/dist/src/router.d.ts +4 -4
- package/dist/src/types.d.ts +2 -0
- package/package.json +24 -8
- package/dist/src/fetch/composite-handler.d.ts +0 -8
- package/dist/src/fetch/orpc-handler.d.ts +0 -20
- package/dist/src/fetch/orpc-payload-codec.d.ts +0 -9
- package/dist/src/fetch/types.d.ts +0 -16
- /package/dist/src/{fetch → adapters/fetch}/super-json.d.ts +0 -0
@@ -0,0 +1,301 @@
|
|
1
|
+
import {
|
2
|
+
__export,
|
3
|
+
createProcedureClient,
|
4
|
+
getRouterChild,
|
5
|
+
isProcedure,
|
6
|
+
unlazy
|
7
|
+
} from "./chunk-ZBJYYEII.js";
|
8
|
+
|
9
|
+
// src/adapters/fetch/super-json.ts
|
10
|
+
var super_json_exports = {};
|
11
|
+
__export(super_json_exports, {
|
12
|
+
deserialize: () => deserialize,
|
13
|
+
serialize: () => serialize
|
14
|
+
});
|
15
|
+
|
16
|
+
// ../../node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/getType.js
|
17
|
+
function getType(payload) {
|
18
|
+
return Object.prototype.toString.call(payload).slice(8, -1);
|
19
|
+
}
|
20
|
+
|
21
|
+
// ../../node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/isPlainObject.js
|
22
|
+
function isPlainObject(payload) {
|
23
|
+
if (getType(payload) !== "Object")
|
24
|
+
return false;
|
25
|
+
const prototype = Object.getPrototypeOf(payload);
|
26
|
+
return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
|
27
|
+
}
|
28
|
+
|
29
|
+
// src/adapters/fetch/super-json.ts
|
30
|
+
function serialize(value, segments = [], meta = []) {
|
31
|
+
if (typeof value === "bigint") {
|
32
|
+
meta.push(["bigint", segments]);
|
33
|
+
return { data: value.toString(), meta };
|
34
|
+
}
|
35
|
+
if (value instanceof Date) {
|
36
|
+
meta.push(["date", segments]);
|
37
|
+
const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
|
38
|
+
return { data, meta };
|
39
|
+
}
|
40
|
+
if (Number.isNaN(value)) {
|
41
|
+
meta.push(["nan", segments]);
|
42
|
+
return { data: "NaN", meta };
|
43
|
+
}
|
44
|
+
if (value instanceof RegExp) {
|
45
|
+
meta.push(["regexp", segments]);
|
46
|
+
return { data: value.toString(), meta };
|
47
|
+
}
|
48
|
+
if (value instanceof URL) {
|
49
|
+
meta.push(["url", segments]);
|
50
|
+
return { data: value.toString(), meta };
|
51
|
+
}
|
52
|
+
if (isPlainObject(value)) {
|
53
|
+
const data = {};
|
54
|
+
for (const k in value) {
|
55
|
+
data[k] = serialize(value[k], [...segments, k], meta).data;
|
56
|
+
}
|
57
|
+
return { data, meta };
|
58
|
+
}
|
59
|
+
if (Array.isArray(value)) {
|
60
|
+
const data = value.map((v, i) => {
|
61
|
+
if (v === void 0) {
|
62
|
+
meta.push(["undefined", [...segments, i]]);
|
63
|
+
return null;
|
64
|
+
}
|
65
|
+
return serialize(v, [...segments, i], meta).data;
|
66
|
+
});
|
67
|
+
return { data, meta };
|
68
|
+
}
|
69
|
+
if (value instanceof Set) {
|
70
|
+
const result = serialize(Array.from(value), segments, meta);
|
71
|
+
meta.push(["set", segments]);
|
72
|
+
return result;
|
73
|
+
}
|
74
|
+
if (value instanceof Map) {
|
75
|
+
const result = serialize(Array.from(value.entries()), segments, meta);
|
76
|
+
meta.push(["map", segments]);
|
77
|
+
return result;
|
78
|
+
}
|
79
|
+
return { data: value, meta };
|
80
|
+
}
|
81
|
+
function deserialize({
|
82
|
+
data,
|
83
|
+
meta
|
84
|
+
}) {
|
85
|
+
if (meta.length === 0) {
|
86
|
+
return data;
|
87
|
+
}
|
88
|
+
const ref = { data };
|
89
|
+
for (const [type, segments] of meta) {
|
90
|
+
let currentRef = ref;
|
91
|
+
let preSegment = "data";
|
92
|
+
for (let i = 0; i < segments.length; i++) {
|
93
|
+
currentRef = currentRef[preSegment];
|
94
|
+
preSegment = segments[i];
|
95
|
+
}
|
96
|
+
switch (type) {
|
97
|
+
case "nan":
|
98
|
+
currentRef[preSegment] = Number.NaN;
|
99
|
+
break;
|
100
|
+
case "bigint":
|
101
|
+
currentRef[preSegment] = BigInt(currentRef[preSegment]);
|
102
|
+
break;
|
103
|
+
case "date":
|
104
|
+
currentRef[preSegment] = new Date(currentRef[preSegment]);
|
105
|
+
break;
|
106
|
+
case "regexp": {
|
107
|
+
const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
|
108
|
+
currentRef[preSegment] = new RegExp(pattern, flags);
|
109
|
+
break;
|
110
|
+
}
|
111
|
+
case "url":
|
112
|
+
currentRef[preSegment] = new URL(currentRef[preSegment]);
|
113
|
+
break;
|
114
|
+
case "undefined":
|
115
|
+
currentRef[preSegment] = void 0;
|
116
|
+
break;
|
117
|
+
case "map":
|
118
|
+
currentRef[preSegment] = new Map(currentRef[preSegment]);
|
119
|
+
break;
|
120
|
+
case "set":
|
121
|
+
currentRef[preSegment] = new Set(currentRef[preSegment]);
|
122
|
+
break;
|
123
|
+
/* v8 ignore next 3 */
|
124
|
+
default: {
|
125
|
+
const _expected = type;
|
126
|
+
}
|
127
|
+
}
|
128
|
+
}
|
129
|
+
return ref.data;
|
130
|
+
}
|
131
|
+
|
132
|
+
// src/adapters/fetch/orpc-payload-codec.ts
|
133
|
+
import { ORPCError } from "@orpc/contract";
|
134
|
+
import { findDeepMatches, set } from "@orpc/shared";
|
135
|
+
var ORPCPayloadCodec = class {
|
136
|
+
/**
|
137
|
+
* If method is GET, the payload will be encoded as query string.
|
138
|
+
* If method is GET and payload contain file, the method will be fallback to fallbackMethod. (fallbackMethod = GET will force to use GET method)
|
139
|
+
*/
|
140
|
+
encode(payload, method = "POST", fallbackMethod = "POST") {
|
141
|
+
const { data, meta } = serialize(payload);
|
142
|
+
const { maps, values } = findDeepMatches((v) => v instanceof Blob, data);
|
143
|
+
if (method === "GET" && (values.length === 0 || fallbackMethod === "GET")) {
|
144
|
+
const query = new URLSearchParams({
|
145
|
+
data: JSON.stringify(data),
|
146
|
+
meta: JSON.stringify(meta)
|
147
|
+
});
|
148
|
+
return {
|
149
|
+
query,
|
150
|
+
method: "GET"
|
151
|
+
};
|
152
|
+
}
|
153
|
+
const nonGETMethod = method === "GET" ? fallbackMethod : method;
|
154
|
+
if (values.length > 0) {
|
155
|
+
const form = new FormData();
|
156
|
+
if (data !== void 0) {
|
157
|
+
form.append("data", JSON.stringify(data));
|
158
|
+
}
|
159
|
+
form.append("meta", JSON.stringify(meta));
|
160
|
+
form.append("maps", JSON.stringify(maps));
|
161
|
+
for (const i in values) {
|
162
|
+
const value = values[i];
|
163
|
+
form.append(i, value);
|
164
|
+
}
|
165
|
+
return {
|
166
|
+
body: form,
|
167
|
+
method: nonGETMethod
|
168
|
+
};
|
169
|
+
}
|
170
|
+
return {
|
171
|
+
body: JSON.stringify({ data, meta }),
|
172
|
+
headers: new Headers({
|
173
|
+
"content-type": "application/json"
|
174
|
+
}),
|
175
|
+
method: nonGETMethod
|
176
|
+
};
|
177
|
+
}
|
178
|
+
async decode(re) {
|
179
|
+
try {
|
180
|
+
if ("method" in re && re.method === "GET") {
|
181
|
+
const url = new URL(re.url);
|
182
|
+
const query = url.searchParams;
|
183
|
+
const data = JSON.parse(query.getAll("data").at(-1));
|
184
|
+
const meta = JSON.parse(query.getAll("meta").at(-1));
|
185
|
+
return deserialize({
|
186
|
+
data,
|
187
|
+
meta
|
188
|
+
});
|
189
|
+
}
|
190
|
+
if (re.headers.get("content-type")?.startsWith("multipart/form-data")) {
|
191
|
+
const form = await re.formData();
|
192
|
+
const rawData = form.get("data");
|
193
|
+
const rawMeta = form.get("meta");
|
194
|
+
const rawMaps = form.get("maps");
|
195
|
+
let data = JSON.parse(rawData);
|
196
|
+
const meta = JSON.parse(rawMeta);
|
197
|
+
const maps = JSON.parse(rawMaps);
|
198
|
+
for (const i in maps) {
|
199
|
+
data = set(data, maps[i], form.get(i));
|
200
|
+
}
|
201
|
+
return deserialize({
|
202
|
+
data,
|
203
|
+
meta
|
204
|
+
});
|
205
|
+
}
|
206
|
+
const json = await re.json();
|
207
|
+
return deserialize(json);
|
208
|
+
} catch (e) {
|
209
|
+
throw new ORPCError({
|
210
|
+
code: "BAD_REQUEST",
|
211
|
+
message: "Cannot parse request/response. Please check the request/response body and Content-Type header.",
|
212
|
+
cause: e
|
213
|
+
});
|
214
|
+
}
|
215
|
+
}
|
216
|
+
};
|
217
|
+
|
218
|
+
// src/adapters/fetch/orpc-procedure-matcher.ts
|
219
|
+
import { trim } from "@orpc/shared";
|
220
|
+
var ORPCProcedureMatcher = class {
|
221
|
+
constructor(router) {
|
222
|
+
this.router = router;
|
223
|
+
}
|
224
|
+
async match(pathname) {
|
225
|
+
const path = trim(pathname, "/").split("/").map(decodeURIComponent);
|
226
|
+
const match = getRouterChild(this.router, ...path);
|
227
|
+
const { default: maybeProcedure } = await unlazy(match);
|
228
|
+
if (!isProcedure(maybeProcedure)) {
|
229
|
+
return void 0;
|
230
|
+
}
|
231
|
+
return {
|
232
|
+
procedure: maybeProcedure,
|
233
|
+
path
|
234
|
+
};
|
235
|
+
}
|
236
|
+
};
|
237
|
+
|
238
|
+
// src/adapters/fetch/orpc-handler.ts
|
239
|
+
import { ORPCError as ORPCError2 } from "@orpc/contract";
|
240
|
+
import { executeWithHooks, trim as trim2 } from "@orpc/shared";
|
241
|
+
var RPCHandler = class {
|
242
|
+
constructor(router, options) {
|
243
|
+
this.options = options;
|
244
|
+
this.procedureMatcher = options?.procedureMatcher ?? new ORPCProcedureMatcher(router);
|
245
|
+
this.payloadCodec = options?.payloadCodec ?? new ORPCPayloadCodec();
|
246
|
+
}
|
247
|
+
procedureMatcher;
|
248
|
+
payloadCodec;
|
249
|
+
async handle(request, ...[options]) {
|
250
|
+
const context = options?.context;
|
251
|
+
const execute = async () => {
|
252
|
+
const url = new URL(request.url);
|
253
|
+
const pathname = `/${trim2(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
|
254
|
+
const match = await this.procedureMatcher.match(pathname);
|
255
|
+
if (!match) {
|
256
|
+
return { matched: false, response: void 0 };
|
257
|
+
}
|
258
|
+
const input = await this.payloadCodec.decode(request);
|
259
|
+
const client = createProcedureClient(match.procedure, {
|
260
|
+
context,
|
261
|
+
path: match.path
|
262
|
+
});
|
263
|
+
const output = await client(input, { signal: request.signal });
|
264
|
+
const { body, headers } = this.payloadCodec.encode(output);
|
265
|
+
const response = new Response(body, { headers });
|
266
|
+
return { matched: true, response };
|
267
|
+
};
|
268
|
+
try {
|
269
|
+
const result = await executeWithHooks({
|
270
|
+
context,
|
271
|
+
execute,
|
272
|
+
input: request,
|
273
|
+
hooks: this.options,
|
274
|
+
meta: {
|
275
|
+
signal: request.signal
|
276
|
+
}
|
277
|
+
});
|
278
|
+
return result;
|
279
|
+
} catch (e) {
|
280
|
+
const error = e instanceof ORPCError2 ? e : new ORPCError2({
|
281
|
+
code: "INTERNAL_SERVER_ERROR",
|
282
|
+
message: "Internal server error",
|
283
|
+
cause: e
|
284
|
+
});
|
285
|
+
const { body, headers } = this.payloadCodec.encode(error.toJSON());
|
286
|
+
const response = new Response(body, {
|
287
|
+
headers,
|
288
|
+
status: error.status
|
289
|
+
});
|
290
|
+
return { matched: true, response };
|
291
|
+
}
|
292
|
+
}
|
293
|
+
};
|
294
|
+
|
295
|
+
export {
|
296
|
+
super_json_exports,
|
297
|
+
ORPCPayloadCodec,
|
298
|
+
ORPCProcedureMatcher,
|
299
|
+
RPCHandler
|
300
|
+
};
|
301
|
+
//# sourceMappingURL=chunk-MB74GD7C.js.map
|
@@ -0,0 +1 @@
|
|
1
|
+
//# sourceMappingURL=chunk-WUOGVGWG.js.map
|
@@ -1,3 +1,9 @@
|
|
1
|
+
var __defProp = Object.defineProperty;
|
2
|
+
var __export = (target, all) => {
|
3
|
+
for (var name in all)
|
4
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
5
|
+
};
|
6
|
+
|
1
7
|
// src/utils.ts
|
2
8
|
function mergeContext(a, b) {
|
3
9
|
if (!a)
|
@@ -23,7 +29,34 @@ function isProcedure(item) {
|
|
23
29
|
if (item instanceof Procedure) {
|
24
30
|
return true;
|
25
31
|
}
|
26
|
-
return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "Procedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "contract" in item["~orpc"] && isContractProcedure(item["~orpc"].contract) && "
|
32
|
+
return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "Procedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "contract" in item["~orpc"] && isContractProcedure(item["~orpc"].contract) && "handler" in item["~orpc"] && typeof item["~orpc"].handler === "function";
|
33
|
+
}
|
34
|
+
|
35
|
+
// src/error.ts
|
36
|
+
import { ORPCError } from "@orpc/contract";
|
37
|
+
function createORPCErrorConstructorMap(errors) {
|
38
|
+
const constructors = {};
|
39
|
+
if (!errors) {
|
40
|
+
return constructors;
|
41
|
+
}
|
42
|
+
for (const code in errors) {
|
43
|
+
const config = errors[code];
|
44
|
+
if (!config) {
|
45
|
+
continue;
|
46
|
+
}
|
47
|
+
const constructor = (...[options]) => {
|
48
|
+
return new ORPCError({
|
49
|
+
code,
|
50
|
+
defined: true,
|
51
|
+
status: config.status,
|
52
|
+
message: options?.message ?? config.message,
|
53
|
+
data: options?.data,
|
54
|
+
cause: options?.cause
|
55
|
+
});
|
56
|
+
};
|
57
|
+
constructors[code] = constructor;
|
58
|
+
}
|
59
|
+
return constructors;
|
27
60
|
}
|
28
61
|
|
29
62
|
// src/lazy.ts
|
@@ -54,13 +87,13 @@ function flatLazy(lazied) {
|
|
54
87
|
}
|
55
88
|
|
56
89
|
// src/procedure-client.ts
|
57
|
-
import {
|
58
|
-
import {
|
59
|
-
function createProcedureClient(options) {
|
90
|
+
import { ORPCError as ORPCError2, validateORPCError, ValidationError } from "@orpc/contract";
|
91
|
+
import { executeWithHooks, toError, value } from "@orpc/shared";
|
92
|
+
function createProcedureClient(lazyableProcedure, ...[options]) {
|
60
93
|
return async (...[input, callerOptions]) => {
|
61
|
-
const path = options
|
62
|
-
const { default: procedure } = await unlazy(
|
63
|
-
const context = await value(options
|
94
|
+
const path = options?.path ?? [];
|
95
|
+
const { default: procedure } = await unlazy(lazyableProcedure);
|
96
|
+
const context = await value(options?.context, callerOptions?.context);
|
64
97
|
const meta = {
|
65
98
|
path,
|
66
99
|
procedure,
|
@@ -68,21 +101,32 @@ function createProcedureClient(options) {
|
|
68
101
|
};
|
69
102
|
const executeWithValidation = async () => {
|
70
103
|
const validInput = await validateInput(procedure, input);
|
71
|
-
const output = await executeMiddlewareChain(
|
72
|
-
procedure,
|
73
|
-
validInput,
|
104
|
+
const output = await executeMiddlewareChain({
|
74
105
|
context,
|
75
|
-
|
76
|
-
|
106
|
+
input: validInput,
|
107
|
+
path,
|
108
|
+
procedure,
|
109
|
+
signal: callerOptions?.signal,
|
110
|
+
errors: createORPCErrorConstructorMap(procedure["~orpc"].contract["~orpc"].errorMap)
|
111
|
+
});
|
77
112
|
return validateOutput(procedure, output);
|
78
113
|
};
|
79
|
-
|
80
|
-
|
81
|
-
|
82
|
-
|
83
|
-
|
84
|
-
|
85
|
-
|
114
|
+
try {
|
115
|
+
const output = await executeWithHooks({
|
116
|
+
hooks: options,
|
117
|
+
input,
|
118
|
+
context,
|
119
|
+
meta,
|
120
|
+
execute: executeWithValidation
|
121
|
+
});
|
122
|
+
return output;
|
123
|
+
} catch (e) {
|
124
|
+
if (!(e instanceof ORPCError2)) {
|
125
|
+
throw toError(e);
|
126
|
+
}
|
127
|
+
const validated = await validateORPCError(procedure["~orpc"].contract["~orpc"].errorMap, e);
|
128
|
+
throw validated;
|
129
|
+
}
|
86
130
|
};
|
87
131
|
}
|
88
132
|
async function validateInput(procedure, input) {
|
@@ -91,10 +135,13 @@ async function validateInput(procedure, input) {
|
|
91
135
|
return input;
|
92
136
|
const result = await schema["~standard"].validate(input);
|
93
137
|
if (result.issues) {
|
94
|
-
throw new
|
138
|
+
throw new ORPCError2({
|
95
139
|
message: "Input validation failed",
|
96
140
|
code: "BAD_REQUEST",
|
97
|
-
|
141
|
+
data: {
|
142
|
+
issues: result.issues
|
143
|
+
},
|
144
|
+
cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
|
98
145
|
});
|
99
146
|
}
|
100
147
|
return result.value;
|
@@ -105,31 +152,27 @@ async function validateOutput(procedure, output) {
|
|
105
152
|
return output;
|
106
153
|
const result = await schema["~standard"].validate(output);
|
107
154
|
if (result.issues) {
|
108
|
-
throw new
|
155
|
+
throw new ORPCError2({
|
109
156
|
message: "Output validation failed",
|
110
157
|
code: "INTERNAL_SERVER_ERROR",
|
111
|
-
issues: result.issues
|
158
|
+
cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
|
112
159
|
});
|
113
160
|
}
|
114
161
|
return result.value;
|
115
162
|
}
|
116
|
-
async function executeMiddlewareChain(
|
117
|
-
const middlewares = procedure["~orpc"].middlewares ?? [];
|
163
|
+
async function executeMiddlewareChain(opt) {
|
164
|
+
const middlewares = opt.procedure["~orpc"].middlewares ?? [];
|
118
165
|
let currentMidIndex = 0;
|
119
|
-
let currentContext = context;
|
166
|
+
let currentContext = opt.context;
|
120
167
|
const next = async (nextOptions) => {
|
121
168
|
const mid = middlewares[currentMidIndex];
|
122
169
|
currentMidIndex += 1;
|
123
170
|
currentContext = mergeContext(currentContext, nextOptions.context);
|
124
171
|
if (mid) {
|
125
|
-
return await mid(
|
126
|
-
...meta,
|
127
|
-
next,
|
128
|
-
output: (output) => ({ output, context: void 0 })
|
129
|
-
});
|
172
|
+
return await mid({ ...opt, context: currentContext, next }, opt.input, (output) => ({ output, context: void 0 }));
|
130
173
|
}
|
131
174
|
const result = {
|
132
|
-
output: await procedure["~orpc"].
|
175
|
+
output: await opt.procedure["~orpc"].handler({ ...opt, context: currentContext }),
|
133
176
|
context: currentContext
|
134
177
|
};
|
135
178
|
return result;
|
@@ -168,9 +211,11 @@ function getRouterChild(router, ...path) {
|
|
168
211
|
}
|
169
212
|
|
170
213
|
export {
|
214
|
+
__export,
|
171
215
|
mergeContext,
|
172
216
|
Procedure,
|
173
217
|
isProcedure,
|
218
|
+
createORPCErrorConstructorMap,
|
174
219
|
LAZY_LOADER_SYMBOL,
|
175
220
|
lazy,
|
176
221
|
isLazy,
|
@@ -179,4 +224,4 @@ export {
|
|
179
224
|
createProcedureClient,
|
180
225
|
getRouterChild
|
181
226
|
};
|
182
|
-
//# sourceMappingURL=chunk-
|
227
|
+
//# sourceMappingURL=chunk-ZBJYYEII.js.map
|