state-jet 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,14 @@
+# ⚡ fast-state: Ultra-Lightweight Global State for React
+
+A zero-boilerplate, ultra-fast global state management library for React. No context, reducers, or providers—just simple reactive state.
+
+## 🚀 Why fast-state?
+- ✅ **No Context, No Providers** – Works outside React, reducing unnecessary re-renders.
+- ✅ **Automatic Re-Renders** – Only components using specific state values update.
+- ✅ **Super Lightweight** – Less than **1KB** minified!
+- ✅ **SSR & Next.js Support** – Works on both client and server.
+
+## 🛠 Installation
+```bash
+npm install state-jet
+```

package/dist/example/App.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = App;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const index_1 = require("../src/index");
+const middleware_1 = require("../src/middleware");
+const counter = (0, index_1.useStateGlobal)("counter", 0, { middleware: [middleware_1.loggerMiddleware] });
+function App() {
+    const { undo, redo } = counter;
+    const count = counter.useStore();
+    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("button", { onClick: () => counter.set(count + 1), children: "+" }), (0, jsx_runtime_1.jsx)("button", { onClick: () => counter.set(count - 1), children: "-" }), (0, jsx_runtime_1.jsx)("button", { onClick: undo, children: "Undo" }), (0, jsx_runtime_1.jsx)("button", { onClick: redo, children: "Redo" }), (0, jsx_runtime_1.jsxs)("p", { children: ["Count: ", count] })] }));
+}

package/dist/src/crdt.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncCRDT = exports.mergeCRDT = void 0;
+const store_1 = require("./store");
+const mergeCRDT = (localState, remoteState) => {
+    return Object.assign(Object.assign(Object.assign({}, localState), remoteState), { lastUpdated: Date.now() });
+};
+exports.mergeCRDT = mergeCRDT;
+const syncCRDT = (key, remoteState) => {
+    const localState = (0, store_1.useStateGlobal)(key).useStore();
+    const merged = (0, exports.mergeCRDT)(localState, remoteState);
+    (0, store_1.useStateGlobal)(key).set(merged);
+};
+exports.syncCRDT = syncCRDT;

package/dist/src/derived.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivedState = void 0;
+const derivedState = (dependencies, computeFn) => {
+    const derived = { value: computeFn(...dependencies.map((d) => d.useStore())) };
+    dependencies.forEach(dep => dep.useStore().listeners.add(() => {
+        derived.value = computeFn(...dependencies.map(d => d.useStore()));
+    }));
+    return () => derived.value;
+};
+exports.derivedState = derivedState;

package/dist/src/devtools.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redoState = exports.undoState = exports.measurePerformance = exports.notifyDevTools = void 0;
+const stateHistory = {};
+const stateIndex = {};
+const performanceData = {};
+const devtoolsEnabled = typeof window !== "undefined" && window.__STATE_JET_DEVTOOLS__;
+const notifyDevTools = (key, value) => {
+    if (!stateHistory[key])
+        stateHistory[key] = [];
+    if (stateIndex[key] === undefined)
+        stateIndex[key] = -1;
+    // Remove future states when a new state is set
+    stateHistory[key] = stateHistory[key].slice(0, stateIndex[key] + 1);
+    stateHistory[key].push(value);
+    stateIndex[key]++;
+    if (devtoolsEnabled && window.__STATE_JET_DEVTOOLS__.updateState) {
+        window.__STATE_JET_DEVTOOLS__.updateState(key, value, stateHistory[key]);
+    }
+};
+exports.notifyDevTools = notifyDevTools;
+const measurePerformance = (key, callback) => {
+    const start = performance.now();
+    callback();
+    const duration = performance.now() - start;
+    if (!performanceData[key])
+        performanceData[key] = [];
+    performanceData[key].push(duration);
+    if (devtoolsEnabled && window.__STATE_JET_DEVTOOLS__.updatePerformance) {
+        window.__STATE_JET_DEVTOOLS__.updatePerformance(key, duration);
+    }
+};
+exports.measurePerformance = measurePerformance;
+const undoState = (key) => {
+    if (stateIndex[key] > 0) {
+        stateIndex[key]--;
+        return stateHistory[key][stateIndex[key]];
+    }
+};
+exports.undoState = undoState;
+const redoState = (key) => {
+    if (stateIndex[key] < stateHistory[key].length - 1) {
+        stateIndex[key]++;
+        return stateHistory[key][stateIndex[key]];
+    }
+};
+exports.redoState = redoState;

