state-jet 1.0.0 → 1.0.1

package/dist/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/index.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 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() });
+    }
+    const state = (0, react_1.useMemo)(() => {
+        if (!store.has(key)) {
+            store.set(key, { value: initialValue, listeners: new Set() });
+        }
+        return store.get(key);
+    }, [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, () => { });
+            }
+        });
+        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/dist/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "state-jet",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Ultra-lightweight global state management for React",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,16 +24,44 @@
   ],
   "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"
+    "prepare": "npm run clean && npm run build"
   },
   "devDependencies": {
     "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"
+    "use-sync-external-store": "^1.4.0",
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "@types/react": ">=18.0.0",
+    "immer": ">=9.0.6",
+    "react": ">=18.0.0",
+    "use-sync-external-store": ">=1.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "immer": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "use-sync-external-store": {
+      "optional": true
+    }
   }
 }