@tempots/std 0.11.0 → 0.13.0

package/validation.d.ts

@@ -1,24 +1,92 @@
 import { Result } from './result';
 
+/**
+ * Represents a valid result.
+ * @public
+ */
 export interface Valid {
     type: 'valid';
 }
+/**
+ * Represents an invalid value with an associated error.
+ * @typeParam E - The type of the error.
+ * @public
+ */
 export interface Invalid<E> {
     type: 'invalid';
     error: E;
 }
+/**
+ * Represents a type that can either be `Valid` or `Invalid`.
+ * @typeParam E - The type of the error associated with an `Invalid` value.
+ * @public
+ */
 export type Validation<E> = Valid | Invalid<E>;
+/**
+ * Represents a promise that resolves to a `Validation` object.
+ * @typeParam E - The type of the error value in the `Validation` object.
+ * @public
+ */
 export type PromiseValidation<E> = PromiseLike<Validation<E>>;
+/**
+ * Utility functions for working with `Validation` types.
+ * @public
+ */
 export declare const Validation: {
+    /**
+     * Creates a valid `Validation`.
+     * @returns A `Validation` that is `Valid`.
+     */
     valid: {
         type: "valid";
     };
+    /**
+     * Creates an invalid `Validation`.
+     * @param error - The error associated with the invalid value.
+     * @returns A `Validation` that is `Invalid`.
+     */
     invalid<E>(error: E): Validation<E>;
+    /**
+     * Checks if a `Validation` is `Valid`.
+     * @param r - The `Validation` to check.
+     * @returns `true` if the `Validation` is `Valid`, otherwise `false`.
+     */
     isValid<E>(r: Validation<E>): r is Valid;
+    /**
+     * Checks if a `Validation` is `Invalid`.
+     * @param r - The `Validation` to check.
+     * @returns `true` if the `Validation` is `Invalid`, otherwise `false`.
+     */
     isInvalid<E>(r: Validation<E>): r is Invalid<E>;
-    cmatch: <V, E>(valid: () => V, invalid: (error: E) => V) => (r: Validation<E>) => V;
+    /**
+     * Maps the value of a `Validation` to a new value.
+     * @param r - The `Validation` to map.
+     * @param valid - The mapping function for a valid value.
+     * @param invalid - The mapping function for an invalid value.
+     * @returns The mapped value.
+     */
     match: <V, E>(r: Validation<E>, valid: () => V, invalid: (error: E) => V) => V;
-    toResult: <T, E>(value: T) => ((validation: Validation<E>) => Result<T, E>);
-    whenValid: <E>(apply: () => void) => (r: Validation<E>) => Validation<E>;
-    whenInvalid: <E>(apply: (e: E) => void) => (r: Validation<E>) => Validation<E>;
+    /**
+     * Maps the value of a `Validation` to a new `Validation`.
+     * @param validation - The `Validation` to map.
+     * @param value - The value to map.
+     * @returns A new `Validation` with the mapped value.
+     */
+    toResult: <T, E>(validation: Validation<E>, value: T) => Result<T, E>;
+    /**
+     * Execute a function when the `Validation` is valid.
+     *
+     * @param r - The `Validation` to check.
+     * @param apply - The function to execute when the `Validation` is valid.
+     * @returns The `Validation` object.
+     */
+    whenValid: <E>(r: Validation<E>, apply: () => void) => Validation<E>;
+    /**
+     * Execute a function when the `Validation` is invalid.
+     *
+     * @param r - The `Validation` to check.
+     * @param apply - The function to execute when the `Validation` is invalid.
+     * @returns The `Validation` object.
+     */
+    whenInvalid: <E>(r: Validation<E>, apply: (e: E) => void) => Validation<E>;
 };

package/validation.js

@@ -1,25 +1,4 @@
-import { Result as a } from "./result.js";
-const r = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  valid: { type: "valid" },
-  invalid(i) {
-    return { type: "invalid", error: i };
-  },
-  isValid(i) {
-    return i.type === "valid";
-  },
-  isInvalid(i) {
-    return i.type === "invalid";
-  },
-  cmatch: (i, e) => (t) => r.isValid(t) ? i() : e(t.error),
-  match: (i, e, t) => r.isValid(i) ? e() : t(i.error),
-  toResult: (i) => r.cmatch(
-    () => a.success(i),
-    (e) => a.failure(e)
-  ),
-  whenValid: (i) => (e) => (r.isValid(e) && i(), e),
-  whenInvalid: (i) => (e) => (r.isInvalid(e) && i(e.error), e)
-};
+import { V as i } from "./result-Czm7RKNP.js";
 export {
-  r as Validation
+  i as Validation
 };

package/maybe.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e={nothing:void 0,just:t=>t,isNothing:t=>t==null,isJust:t=>t!=null};exports.Maybe=e;

package/maybe.d.ts

@@ -1,9 +0,0 @@
-export type Maybe<T> = Just<T> | Nothing;
-export type Nothing = undefined;
-export type Just<T> = NonNullable<T>;
-export declare const Maybe: {
-    nothing: Maybe<never>;
-    just: <T>(value: T) => Maybe<T>;
-    isNothing: <T>(maybe: Maybe<T>) => maybe is Nothing;
-    isJust: <T>(maybe: Maybe<T>) => maybe is Just<T>;
-};

package/maybe.js

@@ -1,9 +0,0 @@
-const t = {
-  nothing: void 0,
-  just: (n) => n,
-  isNothing: (n) => n == null,
-  isJust: (n) => n != null
-};
-export {
-  t as Maybe
-};