react-state-monad 1.0.21 → 1.0.22

package/src/hooks/useFieldState.ts

@@ -1,54 +1,54 @@
-import {StateObject} from "../stateObject";
-import {ValidFieldFrom} from "./types";
-
-/**
- * Hook that derives a field from the state object and creates a new StateObject for the field's value.
- *
- * @template TOriginal - The type of the original state object.
- * @template TField - The type of the field value to be derived.
- * @param state - The StateObject containing the original state.
- * @param field - The field name to be derived from the state.
- * @returns A new StateObject for the derived field.
- */
-export function useFieldState<TOriginal, TField>(
-    state: StateObject<TOriginal>,
-    field: ValidFieldFrom<TOriginal, TField>
-): StateObject<TField> {
-    return state.map(
-        (original) => original[field] as TField,  // Extracts the field value.
-        (newField, original) => ({...original, [field]: newField} as TOriginal)  // Updates the field with the new value.
-    );
-}
-
-/**
- * Hook that remaps the keys of a state object to a record of StateObjects.
- *
- * @template TOriginal - The type of the original state object.
- * @template TField - The type of the field value to be derived.
- * @param state - The StateObject containing the original state.
- * @returns A record where each key is mapped to a new StateObject for the corresponding field.
- */
-
-export function useRemapKeysState<TOriginal extends object, TField>(state: StateObject<TOriginal>): Record<string, StateObject<TField>> {
-    // si state no tiene valor, retornar un invalid
-
-    if (!state.hasValue) {
-        return {} as Record<string, StateObject<TField>>;
-    }
-
-    if (Array.isArray(state.value)) {
-        console.warn('useRemapKeysState should be used with objects, use useRemapArray for arrays');
-        return {} as Record<string, StateObject<TField>>;
-    }
-
-    const keys = Object.keys(state.value); 
-
-    return keys.reduce((acc, key) => {
-        acc[key] = useFieldState(state, key as ValidFieldFrom<TOriginal, TField>);
-        return acc;
-    }, {} as Record<string, StateObject<TField>>);
-}
-
- 
-
+import {StateObject} from "../stateObject";
+import {ValidFieldFrom} from "./types";
+
+/**
+ * Hook that derives a field from the state object and creates a new StateObject for the field's value.
+ *
+ * @template TOriginal - The type of the original state object.
+ * @template TField - The type of the field value to be derived.
+ * @param state - The StateObject containing the original state.
+ * @param field - The field name to be derived from the state.
+ * @returns A new StateObject for the derived field.
+ */
+export function useFieldState<TOriginal, TField>(
+    state: StateObject<TOriginal>,
+    field: ValidFieldFrom<TOriginal, TField>
+): StateObject<TField> {
+    return state.map(
+        (original) => original[field] as TField,  // Extracts the field value.
+        (newField, original) => ({...original, [field]: newField} as TOriginal)  // Updates the field with the new value.
+    );
+}
+
+/**
+ * Hook that remaps the keys of a state object to a record of StateObjects.
+ *
+ * @template TOriginal - The type of the original state object.
+ * @template TField - The type of the field value to be derived.
+ * @param state - The StateObject containing the original state.
+ * @returns A record where each key is mapped to a new StateObject for the corresponding field.
+ */
+
+export function useRemapKeysState<TOriginal extends object, TField>(state: StateObject<TOriginal>): Record<string, StateObject<TField>> {
+    // si state no tiene valor, retornar un invalid
+
+    if (!state.hasValue) {
+        return {} as Record<string, StateObject<TField>>;
+    }
+
+    if (Array.isArray(state.value)) {
+        console.warn('useRemapKeysState should be used with objects, use useRemapArray for arrays');
+        return {} as Record<string, StateObject<TField>>;
+    }
+
+    const keys = Object.keys(state.value); 
+
+    return keys.reduce((acc, key) => {
+        acc[key] = useFieldState(state, key as ValidFieldFrom<TOriginal, TField>);
+        return acc;
+    }, {} as Record<string, StateObject<TField>>);
+}
+
+ 
+
     

