@mionjs/client 0.8.0-alpha.0 → 0.8.4

package/.dist/esm/_virtual/jit-fns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jit-fns.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/_virtual/pure-fns.js

@@ -1,109 +0,0 @@
-const pureFnsCache = { mion: { asJSONString: { namespace: "mion", paramNames: [], code: `if (typeof Bun !== "undefined") return JSON.stringify;
-  const STR_ESCAPE = /[\\u0000-\\u001f\\u0022\\u005c\\ud800-\\udfff]/;
-  const MAX_SCAPE_TEST_LENGTH = 1e3;
-  return function _asJSONStringRegexOnly(str) {
-    if (str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === false) {
-      return '"' + str + '"';
-    } else {
-      return JSON.stringify(str);
-    }
-  };`, fnName: "asJSONString", bodyHash: "4WYkR03dXOzAUe", pureFnDependencies: [], createPureFn: function() {
-  if (typeof Bun < "u") return JSON.stringify;
-  const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/, MAX_SCAPE_TEST_LENGTH = 1e3;
-  return function(str) {
-    return str.length < MAX_SCAPE_TEST_LENGTH && STR_ESCAPE.test(str) === !1 ? '"' + str + '"' : JSON.stringify(str);
-  };
-}, fn: void 0 }, getUnknownKeysFromArray: { namespace: "mion", paramNames: [], code: `const MAX_UNKNOWN_KEYS = 10;
-  return function _getUnknownKeysFromArray(obj, keys) {
-    const unknownKeys = [];
-    for (const prop in obj) {
-      let found = false;
-      for (let j = 0; j < keys.length; j++) {
-        if (keys[j] === prop) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        unknownKeys.push(prop);
-        if (unknownKeys.length >= MAX_UNKNOWN_KEYS) throw new Error("Too many unknown keys");
-      }
-    }
-    return unknownKeys;
-  };`, fnName: "getUnknownKeysFromArray", bodyHash: "D2CDXI8OoGLGyW", pureFnDependencies: [], createPureFn: function() {
-  return function(obj, keys) {
-    const unknownKeys = [];
-    for (const prop in obj) {
-      let found = !1;
-      for (let j = 0; j < keys.length; j++)
-        if (keys[j] === prop) {
-          found = !0;
-          break;
-        }
-      if (!found && (unknownKeys.push(prop), unknownKeys.length >= 10))
-        throw new Error("Too many unknown keys");
-    }
-    return unknownKeys;
-  };
-}, fn: void 0 }, hasUnknownKeysFromArray: { namespace: "mion", paramNames: [], code: `return function _hasUnknownKeysFromArray(obj, keys) {
-    for (const prop in obj) {
-      let found = false;
-      for (let j = 0; j < keys.length; j++) {
-        if (keys[j] === prop) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) return true;
-    }
-    return false;
-  };`, fnName: "hasUnknownKeysFromArray", bodyHash: "K7uzDGNnPwcqQ9", pureFnDependencies: [], createPureFn: function() {
-  return function(obj, keys) {
-    for (const prop in obj) {
-      let found = !1;
-      for (let j = 0; j < keys.length; j++)
-        if (keys[j] === prop) {
-          found = !0;
-          break;
-        }
-      if (!found) return !0;
-    }
-    return !1;
-  };
-}, fn: void 0 }, newRunTypeErr: { namespace: "mion", paramNames: [], code: `return function _err(p\\u03BBth, \\u03B5rr, expected, accessPath) {
-    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];
-    const runTypeErr = { expected, path };
-    \\u03B5rr.push(runTypeErr);
-  };`, fnName: "newRunTypeErr", bodyHash: "eCwDrS1nuSv7ge", pureFnDependencies: [], createPureFn: function() {
-  return function(pλth, εrr, expected, accessPath) {
-    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth], runTypeErr = { expected, path };
-    εrr.push(runTypeErr);
-  };
-}, fn: void 0 }, formatErr: { namespace: "mion", paramNames: [], code: `return function _formatErr(p\\u03BBth, \\u03B5rr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {
-    const path = accessPath?.length ? [...p\\u03BBth, ...accessPath] : [...p\\u03BBth];
-    const formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName];
-    const format = { name: fmtName, formatPath, val: paramVal };
-    const runTypeErr = { expected, path, format };
-    \\u03B5rr.push(runTypeErr);
-  };`, fnName: "formatErr", bodyHash: "2isPiuLWPtohVR", pureFnDependencies: [], createPureFn: function() {
-  return function(pλth, εrr, expected, fmtName, paramName, paramVal, fmtPath, accessPath, fmtAccessPath) {
-    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth], formatPath = fmtAccessPath?.length ? [...fmtPath, ...fmtAccessPath, paramName] : [...fmtPath, paramName], runTypeErr = { expected, path, format: { name: fmtName, formatPath, val: paramVal } };
-    εrr.push(runTypeErr);
-  };
-}, fn: void 0 }, safeIterableKey: { namespace: "mion", paramNames: [], code: `return function _safeKey(value) {
-    if (value === void 0) return null;
-    if (value === null) return null;
-    const type = typeof value;
-    if (type === "number" || type === "string" || type === "boolean") return value;
-    return null;
-  };`, fnName: "safeIterableKey", bodyHash: "BrjL47E-GRjUpQ", pureFnDependencies: [], createPureFn: function() {
-  return function(value) {
-    if (value === void 0 || value === null) return null;
-    const type = typeof value;
-    return type === "number" || type === "string" || type === "boolean" ? value : null;
-  };
-}, fn: void 0 } } };
-export {
-  pureFnsCache
-};
-//# sourceMappingURL=pure-fns.js.map

