erreur - npm Package Compare versions

Comparing version 1.1.1 to 2.0.0-0

dist/mod.d.ts

@@ -1,60 +0,34 @@
-declare type ErreurInfos = {
-    kind: string | number | symbol;
-    message: string;
-};
-declare class Erreur<T extends ErreurInfos> extends Error {
-    static is(val: unknown): val is Erreur<ErreurInfos>;
-    readonly infos: T;
-    readonly kind: T['kind'];
-    constructor(infos: T);
+declare const INTERNAL: unique symbol;
+declare type OnError = (error: unknown) => Erreur;
+/**
+ * Make sure the function either returns a value or throws an Erreur
+ */
+declare function wrap<Res>(fn: () => Res, onError: OnError): Res;
+declare function wrapAsync<Res>(fn: () => Promise<Res>, onError: OnError): Promise<Res>;
+/**
+ * Same as wrap but returns the error instead of throwing it
+ */
+declare function resolve<Res>(fn: () => Res, onError: OnError): Res | Erreur;
+declare function resolveAsync<Res>(fn: () => Promise<Res>, onError: OnError): Promise<Res | Erreur>;
+interface ErreurType<Data> {
+    readonly [INTERNAL]: Data;
+    readonly name: string;
+    readonly create: (data: Data) => Erreur;
+    readonly is: (error: unknown) => error is Erreur;
+    readonly match: (error: unknown) => Data | null;
 }
-declare type ErreursMapErrors = Record<string, (...args: any[]) => {
-    message: string;
-}>;
-declare type ErreursMapCreate<Errors extends ErreursMapErrors> = {
-    [K in keyof Errors]: (...params: Parameters<Errors[K]>) => Erreur<{
-        kind: K;
-    } & ReturnType<Errors[K]>>;
-};
-declare type Expand<T> = T extends unknown ? {
-    [K in keyof T]: T[K];
-} : never;
-declare type FromTypes<Errors extends {
-    kind: string;
-    message: string;
-}> = {
-    [K in Errors['kind']]: (...args: any[]) => Omit<Extract<Errors, {
-        kind: K;
-    }>, 'kind'>;
-};
-declare type FromTypesFactory<ErrorsInfos extends {
-    kind: string;
-    message: string;
-}> = <Errors extends FromTypes<ErrorsInfos>>(errors: Errors) => ErreursMap<Errors>;
-declare class ErreursMap<Errors extends ErreursMapErrors> {
-    static fromTypes<ErrorsInfos extends {
-        kind: string;
-        message: string;
-    }>(): FromTypesFactory<ErrorsInfos>;
-    readonly errors: Errors;
-    /**
-     * This property expose the type of the error.
-     * type MyError = typeof MyError.infered
-     */
-    readonly infered: Erreur<{
-        [K in keyof Errors]: Expand<{
-            kind: K;
-        } & ReturnType<Errors[K]>>;
-    }[keyof Errors]>;
-    /**
-     * Create an instance of Erreur with the given kind.
-     * `UserErreurs.create.[ErrorKind](...args)`
-     */
-    readonly create: ErreursMapCreate<Errors>;
-    constructor(errors: Errors);
-    is(val: unknown): val is this['infered'];
-    wrap<T>(fn: () => T, mapOtherErr: (err: unknown) => this['infered']): T | this['infered'];
-    wrapAsync<T>(fn: () => Promise<T> | T, mapOtherErr: (err: unknown) => this['infered']): Promise<T | this['infered']>;
+declare class Erreur extends Error {
+    private [INTERNAL];
+    static readonly wrap: typeof wrap;
+    static readonly wrapAsync: typeof wrapAsync;
+    static readonly resolve: typeof resolve;
+    static readonly resolveAsync: typeof resolveAsync;
+    static create<Data>(name: string): ErreurType<Data>;
+    static is(error: unknown, type?: ErreurType<any>): error is Error;
+    static isOneOf(error: unknown, types: ErreurType<any>[]): error is Erreur;
+    private constructor();
+    is(type: ErreurType<any>): boolean;
+    isOneOf(types: ErreurType<any>[]): boolean;
 }
 
-export { Erreur, ErreurInfos, ErreursMap, ErreursMapCreate, ErreursMapErrors, Expand, FromTypes, FromTypesFactory };
+export { Erreur, ErreurType, OnError, resolve, resolveAsync, wrap, wrapAsync };

dist/mod.js

 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 var __export = (target, all) => {
@@ -37,66 +23,106 @@ for (var name in all)
   Erreur: () => Erreur,
-  ErreursMap: () => ErreursMap
+  resolve: () => resolve,
+  resolveAsync: () => resolveAsync,
+  wrap: () => wrap,
+  wrapAsync: () => wrapAsync
 });
 module.exports = __toCommonJS(mod_exports);
-var Erreur = class extends Error {
-  constructor(infos) {
-    super("[Erreur] " + infos.message);
-    this.infos = infos;
-    this.kind = infos.kind;
-    Object.setPrototypeOf(this, Erreur.prototype);
+var INTERNAL = Symbol("INTERNAL");
+function wrap(fn, onError) {
+  try {
+    return fn();
+  } catch (e) {
+    if (Erreur.is(e)) {
+      throw e;
+    }
+    throw onError(e);
   }
-  static is(val) {
-    return val instanceof Erreur;
+}
+async function wrapAsync(fn, onError) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (Erreur.is(error)) {
+      throw error;
+    }
+    throw onError(error);
   }
-};
-var ErreursMap = class {
-  constructor(errors) {
-    this.infered = null;
-    this.errors = errors;
-    this.create = Object.fromEntries(Object.entries(errors).map(([key, fn]) => [
-      key,
-      (...args) => new Erreur(__spreadValues({ kind: key }, fn(...args)))
-    ]));
+}
+function resolve(fn, onError) {
+  try {
+    return wrap(fn, onError);
+  } catch (error) {
+    return error;
   }
-  static fromTypes() {
-    return (errors) => new ErreursMap(errors);
+}
+async function resolveAsync(fn, onError) {
+  try {
+    return await wrapAsync(fn, onError);
+  } catch (error) {
+    return error;
   }
-  is(val) {
-    if (val instanceof Erreur && val.kind in this.errors) {
-      return true;
-    }
-    return false;
+}
+var _Erreur = class extends Error {
+  constructor(internal) {
+    super(`[Erreur]: ${internal.type.name} ${JSON.stringify(internal.data)}`);
+    this[INTERNAL] = internal;
+    Object.setPrototypeOf(this, new.target.prototype);
   }
-  wrap(fn, mapOtherErr) {
-    try {
-      const result = fn();
-      if (isPromise(result)) {
-        console.warn("[Erreur.wrap]: Wrap received a promise, did you mean to use wrapAsync ?");
+  static create(name) {
+    const type = {
+      [INTERNAL]: {},
+      name,
+      create: (data) => new _Erreur({ type, data }),
+      is: (error) => {
+        if (error instanceof _Erreur) {
+          return error[INTERNAL].type === type;
+        }
+        return false;
+      },
+      match: (error) => {
+        if (error instanceof _Erreur) {
+          if (error[INTERNAL].type === type) {
+            return error[INTERNAL].data;
+          }
+        }
+        return null;
       }
-      return result;
-    } catch (error) {
-      if (this.is(error)) {
-        return error;
+    };
+    return type;
+  }
+  static is(error, type) {
+    if (error instanceof _Erreur) {
+      if (type) {
+        return error[INTERNAL].type === type;
       }
-      return mapOtherErr(error);
+      return true;
     }
+    return false;
   }
-  async wrapAsync(fn, mapOtherErr) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (this.is(error)) {
-        return error;
-      }
-      return mapOtherErr(error);
+  static isOneOf(error, types) {
+    if (error instanceof _Erreur) {
+      return types.some((type) => error[INTERNAL].type === type);
     }
+    return false;
   }
+  is(type) {
+    return this[INTERNAL].type === type;
+  }
+  isOneOf(types) {
+    return types.some((type) => this[INTERNAL].type === type);
+  }
 };
-function isPromise(val) {
-  return Promise.resolve(val) === val;
-}
+var Erreur = _Erreur;
+INTERNAL;
+Erreur.wrap = wrap;
+Erreur.wrapAsync = wrapAsync;
+Erreur.resolve = resolve;
+Erreur.resolveAsync = resolveAsync;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Erreur,
-  ErreursMap
+  resolve,
+  resolveAsync,
+  wrap,
+  wrapAsync
 });

package.json

 {
   "name": "erreur",
-  "version": "1.1.1",
+  "version": "2.0.0-0",
   "description": "Type safe custom errors",
@@ -5,0 +5,0 @@ "keywords": [

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

258

increased by8.86%

Worsened metrics

Total package byte prevSize

12186

decreased by-3.75%

Number of low quality alerts

1

increased byInfinity%

No dependency changes