@stacksjs/error-handling 0.57.4 → 0.58.19

package/README.md

@@ -20,7 +20,7 @@ Currently, a wrapper of the `neverthrow` API.
 ## 🤖 Usage
 
 ```bash
-pnpm i -D @stacksjs/error-handling
+bun install -d @stacksjs/error-handling
 ```
 
 You can now use it in your project:
@@ -55,7 +55,7 @@ result.isErr() // false
 ### Example #2
 
 ```js
-const command = 'rimraf ./pnpm-lock.yaml ./node_modules/ ./.stacks/**/node_modules'
+const command = 'rimraf ./bun.lockb ./node_modules ./core/**/dist'
 const result = await runCommand(command, options)
 
 if (result.isOk()) {
@@ -72,7 +72,7 @@ Learn more in the [docs](https://github.com/supermacro/neverthrow/wiki).
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 🤗 Motivation
@@ -122,10 +122,10 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 📄 License
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/index.js

@@ -0,0 +1,432 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// /Users/chrisbreuer/Code/stacks/node_modules/neverthrow/dist/index.cjs.js
+var require_index_cjs = __commonJS((exports) => {
+  var __awaiter = function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var __values = function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m)
+      return m.call(o);
+    if (o && typeof o.length === "number")
+      return {
+        next: function() {
+          if (o && i >= o.length)
+            o = undefined;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  };
+  var __await = function(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+  };
+  var __asyncGenerator = function(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator)
+      throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i;
+    function verb(n) {
+      if (g[n])
+        i[n] = function(v) {
+          return new Promise(function(a, b) {
+            q.push([n, v, a, b]) > 1 || resume(n, v);
+          });
+        };
+    }
+    function resume(n, v) {
+      try {
+        step(g[n](v));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
+    }
+    function step(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+      resume("next", value);
+    }
+    function reject(value) {
+      resume("throw", value);
+    }
+    function settle(f, v) {
+      if (f(v), q.shift(), q.length)
+        resume(q[0][0], q[0][1]);
+    }
+  };
+  var __asyncDelegator = function(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function(e) {
+      throw e;
+    }), verb("return"), i[Symbol.iterator] = function() {
+      return this;
+    }, i;
+    function verb(n, f) {
+      i[n] = o[n] ? function(v) {
+        return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+      } : f;
+    }
+  };
+  var __asyncValues = function(o) {
+    if (!Symbol.asyncIterator)
+      throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i);
+    function verb(n) {
+      i[n] = o[n] && function(v) {
+        return new Promise(function(resolve, reject) {
+          v = o[n](v), settle(resolve, reject, v.done, v.value);
+        });
+      };
+    }
+    function settle(resolve, reject, d, v) {
+      Promise.resolve(v).then(function(v2) {
+        resolve({ value: v2, done: d });
+      }, reject);
+    }
+  };
+  var safeTry = function(body) {
+    const n = body().next();
+    if (n instanceof Promise) {
+      return n.then((r) => r.value);
+    }
+    return n.value;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var defaultErrorConfig = {
+    withStackTrace: false
+  };
+  var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+    const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+    const maybeStack = config.withStackTrace ? new Error().stack : undefined;
+    return {
+      data,
+      message,
+      stack: maybeStack
+    };
+  };
+
+  class ResultAsync {
+    constructor(res) {
+      this._promise = res;
+    }
+    static fromSafePromise(promise) {
+      const newPromise = promise.then((value) => new Ok(value));
+      return new ResultAsync(newPromise);
+    }
+    static fromPromise(promise, errorFn) {
+      const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+      return new ResultAsync(newPromise);
+    }
+    static combine(asyncResultList) {
+      return combineResultAsyncList(asyncResultList);
+    }
+    static combineWithAllErrors(asyncResultList) {
+      return combineResultAsyncListWithAllErrors(asyncResultList);
+    }
+    map(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        return new Ok(yield f(res.value));
+      })));
+    }
+    mapErr(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isOk()) {
+          return new Ok(res.value);
+        }
+        return new Err(yield f(res.error));
+      })));
+    }
+    andThen(f) {
+      return new ResultAsync(this._promise.then((res) => {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        const newValue = f(res.value);
+        return newValue instanceof ResultAsync ? newValue._promise : newValue;
+      }));
+    }
+    orElse(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isErr()) {
+          return f(res.error);
+        }
+        return new Ok(res.value);
+      })));
+    }
+    match(ok2, _err) {
+      return this._promise.then((res) => res.match(ok2, _err));
+    }
+    unwrapOr(t) {
+      return this._promise.then((res) => res.unwrapOr(t));
+    }
+    safeUnwrap() {
+      return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+        return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+      });
+    }
+    then(successCallback, failureCallback) {
+      return this._promise.then(successCallback, failureCallback);
+    }
+  }
+  var okAsync = (value) => new ResultAsync(Promise.resolve(new Ok(value)));
+  var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
+  var fromPromise = ResultAsync.fromPromise;
+  var fromSafePromise = ResultAsync.fromSafePromise;
+  var appendValueToEndOfList = (value) => (list) => [...list, value];
+  var combineResultList = (resultList) => resultList.reduce((acc, result) => acc.isOk() ? result.isErr() ? err(result.error) : acc.map(appendValueToEndOfList(result.value)) : acc, ok([]));
+  var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+  var combineResultListWithAllErrors = (resultList) => resultList.reduce((acc, result) => result.isErr() ? acc.isErr() ? err([...acc.error, result.error]) : err([result.error]) : acc.isErr() ? acc : ok([...acc.value, result.value]), ok([]));
+  var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+  exports.Result = undefined;
+  (function(Result) {
+    function fromThrowable2(fn, errorFn) {
+      return (...args) => {
+        try {
+          const result = fn(...args);
+          return ok(result);
+        } catch (e) {
+          return err(errorFn ? errorFn(e) : e);
+        }
+      };
+    }
+    Result.fromThrowable = fromThrowable2;
+    function combine(resultList) {
+      return combineResultList(resultList);
+    }
+    Result.combine = combine;
+    function combineWithAllErrors(resultList) {
+      return combineResultListWithAllErrors(resultList);
+    }
+    Result.combineWithAllErrors = combineWithAllErrors;
+  })(exports.Result || (exports.Result = {}));
+  var ok = (value) => new Ok(value);
+  var err = (err2) => new Err(err2);
+
+  class Ok {
+    constructor(value) {
+      this.value = value;
+    }
+    isOk() {
+      return true;
+    }
+    isErr() {
+      return !this.isOk();
+    }
+    map(f) {
+      return ok(f(this.value));
+    }
+    mapErr(_f) {
+      return ok(this.value);
+    }
+    andThen(f) {
+      return f(this.value);
+    }
+    orElse(_f) {
+      return ok(this.value);
+    }
+    asyncAndThen(f) {
+      return f(this.value);
+    }
+    asyncMap(f) {
+      return ResultAsync.fromSafePromise(f(this.value));
+    }
+    unwrapOr(_v) {
+      return this.value;
+    }
+    match(ok2, _err) {
+      return ok2(this.value);
+    }
+    safeUnwrap() {
+      const value = this.value;
+      return function* () {
+        return value;
+      }();
+    }
+    _unsafeUnwrap(_) {
+      return this.value;
+    }
+    _unsafeUnwrapErr(config) {
+      throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+    }
+  }
+
+  class Err {
+    constructor(error) {
+      this.error = error;
+    }
+    isOk() {
+      return false;
+    }
+    isErr() {
+      return !this.isOk();
+    }
+    map(_f) {
+      return err(this.error);
+    }
+    mapErr(f) {
+      return err(f(this.error));
+    }
+    andThen(_f) {
+      return err(this.error);
+    }
+    orElse(f) {
+      return f(this.error);
+    }
+    asyncAndThen(_f) {
+      return errAsync(this.error);
+    }
+    asyncMap(_f) {
+      return errAsync(this.error);
+    }
+    unwrapOr(v) {
+      return v;
+    }
+    match(_ok, err2) {
+      return err2(this.error);
+    }
+    safeUnwrap() {
+      const error = this.error;
+      return function* () {
+        yield err(error);
+        throw new Error("Do not use this generator out of `safeTry`");
+      }();
+    }
+    _unsafeUnwrap(config) {
+      throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+    }
+    _unsafeUnwrapErr(_) {
+      return this.error;
+    }
+  }
+  var fromThrowable = exports.Result.fromThrowable;
+  exports.Err = Err;
+  exports.Ok = Ok;
+  exports.ResultAsync = ResultAsync;
+  exports.err = err;
+  exports.errAsync = errAsync;
+  exports.fromPromise = fromPromise;
+  exports.fromSafePromise = fromSafePromise;
+  exports.fromThrowable = fromThrowable;
+  exports.ok = ok;
+  exports.okAsync = okAsync;
+  exports.safeTry = safeTry;
+});
+
+// src/handler.ts
+import {logsPath} from "@stacksjs/path";
+function handleError(err, options) {
+  return ErrorHandler.handle(err, options);
+}
+var StacksError = Error;
+
+class ErrorHandler {
+  static logFile = logsPath("errors.log");
+  static handle(err, options) {
+    if (!(options instanceof Error) && options?.silent !== false)
+      this.writeErrorToConsole(err, options);
+    if (typeof err === "string")
+      err = new StacksError(err);
+    this.writeErrorToFile(err).catch((e) => console.error(e));
+    return err;
+  }
+  static handleError(err, options) {
+    this.handle(err, options);
+    return err;
+  }
+  static async writeErrorToFile(err) {
+    const formattedError = `[${new Date().toISOString()}] ${err.name}: ${err.message}\n`;
+    const file = Bun.file(this.logFile);
+    const writer = file.writer();
+    const text = await file.text();
+    writer.write(`${text}\n`);
+    writer.write(`${formattedError}\n`);
+    await writer.end();
+  }
+  static writeErrorToConsole(err, options) {
+    if (options)
+      console.error(err, options);
+    else
+      console.error(err);
+  }
+}
+
+// src/index.ts
+var import_neverthrow = __toESM(require_index_cjs(), 1);
+var export_okAsync = import_neverthrow.okAsync;
+var export_ok = import_neverthrow.ok;
+var export_fromThrowable = import_neverthrow.fromThrowable;
+var export_fromSafePromise = import_neverthrow.fromSafePromise;
+var export_fromPromise = import_neverthrow.fromPromise;
+var export_errAsync = import_neverthrow.errAsync;
+var export_err = import_neverthrow.err;
+var export_ResultAsync = import_neverthrow.ResultAsync;
+var export_Result = import_neverthrow.Result;
+var export_Ok = import_neverthrow.Ok;
+var export_Err = import_neverthrow.Err;
+
+export {
+  export_okAsync as okAsync,
+  export_ok as ok,
+  handleError,
+  export_fromThrowable as fromThrowable,
+  export_fromSafePromise as fromSafePromise,
+  export_fromPromise as fromPromise,
+  export_errAsync as errAsync,
+  export_err as err,
+  StacksError,
+  export_ResultAsync as ResultAsync,
+  export_Result as Result,
+  export_Ok as Ok,
+  ErrorHandler,
+  export_Err as Err
+};

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@stacksjs/error-handling",
   "type": "module",
-  "version": "0.57.4",
-  "packageManager": "pnpm@8.6.6",
+  "version": "0.58.19",
   "description": "Type safe error handling.",
   "author": "Chris Breuer",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/.stacks/core/error-handling#readme",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/error-handling#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./.stacks/core/error-handling"
+    "directory": "./storage/framework/core/src/error-handling"
   },
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
@@ -25,33 +24,39 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./*"
     }
   },
-  "module": "dist/index.mjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "contributors": [
-    "Chris Breuer <chris@ow3.org>"
+    "Chris Breuer <chris@stacksjs.org>"
   ],
   "files": [
-    "dist",
-    "README.md"
+    "README.md",
+    "dist"
   ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
+  },
   "peerDependencies": {
-    "@ow3/eslint-config": "^0.44.2",
-    "@stacksjs/cli": "0.57.4"
+    "@stacksjs/cli": "workspace:*",
+    "@stacksjs/path": "workspace:*",
+    "@stacksjs/types": "workspace:*"
   },
   "dependencies": {
-    "neverthrow": "^6.0.0",
-    "@stacksjs/cli": "0.57.4"
+    "@stacksjs/cli": "workspace:*",
+    "@stacksjs/path": "workspace:*",
+    "@stacksjs/types": "workspace:*",
+    "neverthrow": "^6.1.0"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.57.4"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit"
+    "@stacksjs/development": "workspace:*"
   }
-}
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2022 Open Web Foundation
-
-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/dist/index.d.ts

@@ -1,3 +0,0 @@
-import type { StacksError } from '@stacksjs/types';
-export { Err, Ok, Result, ResultAsync, err, errAsync, fromPromise, fromSafePromise, fromThrowable, ok, okAsync, } from 'neverthrow';
-export declare function handleError(err: StacksError, options?: any): void;

package/dist/index.mjs

@@ -1,47 +0,0 @@
-import { fs } from "@stacksjs/storage";
-import { log } from "@stacksjs/cli";
-import { logsPath } from "@stacksjs/path";
-export {
-  Err,
-  Ok,
-  Result,
-  ResultAsync,
-  err,
-  errAsync,
-  fromPromise,
-  fromSafePromise,
-  fromThrowable,
-  ok,
-  okAsync
-} from "neverthrow";
-class ErrorHandler {
-  static handle(err2, options) {
-    this.writeErrorToConsole(err2, options);
-    this.writeErrorToFile(err2);
-  }
-  static handleError(err2, options) {
-    this.handle(err2, options);
-  }
-  static writeErrorToFile(err2) {
-    let formattedError;
-    if (isErrorOfTypeValidation(err2))
-      formattedError = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${err2.name}: ${err2.messages}
-`;
-    else
-      formattedError = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${err2.name}: ${err2.message}
-`;
-    fs.appendFile(this.logFile, formattedError, "utf8").catch((err3) => {
-      log.error(`Failed to write error to ./storage/logs/errors.log: ${italic(err3.message)}`, err3);
-    });
-  }
-  static writeErrorToConsole(err2, options) {
-    log.error(err2, options);
-  }
-}
-ErrorHandler.logFile = logsPath("errors.log");
-function isErrorOfTypeValidation(err2) {
-  return err2 && typeof err2.message === "string";
-}
-export function handleError(err2, options) {
-  ErrorHandler.handle(err2, options);
-}