evstream 1.0.1 → 1.0.3

package/.husky/pre-commit

@@ -0,0 +1 @@
+npm run lint-staged

package/.me/dump.ts

@@ -0,0 +1,102 @@
+import { EvState, EvStreamManager } from 'evstream'
+import { EvRedisAdapter } from 'evstream/adapter/redis'
+import type Redis from 'ioredis'
+
+type SharedStateMessage =
+    | { action: 'create'; key: string; initialValue: any }
+    | { action: 'remove'; key: string }
+
+export class EvCustomSharedState {
+    private states = new Map<string, EvState>()
+    private redis: Redis
+    private pub: Redis
+    private manager: EvStreamManager
+    private adapter: EvRedisAdapter
+    private controlChannel = 'ev:shared-state'
+
+    constructor(options: {
+        redis: Redis
+        publisher?: Redis
+        manager: EvStreamManager
+        adapter: EvRedisAdapter
+    }) {
+        this.redis = options.redis
+        this.pub = options.publisher ?? options.redis
+        this.manager = options.manager
+        this.adapter = options.adapter
+
+        this.init()
+    }
+
+    private async init() {
+        await this.redis.subscribe(this.controlChannel)
+
+        this.redis.on('message', (_, raw) => {
+            try {
+                const msg = JSON.parse(raw) as SharedStateMessage
+                this.handleMessage(msg)
+            } catch {
+                /* ignore malformed messages */
+            }
+        })
+    }
+
+    private handleMessage(msg: SharedStateMessage) {
+        if (msg.action === 'create') {
+            this.createLocalState(msg.key, msg.initialValue)
+        }
+
+        if (msg.action === 'remove') {
+            this.removeLocalState(msg.key)
+        }
+    }
+
+    private createLocalState(key: string, initialValue: any) {
+        if (this.states.has(key)) return
+
+        const state = new EvState({
+            channel: key,
+            initialValue,
+            manager: this.manager,
+            adapter: this.adapter,
+        })
+
+        this.states.set(key, state)
+    }
+
+    private removeLocalState(key: string) {
+        const state = this.states.get(key)
+        if (!state) return
+
+        // EvState has no destroy API, so we simply stop tracking it
+        this.states.delete(key)
+    }
+
+    /* ================= PUBLIC API ================= */
+
+    async create(key: string, initialValue: any) {
+        await this.pub.publish(
+            this.controlChannel,
+            JSON.stringify({ action: 'create', key, initialValue })
+        )
+    }
+
+    async remove(key: string) {
+        await this.pub.publish(
+            this.controlChannel,
+            JSON.stringify({ action: 'remove', key })
+        )
+    }
+
+    get(key: string): EvState | undefined {
+        return this.states.get(key)
+    }
+
+    has(key: string): boolean {
+        return this.states.has(key)
+    }
+
+    keys(): string[] {
+        return [...this.states.keys()]
+    }
+}

package/.prettierignore

@@ -0,0 +1,15 @@
+# Ignore build outputs
+dist/
+build/
+coverage/
+
+# Ignore dependencies
+node_modules/
+
+# Ignore generated files
+*.min.js
+*.bundle.js
+
+# Ignore specific files
+package-lock.json
+yarn.lock

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+	"semi": false,
+	"singleQuote": true,
+	"tabWidth": 2,
+	"trailingComma": "es5",
+	"jsxSingleQuote": true,
+	"useTabs": true
+}

package/dist/adapters/pub-sub.d.ts

@@ -0,0 +1,14 @@
+import { RedisOptions } from 'ioredis';
+interface EvRedisPubSubOptions {
+    subject?: string;
+    options: RedisOptions;
+    onMessage?: (message: Object) => void;
+}
+export declare class EvRedisPubSub {
+    #private;
+    constructor({ options, subject, onMessage }: EvRedisPubSubOptions);
+    private init;
+    send(msg: Object): Promise<void>;
+    onMessage(callback: (msg: Object) => void): void;
+}
+export {};

package/dist/adapters/pub-sub.js

