@mionjs/client 0.8.0-alpha.0

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

@@ -0,0 +1,152 @@
+import { RpcError, CoreRouterOptions, Prettify, RunTypeError, SerializerMode, ValidationError } from '@mionjs/core';
+import { PublicHeadersFn, PublicMiddleFn, RemoteApi, PublicRoute } from '@mionjs/router';
+import { TypedEvent } from './typedEvent.ts';
+export type Result<RouteSuccess, RouteError, MiddleFnsResults extends Record<string, unknown> = Record<string, unknown>, MiddleFnsErrors extends Record<string, RpcError<string, unknown>> = Record<string, RpcError<string, unknown>>> = [RouteSuccess | undefined, RouteError | undefined, MiddleFnsResults | undefined, MiddleFnsErrors | undefined];
+export type MiddleFnSuccess<H> = H extends HSubRequest<infer PH> ? HandlerSuccessResponse<PH> : never;
+export type MiddleFnError<H> = H extends HSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> : never;
+export type CallWithMiddleFnsResult<RouteSuccess, RouteError, MiddleFns extends Record<string, HSubRequest<any>>> = [
+    RouteSuccess | undefined,
+    RouteError | ValidationError | undefined,
+    {
+        [K in keyof MiddleFns]?: MiddleFnSuccess<MiddleFns[K]>;
+    } | undefined,
+    {
+        [K in keyof MiddleFns]?: MiddleFnError<MiddleFns[K]>;
+    } | undefined
+];
+export type WorkflowResult<Routes extends RSubRequest<any>[], MiddleFns extends Record<string, HSubRequest<any>> = Record<string, HSubRequest<any>>> = [
+    WorkflowRouteResults<Routes>,
+    WorkflowRouteErrors<Routes>,
+    {
+        [K in keyof MiddleFns]?: MiddleFnSuccess<MiddleFns[K]>;
+    } | undefined,
+    {
+        [K in keyof MiddleFns]?: MiddleFnError<MiddleFns[K]>;
+    } | undefined
+];
+export type WorkflowRouteResults<Routes extends RSubRequest<any>[]> = {
+    [K in keyof Routes]: Routes[K] extends RSubRequest<infer PH> ? HandlerSuccessResponse<PH> | undefined : never;
+};
+export type WorkflowRouteErrors<Routes extends RSubRequest<any>[]> = {
+    [K in keyof Routes]: Routes[K] extends RSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> | undefined : never;
+};
+export interface ClientOptions extends CoreRouterOptions {
+    baseURL: string;
+    basePath: string;
+    suffix: string;
+    autoGenerateErrorId: boolean;
+    fetchOptions: RequestInit;
+    validateParams: boolean;
+    serializer: SerializerMode;
+}
+type PublicHandler = (...args: any[]) => Promise<any>;
+type PublicMethod = PublicRoute | PublicMiddleFn | PublicHeadersFn;
+type ExtractHandler<PM extends PublicMethod> = PM extends {
+    handler: infer H;
+} ? H : never;
+export type InitClientOptions = Partial<ClientOptions> & {
+    baseURL: string;
+};
+export type RequestHeaders = {
+    [key: string]: string;
+};
+export type RequestBody = {
+    [key: string]: any[];
+};
+export type RouteParamsType<PM extends PublicMethod> = Parameters<ExtractHandler<PM>>;
+export type RouteParamType<PM extends PublicMethod, Index extends number> = Parameters<ExtractHandler<PM>>[Index];
+export type HeadersParamsType<PM extends PublicHeadersFn> = Parameters<ExtractHandler<PM>>[0];
+export type RouteReturnType<PM extends PublicMethod> = HandlerSuccessResponse<ExtractHandler<PM>>;
+export type HandlerResponse<PH extends PublicHandler> = Awaited<ReturnType<PH>>;
+export type HandlerSuccessResponse<PH extends PublicHandler> = Exclude<HandlerResponse<PH>, RpcError<string>>;
+export type HandlerFailResponse<PH extends PublicHandler> = Extract<HandlerResponse<PH>, RpcError<string>>;
+export type SuccessResponse<MR extends SubRequest<any>> = Required<MR>['resolvedValue'];
+export type SuccessResponses<List extends SubRequest<any>[]> = {
+    [P in keyof List]: SuccessResponse<List[P]>;
+};
+export type FailResponse<MR extends SubRequest<any>> = Required<MR>['error'];
+export type FailResponses<List extends SubRequest<any>[]> = {
+    [P in keyof List]: FailResponse<List[P]>;
+};
+export type RequestErrors = Map<string, RpcError<string>>;
+export type ErrorHandler<E extends RpcError<string, any>> = (error: E) => void;
+export type UnknownErrorHandler = (error: RpcError<string, any>) => void;
+export type SuccessHandler<S> = (result: S) => void;
+type Simplify<T> = T extends any ? T : never;
+export type HandlerErrors<PH extends (...args: any[]) => Promise<any>> = Simplify<Extract<HandlerResponse<PH>, RpcError<string, any>> | ValidationError>;
+export interface SubRequest<PH extends PublicHandler> {
+    pointer: string[];
+    id: string;
+    isResolved: boolean;
+    params: Parameters<PH>;
+    resolvedValue?: HandlerSuccessResponse<PH>;
+    error?: HandlerFailResponse<PH>;
+    serializedParams?: any[];
+}
+export interface RSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
+    typeErrors: () => Promise<RunTypeError[]>;
+    call: () => Promise<Result<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, Record<string, unknown>, Record<string, RpcError<string, unknown> | ValidationError>>>;
+    callWithMiddleFns: <H extends Record<string, HSubRequest<any>>>(middleFns: H) => Promise<CallWithMiddleFnsResult<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, H>>;
+    callWithWorkflow: <OtherRoutes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(otherRoutes: [...OtherRoutes], middleFns?: H) => Promise<WorkflowResult<any, H>>;
+}
+export interface HSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
+    typeErrors: () => Promise<RunTypeError[]>;
+    prefill: () => TypedEvent<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>>;
+    removePrefill: () => Promise<void>;
+}
+export type NonClientRoute = never | PublicMiddleFn | PublicHeadersFn;
+export type ClientRoutes<RA extends RemoteApi> = Prettify<{
+    [Property in keyof RA as RA[Property] extends NonClientRoute ? never : Property]: RA[Property] extends PublicRoute ? (...params: Parameters<RA[Property]['handler']>) => RSubRequest<RA[Property]['handler']> : RA[Property] extends RemoteApi ? ClientRoutes<RA[Property]> : never;
+}>;
+export type NonClientMiddleFn = never | PublicRoute | {
+    [key: string]: PublicRoute;
+};
+export type ClientMiddleFns<RA extends RemoteApi> = Prettify<{
+    [Property in keyof RA as RA[Property] extends NonClientMiddleFn ? never : Property]: RA[Property] extends PublicMiddleFn | PublicHeadersFn ? (...params: Parameters<RA[Property]['handler']>) => HSubRequest<RA[Property]['handler']> : RA[Property] extends RemoteApi ? ClientMiddleFns<RA[Property]> : never;
+}>;
+export type Cleaned<RMS extends RemoteApi> = {
+    [Property in keyof RMS as RMS[Property] extends never ? never : Property]: RMS[Property];
+};
+export type SuccessClientResponse<RS extends RSubRequest<any>, RHList extends HSubRequest<any>[]> = [
+    SuccessResponse<RS>,
+    ...SuccessResponses<RHList>
+];
+export type PrefilledMiddleFnsCache = Map<string, SubRequest<any>>;
+export {};
+export declare type __ΩResult = any[];
+export declare type __ΩMiddleFnSuccess = any[];
+export declare type __ΩMiddleFnError = any[];
+export declare type __ΩCallWithMiddleFnsResult = any[];
+export declare type __ΩWorkflowResult = any[];
+export declare type __ΩWorkflowRouteResults = any[];
+export declare type __ΩWorkflowRouteErrors = any[];
+export declare type __ΩClientOptions = any[];
+export declare type __ΩInitClientOptions = any[];
+export declare type __ΩRequestHeaders = any[];
+export declare type __ΩRequestBody = any[];
+export declare type __ΩRouteParamsType = any[];
+export declare type __ΩRouteParamType = any[];
+export declare type __ΩHeadersParamsType = any[];
+export declare type __ΩRouteReturnType = any[];
+export declare type __ΩHandlerResponse = any[];
+export declare type __ΩHandlerSuccessResponse = any[];
+export declare type __ΩHandlerFailResponse = any[];
+export declare type __ΩSuccessResponse = any[];
+export declare type __ΩSuccessResponses = any[];
+export declare type __ΩFailResponse = any[];
+export declare type __ΩFailResponses = any[];
+export declare type __ΩRequestErrors = any[];
+export declare type __ΩErrorHandler = any[];
+export declare type __ΩUnknownErrorHandler = any[];
+export declare type __ΩSuccessHandler = any[];
+export declare type __ΩHandlerErrors = any[];
+export declare type __ΩSubRequest = any[];
+export declare type __ΩRSubRequest = any[];
+export declare type __ΩHSubRequest = any[];
+export declare type __ΩNonClientRoute = any[];
+export declare type __ΩClientRoutes = any[];
+export declare type __ΩNonClientMiddleFn = any[];
+export declare type __ΩClientMiddleFns = any[];
+export declare type __ΩCleaned = any[];
+export declare type __ΩSuccessClientResponse = any[];
+export declare type __ΩPrefilledMiddleFnsCache = any[];

