nextemos 1.0.0

package/README.md

@@ -0,0 +1,20 @@
+# Introduction 
+TODO: Give a short introduction of your project. Let this section explain the objectives or the motivation behind this project. 
+
+# Getting Started
+TODO: Guide users through getting your code up and running on their own system. In this section you can talk about:
+1.	Installation process
+2.	Software dependencies
+3.	Latest releases
+4.	API references
+
+# Build and Test
+TODO: Describe and show how to build your code and run the tests. 
+
+# Contribute
+TODO: Explain how other users and developers can contribute to make your code better. 
+
+If you want to learn more about creating good readme files then refer the following [guidelines](https://docs.microsoft.com/en-us/azure/devops/repos/git/create-a-readme?view=azure-devops). You can also seek inspiration from the below readme files:
+- [ASP.NET Core](https://github.com/aspnet/Home)
+- [Visual Studio Code](https://github.com/Microsoft/vscode)
+- [Chakra Core](https://github.com/Microsoft/ChakraCore)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useFetch } from './useFetch';
+export { default as useLocalStorage } from './useLocalStorage';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocalStorage = exports.useFetch = void 0;
+var useFetch_1 = require("./useFetch");
+Object.defineProperty(exports, "useFetch", { enumerable: true, get: function () { return __importDefault(useFetch_1).default; } });
+var useLocalStorage_1 = require("./useLocalStorage");
+Object.defineProperty(exports, "useLocalStorage", { enumerable: true, get: function () { return __importDefault(useLocalStorage_1).default; } });

package/dist/useFetch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Interface for the fetch props.
+ */
+interface IFetchProps {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
+    url: string;
+    requestOptions?: any;
+}
+/**
+ * Custom hook for making HTTP requests using the fetch API.
+ *
+ * @param {IFetchProps} param0 - The fetch props.
+ * @returns {Object} - An object containing the response, loading state, error, and refetch function.
+ */
+declare const useFetch: ({ method, url, requestOptions }: IFetchProps) => {
+    response: null;
+    loading: boolean;
+    error: string | null;
+    refetch: () => void;
+};
+export default useFetch;

package/dist/useFetch.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * Custom hook for making HTTP requests using the fetch API.
+ *
+ * @param {IFetchProps} param0 - The fetch props.
+ * @returns {Object} - An object containing the response, loading state, error, and refetch function.
+ */
+const useFetch = ({ method = "GET", url, requestOptions = {} }) => {
+    // State for storing the response data.
+    const [response, setResponse] = (0, react_1.useState)(null);
+    // State for tracking the loading state.
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    // State for storing the error message.
+    const [error, setError] = (0, react_1.useState)(null);
+    // State for triggering a refetch.
+    const [reload, setReload] = (0, react_1.useState)(0);
+    /**
+     * Function for triggering a refetch.
+     */
+    const refetch = () => setReload((prev) => prev + 1);
+    (0, react_1.useEffect)(() => {
+        // Create an AbortController instance to cancel the fetch request if needed.
+        const controller = new AbortController();
+        const signal = controller.signal;
+        /**
+         * Function for fetching the data.
+         */
+        const fetchData = () => __awaiter(void 0, void 0, void 0, function* () {
+            setLoading(true);
+            try {
+                // Make the fetch request with the provided method, URL, and options.
+                const res = yield fetch(url, Object.assign(Object.assign({ method: method.toUpperCase() }, requestOptions), { signal }));
+                // Check if the response is not OK and throw an error.
+                if (!res.ok) {
+                    throw new Error(`Error: ${res.statusText}`);
+                }
+                // Parse the response data as JSON.
+                const data = yield res.json();
+                // Update the response state with the fetched data.
+                setResponse(data);
+            }
+            catch (error) {
+                // Handle any errors that occur during the fetch request.
+                if (error instanceof Error) {
+                    setError(error.message);
+                }
+                else {
+                    setError('An unknown error occurred');
+                }
+            }
+            finally {
+                setLoading(false);
+            }
+        });
+        // Call the fetchData function.
+        fetchData();
+        // Cleanup function to abort the fetch request if the component unmounts or the dependencies change.
+        return () => controller.abort();
+    }, [url, method, requestOptions, reload]);
+    // Return the response, loading state, error, and refetch function.
+    return {
+        response,
+        loading,
+        error,
+        refetch
+    };
+};
+exports.default = useFetch;

package/dist/useLocalStorage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Custom hook that synchronizes state with localStorage.
+ *
+ * @param {string} key - The key to store the value under in localStorage.
+ * @param {any} initialValue - The initial value to use if the key does not exist in localStorage.
+ * @returns {[any, function]} - The current value stored in localStorage and a function to update it.
+ */
+declare const useLocalStorage: (key: string, initialValue: any) => any[];
+export default useLocalStorage;

package/dist/useLocalStorage.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * Custom hook that synchronizes state with localStorage.
+ *
+ * @param {string} key - The key to store the value under in localStorage.
+ * @param {any} initialValue - The initial value to use if the key does not exist in localStorage.
+ * @returns {[any, function]} - The current value stored in localStorage and a function to update it.
+ */
+const useLocalStorage = (key, initialValue) => {
+    // Initialize the state with a function to read from localStorage or use the initial value
+    const [storedValue, setStoredValue] = (0, react_1.useState)(() => {
+        try {
+            // Attempt to get the item from localStorage using the key
+            const item = window.localStorage.getItem(key);
+            // If the item exists, parse it from JSON; otherwise, return the initial value
+            return item ? JSON.parse(item) : initialValue;
+        }
+        catch (error) {
+            // Log any errors and return the initial value
+            console.error(error);
+            return initialValue;
+        }
+    });
+    /**
+     * Function to update the state and localStorage.
+     *
+     * @param {any} value - The new value to store, or a function that returns the new value.
+     */
+    const setValue = (value) => {
+        try {
+            // Determine the new value to store, supporting functional updates
+            const valueToStore = value instanceof Function ? value(storedValue) : value;
+            // Update the state with the new value
+            setStoredValue(valueToStore);
+            // Store the new value in localStorage as a JSON string
+            window.localStorage.setItem(key, JSON.stringify(valueToStore));
+        }
+        catch (error) {
+            // Log any errors that occur during the update
+            console.error(error);
+        }
+    };
+    // Return the current value and the function to update it
+    return [storedValue, setValue];
+};
+exports.default = useLocalStorage;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "nextemos",
+  "version": "1.0.0",
+  "description": "For helpers and hooks used in NextJS projects",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "typescript": "^5.4.5"
+  }
+}