@orpc/shared 0.0.0-next.31590a1 → 0.0.0-next.32cb70c

package/dist/index.js

@@ -22,19 +22,6 @@ function toError(error) {
   return new Error("Unknown error", { cause: error });
 }
 
-// src/function.ts
-function once(fn) {
-  let cached;
-  return () => {
-    if (cached) {
-      return cached.result;
-    }
-    const result = fn();
-    cached = { result };
-    return result;
-  };
-}
-
 // src/hook.ts
 async function executeWithHooks(options) {
   const interceptors = convertToArray(options.hooks?.interceptor);
@@ -54,8 +41,8 @@ async function executeWithHooks(options) {
     }
     let state = { status: "pending", input: options.input, output: void 0, error: void 0 };
     try {
-      for (const onStart2 of onStarts) {
-        await onStart2(state, options.context, options.meta);
+      for (const onStart of onStarts) {
+        await onStart(state, options.context, options.meta);
       }
       const output = await options.execute();
       state = { status: "success", input: options.input, output, error: void 0 };
@@ -93,60 +80,6 @@ function convertToArray(value2) {
   return Array.isArray(value2) ? value2 : [value2];
 }
 
-// src/interceptor.ts
-function onStart(callback) {
-  return async (options, ...rest) => {
-    await callback(options, ...rest);
-    return await options.next();
-  };
-}
-function onSuccess(callback) {
-  return async (options, ...rest) => {
-    const result = await options.next();
-    await callback(result, options, ...rest);
-    return result;
-  };
-}
-function onError(callback) {
-  return async (options, ...rest) => {
-    try {
-      return await options.next();
-    } catch (error) {
-      await callback(error, options, ...rest);
-      throw error;
-    }
-  };
-}
-function onFinish(callback) {
-  let state;
-  return async (options, ...rest) => {
-    try {
-      const result = await options.next();
-      state = [result, void 0, "success"];
-      return result;
-    } catch (error) {
-      state = [void 0, error, "error"];
-      throw error;
-    } finally {
-      await callback(state, options, ...rest);
-    }
-  };
-}
-async function intercept(interceptors, options, main) {
-  let index = 0;
-  const next = async (nextOptions = options) => {
-    const interceptor = interceptors[index++];
-    if (!interceptor) {
-      return await main(nextOptions);
-    }
-    return await interceptor({
-      ...nextOptions,
-      next
-    });
-  };
-  return await next();
-}
-
 // src/json.ts
 function parseJSONSafely(text) {
   if (text === "")
@@ -252,16 +185,10 @@ export {
   get,
   group,
   guard,
-  intercept,
   isPlainObject3 as isPlainObject,
   mapEntries,
   mapValues,
   omit,
-  onError,
-  onFinish,
-  onStart,
-  onSuccess,
-  once,
   parseJSONSafely,
   set,
   toError,

package/dist/src/function.d.ts

@@ -1,3 +1,2 @@
 export type AnyFunction = (...args: any[]) => any;
-export declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
 //# sourceMappingURL=function.d.ts.map

package/dist/src/index.d.ts

@@ -3,7 +3,6 @@ export * from './constants';
 export * from './error';
 export * from './function';
 export * from './hook';
-export * from './interceptor';
 export * from './json';
 export * from './object';
 export * from './proxy';

package/dist/src/object.d.ts

@@ -1,5 +1,5 @@
 export type Segment = string | number;
-export declare function set(root: unknown, segments: Readonly<Segment[]>, value: unknown): unknown;
+export declare function set(root: Readonly<Record<string, unknown> | unknown[]>, segments: Readonly<Segment[]>, value: unknown): unknown;
 export declare function get(root: Readonly<Record<string, unknown> | unknown[]>, segments: Readonly<Segment[]>): unknown;
 export declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
     maps: Segment[][];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.31590a1",
+  "version": "0.0.0-next.32cb70c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {

package/dist/src/interceptor.d.ts

@@ -1,47 +0,0 @@
-import type { Promisable } from 'type-fest';
-import type { AnyFunction } from './function';
-export type InterceptableOptions = Record<string, any>;
-export type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<TOptions, 'next'> & {
-    next(options?: TOptions): Promise<TResult>;
-};
-export type Interceptor<TOptions extends InterceptableOptions, TResult, TError> = (options: InterceptorOptions<TOptions, TResult>) => Promise<TResult> & {
-    __error?: {
-        type: TError;
-    };
-};
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onStart<TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>>;
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onSuccess<TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>>;
-export type InferError<T extends AnyFunction> = T extends Interceptor<any, any, infer TError> ? TError : unknown;
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onError<TError, TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(error: TError, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>> & {
-    __error?: {
-        type: TError;
-    };
-};
-export type OnFinishState<TResult, TError> = [TResult, undefined, 'success'] | [undefined, TError, 'error'];
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onFinish<TError, TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, TError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>> & {
-    __error?: {
-        type: TError;
-    };
-};
-export declare function intercept<TOptions extends InterceptableOptions, TResult, TError>(interceptors: Interceptor<TOptions, TResult, TError>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => Promisable<TResult>>): Promise<TResult>;
-//# sourceMappingURL=interceptor.d.ts.map