package/.dist/esm/src/types.js

@@ -0,0 +1,42 @@
+import { RpcError } from "@mionjs/core";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`], __ΩPartial = ["T", "Partial", 'l+e#!e"!fRb!Pde"!gN#"w"y'], __ΩParameters = ["T", "args", "", "Parameters", `l>e"!R!RPde#!Ph"!@2""/#qk#'QRb!Pde"!p)w$y`], __ΩAwaited = ["T", "onfulfilled", "args", "then", "value", "", 0, "Awaited", `lŒe$!Re"!o'"R!RPde#!Ph"!2%h&"@2#"/&qk'.QRPde#!p0Re$!RPdde#!P%PPh$!2"h$"@2#"1$MKqkJRQRPde%!pVRPe#!P,-Jqk#vQRb!Pde"!p~w(y`], __ΩReturnType = ["T", "args", "", "ReturnType", `l>e"!R"RPde#!P"@2"h"!/#qk#'QRb!Pde"!p)w$y`], __ΩExclude = ["T", "U", "Exclude", 'l6!Re$!RPe#!e$"qk#%QRb!b"Pde"!p)w#y'], __ΩExtract = ["T", "U", "Extract", `l6e$!R!RPe#!e$"qk#'QRb!b"Pde"!p)w#y`], __ΩRequired = ["T", "Required", 'l+e#!e"!fRb!Pde"!gN##w"y'], __ΩResult = ["RouteSuccess", "RouteError", () => __ΩRecord, "MiddleFnsResults", () => __ΩRecord, () => RpcError, "MiddleFnsErrors", "Result", `b!b"&#o##c$&P&#7&o%#c'PPe#!-JPe#"-JPe##-JPe#$-JGw(y`], __ΩMiddleFnSuccess = ["H", () => __ΩHSubRequest, () => __ΩHandlerSuccessResponse, "MiddleFnSuccess", 'l=e"!o#"R!RPde#!h!!o""qk#*QRb!Pde"!p,w$y'], __ΩMiddleFnError = ["H", () => __ΩHSubRequest, () => __ΩSimplify, () => __ΩHandlerErrors, "MiddleFnError", 'l@e"!o$"o#"R!RPde#!h!!o""qk#-QRb!Pde"!p/w%y'], __ΩCallWithMiddleFnsResult = ["RouteSuccess", "RouteError", "MiddleFns", "ValidationError", () => __ΩMiddleFnSuccess, () => __ΩMiddleFnError, "CallWithMiddleFnsResult", `l9e%#e"!fo%"Re%#e"!fo&"Rb!b"b#PPe#!-JPe#""w$-JPPde$#gN#"-JPPde$#gN."-JGw'y`], __ΩWorkflowResult = ["Routes", () => __ΩRecord, () => __ΩHSubRequest, "MiddleFns", () => __ΩWorkflowRouteResults, () => __ΩWorkflowRouteErrors, () => __ΩMiddleFnSuccess, () => __ΩMiddleFnError, "WorkflowResult", `l9e%"e"!fo'"Re%"e"!fo("Rb!&"o#"o"#c$Pe"!o%"e"!o&"PPde$"gN#"-JPPde$"gN."-JGw)y`], __ΩWorkflowRouteResults = ["Routes", () => __ΩRSubRequest, () => __ΩHandlerSuccessResponse, "WorkflowRouteResults", 'lDPe#!o#"-JR!RPde$!e#!fh!!o""qk#-QRb!Pde"!gN/!w$y'], __ΩWorkflowRouteErrors = ["Routes", () => __ΩRSubRequest, () => __ΩSimplify, () => __ΩHandlerErrors, "WorkflowRouteErrors", 'lGPe#!o$"o#"-JR!RPde$!e#!fh!!o""qk#0QRb!Pde"!gN2!w%y'], __ΩClientOptions = ["CoreRouterOptions", "baseURL", "basePath", "suffix", "autoGenerateErrorId", "fetchOptions", "validateParams", "SerializerMode", "serializer", "ClientOptions", `P"w!&4"&4#&4$)4%!4&)4'"w(4)Mw*y`], __ΩExtractHandler = ["PM", "handler", "ExtractHandler", `l;e"!R!RPde#!Ph"!4"Mqk#'QRb!Pde"!p)w#y`], __ΩInitClientOptions = [() => __ΩPartial, () => __ΩClientOptions, "baseURL", "InitClientOptions", 'Pn"o!"P&4#MKw$y'], __ΩRequestHeaders = ["RequestHeaders", "P&&LMw!y"], __ΩRequestBody = ["RequestBody", 'P&"FLMw!y'], __ΩRouteParamsType = ["PM", () => __ΩParameters, () => __ΩExtractHandler, "RouteParamsType", 'b!e!!o#"o""w$y'], __ΩRouteParamType = ["PM", "Index", () => __ΩParameters, () => __ΩExtractHandler, "RouteParamType", 'b!b"e!!o$"o#"e!"fw%y'], __ΩHeadersParamsType = ["PM", () => __ΩParameters, () => __ΩExtractHandler, 0, "HeadersParamsType", 'b!e!!o#"o"".$fw%y'], __ΩRouteReturnType = ["PM", () => __ΩHandlerSuccessResponse, () => __ΩExtractHandler, "RouteReturnType", 'b!e!!o#"o""w$y'], __ΩHandlerResponse = ["PH", () => __ΩAwaited, () => __ΩReturnType, "HandlerResponse", 'b!e!!o#"o""w$y'], __ΩHandlerSuccessResponse = ["PH", () => __ΩExclude, () => __ΩHandlerResponse, () => RpcError, "HandlerSuccessResponse", 'b!e!!o#"P&7$o"#w%y'], __ΩHandlerFailResponse = ["PH", () => __ΩExtract, () => __ΩHandlerResponse, () => RpcError, "HandlerFailResponse", 'b!e!!o#"P&7$o"#w%y'], __ΩSuccessResponse = ["MR", () => __ΩRequired, "resolvedValue", "SuccessResponse", 'b!e!!o"".#fw$y'], __ΩSuccessResponses = ["List", () => __ΩSuccessResponse, "SuccessResponses", 'l.e#!e"!fo""Rb!Pde"!gN#!w#y'], __ΩFailResponse = ["MR", () => __ΩRequired, "error", "FailResponse", 'b!e!!o"".#fw$y'], __ΩFailResponses = ["List", () => __ΩFailResponse, "FailResponses", 'l.e#!e"!fo""Rb!Pde"!gN#!w#y'], __ΩRequestErrors = [() => RpcError, "RequestErrors", '&P&7!Ew"y'], __ΩErrorHandler = ["E", "error", "", "ErrorHandler", 'b!Pe"!2"$/#w$y'], __ΩUnknownErrorHandler = [() => RpcError, "error", "", "UnknownErrorHandler", 'PP&"7!2"$/#w$y'], __ΩSuccessHandler = ["S", "result", "", "SuccessHandler", 'b!Pe"!2"$/#w$y'], __ΩSimplify = ["T", "Simplify", `l4e$!R!RPe#!"qk#'QRb!Pde"!p)w"y`], __ΩHandlerErrors = ["PH", () => __ΩSimplify, () => __ΩExtract, () => __ΩHandlerResponse, () => RpcError, "ValidationError", "HandlerErrors", `b!Pe"!o$"P&"7%o##"w&Jo""w'y`], __ΩSubRequest = ["PH", "pointer", "id", "isResolved", () => __ΩParameters, "params", () => __ΩHandlerSuccessResponse, "resolvedValue", () => __ΩHandlerFailResponse, "error", "serializedParams", "SubRequest", `b!P&F4"&4#)4$e"!o%"4&e"!o'"4(8e"!o)"4*8"F4+8Mw,y`], __ΩRSubRequest = ["PH", () => __ΩSubRequest, "RunTypeError", "", "typeErrors", () => __ΩResult, () => __ΩHandlerSuccessResponse, () => __ΩSimplify, () => __ΩHandlerErrors, () => __ΩRecord, () => __ΩRecord, () => RpcError, "ValidationError", "call", "middleFns", () => __ΩCallWithMiddleFnsResult, () => __ΩHandlerSuccessResponse, () => __ΩSimplify, () => __ΩHandlerErrors, "callWithMiddleFns", "otherRoutes", () => __ΩWorkflowResult, "callWithWorkflow", "RSubRequest", 'b!Pe"!o""P"w#F`/$4%Pe#!o\'"e#!o)"o("&#o*#&PP&#7,"w-Jo+#o&%`/$4.P"2/e#!o1"e#!o3"o2""o0$`/$44PP"@G25"2/8""o6#`/$47Mw8y'], __ΩHSubRequest = ["PH", () => __ΩSubRequest, "RunTypeError", "", "typeErrors", "TypedEvent", "prefill", "removePrefill", "HSubRequest", 'b!Pe"!o""P"w#F`/$4%P"w&/$4\'P$`/$4(Mw)y'], __ΩNonClientRoute = ["PublicMiddleFn", "PublicHeadersFn", "NonClientRoute", 'P!"w!"w"Jw#y'], __ΩClientRoutes = ["RA", "Prettify", "ClientRoutes", 'b!"w"w#y'], __ΩNonClientMiddleFn = ["PublicRoute", "NonClientMiddleFn", 'P!"w!P&"w!LMJw"y'], __ΩClientMiddleFns = ["RA", "Prettify", "ClientMiddleFns", 'b!"w"w#y'], __ΩCleaned = ["RMS", "Cleaned", 'lA!Re%!RPe$!e#!fPe%!e$!f!qk#%QGRb!Pde"!gt)!w"y'], __ΩSuccessClientResponse = ["RS", "RHList", () => __ΩSuccessResponse, () => __ΩSuccessResponses, "SuccessClientResponse", 'b!b"Pe"!o#"e""o$"@Gw%y'], __ΩPrefilledMiddleFnsCache = [() => __ΩSubRequest, "PrefilledMiddleFnsCache", '&"o!"Ew"y'];
+export {
+  __ΩCallWithMiddleFnsResult,
+  __ΩCleaned,
+  __ΩClientMiddleFns,
+  __ΩClientOptions,
+  __ΩClientRoutes,
+  __ΩErrorHandler,
+  __ΩFailResponse,
+  __ΩFailResponses,
+  __ΩHSubRequest,
+  __ΩHandlerErrors,
+  __ΩHandlerFailResponse,
+  __ΩHandlerResponse,
+  __ΩHandlerSuccessResponse,
+  __ΩHeadersParamsType,
+  __ΩInitClientOptions,
+  __ΩMiddleFnError,
+  __ΩMiddleFnSuccess,
+  __ΩNonClientMiddleFn,
+  __ΩNonClientRoute,
+  __ΩPrefilledMiddleFnsCache,
+  __ΩRSubRequest,
+  __ΩRequestBody,
+  __ΩRequestErrors,
+  __ΩRequestHeaders,
+  __ΩResult,
+  __ΩRouteParamType,
+  __ΩRouteParamsType,
+  __ΩRouteReturnType,
+  __ΩSubRequest,
+  __ΩSuccessClientResponse,
+  __ΩSuccessHandler,
+  __ΩSuccessResponse,
+  __ΩSuccessResponses,
+  __ΩUnknownErrorHandler,
+  __ΩWorkflowResult,
+  __ΩWorkflowRouteErrors,
+  __ΩWorkflowRouteResults
+};
+//# sourceMappingURL=types.js.map

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

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

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