package/.dist/esm/_virtual/pure-fns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pure-fns.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/_virtual/router-cache.js

@@ -1,5 +0,0 @@
-const routerCache = { "@thrownErrors": { paramNames: [], type: 1, id: "@thrownErrors", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "cm6MsK", pointer: ["@thrownErrors"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@notFound": { paramNames: [], type: 1, id: "mion@notFound", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "a8UQwC", pointer: ["mion@notFound"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@platformError": { paramNames: [], type: 1, id: "mion@platformError", isAsync: !1, hasReturnData: !0, paramsJitHash: "", returnJitHash: "zxRrbt", pointer: ["mion@platformError"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "json" } }, "mion@methodsMetadataById": { paramNames: ["methodsIds", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataById", isAsync: !1, hasReturnData: !0, paramsJitHash: "JtnVhp", returnJitHash: "rFrbJx", pointer: ["mion@methodsMetadataById"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@methodsMetadataByPath": { paramNames: ["path", "getAllRemoteMethods"], type: 1, id: "mion@methodsMetadataByPath", isAsync: !1, hasReturnData: !0, paramsJitHash: "hZzD9z", returnJitHash: "rFrbJx", pointer: ["mion@methodsMetadataByPath"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1, serializer: "stringifyJson" } }, "mion@mionEmptyMiddleFn": { paramNames: [], type: 2, id: "mion@mionEmptyMiddleFn", isAsync: !1, hasReturnData: !1, paramsJitHash: "", returnJitHash: "", pointer: ["mion@mionEmptyMiddleFn"], nestLevel: 0, options: { runOnError: !1, validateParams: !0, validateReturn: !1 } } };
-export {
-  routerCache
-};
-//# sourceMappingURL=router-cache.js.map

package/.dist/esm/_virtual/router-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"router-cache.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/.dist/esm/src/aot/loadClientAOTCaches.d.ts

@@ -1,8 +0,0 @@
-import { InitClientOptions } from '../types.ts';
-import { RemoteApi } from '@mionjs/router';
-export declare function loadClientAotCaches(): void;
-export declare function initAOTClient<RM extends RemoteApi>(options: InitClientOptions): {
-    client: import('../client.ts').MionClient;
-    routes: { [Property in keyof RM as RM[Property] extends import('../types.ts').NonClientRoute ? never : Property]: RM[Property] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<RM[Property]["handler"]>) => import('../types.ts').RSubRequest<RM[Property]["handler"]> : RM[Property] extends RemoteApi ? (RM[Property] extends infer T_2 extends RemoteApi ? { [Property_2 in keyof T_2 as RM[Property][Property_2] extends import('../types.ts').NonClientRoute ? never : Property_2]: T_2[Property_2] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_2[Property_2]["handler"]>) => import('../types.ts').RSubRequest<T_2[Property_2]["handler"]> : T_2[Property_2] extends RemoteApi ? (T_2[Property_2] extends infer T_4 extends RemoteApi ? { [Property_3 in keyof T_4 as T_2[Property_2][Property_3] extends import('../types.ts').NonClientRoute ? never : Property_3]: T_4[Property_3] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_4[Property_3]["handler"]>) => import('../types.ts').RSubRequest<T_4[Property_3]["handler"]> : T_4[Property_3] extends RemoteApi ? (T_4[Property_3] extends infer T_6 extends RemoteApi ? { [Property_4 in keyof T_6 as T_4[Property_3][Property_4] extends import('../types.ts').NonClientRoute ? never : Property_4]: T_6[Property_4] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_6[Property_4]["handler"]>) => import('../types.ts').RSubRequest<T_6[Property_4]["handler"]> : T_6[Property_4] extends RemoteApi ? (T_6[Property_4] extends infer T_8 extends RemoteApi ? { [Property_5 in keyof T_8 as T_6[Property_4][Property_5] extends import('../types.ts').NonClientRoute ? never : Property_5]: T_8[Property_5] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_8[Property_5]["handler"]>) => import('../types.ts').RSubRequest<T_8[Property_5]["handler"]> : T_8[Property_5] extends RemoteApi ? (T_8[Property_5] extends infer T_10 extends RemoteApi ? { [Property_6 in keyof T_10 as T_8[Property_5][Property_6] extends import('../types.ts').NonClientRoute ? never : Property_6]: T_10[Property_6] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_10[Property_6]["handler"]>) => import('../types.ts').RSubRequest<T_10[Property_6]["handler"]> : T_10[Property_6] extends RemoteApi ? (T_10[Property_6] extends infer T_12 extends RemoteApi ? { [Property_7 in keyof T_12 as T_10[Property_6][Property_7] extends import('../types.ts').NonClientRoute ? never : Property_7]: T_12[Property_7] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_12[Property_7]["handler"]>) => import('../types.ts').RSubRequest<T_12[Property_7]["handler"]> : T_12[Property_7] extends RemoteApi ? (T_12[Property_7] extends infer T_14 extends RemoteApi ? { [Property_8 in keyof T_14 as T_12[Property_7][Property_8] extends import('../types.ts').NonClientRoute ? never : Property_8]: T_14[Property_8] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_14[Property_8]["handler"]>) => import('../types.ts').RSubRequest<T_14[Property_8]["handler"]> : T_14[Property_8] extends RemoteApi ? (T_14[Property_8] extends infer T_16 extends RemoteApi ? { [Property_9 in keyof T_16 as T_14[Property_8][Property_9] extends import('../types.ts').NonClientRoute ? never : Property_9]: T_16[Property_9] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_16[Property_9]["handler"]>) => import('../types.ts').RSubRequest<T_16[Property_9]["handler"]> : T_16[Property_9] extends RemoteApi ? (T_16[Property_9] extends infer T_18 extends RemoteApi ? { [Property_10 in keyof T_18 as T_16[Property_9][Property_10] extends import('../types.ts').NonClientRoute ? never : Property_10]: T_18[Property_10] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_18[Property_10]["handler"]>) => import('../types.ts').RSubRequest<T_18[Property_10]["handler"]> : T_18[Property_10] extends RemoteApi ? (T_18[Property_10] extends infer T_20 extends RemoteApi ? { [Property_11 in keyof T_20 as T_18[Property_10][Property_11] extends import('../types.ts').NonClientRoute ? never : Property_11]: T_20[Property_11] extends import('@mionjs/router').PublicRoute<any> ? (...params: Parameters<T_20[Property_11]["handler"]>) => import('../types.ts').RSubRequest<T_20[Property_11]["handler"]> : T_20[Property_11] extends RemoteApi ? any : never; } : never) extends infer T_19 ? { [P_10 in keyof T_19]: T_19[P_10]; } : never : never; } : never) extends infer T_17 ? { [P_9 in keyof T_17]: T_17[P_9]; } : never : never; } : never) extends infer T_15 ? { [P_8 in keyof T_15]: T_15[P_8]; } : never : never; } : never) extends infer T_13 ? { [P_7 in keyof T_13]: T_13[P_7]; } : never : never; } : never) extends infer T_11 ? { [P_6 in keyof T_11]: T_11[P_6]; } : never : never; } : never) extends infer T_9 ? { [P_5 in keyof T_9]: T_9[P_5]; } : never : never; } : never) extends infer T_7 ? { [P_4 in keyof T_7]: T_7[P_4]; } : never : never; } : never) extends infer T_5 ? { [P_3 in keyof T_5]: T_5[P_3]; } : never : never; } : never) extends infer T_3 ? { [P_2 in keyof T_3]: T_3[P_2]; } : never : never; } : never) extends infer T_1 ? { [P_1 in keyof T_1]: T_1[P_1]; } : never : never; } extends infer T ? { [P in keyof T]: T[P]; } : never;
-    middleFns: { [Property_1 in keyof RM as RM[Property_1] extends import('../types.ts').NonClientMiddleFn ? never : Property_1]: RM[Property_1] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<RM[Property_1]["handler"]>) => import('../types.ts').HSubRequest<RM[Property_1]["handler"]> : RM[Property_1] extends RemoteApi ? (RM[Property_1] extends infer T_3 extends RemoteApi ? { [Property_3 in keyof T_3 as RM[Property_1][Property_3] extends import('../types.ts').NonClientMiddleFn ? never : Property_3]: T_3[Property_3] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_3[Property_3]["handler"]>) => import('../types.ts').HSubRequest<T_3[Property_3]["handler"]> : T_3[Property_3] extends RemoteApi ? (T_3[Property_3] extends infer T_5 extends RemoteApi ? { [Property_4 in keyof T_5 as T_3[Property_3][Property_4] extends import('../types.ts').NonClientMiddleFn ? never : Property_4]: T_5[Property_4] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_5[Property_4]["handler"]>) => import('../types.ts').HSubRequest<T_5[Property_4]["handler"]> : T_5[Property_4] extends RemoteApi ? (T_5[Property_4] extends infer T_7 extends RemoteApi ? { [Property_5 in keyof T_7 as T_5[Property_4][Property_5] extends import('../types.ts').NonClientMiddleFn ? never : Property_5]: T_7[Property_5] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_7[Property_5]["handler"]>) => import('../types.ts').HSubRequest<T_7[Property_5]["handler"]> : T_7[Property_5] extends RemoteApi ? (T_7[Property_5] extends infer T_9 extends RemoteApi ? { [Property_6 in keyof T_9 as T_7[Property_5][Property_6] extends import('../types.ts').NonClientMiddleFn ? never : Property_6]: T_9[Property_6] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_9[Property_6]["handler"]>) => import('../types.ts').HSubRequest<T_9[Property_6]["handler"]> : T_9[Property_6] extends RemoteApi ? (T_9[Property_6] extends infer T_11 extends RemoteApi ? { [Property_7 in keyof T_11 as T_9[Property_6][Property_7] extends import('../types.ts').NonClientMiddleFn ? never : Property_7]: T_11[Property_7] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_11[Property_7]["handler"]>) => import('../types.ts').HSubRequest<T_11[Property_7]["handler"]> : T_11[Property_7] extends RemoteApi ? (T_11[Property_7] extends infer T_13 extends RemoteApi ? { [Property_8 in keyof T_13 as T_11[Property_7][Property_8] extends import('../types.ts').NonClientMiddleFn ? never : Property_8]: T_13[Property_8] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_13[Property_8]["handler"]>) => import('../types.ts').HSubRequest<T_13[Property_8]["handler"]> : T_13[Property_8] extends RemoteApi ? (T_13[Property_8] extends infer T_15 extends RemoteApi ? { [Property_9 in keyof T_15 as T_13[Property_8][Property_9] extends import('../types.ts').NonClientMiddleFn ? never : Property_9]: T_15[Property_9] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_15[Property_9]["handler"]>) => import('../types.ts').HSubRequest<T_15[Property_9]["handler"]> : T_15[Property_9] extends RemoteApi ? (T_15[Property_9] extends infer T_17 extends RemoteApi ? { [Property_10 in keyof T_17 as T_15[Property_9][Property_10] extends import('../types.ts').NonClientMiddleFn ? never : Property_10]: T_17[Property_10] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_17[Property_10]["handler"]>) => import('../types.ts').HSubRequest<T_17[Property_10]["handler"]> : T_17[Property_10] extends RemoteApi ? (T_17[Property_10] extends infer T_19 extends RemoteApi ? { [Property_11 in keyof T_19 as T_17[Property_10][Property_11] extends import('../types.ts').NonClientMiddleFn ? never : Property_11]: T_19[Property_11] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_19[Property_11]["handler"]>) => import('../types.ts').HSubRequest<T_19[Property_11]["handler"]> : T_19[Property_11] extends RemoteApi ? (T_19[Property_11] extends infer T_21 extends RemoteApi ? { [Property_12 in keyof T_21 as T_19[Property_11][Property_12] extends import('../types.ts').NonClientMiddleFn ? never : Property_12]: T_21[Property_12] extends import('@mionjs/router').PublicMiddleFn<any> | import('@mionjs/router').PublicHeadersFn<any> ? (...params: Parameters<T_21[Property_12]["handler"]>) => import('../types.ts').HSubRequest<T_21[Property_12]["handler"]> : T_21[Property_12] extends RemoteApi ? any : never; } : never) extends infer T_20 ? { [P_11 in keyof T_20]: T_20[P_11]; } : never : never; } : never) extends infer T_18 ? { [P_10 in keyof T_18]: T_18[P_10]; } : never : never; } : never) extends infer T_16 ? { [P_9 in keyof T_16]: T_16[P_9]; } : never : never; } : never) extends infer T_14 ? { [P_8 in keyof T_14]: T_14[P_8]; } : never : never; } : never) extends infer T_12 ? { [P_7 in keyof T_12]: T_12[P_7]; } : never : never; } : never) extends infer T_10 ? { [P_6 in keyof T_10]: T_10[P_6]; } : never : never; } : never) extends infer T_8 ? { [P_5 in keyof T_8]: T_8[P_5]; } : never : never; } : never) extends infer T_6 ? { [P_4 in keyof T_6]: T_6[P_4]; } : never : never; } : never) extends infer T_4 ? { [P_3 in keyof T_4]: T_4[P_3]; } : never : never; } : never) extends infer T_2 ? { [P_2 in keyof T_2]: T_2[P_2]; } : never : never; } extends infer T_1 ? { [P_1 in keyof T_1]: T_1[P_1]; } : never;
-};

