stacks 0.58.72 → 0.59.1

package/core/error-handling/dist/index.js

@@ -1,432 +0,0 @@
-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);
-
-// /home/runner/work/stacks/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/core/error-handling/package.json

@@ -1,63 +0,0 @@
-{
-  "name": "@stacksjs/error-handling",
-  "type": "module",
-  "version": "0.58.72",
-  "description": "Type safe error handling.",
-  "author": "Chris Breuer",
-  "license": "MIT",
-  "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/error-handling#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./storage/framework/core/error-handling"
-  },
-  "bugs": {
-    "url": "https://github.com/stacksjs/stacks/issues"
-  },
-  "keywords": [
-    "errors",
-    "error-handling",
-    "neverthrow",
-    "type safe",
-    "stacks"
-  ],
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "import": "./dist/index.js"
-    },
-    "./*": {
-      "bun": "./*"
-    }
-  },
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
-    "prepublishOnly": "bun --bun run build"
-  },
-  "peerDependencies": {
-    "@stacksjs/cli": "workspace:*",
-    "@stacksjs/path": "workspace:*",
-    "@stacksjs/types": "workspace:*"
-  },
-  "dependencies": {
-    "@stacksjs/cli": "workspace:*",
-    "@stacksjs/path": "workspace:*",
-    "@stacksjs/types": "workspace:*",
-    "neverthrow": "^6.1.0"
-  },
-  "devDependencies": {
-    "@stacksjs/development": "workspace:*"
-  }
-}

package/core/error-handling/src/handler.ts

@@ -1,51 +0,0 @@
-import { logsPath } from '@stacksjs/path'
-
-interface ErrorOptions {
-  silent?: boolean
-}
-
-export const StacksError = Error
-
-export class ErrorHandler {
-  static logFile = logsPath('errors.log')
-
-  static handle(err: ErrorDescription | Error, options?: ErrorOptions | Error) {
-    // let's only write to the console if we are not in silent mode
-    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: Error, options?: ErrorOptions) {
-    this.handle(err, options)
-    return err
-  }
-
-  static async writeErrorToFile(err: Error) {
-    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: string | Error, options?: ErrorOptions) {
-    if (options)
-      console.error(err, options)
-    else
-      console.error(err)
-  }
-}
-
-type ErrorDescription = string
-export function handleError(err: ErrorDescription | Error, options?: ErrorOptions | Error): Error {
-  return ErrorHandler.handle(err, options)
-}

package/core/error-handling/src/index.ts

@@ -1,2 +0,0 @@
-export * from './handler'
-export { err, errAsync, fromPromise, fromSafePromise, fromThrowable, ok, okAsync, Err, Ok, Result, ResultAsync } from 'neverthrow'

package/core/error-handling/tests/example.test.ts

@@ -1,5 +0,0 @@
-describe('example test', () => {
-  it('assert', () => {
-    expect(1).toBe(1)
-  })
-})

package/core/error-handling/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../tsconfig.json"
-}

package/core/eslint-config/.gitattributes

@@ -1,2 +0,0 @@
-* text=auto
-*.* text eol=lf