resumon 2.1.0 → 2.1.2

package/README.md

@@ -17,9 +17,6 @@
   <a href="https://opensource.org/licenses/MIT">
     <img alt="MIT" src="https://img.shields.io/npm/l/resumon?color=%234DC71F">
   </a>
-  <a href="https://bundlephobia.com/package/resumon">
-    <img alt="npm bundle size" src="https://img.shields.io/bundlephobia/minzip/resumon">
-  </a>
 </p>
 
 ## Installation

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+//#region src/result.d.ts
+interface Result<D, E> extends Succeedable<D>, Failable<E> {
+  readonly isOk: boolean;
+  readonly isError: boolean;
+  andThen: <T>(map: (data: D) => Result<T, E>) => Result<T, E>;
+  map: <T>(map: (data: D) => T) => Result<T, E>;
+  mapError: <U>(map: (error: E) => U) => Result<D, U>;
+}
+interface Succeedable<D> {
+  get: () => D;
+  getOrElse: (other: D) => D;
+  getOrNull: () => D | null;
+  getOrUndefined: () => D | undefined;
+}
+interface Succeeded<D> extends Succeedable<D> {
+  getOrElse: () => D;
+  getOrNull: () => D;
+  getOrUndefined: () => D;
+}
+interface Failable<E> {
+  getError: () => E;
+  getErrorOrElse: (other: E) => E;
+  getErrorOrNull: () => E | null;
+  getErrorOrUndefined: () => E | undefined;
+}
+interface Failed<E> extends Failable<E> {
+  getErrorOrElse: () => E;
+  getErrorOrNull: () => E;
+  getErrorOrUndefined: () => E;
+}
+declare class IllegalStateError extends Error {}
+//#endregion
+//#region src/err.d.ts
+declare class Err<D, E> implements Result<D, E>, Failed<E> {
+  readonly isOk = false;
+  readonly isError = true;
+  private readonly error;
+  constructor(error: E);
+  get(): D;
+  getOrElse(other: D): D;
+  getOrNull(): null;
+  getOrUndefined(): undefined;
+  getError(): E;
+  getErrorOrElse(): E;
+  getErrorOrNull(): E;
+  getErrorOrUndefined(): E;
+  andThen<T>(): Result<T, E>;
+  map<T>(): Result<T, E>;
+  mapError<T, U>(map: (error: E) => U): Result<T, U>;
+}
+declare function err<D, E>(error: E): Result<D, E>;
+//#endregion
+//#region src/ok.d.ts
+declare class Ok<D, E> implements Result<D, E>, Succeeded<D> {
+  readonly isOk = true;
+  readonly isError = false;
+  private readonly data;
+  constructor(data: D);
+  get(): D;
+  getOrElse(): D;
+  getOrNull(): D;
+  getOrUndefined(): D;
+  getError(): E;
+  getErrorOrElse(other: E): E;
+  getErrorOrNull(): null;
+  getErrorOrUndefined(): undefined;
+  andThen<T>(map: (data: D) => Result<T, E>): Result<T, E>;
+  map<T>(map: (data: D) => T): Result<T, E>;
+  mapError<U>(): Result<D, U>;
+}
+declare function ok<D, E>(data: D): Result<D, E>;
+//#endregion
+export { Err, Failable, Failed, IllegalStateError, Ok, Result, Succeedable, Succeeded, err, ok };

package/dist/index.js

@@ -0,0 +1,95 @@
+//#region src/result.ts
+var IllegalStateError = class extends Error {};
+
+//#endregion
+//#region src/err.ts
+var Err = class Err {
+	isOk = false;
+	isError = true;
+	error;
+	constructor(error) {
+		this.error = error;
+	}
+	get() {
+		throw new IllegalStateError("Cannot get data or Err");
+	}
+	getOrElse(other) {
+		return other;
+	}
+	getOrNull() {
+		return null;
+	}
+	getOrUndefined() {}
+	getError() {
+		return this.error;
+	}
+	getErrorOrElse() {
+		return this.error;
+	}
+	getErrorOrNull() {
+		return this.error;
+	}
+	getErrorOrUndefined() {
+		return this.error;
+	}
+	andThen() {
+		return this;
+	}
+	map() {
+		return this;
+	}
+	mapError(map) {
+		return new Err(map(this.error));
+	}
+};
+function err(error) {
+	return new Err(error);
+}
+
+//#endregion
+//#region src/ok.ts
+var Ok = class Ok {
+	isOk = true;
+	isError = false;
+	data;
+	constructor(data) {
+		this.data = data;
+	}
+	get() {
+		return this.data;
+	}
+	getOrElse() {
+		return this.data;
+	}
+	getOrNull() {
+		return this.data;
+	}
+	getOrUndefined() {
+		return this.data;
+	}
+	getError() {
+		throw new IllegalStateError("Cannot get error of Ok");
+	}
+	getErrorOrElse(other) {
+		return other;
+	}
+	getErrorOrNull() {
+		return null;
+	}
+	getErrorOrUndefined() {}
+	andThen(map) {
+		return map(this.data);
+	}
+	map(map) {
+		return new Ok(map(this.data));
+	}
+	mapError() {
+		return this;
+	}
+};
+function ok(data) {
+	return new Ok(data);
+}
+
+//#endregion
+export { Err, IllegalStateError, Ok, err, ok };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "resumon",
   "type": "module",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "A tiny TypeScript result monad.",
   "author": {
     "name": "Jan Müller",
@@ -26,31 +26,29 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/types/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       }
     }
   },
