@chocbite/ts-lib-result 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,151 @@
+interface OptionBase<T> {
+    /**Is true when a value is available*/
+    readonly some: boolean;
+    /**Is true when no value is available*/
+    readonly none: boolean;
+    /**The value*/
+    readonly value?: T;
+    /**Returns the contained value, if exists. Throws an error if not.
+     * @param msg the message to throw if no value exists.*/
+    expect(msg: string): T;
+    /**Returns the contained value, if exists. Throws an error if not.*/
+    get unwrap(): T;
+    /**Returns the contained value or a provided default.
+     * @param value value to use as default*/
+    unwrap_or<T2>(value: T2): T | T2;
+    /**Calls mapper if the Option is `Some`, otherwise returns `None`.
+     * This function can be used for control flow based on `Optional` values.*/
+    and_then<T2>(mapper: (value: T) => OptionSome<T2>): Option<T2>;
+    and_then(mapper: (value: T) => OptionNone): Option<T>;
+    and_then<T2>(mapper: (value: T) => Option<T2>): Option<T2>;
+    /**Calls mapper if the Option is `None`, otherwise returns `Some`.
+     * This function can be used for control flow based on `Optional` values.*/
+    or_else<T2>(mapper: () => OptionSome<T2>): Option<T2>;
+    or_else(mapper: () => OptionNone): Option<T>;
+    or_else<T2>(mapper: () => Option<T2>): Option<T2>;
+    /**Maps an `Optional<T>` to `Optional<U>` by applying a function to a contained `Some` value, leaving a `None` value untouched.
+     * This function can be used to compose the Options of two functions.*/
+    map<U>(mapper: (value: T) => U): Option<U>;
+    /**Compares two `Optional<T>` values for equality.
+     * @returns true if equal, false otherwise. */
+    compare(other: Option<T>): boolean;
+    /**Maps an `Optional<T>` to a `Result<T, E>`.*/
+    to_result<E>(error: E): Result<T, E>;
+}
+declare class OptionSome<T> implements OptionBase<T> {
+    readonly value: T;
+    constructor(value: T);
+    get some(): true;
+    get none(): false;
+    expect(): T;
+    get unwrap(): T;
+    unwrap_or(): T;
+    and_then<T2>(mapper: (value: T) => OptionSome<T2>): OptionSome<T2>;
+    and_then(mapper: (value: T) => OptionNone): OptionNone;
+    and_then<T2>(mapper: (value: T) => Option<T2>): Option<T2>;
+    or_else(): OptionSome<T>;
+    map<U>(mapper: (value: T) => U): OptionSome<U>;
+    compare(other: Option<T>): boolean;
+    to_result(): ResultOk<T>;
+}
+declare class OptionNone implements OptionBase<never> {
+    get some(): false;
+    get none(): true;
+    expect(msg: string): never;
+    get unwrap(): never;
+    unwrap_or<T2>(val: T2): T2;
+    and_then(): OptionNone;
+    or_else<T2>(mapper: () => OptionSome<T2>): OptionSome<T2>;
+    or_else(mapper: () => OptionNone): OptionNone;
+    or_else<T2>(mapper: () => Option<T2>): Option<T2>;
+    map(): OptionNone;
+    compare(other: Option<never>): boolean;
+    to_result<E>(error: E): ResultErr<E>;
+}
+interface ResultBase<T, E> {
+    /**Is true when the result is valid and false when it is invalid*/
+    readonly ok: boolean;
+    /**Is false when the result is valid and true when it is invalid*/
+    readonly err: boolean;
+    /**The value for the result, only exists when it is valid*/
+    readonly value?: T;
+    /**The error for the result, only exists when it is invalid*/
+    readonly error?: E;
+    /**Returns the contained valid value, if exists. Throws an error if not.
+     * @param msg the message to throw if the value is invalid.*/
+    expect(msg: string): T;
+    /**Returns the contained valid value, if does not exist. Throws an error if it does.
+     * @param msg the message to throw if the value is valid.*/
+    expect_err(msg: string): E;
+    /**Returns the contained valid value.
+     * Throws if the value is invalid, with a message provided by the error's value.*/
+    get unwrap(): T;
+    /**Returns the contained valid value or a provided default.*/
+    unwrap_or<T2>(value: T2): T | T2;
+    /**Calls mapper function if the result is valid, otherwise returns the error value of self.
+     * This function can be used for control flow based on `Result` values.*/
+    and_then<T2>(mapper: (value: T) => ResultOk<T2>): Result<T2, E>;
+    and_then<E2>(mapper: (value: T) => ResultErr<E2>): Result<T, E2>;
+    and_then<T2, E2>(mapper: (value: T) => Result<T2, E2>): Result<T2, E2>;
+    /**Calls mapper function if the result is an error, otherwise returns the value self.
+     * This function can be used for control flow based on `Result` values.*/
+    or_else<T2>(mapper: (error: E) => ResultOk<T2>): Result<T2, E>;
+    or_else<E2>(mapper: (error: E) => ResultErr<E2>): Result<T, E2>;
+    or_else<T2, E2>(mapper: (error: E) => Result<T2, E2>): Result<T2, E2>;
+    /**Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained valid value, leaving an error value untouched.
+     * This function can be used to compose the results of two functions.*/
+    map<U>(mapper: (value: T) => U): Result<U, E>;
+    /**Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained error value, leaving a valid value untouched.
+     * This function can be used to pass through a successful result while handling an error.*/
+    map_err<F>(mapper: (error: E) => F): Result<T, F>;
+    /**Compares two `Result<T, E>` values for equality.
+     * @returns true if equal, false otherwise. */
+    compare(other: Result<T, E>): boolean;
+    /**Converts from `Result<T, E>` to `Optional<T>`, discarding the error if any*/
+    get to_option(): Option<T>;
+}
+declare class ResultOk<T> implements ResultBase<T, never> {
+    readonly value: T;
+    constructor(value: T);
+    get ok(): true;
+    get err(): false;
+    expect(): T;
+    expect_err(msg: string): never;
+    get unwrap(): T;
+    unwrap_or(): T;
+    and_then<T2>(mapper: (value: T) => ResultOk<T2>): ResultOk<T2>;
+    and_then<E2>(mapper: (value: T) => ResultErr<E2>): ResultErr<E2>;
+    and_then<T2, E2>(mapper: (value: T) => Result<T2, E2>): Result<T2, E2>;
+    or_else(): ResultOk<T>;
+    map<U>(func: (value: T) => U): ResultOk<U>;
+    map_err(): ResultOk<T>;
+    compare(other: Result<T, any>): boolean;
+    get to_option(): OptionSome<T>;
+}
+declare class ResultErr<E> implements ResultBase<never, E> {
+    readonly error: E;
+    constructor(error: E);
+    get valid(): false;
+    get ok(): false;
+    get err(): true;
+    expect(msg: string): never;
+    expect_err(): E;
+    get unwrap(): never;
+    unwrap_or<T2>(val: T2): T2;
+    and_then(): ResultErr<E>;
+    or_else<T2>(mapper: (error: E) => ResultOk<T2>): ResultOk<T2>;
+    or_else<E2>(mapper: (error: E) => ResultErr<E2>): ResultErr<E2>;
+    or_else<T2, E2>(mapper: (error: E) => Result<T2, E2>): Result<T2, E2>;
+    map(): ResultErr<E>;
+    map_err<F>(mapper: (error: E) => F): ResultErr<F>;
+    compare(other: Result<any, E>): boolean;
+    get to_option(): OptionNone;
+}
+type Result<T, E> = ResultOk<T> | ResultErr<E>;
+type Option<T> = OptionSome<T> | OptionNone;
+declare function ok<T>(value: T): ResultOk<T>;
+declare function err<E>(error: E): ResultErr<E>;
+declare function some<T>(value: T): OptionSome<T>;
+declare function none(): OptionNone;
+
+export { type Option, OptionNone, OptionSome, type Result, ResultErr, ResultOk, err, none, ok, some };

