functype 0.8.61 → 0.8.62

package/dist/list/index.mjs

@@ -1,2 +1,5 @@
-export{h as List}from'../chunk-A3EHNBZM.mjs';import'../chunk-OQWAJKZJ.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+import { e as r } from "../index-CgMYHgdG.mjs";
+export {
+  r as List
+};
+//# sourceMappingURL=index.mjs.map

package/dist/list/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/map/Map.d.ts

@@ -0,0 +1,19 @@
+import { Collection } from '../collections';
+import { Traversable, Typeable } from '../index';
+import { IterableType } from '../iterable';
+import { Option } from '../option/Option';
+import { Tuple } from '../tuple/Tuple';
+import { Valuable } from '../valuable/Valuable';
+import { IESMap } from './shim';
+type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap">;
+export type Map<K, V> = {
+    add(item: Tuple<[K, V]>): Map<K, V>;
+    remove(value: K): Map<K, V>;
+    map<U>(f: (value: V) => U): Map<K, U>;
+    flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => IterableType<[K2, V2]>): Map<K2, V2>;
+    get(key: K): Option<V>;
+    getOrElse(key: K, defaultValue: V): V;
+    orElse(key: K, alternative: Option<V>): Option<V>;
+} & SafeTraversable<K, V> & Collection<Tuple<[K, V]>> & Typeable<"Map"> & Valuable<"Map", IESMap<K, V>>;
+export declare const Map: <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map<K, V>;
+export {};

package/dist/map/index.d.ts

@@ -1,3 +1,2 @@
-export { M as Map } from '../option/index.js';
-import '../Tuple-GXgoHfiN.js';
-import '../branded/index.js';
+export * from './Map';
+export * from './shim';

package/dist/map/index.mjs

@@ -1,2 +1,7 @@
-export{z as Map}from'../chunk-A3EHNBZM.mjs';import'../chunk-OQWAJKZJ.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+import "../index-CgMYHgdG.mjs";
+import { M as t } from "../Map-BNxKlujn.mjs";
+import "../tuple/index.mjs";
+export {
+  t as Map
+};
+//# sourceMappingURL=index.mjs.map

package/dist/map/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/map/shim.d.ts

@@ -0,0 +1,2 @@
+export type IESMap<K, V> = Map<K, V>;
+export declare const ESMap: MapConstructor;

package/dist/option/Option.d.ts