-  "types": "dist/types/index.d.mts",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
   "devDependencies": {
-    "@types/node": "22.13.8",
-    "@vue/component-compiler-utils": "3.3.0",
-    "typescript": "5.8.2",
-    "vite": "6.2.0",
-    "@yeger/tsconfig": "2.1.0",
-    "vite-plugin-lib": "2.1.6"
+    "tsdown": "0.15.11",
+    "typescript": "5.9.3",
+    "@yeger/tsconfig": "2.1.1",
+    "@yeger/vitest-utils": "1.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "vite build",
+    "build": "tsdown",
     "check:publish": "publint run --strict",
     "check:tsc": "tsc",
-    "dev": "vite build --watch",
+    "dev": "tsdown --watch",
     "lint": "yeger-lint",
     "test": "vitest"
   }

package/dist/index.mjs

@@ -1,98 +0,0 @@
-var a = Object.defineProperty;
-var i = (t, r, n) => r in t ? a(t, r, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[r] = n;
-var e = (t, r, n) => i(t, typeof r != "symbol" ? r + "" : r, n);
-class u extends Error {
-}
-class o {
-  constructor(r) {
-    e(this, "isOk", !1);
-    e(this, "isError", !0);
-    e(this, "error");
-    this.error = r;
-  }
-  get() {
-    throw new u("Cannot get data or Err");
-  }
-  getOrElse(r) {
-    return r;
-  }
-  getOrNull() {
-    return null;
-  }
-  getOrUndefined() {
-  }
-  getError() {
-    return this.error;
-  }
-  getErrorOrElse() {
-    return this.error;
-  }
-  getErrorOrNull() {
-    return this.error;
-  }
-  getErrorOrUndefined() {
-    return this.error;
-  }
-  andThen() {
-    return this;
-  }
-  map() {
-    return this;
-  }
-  mapError(r) {
-    return new o(r(this.error));
-  }
-}
-function d(t) {
-  return new o(t);
-}
-class s {
-  constructor(r) {
-    e(this, "isOk", !0);
-    e(this, "isError", !1);
-    e(this, "data");
-    this.data = r;
-  }
-  get() {
-    return this.data;
-  }
-  getOrElse() {
-    return this.data;
-  }
-  getOrNull() {
-    return this.data;
-  }
-  getOrUndefined() {
-    return this.data;
-  }
-  getError() {
-    throw new u("Cannot get error of Ok");
-  }
-  getErrorOrElse(r) {
-    return r;
-  }
-  getErrorOrNull() {
-    return null;
-  }
-  getErrorOrUndefined() {
-  }
-  andThen(r) {
-    return r(this.data);
-  }
-  map(r) {
-    return new s(r(this.data));
-  }
-  mapError() {
-    return this;
-  }
-}
-function h(t) {
-  return new s(t);
-}
-export {
-  o as Err,
-  u as IllegalStateError,
-  s as Ok,
-  d as err,
-  h as ok
-};

package/dist/types/err.d.mts

@@ -1,19 +0,0 @@
-import { Failed, Result } from './result.mjs';
-export declare class Err<D, E> implements Result<D, E>, Failed<E> {
-    readonly isOk = false;
-    readonly isError = true;
-    private readonly error;
-    constructor(error: E);
-    get(): D;
-    getOrElse(other: D): D;
-    getOrNull(): null;
-    getOrUndefined(): undefined;
-    getError(): E;
-    getErrorOrElse(): E;
-    getErrorOrNull(): E;
-    getErrorOrUndefined(): E;
-    andThen<T>(): Result<T, E>;
-    map<T>(): Result<T, E>;
-    mapError<T, U>(map: (error: E) => U): Result<T, U>;
-}
-export declare function err<D, E>(error: E): Result<D, E>;

package/dist/types/index.d.mts

@@ -1,3 +0,0 @@
-export * from './err.mjs';
-export * from './ok.mjs';
-export * from './result.mjs';

package/dist/types/ok.d.mts

@@ -1,19 +0,0 @@
-import { Result, Succeeded } from './result.mjs';
-export declare class Ok<D, E> implements Result<D, E>, Succeeded<D> {
-    readonly isOk = true;
-    readonly isError = false;
-    private readonly data;
-    constructor(data: D);
-    get(): D;
-    getOrElse(): D;
-    getOrNull(): D;
-    getOrUndefined(): D;
-    getError(): E;
-    getErrorOrElse(other: E): E;
-    getErrorOrNull(): null;
-    getErrorOrUndefined(): undefined;
-    andThen<T>(map: (data: D) => Result<T, E>): Result<T, E>;
-    map<T>(map: (data: D) => T): Result<T, E>;
-    mapError<U>(): Result<D, U>;
-}
-export declare function ok<D, E>(data: D): Result<D, E>;

package/dist/types/result.d.mts

@@ -1,31 +0,0 @@
-export interface Result<D, E> extends Succeedable<D>, Failable<E> {
-    readonly isOk: boolean;
-    readonly isError: boolean;
-    andThen: <T>(map: (data: D) => Result<T, E>) => Result<T, E>;
-    map: <T>(map: (data: D) => T) => Result<T, E>;
-    mapError: <U>(map: (error: E) => U) => Result<D, U>;
-}
-export interface Succeedable<D> {
-    get: () => D;
-    getOrElse: (other: D) => D;
-    getOrNull: () => D | null;
-    getOrUndefined: () => D | undefined;
-}
-export interface Succeeded<D> extends Succeedable<D> {
-    getOrElse: () => D;
-    getOrNull: () => D;
-    getOrUndefined: () => D;
-}
-export interface Failable<E> {
-    getError: () => E;
-    getErrorOrElse: (other: E) => E;
-    getErrorOrNull: () => E | null;
-    getErrorOrUndefined: () => E | undefined;
-}
-export interface Failed<E> extends Failable<E> {
-    getErrorOrElse: () => E;
-    getErrorOrNull: () => E;
-    getErrorOrUndefined: () => E;
-}
-export declare class IllegalStateError extends Error {
-}