package/dist/index.js

@@ -0,0 +1,178 @@
+// src/index.ts
+var OptionSome = class _OptionSome {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  get some() {
+    return true;
+  }
+  get none() {
+    return false;
+  }
+  expect() {
+    return this.value;
+  }
+  get unwrap() {
+    return this.value;
+  }
+  unwrap_or() {
+    return this.value;
+  }
+  and_then(mapper) {
+    return mapper(this.value);
+  }
+  or_else() {
+    return this;
+  }
+  map(mapper) {
+    return new _OptionSome(mapper(this.value));
+  }
+  compare(other) {
+    return other.some && this.value === other.value;
+  }
+  to_result() {
+    return new ResultOk(this.value);
+  }
+};
+var OptionNone = class {
+  get some() {
+    return false;
+  }
+  get none() {
+    return true;
+  }
+  expect(msg) {
+    throw new Error(msg);
+  }
+  get unwrap() {
+    throw new Error(`Tried to unwrap None`);
+  }
+  unwrap_or(val) {
+    return val;
+  }
+  and_then() {
+    return this;
+  }
+  or_else(mapper) {
+    return mapper();
+  }
+  map() {
+    return this;
+  }
+  compare(other) {
+    return other.none;
+  }
+  to_result(error) {
+    return new ResultErr(error);
+  }
+};
+var ResultOk = class _ResultOk {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  get ok() {
+    return true;
+  }
+  get err() {
+    return false;
+  }
+  expect() {
+    return this.value;
+  }
+  expect_err(msg) {
+    throw new Error(msg);
+  }
+  get unwrap() {
+    return this.value;
+  }
+  unwrap_or() {
+    return this.value;
+  }
+  and_then(mapper) {
+    return mapper(this.value);
+  }
+  or_else() {
+    return this;
+  }
+  map(func) {
+    return new _ResultOk(func(this.value));
+  }
+  map_err() {
+    return this;
+  }
+  compare(other) {
+    return other.ok && this.value === other.value;
+  }
+  get to_option() {
+    return new OptionSome(this.value);
+  }
+};
+var ResultErr = class _ResultErr {
+  error;
+  constructor(error) {
+    this.error = error;
+  }
+  get valid() {
+    return false;
+  }
+  get ok() {
+    return false;
+  }
+  get err() {
+    return true;
+  }
+  expect(msg) {
+    throw new Error(msg + "\nOriginal " + this.error);
+  }
+  expect_err() {
+    return this.error;
+  }
+  get unwrap() {
+    throw new Error("Tried to unwrap Error\nOriginal " + this.error);
+  }
+  unwrap_or(val) {
+    return val;
+  }
+  and_then() {
+    return this;
+  }
+  or_else(mapper) {
+    return mapper(this.error);
+  }
+  map() {
+    return this;
+  }
+  map_err(mapper) {
+    return new _ResultErr(mapper(this.error));
+  }
+  compare(other) {
+    return other.err && this.error === other.error;
+  }
+  get to_option() {
+    return new OptionNone();
+  }
+};
+function ok(value) {
+  return new ResultOk(value);
+}
+function err(error) {
+  return new ResultErr(error);
+}
+function some(value) {
+  return new OptionSome(value);
+}
+function none() {
+  return new OptionNone();
+}
+export {
+  OptionNone,
+  OptionSome,
+  ResultErr,
+  ResultOk,
+  err,
+  none,
+  ok,
+  some
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@chocbite/ts-lib-result",
+  "version": "1.0.0",
+  "description": "Rust like result type for TypeScript",
+  "author": "chocolateandmilkwin",
+  "license": "MIT",
+  "type": "module",
+  "private": false,
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite --port 9951",
+    "build": "tsup src/index.ts --format esm --dts",
+    "lint": "eslint src/**/*.ts",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsup": "^8.0.0",
+    "vite": "^7.0.0",
+    "vitest": "^4.0.0",
+    "eslint": "^9.0.0",
+    "typescript-eslint": "^8.0.0",
+    "@vitest/browser-playwright": "^4.0.0"
+  }
+}