package/.dist/esm/src/aot/loadClientAOTCaches.js

@@ -1,19 +0,0 @@
-import { addAOTCaches, addRoutesToCache } from "@mionjs/core";
-import { jitFnsCache } from "../../_virtual/jit-fns.js";
-import { pureFnsCache } from "../../_virtual/pure-fns.js";
-import { routerCache } from "../../_virtual/router-cache.js";
-import { initClient } from "../client.js";
-import { __ΩInitClientOptions as ___InitClientOptions } from "../types.js";
-function loadClientAotCaches() {
-  addAOTCaches(jitFnsCache, pureFnsCache), addRoutesToCache(routerCache);
-}
-loadClientAotCaches.__type = ["loadClientAotCaches", 'P"/!'];
-function initAOTClient(options) {
-  return loadClientAotCaches(), initClient.Ω = [["RemoteApi", '"w!']], initClient(options);
-}
-initAOTClient.__type = [() => ___InitClientOptions, "options", "initAOTClient", 'Pn!2""/#'];
-export {
-  initAOTClient,
-  loadClientAotCaches
-};
-//# sourceMappingURL=loadClientAOTCaches.js.map

package/.dist/esm/src/aot/loadClientAOTCaches.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadClientAOTCaches.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;"}

package/.dist/esm/src/clientMethodsMetadata.d.ts

