react-state-monad 1.0.8 → 1.0.9

package/dist/index.cjs

@@ -0,0 +1,169 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  useArrayState: () => useArrayState,
+  useElementState: () => useElementState,
+  useEmptyState: () => useEmptyState,
+  useFieldState: () => useFieldState,
+  useRemapArray: () => useRemapArray,
+  useStateObject: () => useStateObject
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_react = require("react");
+function useStateObject(initialState) {
+  const [state, setState] = (0, import_react.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useArrayState,
+  useElementState,
+  useEmptyState,
+  useFieldState,
+  useRemapArray,
+  useStateObject
+});

package/dist/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/dist/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/dist/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-state-monad",
   "type": "module",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "A set of hooks to manage/transform/filter states with monads in React",
   "keywords": [
     "maybe",
@@ -35,6 +35,4 @@
   "module": "dist/index.mjs",
   "types": "dist/types/index.d.ts"
   
-  
-  
 }