react-state-monad 1.0.8 → 1.0.10

package/index.d.cts

@@ -0,0 +1,132 @@
+/**
+ * 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.
+ */
+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>;
+};
+
+/**
+ * Helper type that ensures a field is a valid key of an object and that the field's type matches the expected type.
+ *
+ * @template TObject - The object type.
+ * @template TField - The expected type of the field.
+ */
+type ValidFieldFrom<TObject, TField> = {
+    [Key in keyof TObject]: TObject[Key] extends TField ? Key : never;
+}[keyof TObject];
+
+/**
+ * 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.
+ */
+declare function useFieldState<TOriginal, TField>(state: StateObject<TOriginal>, field: ValidFieldFrom<TOriginal, TField>): StateObject<TField>;
+
+/**
+ * Hook that allows you to derive and update a specific element in an array within a StateObject.
+ *
+ * @template T - The type of the array elements.
+ * @param state - The StateObject containing an array.
+ * @param index - The index of the element to be derived.
+ * @returns A new StateObject representing the element at the given index.
+ */
+declare function useElementState<T>(state: StateObject<T[]>, index: number): StateObject<T>;
+
+/**
+ * Hook that initializes a StateObject with an empty state.
+ * This is useful as a fallback when no valid state is available.
+ *
+ * @template T - The type of the value that could be held by the state.
+ * @returns A StateObject representing an empty state.
+ */
+declare function useEmptyState<T>(): StateObject<T>;
+
+/**
+ * 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.
+ */
+declare function useRemapArray<T>(state: StateObject<T[]>): StateObject<T>[];
+/**
+ * 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.
+ */
+declare function useArrayState<T>(states: StateObject<T>[]): StateObject<T[]>;
+
+/**
+ * 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.
+ */
+declare function useStateObject<T>(initialState: T): StateObject<T>;
+
+declare const _default: undefined;
+
+export { type StateObject, _default as default, useArrayState, useElementState, useEmptyState, useFieldState, useRemapArray, useStateObject };

package/index.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 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.
+ */
+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>;
+};
+
+/**
+ * Helper type that ensures a field is a valid key of an object and that the field's type matches the expected type.
+ *
+ * @template TObject - The object type.
+ * @template TField - The expected type of the field.
+ */
+type ValidFieldFrom<TObject, TField> = {
+    [Key in keyof TObject]: TObject[Key] extends TField ? Key : never;
+}[keyof TObject];
+
+/**
+ * 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.
+ */
+declare function useFieldState<TOriginal, TField>(state: StateObject<TOriginal>, field: ValidFieldFrom<TOriginal, TField>): StateObject<TField>;
+
+/**
+ * Hook that allows you to derive and update a specific element in an array within a StateObject.
+ *
+ * @template T - The type of the array elements.
+ * @param state - The StateObject containing an array.
+ * @param index - The index of the element to be derived.
+ * @returns A new StateObject representing the element at the given index.
+ */
+declare function useElementState<T>(state: StateObject<T[]>, index: number): StateObject<T>;
+
+/**
+ * Hook that initializes a StateObject with an empty state.
+ * This is useful as a fallback when no valid state is available.
+ *
+ * @template T - The type of the value that could be held by the state.
+ * @returns A StateObject representing an empty state.
+ */
+declare function useEmptyState<T>(): StateObject<T>;
+
+/**
+ * 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.
+ */
+declare function useRemapArray<T>(state: StateObject<T[]>): StateObject<T>[];
+/**
+ * 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.
+ */
+declare function useArrayState<T>(states: StateObject<T>[]): StateObject<T[]>;
+
+/**
+ * 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.
+ */
+declare function useStateObject<T>(initialState: T): StateObject<T>;
+
+declare const _default: undefined;
+
+export { type StateObject, _default as default, useArrayState, useElementState, useEmptyState, useFieldState, useRemapArray, useStateObject };

package/index.js

