react-state-monad 1.0.26 → 1.0.27

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-state-monad",
   "type": "module",
-  "version": "1.0.26",
+  "version": "1.0.27",
   "description": "A set of hooks to manage/transform/filter states with monads in React",
   "keywords": [
     "maybe",
@@ -31,7 +31,18 @@
     "url": "https://github.com/alvmivan"
   },
   "license": "GPL-3.0",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts"
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false
 }

package/.github/workflows/publish.yml

@@ -1,73 +0,0 @@
-name: Publish to npm
-
-on:
-  push:
-    branches:
-      - release
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Get package version
-        id: get_version
-        run: echo "PACKAGE_VERSION=$(node -p -e 'require(`./package.json`).version')" >> $GITHUB_ENV
-
-      - name: Get package name
-        id: get_name
-        run: echo "PACKAGE_NAME=$(node -p -e 'require(`./package.json`).name')" >> $GITHUB_ENV
-
-      - name: Check if version exists on npm
-        run: |
-          if npm view ${{ env.PACKAGE_NAME }}@${{ env.PACKAGE_VERSION }} > /dev/null 2>&1; then
-            echo "Version ${{ env.PACKAGE_VERSION }} already exists on npm. Exiting."
-            exit 0
-          fi
-
-      - name: Configure git
-        run: |
-          git config --global user.name "github-actions[bot]"
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Create GitHub tag
-        run: git tag v${{ env.PACKAGE_VERSION }}
-
-      - name: Push GitHub tag
-        run: git push origin --tags
-
-      - name: Create GitHub release
-        uses: actions/create-release@v1.1.0
-        with:
-          tag_name: v${{ env.PACKAGE_VERSION }}
-          release_name: Release v${{ env.PACKAGE_VERSION }}
-          body: |
-            Release of version ${{ env.PACKAGE_VERSION }} to npm.
-            - Package name: ${{ env.PACKAGE_NAME }}
-            - Version: ${{ env.PACKAGE_VERSION }}
-            - [View on npm](https://www.npmjs.com/package/${{ env.PACKAGE_NAME }}/v/${{ env.PACKAGE_VERSION }})
-          draft: false
-          prerelease: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Publish to npm
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npm publish
-
-      - name: Print npm package URL
-        run: |
-          echo "Package published at: https://www.npmjs.com/package/${{ env.PACKAGE_NAME }}/v/${{ env.PACKAGE_VERSION }}"

package/src/hooks/types.ts

@@ -1,12 +0,0 @@
-/**
- * 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 +0,0 @@
-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 +0,0 @@
-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,55 +0,0 @@
-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<keyof TOriginal, StateObject<TField>> {
-    // si state no tiene valor, retornar un invalid
-
-    if (!state.hasValue) {
-        return {} as Record<keyof TOriginal, StateObject<TField>>;
-    }
-
-    if (Array.isArray(state.value)) {
-        console.warn('useRemapKeysState should be used with objects, use useRemapArray for arrays');
-        return {} as Record<keyof TOriginal, StateObject<TField>>;
-    }
-
-    const keys = Object.keys(state.value) as (keyof TOriginal)[];
-    
-    return keys.reduce((acc, key) => {
-            acc[key] = useFieldState(state, key as ValidFieldFrom<TOriginal, TField>);
-            return acc;
-        }
-        , {} as Record<keyof TOriginal, StateObject<TField>>);
-}
-
- 
-
-    

package/src/hooks/useNullSafety.ts

@@ -1,24 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-/**
- * 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,16 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "ESNext",
-    "target": "ESNext",
-    "declaration": true,
-    "declarationDir": "./",
-    "outDir": "dist",
-    "moduleResolution": "Node",
-    "esModuleInterop": true,
-    "strict": true
-  },
-  "include": [
-    "src/**/*",
-    "index.ts"
-  ]
-}