@@ -0,0 +1,66 @@
+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());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EvRedisPubSub_options, _EvRedisPubSub_subject, _EvRedisPubSub_pub, _EvRedisPubSub_sub, _EvRedisPubSub_instanceId, _EvRedisPubSub_onMessage;
+import Redis from 'ioredis';
+import { uid } from '../utils.js';
+export class EvRedisPubSub {
+    constructor({ options, subject, onMessage }) {
+        _EvRedisPubSub_options.set(this, void 0);
+        _EvRedisPubSub_subject.set(this, void 0);
+        _EvRedisPubSub_pub.set(this, void 0);
+        _EvRedisPubSub_sub.set(this, void 0);
+        _EvRedisPubSub_instanceId.set(this, void 0);
+        _EvRedisPubSub_onMessage.set(this, void 0);
+        __classPrivateFieldSet(this, _EvRedisPubSub_pub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_sub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_onMessage, onMessage, "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_instanceId, uid({ prefix: subject, counter: Math.random() }), "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_subject, subject, "f");
+        this.init();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").on('error', (err) => { });
+            __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('error', (err) => { });
+            yield __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").subscribe(__classPrivateFieldGet(this, _EvRedisPubSub_subject, "f"));
+            __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('message', (_, raw) => {
+                try {
+                    const msg = JSON.parse(raw);
+                    console.log("Incoming Message");
+                    console.log(msg);
+                    if ((msg === null || msg === void 0 ? void 0 : msg.uid) !== __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f")) {
+                        __classPrivateFieldGet(this, _EvRedisPubSub_onMessage, "f").call(this, msg === null || msg === void 0 ? void 0 : msg.msg);
+                    }
+                }
+                catch (_a) { }
+            });
+        });
+    }
+    send(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").publish(__classPrivateFieldGet(this, _EvRedisPubSub_subject, "f"), JSON.stringify({ uid: __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f"), msg }));
+        });
+    }
+    onMessage(callback) {
+        __classPrivateFieldSet(this, _EvRedisPubSub_onMessage, callback, "f");
+    }
+}
+_EvRedisPubSub_options = new WeakMap(), _EvRedisPubSub_subject = new WeakMap(), _EvRedisPubSub_pub = new WeakMap(), _EvRedisPubSub_sub = new WeakMap(), _EvRedisPubSub_instanceId = new WeakMap(), _EvRedisPubSub_onMessage = new WeakMap();

package/dist/adapters/redis.d.ts

@@ -1,6 +1,7 @@
 import { RedisOptions } from 'ioredis';
+import { EvRedisPubSub } from './pub-sub.js';
 import { EvStateAdapter } from '../types.js';