@@ -0,0 +1,137 @@
+// src/hooks/useFieldState.ts
+function useFieldState(state, field) {
+  return state.map(
+    (original) => original[field],
+    // Extracts the field value.
+    (newField, original) => ({ ...original, [field]: newField })
+    // Updates the field with the new value.
+  );
+}
+
+// src/implementations/emptyState.ts
+var EmptyState = class _EmptyState {
+  // No value stored, returns an error when accessed.
+  get value() {
+    throw new Error("Not implemented");
+  }
+  get hasValue() {
+    return false;
+  }
+  orElse(orElse) {
+    return orElse;
+  }
+  do() {
+  }
+  filter() {
+    return this;
+  }
+  set value(_) {
+  }
+  flatMap() {
+    return new _EmptyState();
+  }
+  map() {
+    return new _EmptyState();
+  }
+};
+
+// src/implementations/validState.ts
+var ValidState = class _ValidState {
+  state;
+  setter;
+  constructor(state, setter) {
+    this.state = state;
+    this.setter = setter;
+  }
+  get value() {
+    return this.state;
+  }
+  do(action) {
+    action(this.state);
+  }
+  orElse() {
+    return this.state;
+  }
+  set value(newState) {
+    this.setter(newState);
+  }
+  map(mappingFunction, inverseMappingFunction) {
+    const derivedState = mappingFunction(this.state);
+    const derivedSetter = (newState) => {
+      this.setter(inverseMappingFunction(newState, this.state));
+    };
+    return new _ValidState(derivedState, derivedSetter);
+  }
+  flatMap(mappingFunction) {
+    return mappingFunction(this.state);
+  }
+  get hasValue() {
+    return true;
+  }
+  filter(predicate) {
+    return predicate(this.state) ? this : new EmptyState();
+  }
+};
+
+// src/hooks/useElementState.ts
+function useElementState(state, index) {
+  if (!state.hasValue || index < 0 || index >= state.value.length) {
+    return new EmptyState();
+  }
+  return new ValidState(
+    state.value[index],
+    (newElement) => {
+      const arrayCopy = [...state.value];
+      arrayCopy[index] = newElement;
+      state.value = arrayCopy;
+    }
+  );
+}
+
+// src/hooks/useEmptyState.ts
+function useEmptyState() {
+  return new EmptyState();
+}
+
+// src/hooks/useStateObject.ts
+import { useState } from "react";
+function useStateObject(initialState) {
+  const [state, setState] = useState(initialState);
+  return new ValidState(state, setState);
+}
+
+// src/hooks/useRemapArray.ts
+function useRemapArray(state) {
+  if (!state.hasValue) return [];
+  const count = state.value.length;
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(
+      new ValidState(
+        state.value[i],
+        // The current value of the element at index i.
+        (newElement) => {
+          const arrayCopy = [...state.value];
+          arrayCopy[i] = newElement;
+          state.value = arrayCopy;
+        }
+      )
+    );
+  }
+  return result;
+}
+function useArrayState(states) {
+  return useStateObject(states.filter((state) => state.hasValue).map((state) => state.value));
+}
+
+// index.ts
+var index_default = void 0;
+export {
+  index_default as default,
+  useArrayState,
+  useElementState,
+  useEmptyState,
+  useFieldState,
+  useRemapArray,
+  useStateObject
+};

package/index.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-state-monad",
   "type": "module",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "A set of hooks to manage/transform/filter states with monads in React",
   "keywords": [
     "maybe",
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "validateTypes": "tsc --noEmit",
-    "build": "tsup index.ts --format cjs,esm --dts",
+    "build": "tsup index.ts --format cjs,esm --dts --dts-resolve",
     "cleanBuild": "rm -rf dist"
   },
   "dependencies": {
@@ -33,8 +33,5 @@
   "license": "GPL-3.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
-  "types": "dist/types/index.d.ts"
-  
-  
-  
-}
+  "types": "index.d.ts"
+}