package/dist/src/encryption.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEncryptedState = exports.saveEncryptedState = exports.decrypt = exports.encrypt = void 0;
+const encrypt = (data) => btoa(JSON.stringify(data));
+exports.encrypt = encrypt;
+const decrypt = (data) => JSON.parse(atob(data));
+exports.decrypt = decrypt;
+const saveEncryptedState = (key, value) => {
+    localStorage.setItem(key, (0, exports.encrypt)(value));
+};
+exports.saveEncryptedState = saveEncryptedState;
+const loadEncryptedState = (key) => {
+    const data = localStorage.getItem(key);
+    return data ? (0, exports.decrypt)(data) : null;
+};
+exports.loadEncryptedState = loadEncryptedState;

package/dist/src/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncCRDT = exports.loadEncryptedState = exports.saveEncryptedState = exports.decrypt = exports.encrypt = exports.optimisticUpdate = exports.restoreState = exports.saveState = exports.useStateGlobal = void 0;
+var store_1 = require("./store");
+Object.defineProperty(exports, "useStateGlobal", { enumerable: true, get: function () { return store_1.useStateGlobal; } });
+var persistence_1 = require("./persistence");
+Object.defineProperty(exports, "saveState", { enumerable: true, get: function () { return persistence_1.saveState; } });
+Object.defineProperty(exports, "restoreState", { enumerable: true, get: function () { return persistence_1.restoreState; } });
+var optimistic_1 = require("./optimistic");
+Object.defineProperty(exports, "optimisticUpdate", { enumerable: true, get: function () { return optimistic_1.optimisticUpdate; } });
+var encryption_1 = require("./encryption");
+Object.defineProperty(exports, "encrypt", { enumerable: true, get: function () { return encryption_1.encrypt; } });
+Object.defineProperty(exports, "decrypt", { enumerable: true, get: function () { return encryption_1.decrypt; } });
+Object.defineProperty(exports, "saveEncryptedState", { enumerable: true, get: function () { return encryption_1.saveEncryptedState; } });
+Object.defineProperty(exports, "loadEncryptedState", { enumerable: true, get: function () { return encryption_1.loadEncryptedState; } });
+var crdt_1 = require("./crdt");
+Object.defineProperty(exports, "syncCRDT", { enumerable: true, get: function () { return crdt_1.syncCRDT; } });

package/dist/src/middleware.js

@@ -0,0 +1,69 @@
+"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 });
+exports.debounceMiddleware = exports.reducerMiddleware = exports.optimisticMiddleware = exports.validateAgeMiddleware = exports.apiSyncMiddleware = exports.loggerMiddleware = void 0;
+const loggerMiddleware = (key, prev, next) => {
+    console.log(`[state-jet] ${key}: ${prev} → ${next}`);
+};
+exports.loggerMiddleware = loggerMiddleware;
+const apiSyncMiddleware = (key, prev, next) => __awaiter(void 0, void 0, void 0, function* () {
+    yield fetch("/api/sync", { method: "POST", body: JSON.stringify({ key, next }) });
+});
+exports.apiSyncMiddleware = apiSyncMiddleware;
+const validateAgeMiddleware = (key, prev, next) => {
+    if (key === "age" && next < 0) {
+        console.warn("Age cannot be negative!");
+        return prev;
+    }
+    return next;
+};
+exports.validateAgeMiddleware = validateAgeMiddleware;
+const optimisticMiddleware = (apiUrl) => {
+    return (key, prev, next, set) => __awaiter(void 0, void 0, void 0, function* () {
+        set(next); // Optimistically update state
+        try {
+            yield fetch(apiUrl, {
+                method: "POST",
+                body: JSON.stringify({ key, value: next }),
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        catch (error) {
+            console.warn(`[state-jet] Rollback: Failed to sync ${key}`);
+            set(prev); // Rollback state on failure
+        }
+    });
+};
+exports.optimisticMiddleware = optimisticMiddleware;
+const reducerMiddleware = (key, prev, action) => {
+    switch (action.type) {
+        case "INCREMENT":
+            return prev + 1;
+        case "DECREMENT":
+            return prev - 1;
+        case "RESET":
+            return 0;
+        default:
+            return prev;
+    }
+};
+exports.reducerMiddleware = reducerMiddleware;
+const debounceMiddleware = (delay) => {
+    let timer;
+    return (key, prev, next) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            console.log(`[state-jet] Debounced: ${key} → ${next}`);
+        }, delay);
+        return prev; // Prevent immediate update
+    };
+};
+exports.debounceMiddleware = debounceMiddleware;

package/dist/src/optimistic.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimisticUpdate = void 0;
+const optimisticUpdate = (setState, apiCall, fallback) => {
+    const prevState = setState.useStore();
+    setState.set(apiCall(prevState));
+    apiCall()
+        .catch(() => setState.set(fallback ? fallback(prevState) : prevState));
+};
+exports.optimisticUpdate = optimisticUpdate;