@@ -1,10 +0,0 @@
-import { ClientOptions } from './types.ts';
-import { JitCompiledFnData, MethodsCache, PureFnsDataCache } from '@mionjs/core';
-export declare function fetchRemoteMethodsMetadata(methodIds: string[], options: ClientOptions): Promise<void>;
-export declare function storeDependencies(deps: Record<string, JitCompiledFnData>, pureFnDeps: PureFnsDataCache, options: ClientOptions): void;
-export declare function storeMethodsMetadata(methods: MethodsCache, options: ClientOptions): void;
-export declare function restoreAllDependencies(options: ClientOptions): void;
-export declare function getAOTCaches(): {
-    jitFnsCache: Record<string, any>;
-    pureFnsCache: Record<string, Record<string, any>>;
-};

package/.dist/esm/src/clientMethodsMetadata.js

@@ -1,162 +0,0 @@
-import { pureFnsCache, jitFnsCache } from "virtual:mion-aot/caches";
-import { MION_ROUTES, getRoutePath, isRpcError, RpcError, addSerializedJitCaches, isTestEnv, routesCache, addRoutesToCache } from "@mionjs/core";
-import { __ΩClientOptions as ___ClientOptions } from "./types.js";
-import { STORAGE_KEY } from "./constants.js";
-import { deserializeResponseBody } from "./serializer.js";
-import { getStorage } from "./storage.js";
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-function __assignType(fn, args) {
-  return fn.__type = args, fn;
-}
-async function fetchRemoteMethodsMetadata(methodIds, options) {
-  validateClientCaches(), restoreFromLocalStorage(methodIds, options);
-  const missingAfterLocal = methodIds.filter(__assignType((path) => !routesCache.hasMetadata(path), ["path", "", 'P"2!"/"']));
-  if (!missingAfterLocal.length)
-    return;
-  const shouldReturnAllMethods = !0, body = {
-    [MION_ROUTES.methodsMetadataById]: [missingAfterLocal, shouldReturnAllMethods]
-  };
-  try {
-    const path = getRoutePath([MION_ROUTES.methodsMetadataById], options), url = new URL(path, options.baseURL), response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    }), deserialized = await deserializeResponseBody(response), platformError = deserialized[MION_ROUTES.platformError], serializableMethodsData = deserialized[MION_ROUTES.methodsMetadataById];
-    if (isRpcError(platformError))
-      throw platformError;
-    if (isRpcError(serializableMethodsData))
-      throw serializableMethodsData;
-    if (!serializableMethodsData)
-      throw new RpcError({
-        type: "cant-fetch-remote-methods-metadata",
-        publicMessage: "Failed to fetch remote methods metadata",
-        errorData: { response }
-      });
-    storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options), storeMethodsMetadata(serializableMethodsData.methods, options), addToCaches(serializableMethodsData);
-  } catch (error) {
-    throw new Error(`Error fetching validation and serialization metadata: ${error?.message}`);
-  }
-}
-fetchRemoteMethodsMetadata.__type = ["methodIds", () => ___ClientOptions, "options", "fetchRemoteMethodsMetadata", 'P&F2!n"2#"/$'];
-function getSerializedMethodDataKey(methodId, options) {
-  return `${STORAGE_KEY}:serialized-method-data:${options.baseURL}:${methodId}`;
-}
-getSerializedMethodDataKey.__type = ["methodId", () => ___ClientOptions, "options", "getSerializedMethodDataKey", 'P&2!n"2#"/$'];
-function getJitCompiledFnKey(jitFnHash, options) {
-  return `${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:${jitFnHash}`;
-}
-getJitCompiledFnKey.__type = ["jitFnHash", () => ___ClientOptions, "options", "getJitCompiledFnKey", 'P&2!n"2#"/$'];
-function getJitPureFnKey(namespace, pureFnHash, options) {
-  return `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:${namespace}:${pureFnHash}`;
-}
-getJitPureFnKey.__type = ["namespace", "pureFnHash", () => ___ClientOptions, "options", "getJitPureFnKey", 'P&2!&2"n#2$"/%'];
-function storeDependencies(deps, pureFnDeps, options) {
-  Object.entries(deps).forEach(__assignType(([hash, jitFnData]) => {
-    const key = getJitCompiledFnKey(hash, options);
-    try {
-      getStorage().setItem(key, JSON.stringify(jitFnData));
-    } catch (error) {
-      console.warn(`Failed to store JIT function dependency ${hash}:`, error);
-    }
-  }, ["JitCompiledFnData", "param0", "", 'PP&"w!G2""/#'])), Object.entries(pureFnDeps).forEach(__assignType(([namespace, nsPureFns]) => {
-    Object.entries(nsPureFns).forEach(__assignType(([fnHash, pureFnData]) => {
-      const key = getJitPureFnKey(namespace, fnHash, options);
-      try {
-        getStorage().setItem(key, JSON.stringify(pureFnData));
-      } catch (error) {
-        console.warn(`Failed to store pure function dependency ${namespace}::${fnHash}:`, error);
-      }
-    }, ["PureFunctionData", "param0", "", 'PP&"w!G2""/#']));
-  }, ["param0", "", 'P"2!"/"']));
-}
-storeDependencies.__type = [() => __ΩRecord, "JitCompiledFnData", "deps", "PureFnsDataCache", "pureFnDeps", () => ___ClientOptions, "options", "storeDependencies", `P&"w"o!#2#"w$2%n&2'"/(`];
-function storeMethodsMetadata(methods, options) {
-  Object.entries(methods).forEach(__assignType(([methodId, methodData]) => {
-    const key = getSerializedMethodDataKey(methodId, options);
-    try {
-      getStorage().setItem(key, JSON.stringify(methodData));
-    } catch (error) {
-      console.warn(`Failed to store method metadata ${methodId}:`, error);
-    }
-  }, ["param0", "", 'P"2!"/"']));
-}
-storeMethodsMetadata.__type = ["MethodsCache", "methods", () => ___ClientOptions, "options", "storeMethodsMetadata", 'P"w!2"n#2$"/%'];
-function restoreAllDependencies(options) {
-  const deps = {}, pureFnDeps = {}, pureFnKeyPrefix = `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:`;
-  for (let i = 0; i < getStorage().length; i++) {
-    const key = getStorage().key(i);
-    if (key?.startsWith(`${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:`))
-      try {
-        const data = getStorage().getItem(key);
-        if (data) {
-          const parsedData = JSON.parse(data);
-          deps[parsedData.jitFnHash] = parsedData;
-        }
-      } catch (error) {
-        console.warn(`Failed to restore JIT function from key ${key}:`, error);
-      }
-  }
-  for (let i = 0; i < getStorage().length; i++) {
-    const key = getStorage().key(i);
-    if (key?.startsWith(pureFnKeyPrefix))
-      try {
-        const data = getStorage().getItem(key);
-        if (data) {
-          const parsedData = JSON.parse(data), namespace = key.slice(pureFnKeyPrefix.length).split(":")[0] || parsedData.namespace;
-          pureFnDeps[namespace] || (pureFnDeps[namespace] = {}), pureFnDeps[namespace][parsedData.fnName] = parsedData;
-        }
-      } catch (error) {
-        console.warn(`Failed to restore pure function from key ${key}:`, error);
-      }
-  }
-  (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) && addSerializedJitCaches(deps, pureFnDeps);
-}
-restoreAllDependencies.__type = [() => ___ClientOptions, "options", "restoreAllDependencies", 'Pn!2""/#'];
-function restoreFromLocalStorage(methodIds, options) {
-  restoreAllDependencies(options);
-  const methods = {};
-  let anyMethodsRestored = !1;
-  methodIds.forEach(__assignType((id) => {
-    if (routesCache.hasMetadata(id))
-      return;
-    const methodKey = getSerializedMethodDataKey(id, options), methodMetaJson = getStorage().getItem(methodKey);
-    if (methodMetaJson)
-      try {
-        const methodMeta = JSON.parse(methodMetaJson);
-        methods[id] = methodMeta, anyMethodsRestored = !0;
-      } catch (error) {
-        console.warn(`Failed to restore method metadata for ${id}:`, error), getStorage().removeItem(methodKey);
-      }
-  }, ["id", "", 'P"2!"/"'])), anyMethodsRestored && addToCaches({
-    methods,
-    deps: {},
-    purFnDeps: {}
-  });
-}
-restoreFromLocalStorage.__type = ["methodIds", () => ___ClientOptions, "options", "restoreFromLocalStorage", 'P&F2!n"2#"/$'];
-function addToCaches(serializableMethodsData) {
-  addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps), addRoutesToCache(serializableMethodsData.methods);
-}
-addToCaches.__type = ["SerializableMethodsData", "serializableMethodsData", "addToCaches", 'P"w!2""/#'];
-function getAOTCaches() {
-  return { jitFnsCache, pureFnsCache };
-}
-getAOTCaches.__type = ["getAOTCaches", 'P"/!'];
-let clientCachesValidated = !1;
-function validateClientCaches() {
-  if (clientCachesValidated || isTestEnv())
-    return;
-  clientCachesValidated = !0;
-  const missingRoutes = Object.values(MION_ROUTES).filter(__assignType((routeId) => !routesCache.hasMetadata(routeId), ["routeId", "", 'P"2!"/"']));
-  if (missingRoutes.length > 0)
-    throw new Error(`AOT cache not loaded: Required MION_ROUTES not found in router cache: ${missingRoutes.join(", ")}. Make sure to import '@mionjs/client/aot' or 'virtual:mion-aot/caches' before using the client.`);
-}
-validateClientCaches.__type = ["validateClientCaches", 'P"/!'];
-export {
-  fetchRemoteMethodsMetadata,
-  getAOTCaches,
-  restoreAllDependencies,
-  storeDependencies,
-  storeMethodsMetadata
-};
-//# sourceMappingURL=clientMethodsMetadata.js.map

