result_option 0.1.0 → 0.1.3

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Represents a value that may or may not exist.
-*/
+ */
 export declare class Option<T> {
     #private;
     private constructor();
@@ -18,7 +18,7 @@ export declare class Option<T> {
      * @example
      * const option = Option.None();
      */
-    static None(): Option<never>;
+    static None<T>(): Option<T>;
     /**
      *
      * @returns true if the `Option` is a `Some` value.
@@ -74,7 +74,7 @@ export declare class Option<T> {
      *
      * const x = Option.None();
      * const y = x.unwrap_or("bus"); // -> y = "bus"
-    */
+     */
     unwrap_or(dft: T): T;
     /**
      * @param f lambda.
@@ -85,7 +85,7 @@ export declare class Option<T> {
      *
      * const x = Option.None();
      * const y = x.unwrap_or(() => "bus"); // -> y = "bus"
-    */
+     */
     unwrap_or_else(f: () => T): T;
     /**
      *
@@ -502,3 +502,34 @@ export declare class Result<T, E> {
         Err: (Err: E) => R;
     }): R;
 }
+/**
+ * Helper function for `Option.Some`.
+ * @param value - The value to be `Some`.
+ * @returns Option<T> with `Some` = `value`.
+ * @example
+ * const option = Option.Some(10);
+ */
+export declare function Some<T>(value: T): Option<T>;
+/**
+ * Helper function for `Option.None`.
+ * @returns Option<T> with `None`.
+ * @example
+ * const option = Option.None();
+ */
+export declare function None<T>(): Option<T>;
+/**
+ * Helper function for `Result.Ok`.
+ * @param value - The value to be `Ok`.
+ * @returns `Result<T, E>` with `Ok` = `value`.
+ * @example
+ * const result = Result.Ok(10);
+ */
+export declare function Ok<T, E>(value: T): Result<T, E>;
+/**
+ * Helper function for `Result.Err`.
+ * @param error - The error to be `Err`.
+ * @returns `Result<T, E>` with `Err` = `error`.
+ * @example
+ * const result = Result.Err("something went wrong");
+ */
+export declare function Err<T, E>(error: E): Result<T, E>;

package/dist/index.js

@@ -12,7 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Option_val, _Result_val, _Result_err;
 /**
  * Represents a value that may or may not exist.
-*/
+ */
 export class Option {
     constructor(value) {
         _Option_val.set(this, void 0);
@@ -45,7 +45,7 @@ export class Option {
      * x.is_some(); // -> true
      */
     is_some() {
-        return __classPrivateFieldGet(this, _Option_val, "f") ? true : false;
+        return !!__classPrivateFieldGet(this, _Option_val, "f");
     }
     /**
      *
@@ -66,7 +66,7 @@ export class Option {
     is_some_and(f) {
         return this.match({
             Some: f,
-            None: () => false
+            None: () => false,
         });
     }
     /**
@@ -101,7 +101,7 @@ export class Option {
             Some: (val) => val,
             None: () => {
                 throw new Error("called Option.unwrap() on a none value");
-            }
+            },
         });
     }
     /**
@@ -113,11 +113,11 @@ export class Option {
      *
      * const x = Option.None();
      * const y = x.unwrap_or("bus"); // -> y = "bus"
-    */
+     */
     unwrap_or(dft) {
         return this.match({
             Some: (val) => val,
-            None: () => dft
+            None: () => dft,
         });
     }
     /**
@@ -129,11 +129,11 @@ export class Option {
      *
      * const x = Option.None();
      * const y = x.unwrap_or(() => "bus"); // -> y = "bus"
-    */
+     */
     unwrap_or_else(f) {
         return this.match({
             Some: (val) => val,
-            None: f
+            None: f,
         });
     }
     /**
@@ -153,7 +153,7 @@ export class Option {
             Some: (val) => val,
             None: () => {
                 throw new Error(msg);
-            }
+            },
         });
     }
     /**
@@ -169,7 +169,7 @@ export class Option {
     map(f) {
         return this.match({
             Some: (val) => Option.Some(f(val)),
-            None: () => Option.None()
+            None: () => Option.None(),
         });
     }
     /**
@@ -187,7 +187,7 @@ export class Option {
     map_or(dft, f) {
         return this.match({
             Some: f,
-            None: () => dft
+            None: () => dft,
         });
     }
     /**
@@ -205,7 +205,7 @@ export class Option {
     map_or_else(dft, f) {
         return this.match({
             Some: f,
-            None: dft
+            None: dft,
         });
     }
     /**
@@ -222,7 +222,7 @@ export class Option {
     ok_or(err) {
         return this.match({
             Some: (val) => Result.Ok(val),
-            None: () => Result.Err(err)
+            None: () => Result.Err(err),
         });
     }
     /**
@@ -239,7 +239,7 @@ export class Option {
     ok_or_else(err) {
         return this.match({
             Some: (val) => Result.Ok(val),
-            None: () => Result.Err(err())
+            None: () => Result.Err(err()),
         });
     }
     /**
@@ -258,7 +258,7 @@ export class Option {
     and(optb) {
         return this.match({
             Some: (_) => optb,
-            None: () => Option.None()
+            None: () => Option.None(),
         });
     }
     /**
@@ -296,7 +296,7 @@ export class Option {
     or(optb) {
         return this.match({
             Some: (_) => this,
-            None: () => optb
+            None: () => optb,
         });
     }
     /**
@@ -315,7 +315,7 @@ export class Option {
     or_else(f) {
         return this.match({
             Some: (_) => this,
-            None: f
+            None: f,
         });
     }
     /**
@@ -337,9 +337,7 @@ export class Option {
      * });
      */
     match(cases) {
-        if (__classPrivateFieldGet(this, _Option_val, "f"))
-            return cases.Some(__classPrivateFieldGet(this, _Option_val, "f"));
-        return cases.None();
+        return __classPrivateFieldGet(this, _Option_val, "f") === null ? cases.None() : cases.Some(__classPrivateFieldGet(this, _Option_val, "f"));
     }
 }
 _Option_val = new WeakMap();
@@ -378,7 +376,7 @@ export class Result {
      * x.is_ok(); // -> false
      */
     is_ok() {
-        return __classPrivateFieldGet(this, _Result_val, "f") ? true : false;
+        return !!__classPrivateFieldGet(this, _Result_val, "f");
     }
     /**
      * @returns `true` if the `Result` is `Err`.
@@ -404,7 +402,7 @@ export class Result {
     is_ok_and(f) {
         return this.match({
             Ok: f,
-            Err: (_) => false
+            Err: (_) => false,
         });
     }
     /**
@@ -419,7 +417,7 @@ export class Result {
     is_err_and(f) {
         return this.match({
             Ok: (_) => false,
-            Err: f
+            Err: f,
         });
     }
     /**
@@ -434,7 +432,7 @@ export class Result {
     ok() {
         return this.match({
             Ok: (x) => Option.Some(x),
-            Err: (_) => Option.None()
+            Err: (_) => Option.None(),
         });
     }
     /**
@@ -449,7 +447,7 @@ export class Result {
     err() {
         return this.match({
             Ok: (_) => Option.None(),
-            Err: (x) => Option.Some(x)
+            Err: (x) => Option.Some(x),
         });
     }
     /**
@@ -465,7 +463,7 @@ export class Result {
     map(f) {
         return this.match({
             Ok: (t) => Result.Ok(f(t)),
-            Err: (e) => Result.Err(e)
+            Err: (e) => Result.Err(e),
         });
     }
     /**
@@ -482,7 +480,7 @@ export class Result {
     map_or(dft, f) {
         return this.match({
             Ok: f,
-            Err: (_) => dft
+            Err: (_) => dft,
         });
     }
     /**
@@ -499,7 +497,7 @@ export class Result {
     map_or_else(dft, f) {
         return this.match({
             Ok: f,
-            Err: dft
+            Err: dft,
         });
     }
     /**
@@ -515,7 +513,7 @@ export class Result {
     map_err(op) {
         return this.match({
             Ok: (val) => Result.Ok(val),
-            Err: (e) => Result.Err(op(e))
+            Err: (e) => Result.Err(op(e)),
         });
     }
     /**
@@ -533,7 +531,7 @@ export class Result {
             Ok: (t) => t,
             Err: (e) => {
                 throw new Error(`called Result.unwrap() on an Err value: ${e}`);
-            }
+            },
         });
     }
     /**
@@ -565,7 +563,7 @@ export class Result {
     unwrap_or_else(op) {
         return this.match({
             Ok: (t) => t,
-            Err: op
+            Err: op,
         });
     }
     /**
@@ -602,7 +600,7 @@ export class Result {
             Ok: (t) => t,
             Err: (e) => {
                 throw new Error(`${msg}: ${e}`);
-            }
+            },
         });
     }
     /**
@@ -639,7 +637,7 @@ export class Result {
     and(res) {
         return this.match({
             Ok: (_) => res,
-            Err: (e) => Result.Err(e)
+            Err: (e) => Result.Err(e),
         });
     }
     /**
@@ -655,7 +653,7 @@ export class Result {
     and_then(op) {
         return this.match({
             Ok: op,
-            Err: (e) => Result.Err(e)
+            Err: (e) => Result.Err(e),
         });
     }
     /**
@@ -673,7 +671,7 @@ export class Result {
     or(res) {
         return this.match({
             Ok: (v) => Result.Ok(v),
-            Err: (_) => res
+            Err: (_) => res,
         });
     }
     /**
@@ -689,7 +687,7 @@ export class Result {
     or_else(op) {
         return this.match({
             Ok: (t) => Result.Ok(t),
-            Err: op
+            Err: op,
         });
     }
     /**
@@ -711,9 +709,47 @@ export class Result {
      * });
      */
     match(cases) {
-        if (__classPrivateFieldGet(this, _Result_val, "f"))
-            return cases.Ok(__classPrivateFieldGet(this, _Result_val, "f"));
-        return cases.Err(__classPrivateFieldGet(this, _Result_err, "f"));
+        // biome-ignore lint/style/noNonNullAssertion: <Should not happen ever.>
+        return __classPrivateFieldGet(this, _Result_val, "f") === null ? cases.Err(__classPrivateFieldGet(this, _Result_err, "f")) : cases.Ok(__classPrivateFieldGet(this, _Result_val, "f"));
     }
 }
 _Result_val = new WeakMap(), _Result_err = new WeakMap();
+/**
+ * Helper function for `Option.Some`.
+ * @param value - The value to be `Some`.
+ * @returns Option<T> with `Some` = `value`.
+ * @example
+ * const option = Option.Some(10);
+ */
+export function Some(value) {
+    return Option.Some(value);
+}
+/**
+ * Helper function for `Option.None`.
+ * @returns Option<T> with `None`.
+ * @example
+ * const option = Option.None();
+ */
+export function None() {
+    return Option.None();
+}
+/**
+ * Helper function for `Result.Ok`.
+ * @param value - The value to be `Ok`.
+ * @returns `Result<T, E>` with `Ok` = `value`.
+ * @example
+ * const result = Result.Ok(10);
+ */
+export function Ok(value) {
+    return Result.Ok(value);
+}
+/**
+ * Helper function for `Result.Err`.
+ * @param error - The error to be `Err`.
+ * @returns `Result<T, E>` with `Err` = `error`.
+ * @example
+ * const result = Result.Err("something went wrong");
+ */
+export function Err(error) {
+    return Result.Err(error);
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,373 @@
+// src/index.test.ts
+import { describe, expect, it } from "vitest";
+import { Option, Result } from "./index";
+// ==================== Option ====================
+describe("Option.Some", () => {
+    it("should create a Some value", () => {
+        expect(Option.Some(42).is_some()).toBe(true);
+    });
+    it("should not be None", () => {
+        expect(Option.Some(42).is_none()).toBe(false);
+    });
+});
+describe("Option.None", () => {
+    it("should create a None value", () => {
+        expect(Option.None().is_none()).toBe(true);
+    });
+    it("should not be Some", () => {
+        expect(Option.None().is_some()).toBe(false);
+    });
+});
+describe("Option.is_some_and", () => {
+    it("should return true if Some and predicate matches", () => {
+        expect(Option.Some(10).is_some_and((x) => x > 5)).toBe(true);
+    });
+    it("should return false if Some and predicate does not match", () => {
+        expect(Option.Some(10).is_some_and((x) => x > 20)).toBe(false);
+    });
+    it("should return false if None", () => {
+        expect(Option.None().is_some_and((x) => x > 5)).toBe(false);
+    });
+});
+describe("Option.is_none_or", () => {
+    it("should return true if None", () => {
+        expect(Option.None().is_none_or((x) => x > 5)).toBe(true);
+    });
+    it("should return true if Some and predicate matches", () => {
+        expect(Option.Some(10).is_none_or((x) => x > 5)).toBe(true);
+    });
+    it("should return false if Some and predicate does not match", () => {
+        expect(Option.Some(10).is_none_or((x) => x > 20)).toBe(false);
+    });
+});
+describe("Option.unwrap", () => {
+    it("should return the value if Some", () => {
+        expect(Option.Some(42).unwrap()).toBe(42);
+    });
+    it("should throw if None", () => {
+        expect(() => Option.None().unwrap()).toThrow();
+    });
+});
+describe("Option.unwrap_or", () => {
+    it("should return the value if Some", () => {
+        expect(Option.Some(42).unwrap_or(0)).toBe(42);
+    });
+    it("should return the default if None", () => {
+        expect(Option.None().unwrap_or(0)).toBe(0);
+    });
+});
+describe("Option.unwrap_or_else", () => {
+    it("should return the value if Some", () => {
+        expect(Option.Some(42).unwrap_or_else(() => 0)).toBe(42);
+    });
+    it("should call the lambda and return its result if None", () => {
+        expect(Option.None().unwrap_or_else(() => 0)).toBe(0);
+    });
+});
+describe("Option.expect", () => {
+    it("should return the value if Some", () => {
+        expect(Option.Some(42).expect("error")).toBe(42);
+    });
+    it("should throw with the message if None", () => {
+        expect(() => Option.None().expect("my message")).toThrow("my message");
+    });
+});
+describe("Option.map", () => {
+    it("should apply the lambda if Some", () => {
+        expect(Option.Some(10)
+            .map((x) => x * 2)
+            .unwrap()).toBe(20);
+    });
+    it("should return None if None", () => {
+        expect(Option.None()
+            .map((x) => x * 2)
+            .is_none()).toBe(true);
+    });
+});
+describe("Option.map_or", () => {
+    it("should apply the lambda if Some", () => {
+        expect(Option.Some(10).map_or(0, (x) => x * 2)).toBe(20);
+    });
+    it("should return the default if None", () => {
+        expect(Option.None().map_or(0, (x) => x * 2)).toBe(0);
+    });
+});
+describe("Option.map_or_else", () => {
+    it("should apply f if Some", () => {
+        expect(Option.Some(10).map_or_else(() => 0, (x) => x * 2)).toBe(20);
+    });
+    it("should call dft if None", () => {
+        expect(Option.None().map_or_else(() => 0, (x) => x * 2)).toBe(0);
+    });
+});
+describe("Option.ok_or", () => {
+    it("should return Ok if Some", () => {
+        expect(Option.Some("foo").ok_or("error").unwrap()).toBe("foo");
+    });
+    it("should return Err if None", () => {
+        expect(Option.None().ok_or("error").unwrap_err()).toBe("error");
+    });
+});
+describe("Option.ok_or_else", () => {
+    it("should return Ok if Some", () => {
+        expect(Option.Some("foo")
+            .ok_or_else(() => "error")
+            .unwrap()).toBe("foo");
+    });
+    it("should return Err if None", () => {
+        expect(Option.None()
+            .ok_or_else(() => "error")
+            .unwrap_err()).toBe("error");
+    });
+});
+describe("Option.and", () => {
+    it("should return optb if Some", () => {
+        expect(Option.Some("hello").and(Option.Some(3)).unwrap()).toBe(3);
+    });
+    it("should return None if None", () => {
+        expect(Option.None().and(Option.Some(3)).is_none()).toBe(true);
+    });
+});
+describe("Option.and_then", () => {
+    it("should call f and return the result if Some", () => {
+        expect(Option.Some(10)
+            .and_then((x) => Option.Some(x * 2))
+            .unwrap()).toBe(20);
+    });
+    it("should return None if None", () => {
+        expect(Option.None()
+            .and_then((x) => Option.Some(x * 2))
+            .is_none()).toBe(true);
+    });
+});
+describe("Option.or", () => {
+    it("should return self if Some", () => {
+        expect(Option.Some(2).or(Option.None()).unwrap()).toBe(2);
+    });
+    it("should return optb if None", () => {
+        expect(Option.None().or(Option.Some(100)).unwrap()).toBe(100);
+    });
+});
+describe("Option.or_else", () => {
+    it("should return self if Some", () => {
+        expect(Option.Some(2)
+            .or_else(() => Option.Some(100))
+            .unwrap()).toBe(2);
+    });
+    it("should call f and return result if None", () => {
+        expect(Option.None()
+            .or_else(() => Option.Some(100))
+            .unwrap()).toBe(100);
+    });
+});
+describe("Option.match", () => {
+    it("should call Some arm if Some", () => {
+        expect(Option.Some(42).match({
+            Some: (x) => `got ${x}`,
+            None: () => "nothing",
+        })).toBe("got 42");
+    });
+    it("should call None arm if None", () => {
+        expect(Option.None().match({
+            Some: (x) => `got ${x}`,
+            None: () => "nothing",
+        })).toBe("nothing");
+    });
+});
+// ==================== Result ====================
+describe("Result.Ok", () => {
+    it("should create an Ok value", () => {
+        expect(Result.Ok(42).is_ok()).toBe(true);
+    });
+    it("should not be Err", () => {
+        expect(Result.Ok(42).is_err()).toBe(false);
+    });
+});
+describe("Result.Err", () => {
+    it("should create an Err value", () => {
+        expect(Result.Err("oops").is_err()).toBe(true);
+    });
+    it("should not be Ok", () => {
+        expect(Result.Err("oops").is_ok()).toBe(false);
+    });
+});
+describe("Result.is_ok_and", () => {
+    it("should return true if Ok and predicate matches", () => {
+        expect(Result.Ok(10).is_ok_and((x) => x > 5)).toBe(true);
+    });
+    it("should return false if Ok and predicate does not match", () => {
+        expect(Result.Ok(10).is_ok_and((x) => x > 20)).toBe(false);
+    });
+    it("should return false if Err", () => {
+        expect(Result.Err("oops").is_ok_and((x) => x > 5)).toBe(false);
+    });
+});
+describe("Result.is_err_and", () => {
+    it("should return true if Err and predicate matches", () => {
+        expect(Result.Err("oops").is_err_and((e) => e === "oops")).toBe(true);
+    });
+    it("should return false if Err and predicate does not match", () => {
+        expect(Result.Err("oops").is_err_and((e) => e === "other")).toBe(false);
+    });
+    it("should return false if Ok", () => {
+        expect(Result.Ok(10).is_err_and((e) => e === "oops")).toBe(false);
+    });
+});
+describe("Result.ok", () => {
+    it("should return Some if Ok", () => {
+        expect(Result.Ok("hello").ok().unwrap()).toBe("hello");
+    });
+    it("should return None if Err", () => {
+        expect(Result.Err("error").ok().is_none()).toBe(true);
+    });
+});
+describe("Result.err", () => {
+    it("should return Some if Err", () => {
+        expect(Result.Err("oops").err().unwrap()).toBe("oops");
+    });
+    it("should return None if Ok", () => {
+        expect(Result.Ok(10).err().is_none()).toBe(true);
+    });
+});
+describe("Result.unwrap", () => {
+    it("should return the value if Ok", () => {
+        expect(Result.Ok(42).unwrap()).toBe(42);
+    });
+    it("should throw if Err", () => {
+        expect(() => Result.Err("oops").unwrap()).toThrow();
+    });
+});
+describe("Result.unwrap_or", () => {
+    it("should return the value if Ok", () => {
+        expect(Result.Ok(42).unwrap_or(0)).toBe(42);
+    });
+    it("should return the default if Err", () => {
+        expect(Result.Err("oops").unwrap_or(0)).toBe(0);
+    });
+});
+describe("Result.unwrap_or_else", () => {
+    it("should return the value if Ok", () => {
+        expect(Result.Ok(42).unwrap_or_else(() => 0)).toBe(42);
+    });
+    it("should call op and return its result if Err", () => {
+        expect(Result.Err("oops").unwrap_or_else(() => 0)).toBe(0);
+    });
+});
+describe("Result.unwrap_err", () => {
+    it("should return the error if Err", () => {
+        expect(Result.Err("oops").unwrap_err()).toBe("oops");
+    });
+    it("should throw if Ok", () => {
+        expect(() => Result.Ok(42).unwrap_err()).toThrow();
+    });
+});
+describe("Result.expect", () => {
+    it("should return the value if Ok", () => {
+        expect(Result.Ok(42).expect("error")).toBe(42);
+    });
+    it("should throw with the message if Err", () => {
+        expect(() => Result.Err("oops").expect("my message")).toThrow("my message");
+    });
+});
+describe("Result.expect_err", () => {
+    it("should return the error if Err", () => {
+        expect(Result.Err("oops").expect_err("error")).toBe("oops");
+    });
+    it("should throw with the message if Ok", () => {
+        expect(() => Result.Ok(42).expect_err("my message")).toThrow("my message");
+    });
+});
+describe("Result.map", () => {
+    it("should apply f if Ok", () => {
+        expect(Result.Ok(10)
+            .map((x) => x * 2)
+            .unwrap()).toBe(20);
+    });
+    it("should return Err untouched if Err", () => {
+        expect(Result.Err("oops")
+            .map((x) => x * 2)
+            .unwrap_err()).toBe("oops");
+    });
+});
+describe("Result.map_or", () => {
+    it("should apply f if Ok", () => {
+        expect(Result.Ok(10).map_or(0, (x) => x * 2)).toBe(20);
+    });
+    it("should return the default if Err", () => {
+        expect(Result.Err("oops").map_or(0, (x) => x * 2)).toBe(0);
+    });
+});
+describe("Result.map_or_else", () => {
+    it("should apply f if Ok", () => {
+        expect(Result.Ok(10).map_or_else(() => 0, (x) => x * 2)).toBe(20);
+    });
+    it("should call dft if Err", () => {
+        expect(Result.Err("oops").map_or_else(() => 0, (x) => x * 2)).toBe(0);
+    });
+});
+describe("Result.map_err", () => {
+    it("should apply op to the error if Err", () => {
+        expect(Result.Err("oops")
+            .map_err((e) => e.length)
+            .unwrap_err()).toBe(4);
+    });
+    it("should return Ok untouched if Ok", () => {
+        expect(Result.Ok(10)
+            .map_err((e) => e.length)
+            .unwrap()).toBe(10);
+    });
+});
+describe("Result.and", () => {
+    it("should return res if Ok", () => {
+        expect(Result.Ok(10).and(Result.Ok(20)).unwrap()).toBe(20);
+    });
+    it("should return Err if Err", () => {
+        expect(Result.Err("oops").and(Result.Ok(20)).unwrap_err()).toBe("oops");
+    });
+});
+describe("Result.and_then", () => {
+    it("should call op and return its result if Ok", () => {
+        expect(Result.Ok(10)
+            .and_then((x) => Result.Ok(x * 2))
+            .unwrap()).toBe(20);
+    });
+    it("should return Err if Err", () => {
+        expect(Result.Err("oops")
+            .and_then((x) => Result.Ok(x * 2))
+            .unwrap_err()).toBe("oops");
+    });
+});
+describe("Result.or", () => {
+    it("should return self if Ok", () => {
+        expect(Result.Ok(10).or(Result.Err("late")).unwrap()).toBe(10);
+    });
+    it("should return res if Err", () => {
+        expect(Result.Err("oops").or(Result.Ok(0)).unwrap()).toBe(0);
+    });
+});
+describe("Result.or_else", () => {
+    it("should return self if Ok", () => {
+        expect(Result.Ok(10)
+            .or_else(() => Result.Ok(0))
+            .unwrap()).toBe(10);
+    });
+    it("should call op and return its result if Err", () => {
+        expect(Result.Err("oops")
+            .or_else(() => Result.Ok(0))
+            .unwrap()).toBe(0);
+    });
+});
+describe("Result.match", () => {
+    it("should call Ok arm if Ok", () => {
+        expect(Result.Ok(42).match({
+            Ok: (x) => `got ${x}`,
+            Err: (e) => `error: ${e}`,
+        })).toBe("got 42");
+    });
+    it("should call Err arm if Err", () => {
+        expect(Result.Err("oops").match({
+            Ok: (x) => `got ${x}`,
+            Err: (e) => `error: ${e}`,
+        })).toBe("error: oops");
+    });
+});

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "result_option",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Result and Option types for typescript.",
   "main": "./dist/index.ts",
   "module": "./dist/index.mts",
   "types": "./dist/index.d.ts",
+  "repository": "https://github.com/Cunha-Renato/result_option",
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE.APACHE",
+    "LICENSE.MIT"
   ],
   "keywords": [
     "Result",
@@ -14,7 +18,7 @@
     "Type"
   ],
   "author": "Renato Cunha",
-  "license": "ISC",
+  "license": "MIT or Apache-2.0",
   "dependencies": {
     "typescript": "^6.0.2"
   },