[chore]: logicNot organized

hooks/Math/logicNot/CHANGELOG.md

@@ -0,0 +1,7 @@
+# logicNot
+
+## 0.0.1
+
+### Patch Changes
+
+- [`24bff3d`](https://github.com/changeelog/react-hooks/commit/24bff3d24011de5955505c33d973989cc5786879#diff-df7ad740052307aebbbdde0d86acbb03b4a98ae5518d68b8620cc2a0796f4a54)- Introduced logicNot

hooks/Math/logicNot/README.md

@@ -0,0 +1,19 @@
+# logicNot
+
+`NOT` conditions for refs
+
+Please refer to the [documentation](#) for more information.
+
+## Installation
+
+```bash
+npx changeelog/reactuse@latest add logicNot
+```
+
+## Contribution
+
+Yes please! See the [contributing guidelines](#) for more details!
+
+## License
+
+This project is licensed under the terms of the [MIT License](/LICENSE)

hooks/Math/logicNot/__tests__/logicNot.test.ts

@@ -0,0 +1,42 @@
+import { logicNot } from '../logicNot'
+
+describe('logicNot', () => {
+  test('should return false when input is true', () => {
+    expect(logicNot(true)).toBe(false)
+  })
+
+  test('should return true when input is false', () => {
+    expect(logicNot(false)).toBe(true)
+  })
+
+  test('should return false when getter returns true', () => {
+    const getter = () => true
+    expect(logicNot(getter)).toBe(false)
+  })
+
+  test('should return true when getter returns false', () => {
+    const getter = () => false
+    expect(logicNot(getter)).toBe(true)
+  })
+
+  test('should throw an error for non-boolean and non-function input', () => {
+    const invalidInput = 123
+    expect(() => logicNot(invalidInput as any)).toThrow(
+      'logicNot: Expected a boolean or a function that returns a boolean.'
+    )
+  })
+
+  test('should throw an error when function does not return a boolean', () => {
+    const invalidGetter = () => 'hello'
+    expect(() => logicNot(invalidGetter as any)).toThrow(
+      'logicNot: Expected a boolean or a function that returns a boolean.'
+    )
+  })
+
+  test('should preserve the boolean type', () => {
+    const result1: boolean = logicNot(true)
+    const result2: boolean = logicNot(() => false)
+    expect(result1).toBe(false)
+    expect(result2).toBe(true)
+  })
+})

hooks/Math/logicNot/index.ts

@@ -0,0 +1 @@
+export * from './logicNot'

hooks/Math/logicNot/logicNot.demo.tsx

@@ -0,0 +1,40 @@
+import React, { useState } from 'react'
+import { logicNot } from './logicNot'
+
+const LogicNotDemo = () => {
+  const [value, setValue] = useState(true)
+  const [getterValue, setGetterValue] = useState(true)
+
+  const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    setValue(event.target.checked)
+  }
+
+  const handleGetterChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    setGetterValue(event.target.checked)
+  }
+
+  const notValue = logicNot(value)
+  const notGetterValue = logicNot(() => getterValue)
+
+  return (
+    <div>
+      <h1>Logic Not Demo</h1>
+      <label>
+        Input:
+        <input type="checkbox" checked={value} onChange={handleChange} />
+      </label>
+      <p>NOT: {notValue.toString()}</p>
+      <label>
+        Getter Input:
+        <input
+          type="checkbox"
+          checked={getterValue}
+          onChange={handleGetterChange}
+        />
+      </label>
+      <p>NOT Getter: {notGetterValue.toString()}</p>
+    </div>
+  )
+}
+
+export default LogicNotDemo

hooks/Math/logicNot/logicNot.ts

@@ -3,8 +3,16 @@ type MaybeRefOrGetter<T> = T | (() => T)
 /**
  * `NOT` conditions for refs
  *
- * @param {MaybeRefOrGetter<boolean>} v - The ref or getter to be NOTed.
+ * This utility returns the negation of a boolean value or a getter function that returns a boolean.
+ * 
+ * @param {MaybeRefOrGetter<boolean>} value - The ref or getter to be NOTed.
  * @returns {[boolean, (newValue: boolean) => void]} - An array containing the result of the NOT operation and a function to update the value.
+ *
+ * @example
+ * const [isTrue, setTrue] = logicNot(true);
+ * console.log(isTrue); // Output: false;
+ * setTrue(false);
+ * console.log(istTrue); // Output: true;
  */
 export function logicNot<T extends boolean>(value: MaybeRefOrGetter<T>): T {
   const resolvedValue = typeof value === 'function' ? value() : value