package/.dist/esm/src/clientMethodsMetadata.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientMethodsMetadata.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/handlersRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlersRegistry.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/serializer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/storage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/testUtils.js

@@ -1,48 +0,0 @@
-import { MION_ROUTES, routesCache, resetJitFnCaches, resetJitFunctionsCache, addAOTCaches, getJitFnHashes } from "@mionjs/core";
-import { getAOTCaches } from "./clientMethodsMetadata.js";
-function resetClientCaches() {
-  const { jitFnsCache, pureFnsCache } = getAOTCaches(), mionRouteIds = new Set(Object.values(MION_ROUTES)), cache = routesCache.getCache();
-  for (const key in cache)
-    mionRouteIds.has(key) || delete cache[key];
-  resetJitFnCaches(), resetJitFunctionsCache();
-  const neededJitHashes = (Set.Ω = [["&"]], /* @__PURE__ */ new Set()), neededPureFnKeys = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
-  for (const routeId of mionRouteIds) {
-    const meta = routesCache.getMetadata(routeId);
-    meta && (collectJitDepsFromParentHash(meta.paramsJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), collectJitDepsFromParentHash(meta.returnJitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), meta.headersParam && collectJitDepsFromParentHash(meta.headersParam.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache), meta.headersReturn && collectJitDepsFromParentHash(meta.headersReturn.jitHash, neededJitHashes, neededPureFnKeys, jitFnsCache));
-  }
-  const filteredJitFns = {};
-  for (const hash of neededJitHashes)
-    hash in jitFnsCache && (filteredJitFns[hash] = jitFnsCache[hash]);
-  const filteredPureFns = {};
-  for (const key of neededPureFnKeys) {
-    const [ns, fnHash] = key.split("::");
-    pureFnsCache[ns]?.[fnHash] && (filteredPureFns[ns] || (filteredPureFns[ns] = {}), filteredPureFns[ns][fnHash] = pureFnsCache[ns][fnHash]);
-  }
-  (Object.keys(filteredJitFns).length > 0 || Object.keys(filteredPureFns).length > 0) && addAOTCaches(filteredJitFns, filteredPureFns);
-}
-resetClientCaches.__type = ["resetClientCaches", 'P"/!'];
-function collectJitDepsFromParentHash(parentHash, jitHashes, pureFnKeys, jitFnsCache) {
-  if (!parentHash)
-    return;
-  const hashes = getJitFnHashes(parentHash);
-  for (const individualHash of Object.values(hashes))
-    collectJitDeps(individualHash, jitHashes, pureFnKeys, jitFnsCache);
-}
-collectJitDepsFromParentHash.__type = ["parentHash", "jitHashes", "pureFnKeys", "PersistedJitFunctionsCache", "jitFnsCache", "collectJitDepsFromParentHash", 'P&2!&D2"&D2#"w$2%"/&'];
-function collectJitDeps(hash, jitHashes, pureFnKeys, jitFnsCache) {
-  if (!hash || jitHashes.has(hash))
-    return;
-  jitHashes.add(hash);
-  const entry = jitFnsCache[hash];
-  if (entry) {
-    for (const dep of entry.jitDependencies)
-      collectJitDeps(dep, jitHashes, pureFnKeys, jitFnsCache);
-    for (const pureDep of entry.pureFnDependencies)
-      pureFnKeys.add(pureDep);
-  }
-}
-collectJitDeps.__type = ["hash", "jitHashes", "pureFnKeys", "PersistedJitFunctionsCache", "jitFnsCache", "collectJitDeps", 'P&2!&D2"&D2#"w$2%"/&'];
-export {
-  resetClientCaches
-};
-//# sourceMappingURL=testUtils.js.map

package/.dist/esm/src/testUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"testUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/typedEvent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typedEvent.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/validation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}