react-state-monad 1.0.27 → 1.0.28

package/dist/index.d.cts

@@ -86,7 +86,7 @@ declare function useFieldState<TOriginal, TField>(state: StateObject<TOriginal>,
  * @param state - The StateObject containing the original state.
  * @returns A record where each key is mapped to a new StateObject for the corresponding field.
  */
-declare function useRemapKeysState<TOriginal extends object, TField>(state: StateObject<TOriginal>): Record<string, StateObject<TField>>;
+declare function useRemapKeysState<TOriginal extends object, TField>(state: StateObject<TOriginal>): Record<keyof TOriginal, StateObject<TField>>;
 
 /**
  * Hook that allows you to derive and update a specific element in an array within a StateObject.

package/dist/index.d.ts

@@ -86,7 +86,7 @@ declare function useFieldState<TOriginal, TField>(state: StateObject<TOriginal>,
  * @param state - The StateObject containing the original state.
  * @returns A record where each key is mapped to a new StateObject for the corresponding field.
  */
-declare function useRemapKeysState<TOriginal extends object, TField>(state: StateObject<TOriginal>): Record<string, StateObject<TField>>;
+declare function useRemapKeysState<TOriginal extends object, TField>(state: StateObject<TOriginal>): Record<keyof TOriginal, StateObject<TField>>;
 
 /**
  * Hook that allows you to derive and update a specific element in an array within a StateObject.

package/dist/index.js

@@ -1,3 +1,37 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  useArrayState: () => useArrayState,
+  useElementState: () => useElementState,
+  useEmptyState: () => useEmptyState,
+  useFieldState: () => useFieldState,
+  useNullSafety: () => useNullSafety,
+  useRemapArray: () => useRemapArray,
+  useRemapKeysState: () => useRemapKeysState,
+  useStateObject: () => useStateObject
+});
+module.exports = __toCommonJS(index_exports);
+
 // src/hooks/useFieldState.ts
 function useFieldState(state, field) {
   return state.map(
@@ -16,10 +50,13 @@ function useRemapKeysState(state) {
     return {};
   }
   const keys = Object.keys(state.value);
-  return keys.reduce((acc, key) => {
-    acc[key] = useFieldState(state, key);
-    return acc;
-  }, {});
+  return keys.reduce(
+    (acc, key) => {
+      acc[key] = useFieldState(state, key);
+      return acc;
+    },
+    {}
+  );
 }
 
 // src/implementations/emptyState.ts
@@ -108,9 +145,9 @@ function useEmptyState() {
 }
 
 // src/hooks/useStateObject.ts
-import { useState } from "react";
+var import_react = require("react");
 function useStateObject(initialState) {
-  const [state, setState] = useState(initialState);
+  const [state, setState] = (0, import_react.useState)(initialState);
   return new ValidState(state, setState);
 }
 
@@ -148,8 +185,8 @@ function useNullSafety(state) {
 
 // src/index.ts
 var index_default = void 0;
-export {
-  index_default as default,
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   useArrayState,
   useElementState,
   useEmptyState,
@@ -158,4 +195,4 @@ export {
   useRemapArray,
   useRemapKeysState,
   useStateObject
-};
+});

package/dist/index.mjs

@@ -0,0 +1,164 @@
+// 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.
+  );
+}
+function useRemapKeysState(state) {
+  if (!state.hasValue) {
+    return {};
+  }
+  if (Array.isArray(state.value)) {
+    console.warn("useRemapKeysState should be used with objects, use useRemapArray for arrays");
+    return {};
+  }
+  const keys = Object.keys(state.value);
+  return keys.reduce(
+    (acc, key) => {
+      acc[key] = useFieldState(state, key);
+      return acc;
+    },
+    {}
+  );
+}
+
+// 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));
+}
+
+// src/hooks/useNullSafety.ts
+function useNullSafety(state) {
+  if (!state.hasValue) return new EmptyState();
+  if (state.value === void 0) return new EmptyState();
+  if (state.value === null) return new EmptyState();
+  return new ValidState(state.value, (value) => state.value = value);
+}
+
+// src/index.ts
+var index_default = void 0;
+export {
+  index_default as default,
+  useArrayState,
+  useElementState,
+  useEmptyState,
+  useFieldState,
+  useNullSafety,
+  useRemapArray,
+  useRemapKeysState,
+  useStateObject
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-state-monad",
   "type": "module",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "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 src/index.ts --format cjs,esm --dts --dts-resolve",
+    "build": "tsup",
     "cleanBuild": "rm -rf dist"
   },
   "dependencies": {
@@ -22,7 +22,7 @@
   },
   "devDependencies": {
     "@types/react": "^19.0.7",
-    "tsup": "^8.3.5",
+    "tsup": "^8.5.0",
     "typescript": "^5.7.3"
   },
   "author": {
@@ -45,4 +45,4 @@
     "dist"
   ],
   "sideEffects": false
-}
+}