@@ -0,0 +1,164 @@
+import { AsyncFunctor, Functor, Type } from '../functor';
+import { Typeable } from '../typeable/Typeable';
+import { Valuable } from '../valuable/Valuable';
+import { Either, List, Traversable } from '../index';
+/**
+ * Option type module
+ * @module Option
+ * @category Core
+ */
+/**
+ * The Option type represents a value that may or may not exist.
+ * It's used to handle potentially null or undefined values in a type-safe way.
+ * @typeParam T - The type of the value contained in the Option
+ */
+export type Option<T extends Type> = {
+    /** Tag identifying if this is a Some or None variant */
+    readonly _tag: "Some" | "None";
+    /** The contained value (undefined for None) */
+    readonly value: T | undefined;
+    /** Whether this Option contains no value */
+    isEmpty: boolean;
+    /**
+     * Extracts the value if present
+     * @throws Error if the Option is None
+     * @returns The contained value
+     */
+    get(): T;
+    /**
+     * Returns the contained value or a default value if None
+     * @param defaultValue - The value to return if this Option is None
+     * @returns The contained value or defaultValue
+     */
+    getOrElse(defaultValue: T): T;
+    /**
+     * Returns the contained value or throws a specified error if None
+     * @param error - The error to throw if this Option is None
+     * @returns The contained value
+     * @throws The specified error if the Option is None
+     */
+    getOrThrow(error: Error): T;
+    /**
+     * Returns this Option if it contains a value, otherwise returns the alternative
+     * @param alternative - The alternative Option to return if this is None
+     * @returns This Option or the alternative
+     */
+    orElse(alternative: Option<T>): Option<T>;
+    /**
+     * Returns the contained value or null if None
+     * @returns The contained value or null
+     */
+    orNull(): T | null;
+    /**
+     * Maps the value inside the Option using the provided function
+     * @param f - The mapping function
+     * @returns A new Option containing the mapped value, or None if this Option is None
+     */
+    map<U extends Type>(f: (value: T) => U): Option<U>;
+    /**
+     * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
+     * @param predicate - The predicate function to test the value
+     * @returns This Option or None
+     */
+    filter(predicate: (value: T) => boolean): Option<T>;
+    /**
+     * Maps the value using a function that returns an Option
+     * @param f - The mapping function returning an Option
+     * @returns The result of applying f to the contained value, or None if this Option is None
+     */
+    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
+    /**
+     * Maps the value using an async function that returns an Option
+     * @param f - The async mapping function returning an Option
+     * @returns Promise of the result of applying f to the contained value, or None if this Option is None
+     */
+    flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>;
+    /**
+     * Applies a binary operator to a start value and the contained value
+     * @param f - The binary operator
+     * @returns The result of the reduction
+     */
+    reduce<U>(f: (acc: U, value: T) => U): U;
+    /**
+     * Applies a binary operator to the contained value and a start value
+     * @param f - The binary operator
+     * @returns The result of the reduction
+     */
+    reduceRight<U>(f: (acc: U, value: T) => U): U;
+    /**
+     * Pattern matches over the Option, applying onNone if None and onSome if Some
+     * @param onNone - Function to apply if the Option is None
+     * @param onSome - Function to apply if the Option has a value
+     * @returns The result of applying the appropriate function
+     */
+    fold<U>(onNone: () => U, onSome: (value: T) => U): U;
+    /**
+     * Left-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
+    /**
+     * Right-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
+    /**
+     * Converts this Option to a List
+     * @returns A List containing the value if Some, or empty List if None
+     */
+    toList(): List<T>;
+    /**
+     * Checks if this Option contains the specified value
+     * @param value - The value to check for
+     * @returns true if this Option contains the value, false otherwise
+     */
+    contains(value: T): boolean;
+    /** The number of elements in this Option (0 or 1) */
+    size: number;
+    /**
+     * Converts this Option to an Either
+     * @param left - The value to use for Left if this Option is None
+     * @returns Either.Right with the contained value if Some, or Either.Left with left if None
+     */
+    toEither<E>(left: E): Either<E, T>;
+    /**
+     * Returns a string representation of this Option
+     * @returns A string representation
+     */
+    toString(): string;
+    /**
+     * Returns a simple object representation of this Option
+     * @returns An object with _tag and value properties
+     */
+    toValue(): {
+        _tag: "Some" | "None";
+        value: T;
+    };
+} & (Traversable<T> & Functor<T> & Typeable<"Some" | "None"> & Valuable<"Some" | "None", T> & AsyncFunctor<T>);
+/**
+ * Creates a Some variant of Option containing a value.
+ * @param value - The value to wrap in Some
+ * @returns A new Some instance containing the value
+ * @typeParam T - The type of the value
+ */
+export declare const Some: <T extends Type>(value: T) => Option<T>;
+/**
+ * Creates a None variant of Option representing absence of a value.
+ * @returns A new None instance
+ * @typeParam T - The type that would be contained if this was a Some
+ */
+export declare const None: <T extends Type>() => Option<T>;
+/**
+ * Safely wraps a value that might be null or undefined in an Option.
+ * Creates Some if the value is defined, None otherwise.
+ * @param value - The value to wrap (might be null/undefined)
+ * @returns Some(value) if value is defined, None otherwise
+ * @typeParam T - The type of the value
+ */
+export declare const Option: {
+    <T extends Type>(value: T | null | undefined): Option<T>;
+    from<T>(value: T): Option<T>;
+    none<T>(): Option<T>;
+};