@orpc/shared - npm Package Compare versions

Comparing version 0.0.0-next.83ec2e8 to 0.0.0-next.854b646

dist/index.js

@@ -0,1 +1,92 @@
+// src/constants.ts
+var ORPC_HANDLER_HEADER = "x-orpc-handler";
+var ORPC_HANDLER_VALUE = "orpc";
+
+// src/error.ts
+import { isPlainObject } from "is-what";
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error, { cause: error });
+  }
+  if (isPlainObject(error)) {
+    if ("message" in error && typeof error.message === "string") {
+      return new Error(error.message, { cause: error });
+    }
+    if ("name" in error && typeof error.name === "string") {
+      return new Error(error.name, { cause: 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/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 (options2) => {
+    const interceptor = interceptors[index++];
+    if (!interceptor) {
+      return await main(options2);
+    }
+    return await interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions)
+    });
+  };
+  return await next(options);
+}
+
 // src/json.ts
@@ -13,3 +104,3 @@ function parseJSONSafely(text) {
 // src/object.ts
-import { isPlainObject } from "is-what";
+import { isPlainObject as isPlainObject2 } from "is-what";
 function set(root, segments, value2) {
@@ -50,3 +141,3 @@ const ref = { root };
     });
-  } else if (isPlainObject(payload)) {
+  } else if (isPlainObject2(payload)) {
     for (const key in payload) {
@@ -59,6 +150,34 @@ findDeepMatches(check, payload[key], [...segments, key], maps, values);
 
+// src/proxy.ts
+function createCallableObject(obj, handler) {
+  const proxy = new Proxy(handler, {
+    has(target, key) {
+      return Reflect.has(obj, key) || Reflect.has(target, key);
+    },
+    ownKeys(target) {
+      return Array.from(new Set(Reflect.ownKeys(obj).concat(...Reflect.ownKeys(target))));
+    },
+    get(target, key) {
+      if (!Reflect.has(target, key) || Reflect.has(obj, key)) {
+        return Reflect.get(obj, key);
+      }
+      return Reflect.get(target, key);
+    },
+    defineProperty(_, key, descriptor) {
+      return Reflect.defineProperty(obj, key, descriptor);
+    },
+    set(_, key, value2) {
+      return Reflect.set(obj, key, value2);
+    },
+    deleteProperty(target, key) {
+      return Reflect.deleteProperty(target, key) && Reflect.deleteProperty(obj, key);
+    }
+  });
+  return proxy;
+}
+
 // src/value.ts
-function value(value2) {
+function value(value2, ...args) {
   if (typeof value2 === "function") {
-    return value2();
+    return value2(...args);
   }
@@ -69,14 +188,25 @@ return value2;
 // src/index.ts
-import { isPlainObject as isPlainObject2 } from "is-what";
-import { guard, mapEntries, mapValues, omit, trim } from "radash";
+import { isPlainObject as isPlainObject3 } from "is-what";
+import { group, guard, mapEntries, mapValues, omit, trim } from "radash";
 export {
+  ORPC_HANDLER_HEADER,
+  ORPC_HANDLER_VALUE,
+  createCallableObject,
   findDeepMatches,
   get,
+  group,
   guard,
-  isPlainObject2 as isPlainObject,
+  intercept,
+  isPlainObject3 as isPlainObject,
   mapEntries,
   mapValues,
   omit,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
+  once,
   parseJSONSafely,
   set,
+  toError,
   trim,
@@ -83,0 +213,0 @@ value

dist/src/error.d.ts

@@ -1,58 +0,2 @@
-import { type ZodIssue } from 'zod';
-export declare const ORPC_ERROR_CODE_STATUSES: {
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly METHOD_NOT_SUPPORTED: 405;
-    readonly NOT_ACCEPTABLE: 406;
-    readonly TIMEOUT: 408;
-    readonly CONFLICT: 409;
-    readonly PRECONDITION_FAILED: 412;
-    readonly PAYLOAD_TOO_LARGE: 413;
-    readonly UNSUPPORTED_MEDIA_TYPE: 415;
-    readonly UNPROCESSABLE_CONTENT: 422;
-    readonly TOO_MANY_REQUESTS: 429;
-    readonly CLIENT_CLOSED_REQUEST: 499;
-    readonly INTERNAL_SERVER_ERROR: 500;
-    readonly NOT_IMPLEMENTED: 501;
-    readonly BAD_GATEWAY: 502;
-    readonly SERVICE_UNAVAILABLE: 503;
-    readonly GATEWAY_TIMEOUT: 504;
-};
-export type ORPCErrorCode = keyof typeof ORPC_ERROR_CODE_STATUSES;
-export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
-    zz$oe: {
-        code: TCode;
-        status?: number;
-        message?: string;
-        cause?: unknown;
-    } & (undefined extends TData ? {
-        data?: TData;
-    } : {
-        data: TData;
-    });
-    constructor(zz$oe: {
-        code: TCode;
-        status?: number;
-        message?: string;
-        cause?: unknown;
-    } & (undefined extends TData ? {
-        data?: TData;
-    } : {
-        data: TData;
-    }));
-    get code(): TCode;
-    get status(): number;
-    get data(): TData;
-    get issues(): ZodIssue[] | undefined;
-    toJSON(): {
-        code: TCode;
-        status: number;
-        message: string;
-        data: TData;
-        issues?: ZodIssue[];
-    };
-    static fromJSON(json: unknown): ORPCError<ORPCErrorCode, any> | undefined;
-}
+export declare function toError(error: unknown): Error;
 //# sourceMappingURL=error.d.ts.map

dist/src/index.d.ts

@@ -0,7 +1,13 @@
+export * from './chain';
+export * from './constants';
+export * from './error';
+export * from './function';
+export * from './interceptor';
 export * from './json';
 export * from './object';
+export * from './proxy';
 export * from './value';
 export { isPlainObject } from 'is-what';
-export { guard, mapEntries, mapValues, omit, trim } from 'radash';
+export { group, guard, mapEntries, mapValues, omit, trim } from 'radash';
 export type * from 'type-fest';
 //# sourceMappingURL=index.d.ts.map

dist/src/object.d.ts

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

dist/src/value.d.ts

 import type { Promisable } from 'type-fest';
-export type Value<T> = T | (() => Promisable<T>);
-export declare function value<T extends Value<any>>(value: T): Promise<T extends Value<infer U> ? U : never>;
+export type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => Promisable<T>);
+export declare function value<T extends Value<any, TArgs>, TArgs extends any[] = []>(value: T, ...args: TArgs): Promise<T extends Value<infer U, any> ? U : never>;
 //# sourceMappingURL=value.d.ts.map

package.json

 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.83ec2e8",
+  "version": "0.0.0-next.854b646",
   "license": "MIT",
@@ -13,3 +13,4 @@ "homepage": "https://orpc.unnoq.com",
   "keywords": [
-    "unnoq"
+    "unnoq",
+    "orpc"
   ],
@@ -22,7 +23,2 @@ "exports": {
     },
-    "./error": {
-      "types": "./dist/src/error.d.ts",
-      "import": "./dist/error.js",
-      "default": "./dist/error.js"
-    },
     "./🔒/*": {
@@ -33,4 +29,5 @@ "types": "./dist/src/*.d.ts"
   "files": [
-    "dist",
-    "src"
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
+    "dist"
   ],
@@ -40,7 +37,6 @@ "dependencies": {
     "radash": "^12.1.0",
-    "type-fest": "^4.26.1",
-    "zod": "^3.23.8"
+    "type-fest": "^4.26.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.error=src/error.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
@@ -47,0 +43,0 @@ "type:check": "tsc -b"

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Dependency count

3

decreased by-25%

Worsened metrics

Total package byte prevSize

11895

decreased by-85.99%

Number of package files

13

decreased by-48%

Lines of code

282

decreased by-38.16%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• - Removedzod@^3.23.8

• - Removedzod@3.24.2(transitive)