package/dist/src/persistence.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreState = exports.saveState = void 0;
+const saveState = (key, value, encrypt = false) => {
+    if (typeof window !== "undefined") {
+        let data = JSON.stringify(value);
+        if (encrypt)
+            data = btoa(data);
+        localStorage.setItem(key, data);
+    }
+};
+exports.saveState = saveState;
+const restoreState = (key) => {
+    if (typeof window !== "undefined") {
+        const data = localStorage.getItem(key);
+        return data ? JSON.parse(atob(data)) : undefined;
+    }
+};
+exports.restoreState = restoreState;

package/dist/src/store.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStateGlobal = void 0;
+const react_1 = require("react");
+const immer_1 = require("immer");
+const persistence_1 = require("./persistence");
+const devtools_1 = require("./devtools");
+const store = new Map();
+const pendingUpdates = new Map();
+const history = {};
+const useStateGlobal = (key, initialValue, options) => {
+    if (!store.has(key)) {
+        store.set(key, { value: initialValue, listeners: new Set() });
+        if (options === null || options === void 0 ? void 0 : options.persist)
+            (0, persistence_1.restoreState)(key);
+    }
+    const state = store.get(key);
+    const undo = () => {
+        var _a;
+        if ((_a = history[key]) === null || _a === void 0 ? void 0 : _a.past.length) {
+            history[key].future.unshift(history[key].present);
+            history[key].present = history[key].past.pop();
+            state.value = history[key].present;
+            state.listeners.forEach((listener) => listener());
+            (0, devtools_1.undoState)(key);
+        }
+    };
+    const batchUpdate = () => {
+        pendingUpdates.forEach((newValue, key) => {
+            var _a;
+            let nextValue = newValue;
+            let stateValue = state.value;
+            if (!history[key]) {
+                history[key] = { past: [], present: stateValue, future: [] };
+            }
+            history[key].past.push(stateValue);
+            history[key].present = newValue;
+            history[key].future = [];
+            (_a = options === null || options === void 0 ? void 0 : options.middleware) === null || _a === void 0 ? void 0 : _a.forEach((mw) => {
+                const result = mw(key, stateValue, nextValue);
+                if (result !== undefined)
+                    nextValue = result;
+            });
+            if (typeof nextValue === "function") {
+                state.value = (0, immer_1.produce)(state.value, nextValue);
+            }
+            else if (stateValue !== nextValue) {
+                state.value = nextValue;
+                state.listeners.forEach((listener) => listener());
+                (0, devtools_1.notifyDevTools)(key, nextValue);
+                (0, devtools_1.measurePerformance)(key, () => { });
+                if (options === null || options === void 0 ? void 0 : options.persist)
+                    (0, persistence_1.saveState)(key, nextValue, options.encrypt);
+            }
+        });
+        pendingUpdates.clear();
+    };
+    const redo = () => {
+        var _a;
+        if ((_a = history[key]) === null || _a === void 0 ? void 0 : _a.future.length) {
+            history[key].past.push(history[key].present);
+            history[key].present = history[key].future.shift();
+            state.value = history[key].present;
+            state.listeners.forEach((listener) => listener());
+            (0, devtools_1.redoState)(key);
+        }
+    };
+    const useStore = () => {
+        return (0, react_1.useSyncExternalStore)((callback) => {
+            state.listeners.add(callback);
+            return () => state.listeners.delete(callback);
+        }, () => state.value);
+    };
+    const set = (newValue) => {
+        pendingUpdates.set(key, newValue);
+        if (window === null || window === void 0 ? void 0 : window.requestAnimationFrame)
+            window.requestAnimationFrame(batchUpdate);
+    };
+    return {
+        useStore,
+        set,
+        undo,
+        redo
+    };
+};
+exports.useStateGlobal = useStateGlobal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "state-jet",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Ultra-lightweight global state management for React",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,16 +24,40 @@
   ],
   "author": "venkateshsundaram",
   "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/venkateshsundaram/state-jet/issues"
+  },
   "scripts": {
     "build": "tsc",
     "test": "vitest",
+    "clean": "rm -rf dist/*",
     "publish:npm": "npm publish --access public",
-    "lint": "eslint src --ext .ts,.tsx",
-    "prepare": "npm run build"
+    "lint": "eslint src --ext .ts,.tsx"
   },
   "devDependencies": {
+    "@types/react": "^19.0.3",
+    "@types/react-dom": "^19.0.2",
     "eslint": "^8.57.1",
+    "immer": "^10.1.1",
+    "react": "19.0.0",
+    "react-dom": "19.0.0",
     "typescript": "^5.7.3",
-    "vitest": "^1.6.1"
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "@types/react": ">=18.0.0",
+    "immer": ">=9.0.6",
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "immer": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
   }
 }