react-state-monad 0.0.1 → 1.0.3

package/src/hooks/useFieldState.ts

@@ -1,21 +1,21 @@
-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.
-    );
+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.
+    );
 }

package/src/hooks/useRemapArray.ts

@@ -1,33 +1,33 @@
-import {StateObject} from "../stateObject";
-import {ValidState} from "../implementations/validState";
-
-/**
- * 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.
+import {StateObject} from "../stateObject";
+import {ValidState} from "../implementations/validState";
+
+/**
+ * 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.
 }

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,3 +1,3 @@
-import {StateObject} from "./stateObject";
-
+import {StateObject} from "./stateObject";
+
 // an empty index just to make tsc happy

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>;
 }

package/tsconfig.json

@@ -1,20 +1,20 @@
-{
-  "compilerOptions": {
-    "target": "esnext",                    // Usar un target moderno compatible
-    "module": "esnext",                    // Usar módulos ES
-    "moduleResolution": "node",            // Resolución de módulos tipo Node
-    "declaration": true,                   // Generar los archivos .d.ts
-    "declarationDir": "./dist/types",      // El directorio de las declaraciones de tipo
-    "outDir": "./dist",                    // El directorio de salida para el bundle
-    "strict": true,                        // Habilitar el modo estricto
-    "esModuleInterop": true,               // Interoperabilidad con módulos ES
-    "skipLibCheck": true,                  // Omitir la comprobación de bibliotecas
-    "forceConsistentCasingInFileNames": true // Forzar la consistencia de las mayúsculas/minúsculas en los nombres de archivo
-  },
-  "include": [
-    "src/**/*"                             // Incluir los archivos fuente de la carpeta src
-  ],
-  "exclude": [
-    "node_modules"                         // Excluir node_modules
-  ]
-}
+{
+  "compilerOptions": {
+    "target": "esnext",                    // Usar un target moderno compatible
+    "module": "esnext",                    // Usar módulos ES
+    "moduleResolution": "node",            // Resolución de módulos tipo Node
+    "declaration": true,                   // Generar los archivos .d.ts
+    "declarationDir": "./dist/types",      // El directorio de las declaraciones de tipo
+    "outDir": "./dist",                    // El directorio de salida para el bundle
+    "strict": true,                        // Habilitar el modo estricto
+    "esModuleInterop": true,               // Interoperabilidad con módulos ES
+    "skipLibCheck": true,                  // Omitir la comprobación de bibliotecas
+    "forceConsistentCasingInFileNames": true // Forzar la consistencia de las mayúsculas/minúsculas en los nombres de archivo
+  },
+  "include": [
+    "src/**/*"                             // Incluir los archivos fuente de la carpeta src
+  ],
+  "exclude": [
+    "node_modules"                         // Excluir node_modules
+  ]
+}

package/dist/index.cjs

@@ -1,29 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/index.tsx
-var import_react2 = __toESM(require("react"), 1);
-
-// src/hooks/useStateObject.ts
-var import_react = require("react");

package/dist/index.d.cts

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +0,0 @@
-// src/index.tsx
-import React from "react";
-
-// src/hooks/useStateObject.ts
-import { useState } from "react";