package/src/hooks/types.ts

@@ -1,12 +1,12 @@
-/**
- * Helper type that ensures a field is a valid key of an object and that the field's type matches the expected type.
- *
- * @template TObject - The object type.
- * @template TField - The expected type of the field.
- */
-export type ValidFieldFrom<TObject, TField> = {
-    [Key in keyof TObject]: TObject[Key] extends TField ? Key : never;
-}[keyof TObject];
-
- 
-
+/**
+ * Helper type that ensures a field is a valid key of an object and that the field's type matches the expected type.
+ *
+ * @template TObject - The object type.
+ * @template TField - The expected type of the field.
+ */
+export type ValidFieldFrom<TObject, TField> = {
+    [Key in keyof TObject]: TObject[Key] extends TField ? Key : never;
+}[keyof TObject];
+
+ 
+

package/src/hooks/useElementState.ts

@@ -1,26 +1,26 @@
-import {StateObject} from "../stateObject";
-import {EmptyState} from "../implementations/emptyState";
-import {ValidState} from "../implementations/validState";
-
-/**
- * Hook that allows you to derive and update a specific element in an array within a StateObject.
- *
- * @template T - The type of the array elements.
- * @param state - The StateObject containing an array.
- * @param index - The index of the element to be derived.
- * @returns A new StateObject representing the element at the given index.
- */
-export function useElementState<T>(state: StateObject<T[]>, index: number): StateObject<T> {
-    if (!state.hasValue || index < 0 || index >= state.value.length) {
-        return new EmptyState<T>();  // Returns an empty state if the index is out of bounds or state is empty.
-    }
-
-    return new ValidState<T>(
-        state.value[index],
-        (newElement) => {
-            const arrayCopy = [...state.value];
-            arrayCopy[index] = newElement;
-            state.value = arrayCopy;
-        }
-    );
+import {StateObject} from "../stateObject";
+import {EmptyState} from "../implementations/emptyState";
+import {ValidState} from "../implementations/validState";
+
+/**
+ * Hook that allows you to derive and update a specific element in an array within a StateObject.
+ *
+ * @template T - The type of the array elements.
+ * @param state - The StateObject containing an array.
+ * @param index - The index of the element to be derived.
+ * @returns A new StateObject representing the element at the given index.
+ */
+export function useElementState<T>(state: StateObject<T[]>, index: number): StateObject<T> {
+    if (!state.hasValue || index < 0 || index >= state.value.length) {
+        return new EmptyState<T>();  // Returns an empty state if the index is out of bounds or state is empty.
+    }
+
+    return new ValidState<T>(
+        state.value[index],
+        (newElement) => {
+            const arrayCopy = [...state.value];
+            arrayCopy[index] = newElement;
+            state.value = arrayCopy;
+        }
+    );
 }

package/src/hooks/useEmptyState.ts

@@ -1,13 +1,13 @@
-import {StateObject} from "../stateObject";
-import {EmptyState} from "../implementations/emptyState";
-
-/**
- * Hook that initializes a StateObject with an empty state.
- * This is useful as a fallback when no valid state is available.
- *
- * @template T - The type of the value that could be held by the state.
- * @returns A StateObject representing an empty state.
- */
-export function useEmptyState<T>(): StateObject<T> {
-    return new EmptyState<T>();  // Returns a new EmptyState object.
+import {StateObject} from "../stateObject";
+import {EmptyState} from "../implementations/emptyState";
+
+/**
+ * Hook that initializes a StateObject with an empty state.
+ * This is useful as a fallback when no valid state is available.
+ *
+ * @template T - The type of the value that could be held by the state.
+ * @returns A StateObject representing an empty state.
+ */
+export function useEmptyState<T>(): StateObject<T> {
+    return new EmptyState<T>();  // Returns a new EmptyState object.
 }

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.
+    );
 }