package/src/hooks/useNullSafety.ts

@@ -1,24 +1,24 @@
-import {StateObject} from "../stateObject";
-import {ValidState} from "../implementations/validState";
-import {EmptyState} from "../implementations/emptyState";
-
-/**
- * Hook that ensures a StateObject contains a defined, non-null value.
- * If the StateObject's value is `undefined` or `null`, it returns an EmptyState.
- * Otherwise, it returns a ValidState with the value and a setter to update the value.
- *
- * @template TOrigin - The type of the value contained in the StateObject.
- * @param state - The StateObject which may contain a value, `undefined`, or `null`.
- * @returns A new StateObject containing the value if it is defined and non-null,
- *          otherwise an EmptyState.
- */
-export function useNullSafety<TOrigin>(state: StateObject<TOrigin | undefined | null>): StateObject<TOrigin> {
-
-    if (!state.hasValue) return new EmptyState<TOrigin>();
-
-    if (state.value === undefined) return new EmptyState<TOrigin>();
-
-    if (state.value === null) return new EmptyState<TOrigin>();
-
-    return new ValidState<TOrigin>(state.value, (value: TOrigin) => state.value = value);
+import {StateObject} from "../stateObject";
+import {ValidState} from "../implementations/validState";
+import {EmptyState} from "../implementations/emptyState";
+
+/**
+ * Hook that ensures a StateObject contains a defined, non-null value.
+ * If the StateObject's value is `undefined` or `null`, it returns an EmptyState.
+ * Otherwise, it returns a ValidState with the value and a setter to update the value.
+ *
+ * @template TOrigin - The type of the value contained in the StateObject.
+ * @param state - The StateObject which may contain a value, `undefined`, or `null`.
+ * @returns A new StateObject containing the value if it is defined and non-null,
+ *          otherwise an EmptyState.
+ */
+export function useNullSafety<TOrigin>(state: StateObject<TOrigin | undefined | null>): StateObject<TOrigin> {
+
+    if (!state.hasValue) return new EmptyState<TOrigin>();
+
+    if (state.value === undefined) return new EmptyState<TOrigin>();
+
+    if (state.value === null) return new EmptyState<TOrigin>();
+
+    return new ValidState<TOrigin>(state.value, (value: TOrigin) => state.value = value);
 }

package/src/hooks/useRemapArray.ts

@@ -1,50 +1,50 @@
-import {StateObject} from "../stateObject";
-import {ValidState} from "../implementations/validState";
-import {useState} from "react";
-import {useStateObject} from "./useStateObject";
-
-/**
- * Hook that maps each element in an array within a StateObject to a new StateObject,
- * allowing for independent updates of each element while keeping the overall array state synchronized.
- *
- * @template T - The type of the array elements.
- * @param state - The StateObject containing an array.
- * @returns An array of new StateObjects, each representing an element in the original array,
- *          allowing individual updates while keeping the array state synchronized.
- */
-export function useRemapArray<T>(state: StateObject<T[]>): StateObject<T>[] {
-    if (!state.hasValue) return []  // Returns an empty array if the state has no value.
-
-    const count = state.value.length
-    const result: StateObject<T>[] = []
-
-    for (let i = 0; i < count; i++) {
-        result.push(
-            new ValidState<T>(
-                state.value[i],  // The current value of the element at index i.
-                (newElement) => {  // Setter to update the element at index i in the array.
-                    const arrayCopy = [...state.value];  // Create a copy of the original array.
-                    arrayCopy[i] = newElement;  // Replace the element at index i with the new element.
-                    state.value = arrayCopy;  // Update the state with the new array, triggering a re-render.
-                }
-            )
-        )
-    }
-
-    return result  // Return the array of StateObjects representing each element.
-}
-
-
-/**
- * Hook that takes an array of StateObjects and returns a new StateObject containing that array,
- * allowing for updates to the entire array while keeping it synchronized within a single StateObject.
- *
- * @template T - The type of the elements in the array.
- * @param states - The array of StateObjects.
- * @returns A new StateObject containing the array of StateObjects, allowing for updates to the whole array.
- */
-export function useArrayState<T>(states: StateObject<T>[]): StateObject<T[]> {
-    
-    return useStateObject(states.filter(state => state.hasValue).map(state => state.value));
-
-}
+import {StateObject} from "../stateObject";
+import {ValidState} from "../implementations/validState";
+import {useState} from "react";
+import {useStateObject} from "./useStateObject";
+
+/**
+ * Hook that maps each element in an array within a StateObject to a new StateObject,
+ * allowing for independent updates of each element while keeping the overall array state synchronized.
+ *
+ * @template T - The type of the array elements.
+ * @param state - The StateObject containing an array.
+ * @returns An array of new StateObjects, each representing an element in the original array,
+ *          allowing individual updates while keeping the array state synchronized.
+ */
+export function useRemapArray<T>(state: StateObject<T[]>): StateObject<T>[] {
+    if (!state.hasValue) return []  // Returns an empty array if the state has no value.
+
+    const count = state.value.length
+    const result: StateObject<T>[] = []
+
+    for (let i = 0; i < count; i++) {
+        result.push(
+            new ValidState<T>(
+                state.value[i],  // The current value of the element at index i.
+                (newElement) => {  // Setter to update the element at index i in the array.
+                    const arrayCopy = [...state.value];  // Create a copy of the original array.
+                    arrayCopy[i] = newElement;  // Replace the element at index i with the new element.
+                    state.value = arrayCopy;  // Update the state with the new array, triggering a re-render.
+                }
+            )
+        )
+    }
+
+    return result  // Return the array of StateObjects representing each element.
+}
+
+
+/**
+ * Hook that takes an array of StateObjects and returns a new StateObject containing that array,
+ * allowing for updates to the entire array while keeping it synchronized within a single StateObject.
+ *
+ * @template T - The type of the elements in the array.
+ * @param states - The array of StateObjects.
+ * @returns A new StateObject containing the array of StateObjects, allowing for updates to the whole array.
+ */
+export function useArrayState<T>(states: StateObject<T>[]): StateObject<T[]> {
+    
+    return useStateObject(states.filter(state => state.hasValue).map(state => state.value));
+
+}

package/src/hooks/useStateObject.ts

@@ -1,15 +1,15 @@
-import {StateObject} from "../stateObject";
-import {useState} from "react";
-import {ValidState} from "../implementations/validState";
-
-/**
- * Hook that initializes a StateObject with the given initial value.
- *
- * @template T - The type of the value to be stored in the state.
- * @param initialState - The initial value of the state.
- * @returns A StateObject representing the initialized state.
- */
-export function useStateObject<T>(initialState: T): StateObject<T> {
-    const [state, setState] = useState<T>(initialState);
-    return new ValidState<T>(state, setState);  // Returns a new ValidState object with the initial state value.
+import {StateObject} from "../stateObject";
+import {useState} from "react";
+import {ValidState} from "../implementations/validState";
+
+/**
+ * Hook that initializes a StateObject with the given initial value.
+ *
+ * @template T - The type of the value to be stored in the state.
+ * @param initialState - The initial value of the state.
+ * @returns A StateObject representing the initialized state.
+ */
+export function useStateObject<T>(initialState: T): StateObject<T> {
+    const [state, setState] = useState<T>(initialState);
+    return new ValidState<T>(state, setState);  // Returns a new ValidState object with the initial state value.
 }

package/src/implementations/emptyState.ts

@@ -1,43 +1,43 @@
-import {StateObject} from "../stateObject";
-
-/**
- * Represents a state that holds no value and is considered "empty".
- * This is used as a fallback or default when there is no valid state.
- * you should NEVER use this class directly, use the `StateObject` interface instead.
- * and create instances by using the hooks
- * @template T - The type of the value that could be held by the state.
- */
-export class EmptyState<T> implements StateObject<T> {
-    // No value stored, returns an error when accessed.
-    get value(): T {
-        throw new Error("Not implemented");
-    }
-
-    get hasValue(): boolean {
-        return false;
-    }
-
-    orElse(orElse: T): T {
-        return orElse;  // Returns the fallback value when the state is empty.
-    }
-
-    do() {
-        // No operation for empty state.
-    }
-
-    filter(): StateObject<T> {
-        return this;  // The empty state remains unchanged when filtered.
-    }
-
-    set value(_: T) {
-        // No operation for setting a value in the empty state.
-    }
-
-    flatMap<U>(): StateObject<U> {
-        return new EmptyState<U>();  // Returns an empty state when flatMapped.
-    }
-
-    map<U>(): StateObject<U> {
-        return new EmptyState<U>();  // Returns an empty state when mapped.
-    }
+import {StateObject} from "../stateObject";
+
+/**
+ * Represents a state that holds no value and is considered "empty".
+ * This is used as a fallback or default when there is no valid state.
+ * you should NEVER use this class directly, use the `StateObject` interface instead.
+ * and create instances by using the hooks
+ * @template T - The type of the value that could be held by the state.
+ */
+export class EmptyState<T> implements StateObject<T> {
+    // No value stored, returns an error when accessed.
+    get value(): T {
+        throw new Error("Not implemented");
+    }
+
+    get hasValue(): boolean {
+        return false;
+    }
+
+    orElse(orElse: T): T {
+        return orElse;  // Returns the fallback value when the state is empty.
+    }
+
+    do() {
+        // No operation for empty state.
+    }
+
+    filter(): StateObject<T> {
+        return this;  // The empty state remains unchanged when filtered.
+    }
+
+    set value(_: T) {
+        // No operation for setting a value in the empty state.
+    }
+
+    flatMap<U>(): StateObject<U> {
+        return new EmptyState<U>();  // Returns an empty state when flatMapped.
+    }
+
+    map<U>(): StateObject<U> {
+        return new EmptyState<U>();  // Returns an empty state when mapped.
+    }
 }

package/src/implementations/validState.ts

@@ -1,60 +1,60 @@
-import {EmptyState} from "./emptyState";
-import {StateObject} from "../stateObject";
-
-/**
- * Represents a state that holds a valid value of type T.
- * you should NEVER use this class directly, use the `StateObject` interface instead.
- * and create instances by using the hooks
- * @template T - The type of the value stored in the state.
- */
-export class ValidState<T> implements StateObject<T> {
-    private readonly state: T;
-    private readonly setter: (state: T) => void;
-
-    constructor(state: T, setter: (state: T) => void) {
-        this.state = state;
-        this.setter = setter;
-    }
-
-    get value(): T {
-        return this.state;
-    }
-
-    do(action: (t: T) => void) {
-        action(this.state);  // Performs the given action on the state value.
-    }
-
-    orElse() {
-        return this.state;  // Returns the state value as it is valid.
-    }
-
-    set value(newState: T) {
-        this.setter(newState);  // Sets a new value for the state.
-    }
-
-    map<U>(
-        mappingFunction: (t: T) => U,
-        inverseMappingFunction: (u: U, t: T) => T
-    ): StateObject<U> {
-        const derivedState = mappingFunction(this.state);
-        const derivedSetter = (newState: U) => {
-            this.setter(inverseMappingFunction(newState, this.state));  // Updates the state with the inverse mapping.
-        };
-
-        return new ValidState<U>(derivedState, derivedSetter);  // Returns a new state object with the transformed value.
-    }
-
-    flatMap<U>(
-        mappingFunction: (t: T) => StateObject<U>
-    ): StateObject<U> {
-        return mappingFunction(this.state);  // Applies the mapping function and returns the result.
-    }
-
-    get hasValue(): boolean {
-        return true;
-    }
-
-    filter(predicate: (t: T) => boolean): StateObject<T> {
-        return predicate(this.state) ? (this as StateObject<T>) : new EmptyState<T>();  // Filters the state based on the predicate.
-    }
+import {EmptyState} from "./emptyState";
+import {StateObject} from "../stateObject";
+
+/**
+ * Represents a state that holds a valid value of type T.
+ * you should NEVER use this class directly, use the `StateObject` interface instead.
+ * and create instances by using the hooks
+ * @template T - The type of the value stored in the state.
+ */
+export class ValidState<T> implements StateObject<T> {
+    private readonly state: T;
+    private readonly setter: (state: T) => void;
+
+    constructor(state: T, setter: (state: T) => void) {
+        this.state = state;
+        this.setter = setter;
+    }
+
+    get value(): T {
+        return this.state;
+    }
+
+    do(action: (t: T) => void) {
+        action(this.state);  // Performs the given action on the state value.
+    }
+
+    orElse() {
+        return this.state;  // Returns the state value as it is valid.
+    }
+
+    set value(newState: T) {
+        this.setter(newState);  // Sets a new value for the state.
+    }
+
+    map<U>(
+        mappingFunction: (t: T) => U,
+        inverseMappingFunction: (u: U, t: T) => T
+    ): StateObject<U> {
+        const derivedState = mappingFunction(this.state);
+        const derivedSetter = (newState: U) => {
+            this.setter(inverseMappingFunction(newState, this.state));  // Updates the state with the inverse mapping.
+        };
+
+        return new ValidState<U>(derivedState, derivedSetter);  // Returns a new state object with the transformed value.
+    }
+
+    flatMap<U>(
+        mappingFunction: (t: T) => StateObject<U>
+    ): StateObject<U> {
+        return mappingFunction(this.state);  // Applies the mapping function and returns the result.
+    }
+
+    get hasValue(): boolean {
+        return true;
+    }
+
+    filter(predicate: (t: T) => boolean): StateObject<T> {
+        return predicate(this.state) ? (this as StateObject<T>) : new EmptyState<T>();  // Filters the state based on the predicate.
+    }
 }

package/src/index.ts

@@ -1,10 +1,10 @@
-export * from "./hooks/useFieldState";
-export * from "./hooks/useElementState";
-export * from "./hooks/useEmptyState";
-export * from "./hooks/useFieldState";
-export * from "./hooks/useRemapArray";
-export * from "./hooks/useStateObject";
-export * from "./hooks/useNullSafety";
-export * from "./stateObject";
-
-export default this;
+export * from "./hooks/useFieldState";
+export * from "./hooks/useElementState";
+export * from "./hooks/useEmptyState";
+export * from "./hooks/useFieldState";
+export * from "./hooks/useRemapArray";
+export * from "./hooks/useStateObject";
+export * from "./hooks/useNullSafety";
+export * from "./stateObject";
+
+export default this;

package/src/stateObject.ts

@@ -1,71 +1,71 @@
-/**
- * Represents a state object that holds a value of type T, allowing various state operations.
- * This is the main interface for managing state, with operations like `map`, `filter`, and `flatMap`.
- * initialize with useStateObject<T>(initialState: T) hook
- * @template T - The type of the value stored in the state object.
- */
-export type StateObject<T> = {
-    /**
-     * The current value of the state.
-     */
-    get value(): T;
-
-    /**
-     * Returns true if the state has a valid value, false otherwise.
-     */
-    get hasValue(): boolean;
-
-    /**
-     * Performs an action on the current state value.
-     *
-     * @param action - A function that accepts the current state value and performs some operation.
-     */
-    do(action: (t: T) => void): void;
-
-    /**
-     * Sets a new value for the state.
-     *
-     * @param newState - The new state value to set.
-     */
-    set value(newState: T);
-
-    /**
-     * Transforms the current state into another state object by applying a mapping function.
-     *
-     * @template U - The type of the new state value.
-     * @param mappingFunction - A function that transforms the current state value into a new value.
-     * @param inverseMappingFunction - A function that transforms a new value back to the original state type.
-     * @returns A new StateObject with the transformed value.
-     */
-    map<U>(
-        mappingFunction: (t: T) => U,
-        inverseMappingFunction: (u: U, t: T) => T
-    ): StateObject<U>;
-
-    /**
-     * Filters the state based on a predicate, returning an empty state if the predicate is not satisfied.
-     *
-     * @param predicate - A function that tests the current state value.
-     * @returns A new StateObject with the original value or an empty state.
-     */
-    filter(predicate: (t: T) => boolean): StateObject<T>;
-
-    /**
-     * Returns the current state value if it exists; otherwise, returns the provided alternative value.
-     *
-     * @param orElse - The value to return if the state does not have a valid value.
-     * @returns The current state value or the provided fallback value.
-     */
-    orElse(orElse: T): T;
-
-    /**
-     * Transforms the current state into another state object by applying a mapping function that returns a new state.
-     *
-     * @template U - The type of the new state value.
-     * @param mappingFunction - A function that transforms the current state value into another state object.
-     * @returns A new StateObject based on the result of the mapping function.
-     */
-    flatMap<U>(
-        mappingFunction: (t: T) => StateObject<U>
-    ): StateObject<U>;
+/**
+ * Represents a state object that holds a value of type T, allowing various state operations.
+ * This is the main interface for managing state, with operations like `map`, `filter`, and `flatMap`.
+ * initialize with useStateObject<T>(initialState: T) hook
+ * @template T - The type of the value stored in the state object.
+ */
+export type StateObject<T> = {
+    /**
+     * The current value of the state.
+     */
+    get value(): T;
+
+    /**
+     * Returns true if the state has a valid value, false otherwise.
+     */
+    get hasValue(): boolean;
+
+    /**
+     * Performs an action on the current state value.
+     *
+     * @param action - A function that accepts the current state value and performs some operation.
+     */
+    do(action: (t: T) => void): void;
+
+    /**
+     * Sets a new value for the state.
+     *
+     * @param newState - The new state value to set.
+     */
+    set value(newState: T);
+
+    /**
+     * Transforms the current state into another state object by applying a mapping function.
+     *
+     * @template U - The type of the new state value.
+     * @param mappingFunction - A function that transforms the current state value into a new value.
+     * @param inverseMappingFunction - A function that transforms a new value back to the original state type.
+     * @returns A new StateObject with the transformed value.
+     */
+    map<U>(
+        mappingFunction: (t: T) => U,
+        inverseMappingFunction: (u: U, t: T) => T
+    ): StateObject<U>;
+
+    /**
+     * Filters the state based on a predicate, returning an empty state if the predicate is not satisfied.
+     *
+     * @param predicate - A function that tests the current state value.
+     * @returns A new StateObject with the original value or an empty state.
+     */
+    filter(predicate: (t: T) => boolean): StateObject<T>;
+
+    /**
+     * Returns the current state value if it exists; otherwise, returns the provided alternative value.
+     *
+     * @param orElse - The value to return if the state does not have a valid value.
+     * @returns The current state value or the provided fallback value.
+     */
+    orElse(orElse: T): T;
+
+    /**
+     * Transforms the current state into another state object by applying a mapping function that returns a new state.
+     *
+     * @template U - The type of the new state value.
+     * @param mappingFunction - A function that transforms the current state value into another state object.
+     * @returns A new StateObject based on the result of the mapping function.
+     */
+    flatMap<U>(
+        mappingFunction: (t: T) => StateObject<U>
+    ): StateObject<U>;
 }