@@ -0,0 +1,4 @@
+import { RequestErrors, SubRequest } from './types.ts';
+import { MionClientRequest } from './request.ts';
+export declare function validateSubRequests(subRequestIds: string[], req: MionClientRequest<any, any>, errors: RequestErrors, validateRouteMiddleFns?: boolean): void;
+export declare function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void;

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

@@ -0,0 +1,57 @@
+import { routesCache, RpcError } from "@mionjs/core";
+import { __ΩRequestErrors as ___RequestErrors, __ΩSubRequest as ___SubRequest } from "./types.js";
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+function validateSubRequests(subRequestIds, req, errors, validateRouteMiddleFns = !0) {
+  req.options.validateParams && subRequestIds.forEach(__assignType((id) => {
+    const subRequest = req.subRequestList[id];
+    validateSubRequest(id, subRequest, errors);
+    const methodMeta = routesCache.getMetadata(id);
+    if (validateRouteMiddleFns && methodMeta?.middleFnIds?.length) {
+      const validMiddleFnIds = methodMeta.middleFnIds.filter(__assignType((middleFnId) => middleFnId != null, ["middleFnId", "", 'P"2!"/"']));
+      validateSubRequests(validMiddleFnIds, req, errors, validateRouteMiddleFns);
+    }
+  }, ["id", "", 'P"2!"/"']));
+}
+validateSubRequests.__type = ["subRequestIds", "MionClientRequest", "req", () => ___RequestErrors, "errors", "validateRouteMiddleFns", "validateSubRequests", `P&F2!"w"2#n$2%"2&$/'`];
+function validateSubRequest(id, subRequest, errors) {
+  if (subRequest?.error || subRequest?.isResolved)
+    return;
+  const mappings = subRequest?.mappings;
+  if (Array.isArray(mappings) && mappings.length > 0)
+    return;
+  const params = subRequest?.params || [], validationResponse = getTypeErrors(id, params);
+  if (!validationResponse)
+    return;
+  const error = validationResponse;
+  errors.set(id, error), subRequest && (subRequest.error = error, subRequest.isResolved = !0);
+}
+validateSubRequest.__type = ["id", () => ___SubRequest, "subRequest", () => ___RequestErrors, "errors", "validateSubRequest", 'P&2!"o""2#n$2%$/&'];
+function getTypeErrors(id, params) {
+  const method = routesCache.useMethodJitFns(id);
+  if (!method.paramNames || method.paramNames.length === 0)
+    return;
+  const paramsJit = method.paramsJitFns;
+  if (!paramsJit.typeErrors.isNoop)
+    try {
+      const validationsResponse = paramsJit.isType.fn(params) || paramsJit.typeErrors.fn(params);
+      if (validationsResponse?.length)
+        return new RpcError({
+          type: "validation-error",
+          publicMessage: `Invalid params for Route or MiddleFn '${method.id}', validation failed.`,
+          errorData: validationsResponse
+        });
+    } catch (e) {
+      return new RpcError({
+        type: "unexpected-validation-error",
+        publicMessage: `Could not validate params for Route or MiddleFn '${method.id}': ${e.message} `
+      });
+    }
+}
+getTypeErrors.__type = ["id", "params", "validation-error", "unexpected-validation-error", () => RpcError, "getTypeErrors", 'P&2!"F2"P$PP.#.$J7%J/&'];
+export {
+  validateSubRequest,
+  validateSubRequests
+};
+//# sourceMappingURL=validation.js.map

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

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
+    <img alt='mion, a mikro kit for Typescript Serverless APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
+  </picture>
+</p>
+<p align="center">
+  <strong>Fully typed client for mion APIs
+  </strong>
+</p>
+<p align=center>
+  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+  <img src="https://img.shields.io/badge/license-MIT-97ca00.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+</p>
+
+# `@mionjs/client`
+
+Modern client for mion APIs:
+
+- Strongly typed apis with autocompletion ans static type checking.
+- Fully typed list of remote methods with it's parameters and return values.
+- Automattic Validation and Serialization out of the box.
+- Local Validation (no need to make a server request to validate parameters)
+- Prefill request data to persist across multiple calls.
+- No compilation needed
+
+## Check Out The [Website And Documentation](http://mion.io) 📚
+
+[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+
+---
+
+_[MIT](../../LICENSE) LICENSE_

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@mionjs/client",
+  "version": "0.8.0-alpha.0",
+  "type": "module",
+  "description": "Browser client for mion Apps.",
+  "keywords": [
+    "typescript",
+    "API",
+    "RPC",
+    "json",
+    "schema",
+    "generate",
+    "server",
+    "serverless",
+    "framework",
+    "node"
+  ],
+  "author": "ma jerez",
+  "homepage": "https://mion.io/",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "source": "./index.ts",
+      "types": "./.dist/esm/index.d.ts",
+      "require": "./.dist/cjs/index.cjs",
+      "default": "./.dist/esm/index.js"
+    },
+    "./aot": {
+      "source": "./src/aot/loadClientAOTCaches.ts",
+      "types": "./.dist/esm/src/aot/loadClientAOTCaches.d.ts",
+      "require": "./.dist/cjs/src/aot/loadClientAOTCaches.cjs",
+      "default": "./.dist/esm/src/aot/loadClientAOTCaches.js"
+    }
+  },
+  "directories": {
+    "lib": ".dist"
+  },
+  "files": [
+    ".dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MionKit/mion.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run && npm run test:e2e:ssr",
+    "test:e2e:ssr": "node --experimental-strip-types src/aot/aotSSR.e2e.test.ts",
+    "dev": "vite build --watch",
+    "dev:test": "vitest watch",
+    "lint": "npx eslint src",
+    "format": "prettier --write src/**/*.ts",
+    "build": "vite build",
+    "clean": "rimraf .dist & rimraf .coverage",
+    "fresh-start": "npm run clean && rimraf node_modules",
+    "run-test-server": "ts-node --project test/tsconfig.json test/test-server.ts"
+  },
+  "bugs": {
+    "url": "https://github.com/MionKit/mion/issues"
+  },
+  "gitHead": "5d2ec524ba39d040338ce8946d8edf78aa7291a3",
+  "devDependencies": {
+    "@mionjs/platform-node": "^0.8.0-alpha.0",
+    "@mionjs/router": "^0.8.0-alpha.0",
+    "@mionjs/run-types": "^0.8.0-alpha.0",
+    "@mionjs/test-server": "^0.7.2",
+    "jest-environment-jsdom": "^29.6.2"
+  },
+  "dependencies": {
+    "@mionjs/core": "^0.8.0-alpha.0"
+  }
+}