-export declare class EvRedisAdapter implements EvStateAdapter {
+declare class EvRedisAdapter implements EvStateAdapter {
     #private;
     constructor(options?: RedisOptions);
     publish(channel: string, message: any): Promise<void>;
@@ -8,3 +9,4 @@ export declare class EvRedisAdapter implements EvStateAdapter {
     unsubscribe(channel: string): Promise<void>;
     quit(): void;
 }
+export { EvRedisPubSub, EvRedisAdapter };

package/dist/adapters/redis.js

@@ -18,33 +18,40 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EvRedisAdapter_pub, _EvRedisAdapter_sub, _EvRedisAdapter_listeners;
+var _EvRedisAdapter_pub, _EvRedisAdapter_sub, _EvRedisAdapter_listeners, _EvRedisAdapter_instanceId;
 import Redis from 'ioredis';
-export class EvRedisAdapter {
+import { EvRedisPubSub } from './pub-sub.js';
+import { uid } from '../utils.js';
+class EvRedisAdapter {
     constructor(options) {
         _EvRedisAdapter_pub.set(this, void 0);
         _EvRedisAdapter_sub.set(this, void 0);
         _EvRedisAdapter_listeners.set(this, void 0);
+        _EvRedisAdapter_instanceId.set(this, void 0);
         __classPrivateFieldSet(this, _EvRedisAdapter_pub, new Redis(options), "f");
         __classPrivateFieldSet(this, _EvRedisAdapter_sub, new Redis(options), "f");
         __classPrivateFieldSet(this, _EvRedisAdapter_listeners, new Map(), "f");
+        __classPrivateFieldSet(this, _EvRedisAdapter_instanceId, uid({ counter: Math.ceil(Math.random() * 100) }), "f");
         __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").on('message', (channel, message) => {
             const handlers = __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").get(channel);
             if (handlers) {
                 let parsed;
+                let canHandle;
                 try {
                     parsed = JSON.parse(message);
+                    canHandle = (parsed === null || parsed === void 0 ? void 0 : parsed.id) !== __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f");
                 }
                 catch (_a) {
                     return;
                 }
-                handlers.forEach(handler => handler(parsed));
+                if (canHandle)
+                    handlers.forEach((handler) => handler(parsed === null || parsed === void 0 ? void 0 : parsed.message));
             }
         });
     }
     publish(channel, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify(message));
+            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify({ id: __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f"), message: message }));
         });
     }
     subscribe(channel, onMessage) {
@@ -67,4 +74,5 @@ export class EvRedisAdapter {
         __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").quit();
     }
 }
-_EvRedisAdapter_pub = new WeakMap(), _EvRedisAdapter_sub = new WeakMap(), _EvRedisAdapter_listeners = new WeakMap();
+_EvRedisAdapter_pub = new WeakMap(), _EvRedisAdapter_sub = new WeakMap(), _EvRedisAdapter_listeners = new WeakMap(), _EvRedisAdapter_instanceId = new WeakMap();
+export { EvRedisPubSub, EvRedisAdapter };

package/dist/extensions/state-manager.d.ts

@@ -0,0 +1,21 @@
+import type { EvStreamManager } from '../manager.js';
+import type { EvRedisAdapter } from '../adapters/redis.js';
+import type { EvRedisPubSub } from '../adapters/pub-sub.js';
+import { EvState } from '../state.js';
+interface EvStateManagerOptions {
+    manager: EvStreamManager;
+    adapter?: EvRedisAdapter;
+    pubsub?: EvRedisPubSub;
+}
+export declare class EvStateManager<S extends Record<string, any>> {
+    #private;
+    constructor({ manager, adapter, pubsub }: EvStateManagerOptions);
+    private createLocalState;
+    private removeLocalState;
+    createState<K extends keyof S>(key: K, initialValue: S[K]): EvState<S[K]>;
+    getState<K extends keyof S>(key: K): EvState<S[K]> | undefined;
+    hasState<K extends keyof S>(key: K): boolean;
+    removeState<K extends keyof S>(key: K): void;
+    private pubSubCallback;
+}
+export {};

package/dist/extensions/state-manager.js

@@ -0,0 +1,88 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EvStateManager_states, _EvStateManager_manager, _EvStateManager_adapter, _EvStateManager_pubsub;
+import { EvState } from '../state.js';
+export class EvStateManager {
+    constructor({ manager, adapter, pubsub }) {
+        // 🔑 Internally everything is string-based (Redis-safe)
+        _EvStateManager_states.set(this, new Map());
+        _EvStateManager_manager.set(this, void 0);
+        _EvStateManager_adapter.set(this, void 0);
+        _EvStateManager_pubsub.set(this, void 0);
+        __classPrivateFieldSet(this, _EvStateManager_manager, manager, "f");
+        __classPrivateFieldSet(this, _EvStateManager_adapter, adapter, "f");
+        __classPrivateFieldSet(this, _EvStateManager_pubsub, pubsub, "f");
+        this.pubSubCallback = this.pubSubCallback.bind(this);
+        if (__classPrivateFieldGet(this, _EvStateManager_pubsub, "f")) {
+            __classPrivateFieldGet(this, _EvStateManager_pubsub, "f").onMessage(this.pubSubCallback);
+        }
+    }
+    createLocalState(channel, initialValue) {
+        const state = new EvState({
+            channel,
+            initialValue,
+            manager: __classPrivateFieldGet(this, _EvStateManager_manager, "f"),
+            adapter: __classPrivateFieldGet(this, _EvStateManager_adapter, "f"),
+        });
+        __classPrivateFieldGet(this, _EvStateManager_states, "f").set(channel, state);
+        return state;
+    }
+    removeLocalState(channel) {
+        __classPrivateFieldGet(this, _EvStateManager_states, "f").delete(channel);
+    }
+    createState(key, initialValue) {
+        var _a;
+        const channel = String(key);
+        if (__classPrivateFieldGet(this, _EvStateManager_states, "f").has(channel)) {
+            return __classPrivateFieldGet(this, _EvStateManager_states, "f").get(channel);
+        }
+        const state = this.createLocalState(channel, initialValue);
+        (_a = __classPrivateFieldGet(this, _EvStateManager_pubsub, "f")) === null || _a === void 0 ? void 0 : _a.send({
+            type: 'create',
+            channel,
+            initialValue,
+        });
+        return state;
+    }
+    getState(key) {
+        return __classPrivateFieldGet(this, _EvStateManager_states, "f").get(String(key));
+    }
+    hasState(key) {
+        return __classPrivateFieldGet(this, _EvStateManager_states, "f").has(String(key));
+    }
+    removeState(key) {
+        var _a;
+        const channel = String(key);
+        this.removeLocalState(channel);
+        (_a = __classPrivateFieldGet(this, _EvStateManager_pubsub, "f")) === null || _a === void 0 ? void 0 : _a.send({
+            type: 'remove',
+            channel,
+        });
+    }
+    pubSubCallback(msg) {
+        if (!msg || typeof msg.channel !== 'string')
+            return;
+        switch (msg.type) {
+            case 'create': {
+                if (!__classPrivateFieldGet(this, _EvStateManager_states, "f").has(msg.channel)) {
+                    this.createLocalState(msg.channel, msg.initialValue);
+                }
+                break;
+            }
+            case 'remove': {
+                this.removeLocalState(msg.channel);
+                break;
+            }
+        }
+    }
+}
+_EvStateManager_states = new WeakMap(), _EvStateManager_manager = new WeakMap(), _EvStateManager_adapter = new WeakMap(), _EvStateManager_pubsub = new WeakMap();

package/dist/state.d.ts

@@ -5,7 +5,7 @@ type EvSetState<T> = (val: T) => T;
  */
 export declare class EvState<T> {
     #private;
-    constructor({ channel, initialValue, manager, key, adapter }: EvStateOptions<T>);
+    constructor({ channel, initialValue, manager, key, adapter, }: EvStateOptions<T>);
     /**
      * Returns the current state value.
      */

package/dist/state.js

@@ -16,7 +16,7 @@ const { isEqual } = loadash;
  * EvState holds a reactive state and broadcasts updates to a channel using EvStreamManager.
  */
 export class EvState {
-    constructor({ channel, initialValue, manager, key, adapter }) {
+    constructor({ channel, initialValue, manager, key, adapter, }) {
         _EvState_instances.add(this);
         _EvState_value.set(this, void 0);
         _EvState_channel.set(this, void 0);

package/dist/utils.js

@@ -6,21 +6,21 @@
  * @returns
  */
 export function safeJsonParse(val) {
-    if (typeof val === "string") {
+    if (typeof val === 'string') {
         return val;
     }
-    if (typeof val === "object") {
+    if (typeof val === 'object') {
         try {
             return JSON.stringify(val);
         }
         catch (error) {
-            return "";
+            return '';
         }
     }
-    return "";
+    return '';
 }
 export function uid(opts) {
     const now = Date.now().toString(36);
     const rand = Math.random().toString(26).substring(2, 10);
-    return `${(opts === null || opts === void 0 ? void 0 : opts.prefix) ? `${opts === null || opts === void 0 ? void 0 : opts.prefix}-` : ""}${now}-${rand}-${opts === null || opts === void 0 ? void 0 : opts.counter}`;
+    return `${(opts === null || opts === void 0 ? void 0 : opts.prefix) ? `${opts === null || opts === void 0 ? void 0 : opts.prefix}-` : ''}${now}-${rand}-${opts === null || opts === void 0 ? void 0 : opts.counter}`;
 }

package/package.json

@@ -1,60 +1,77 @@
-{
-  "name": "evstream",
-  "version": "1.0.1",
-  "description": "A simple and easy to implement server sent event library for express.js",
-  "keywords": [
-    "sse",
-    "server-sent-events",
-    "event-source"
-  ],
-  "homepage": "https://github.com/kisshan13/evstream#readme",
-  "bugs": {
-    "url": "https://github.com/kisshan13/evstream/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/kisshan13/evstream.git"
-  },
-  "license": "MIT",
-  "author": "Kishan Sharma",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./adapter/redis": {
-      "import": "./dist/adapters/redis.js",
-      "types": "./dist/adapters/redis.d.ts"
-    }
-  },
-  "scripts": {
-    "dev": "tsc --watch",
-    "clean": "rimraf ./dist",
-    "build": "rimraf ./dist && tsc --incremental false"
-  },
-  "engines": {
-    "node": ">=17.8.0"
-  },
-  "devDependencies": {
-    "@types/ioredis": "^5.0.0",
-    "@types/lodash": "^4.17.19",
-    "@types/node": "^24.0.7",
-    "@typescript-eslint/eslint-plugin": "^8.35.0",
-    "@typescript-eslint/parser": "^8.35.0",
-    "eslint": "^9.30.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.1",
-    "eslint-plugin-simple-import-sort": "^12.1.1",
-    "ioredis": "^5.5.0",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "lodash": "^4.17.21"
-  }
-}
+{
+	"name": "evstream",
+	"version": "1.0.3",
+	"description": "A simple and easy to implement server sent event library for express.js",
+	"keywords": [
+		"sse",
+		"server-sent-events",
+		"event-source"
+	],
+	"homepage": "https://github.com/kisshan13/evstream#readme",
+	"bugs": {
+		"url": "https://github.com/kisshan13/evstream/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/kisshan13/evstream.git"
+	},
+	"license": "MIT",
+	"author": "Kishan Sharma",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./adapter/redis": {
+			"import": "./dist/adapters/redis.js",
+			"types": "./dist/adapters/redis.d.ts"
+		},
+		"./extensions/state-manager": {
+			"import": "./dist/extensions/state-manager.js",
+			"types": "./dist/extensions/state-manager.d.ts"
+		}
+	},
+	"lint-staged": {
+		"*.{js,jsx,ts,tsx,cjs,mjs}": [
+			"prettier --write"
+		],
+		"*.{json,md,yml,yaml}": [
+			"prettier --write"
+		]
+	},
+	"scripts": {
+		"dev": "tsc --watch",
+		"clean": "rimraf ./dist",
+		"build": "rimraf ./dist && tsc --incremental false",
+		"prepare": "husky",
+		"lint-staged": "lint-staged",
+		"format": "prettier --write \"**/*.{js,jsx,ts,tsx}\""
+	},
+	"engines": {
+		"node": ">=17.8.0"
+	},
+	"devDependencies": {
+		"@types/ioredis": "^5.0.0",
+		"@types/lodash": "^4.17.19",
+		"@types/node": "^24.0.7",
+		"@typescript-eslint/eslint-plugin": "^8.35.0",
+		"@typescript-eslint/parser": "^8.35.0",
+		"eslint": "^9.30.0",
+		"eslint-config-prettier": "^10.1.5",
+		"eslint-plugin-import": "^2.32.0",
+		"eslint-plugin-prettier": "^5.5.1",
+		"eslint-plugin-simple-import-sort": "^12.1.1",
+		"ioredis": "^5.5.0",
+		"prettier": "^3.7.4",
+		"rimraf": "^6.0.1",
+		"typescript": "^5.8.3",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.2.7"
+	},
+	"dependencies": {
+		"lodash": "^4.17.21"
+	}
+}