@kuindji/reactive 1.0.0

package/dist/react/useListenToAction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListenToAction = useListenToAction;
+const react_1 = require("react");
+function useListenToAction(action, listener, errorListener) {
+    const listenerRef = (0, react_1.useRef)(listener);
+    const actionRef = (0, react_1.useRef)(action);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    listenerRef.current = listener;
+    const genericHandler = (0, react_1.useCallback)((arg) => {
+        var _a;
+        (_a = listenerRef.current) === null || _a === void 0 ? void 0 : _a.call(listenerRef, arg);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            actionRef.current.removeListener(genericHandler);
+            if (errorListenerRef.current) {
+                actionRef.current.removeErrorListener(errorListenerRef.current);
+            }
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        actionRef.current.removeListener(genericHandler);
+        actionRef.current = action;
+        actionRef.current.addListener(genericHandler);
+    }, [action]);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                actionRef.current.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener;
+            if (errorListener) {
+                actionRef.current.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+}

package/dist/react/useListenToEvent.d.ts

@@ -0,0 +1,4 @@
+import type { BaseEvent, ListenerOptions } from "../../src/event";
+import type { ErrorListenerSignature } from "../lib/types";
+export type { BaseEvent, ErrorListenerSignature, ListenerOptions };
+export declare function useListenToEvent<TEvent extends BaseEvent, TListenerSignature extends TEvent["__type"]["signature"], TErrorListenerSignature extends TEvent["__type"]["errorListenerSignature"]>(event: TEvent, listener: TListenerSignature, options?: ListenerOptions, errorListener?: TErrorListenerSignature): void;

package/dist/react/useListenToEvent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListenToEvent = useListenToEvent;
+const react_1 = require("react");
+function useListenToEvent(event, listener, options, errorListener) {
+    const listenerRef = (0, react_1.useRef)(listener);
+    const eventRef = (0, react_1.useRef)(event);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    listenerRef.current = listener;
+    const genericHandler = (0, react_1.useCallback)((...args) => {
+        return listenerRef.current(...args);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            eventRef.current.removeListener(genericHandler);
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        eventRef.current.removeListener(genericHandler);
+        eventRef.current = event;
+        eventRef.current.addListener(genericHandler, options);
+    }, [event]);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                eventRef.current.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener;
+            if (errorListener) {
+                eventRef.current.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+}

package/dist/react/useListenToEventBus.d.ts

@@ -0,0 +1,5 @@
+import type { BaseEventBus } from "../../src/eventBus";
+import type { ErrorListenerSignature, KeyOf } from "../../src/lib/types";
+import type { ListenerOptions } from "../event";
+export type { BaseEventBus, ErrorListenerSignature, ListenerOptions };
+export declare function useListenToEventBus<TEventBus extends BaseEventBus, TKey extends KeyOf<TEventBus["__type"]["eventSignatures"]>, TListener extends TEventBus["__type"]["eventSignatures"][TKey]>(eventBus: TEventBus, eventName: TKey, listener: TListener, options?: ListenerOptions, errorListener?: ErrorListenerSignature<any[]>): void;

package/dist/react/useListenToEventBus.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useListenToEventBus = useListenToEventBus;
+const react_1 = require("react");
+function useListenToEventBus(eventBus, eventName, listener, options, errorListener) {
+    const listenerRef = (0, react_1.useRef)(listener);
+    const eventBusRef = (0, react_1.useRef)(eventBus);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    listenerRef.current = listener;
+    const genericHandler = (0, react_1.useCallback)((...args) => {
+        return listenerRef.current(...args);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            eventBusRef.current.removeListener(eventName, genericHandler);
+            if (errorListenerRef.current) {
+                eventBusRef.current.removeErrorListener(errorListenerRef.current);
+            }
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        eventBusRef.current.removeListener(eventName, genericHandler);
+        eventBusRef.current = eventBus;
+        eventBusRef.current.addListener(eventName, genericHandler, options);
+    }, [eventBus]);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                eventBusRef.current.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener;
+            if (errorListener) {
+                eventBusRef.current.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+}

package/dist/react/useStore.d.ts

@@ -0,0 +1,51 @@
+import type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper } from "../store";
+export type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper, };
+export declare function useStore<PropMap extends BasePropMap, Store extends StoreDefinitionHelper<PropMap> = StoreDefinitionHelper<PropMap>, Config extends {
+    onChange?: Partial<Store["changeEvents"]>;
+    pipes?: Partial<Store["pipeEvents"]>;
+    control?: Partial<Store["controlEvents"]>;
+} = {
+    onChange?: Partial<Store["changeEvents"]>;
+    pipes?: Partial<Store["pipeEvents"]>;
+    control?: Partial<Store["controlEvents"]>;
+}>(initialData?: Partial<PropMap>, config?: Config): import("..").ApiType<StoreDefinitionHelper<PropMap>, {
+    readonly set: {
+        <K extends import("..").KeyOf<PropMap>>(key: K, value: PropMap[K]): void;
+        (key: Partial<PropMap>): void;
+    };
+    readonly get: <K extends import("..").KeyOf<PropMap> | import("..").KeyOf<PropMap>[]>(key: K) => K extends import("..").KeyOf<PropMap> ? PropMap[K] : K extends import("..").KeyOf<PropMap>[] ? { [AK in K[number]]: PropMap[AK]; } : never;
+    readonly getData: () => PropMap;
+    readonly batch: (fn: () => void) => void;
+    readonly asyncSet: {
+        <K extends import("..").KeyOf<PropMap>>(key: K, value: PropMap[K]): void;
+        (key: Partial<PropMap>): void;
+    };
+    readonly isEmpty: () => boolean;
+    readonly reset: () => void;
+    readonly onChange: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1], previousValue?: PropMap[K_1] | undefined) => void; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1], previousValue?: PropMap[K_1] | undefined) => void; }>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly removeOnChange: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1], previousValue?: PropMap[K_1] | undefined) => void; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1], previousValue?: PropMap[K_1] | undefined) => void; }>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly pipe: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1]) => PropMap[K_1]; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1]) => PropMap[K_1]; }>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly removePipe: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1]) => PropMap[K_1]; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1]) => PropMap[K_1]; }>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly control: <K extends import("..").KeyOf<import("..").GetEventsMap<{
+        beforeChange: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V) => boolean;
+        change: (names: import("..").KeyOf<PropMap>[]) => void;
+        reset: () => void;
+        error: import("..").ErrorListenerSignature<any[]>;
+    }>>, H extends import("..").GetEventsMap<{
+        beforeChange: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V) => boolean;
+        change: (names: import("..").KeyOf<PropMap>[]) => void;
+        reset: () => void;
+        error: import("..").ErrorListenerSignature<any[]>;
+    }>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly removeControl: <K extends import("..").KeyOf<import("..").GetEventsMap<{
+        beforeChange: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V) => boolean;
+        change: (names: import("..").KeyOf<PropMap>[]) => void;
+        reset: () => void;
+        error: import("..").ErrorListenerSignature<any[]>;
+    }>>, H extends import("..").GetEventsMap<{
+        beforeChange: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V) => boolean;
+        change: (names: import("..").KeyOf<PropMap>[]) => void;
+        reset: () => void;
+        error: import("..").ErrorListenerSignature<any[]>;
+    }>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+}>;

package/dist/react/useStore.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStore = useStore;
+const react_1 = require("react");
+const store_1 = require("../store");
+function useStore(initialData = {}, config) {
+    const store = (0, react_1.useMemo)(() => {
+        const store = (0, store_1.createStore)(initialData);
+        if (config === null || config === void 0 ? void 0 : config.onChange) {
+            for (const key in config.onChange) {
+                store.onChange(key, config.onChange[key]);
+            }
+        }
+        if (config === null || config === void 0 ? void 0 : config.pipes) {
+            for (const key in config.pipes) {
+                // @ts-expect-error
+                store.pipe(key, config.pipes[key]);
+            }
+        }
+        if (config === null || config === void 0 ? void 0 : config.control) {
+            for (const key in config.control) {
+                store.control(
+                // @ts-expect-error
+                key, config.control[key]);
+            }
+        }
+        return store;
+    }, []);
+    return store;
+}

package/dist/react/useStoreState.d.ts

@@ -0,0 +1,3 @@
+import { KeyOf } from "../lib/types";
+import { BaseStore } from "../store";
+export declare function useStoreState<TStore extends BaseStore, TKey extends KeyOf<TStore["__type"]["propTypes"]>>(store: TStore, key: TKey): readonly [TStore["__type"]["propTypes"][TKey], (value: TStore["__type"]["propTypes"][TKey] | ((previousValue?: TStore["__type"]["propTypes"][TKey] | undefined) => TStore["__type"]["propTypes"][TKey])) => void];

package/dist/react/useStoreState.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStoreState = useStoreState;
+const react_1 = require("react");
+function useStoreState(store, key) {
+    const [value, setValue] = (0, react_1.useState)(store.get(key));
+    const storeRef = (0, react_1.useRef)(store);
+    const keyRef = (0, react_1.useRef)(key);
+    const onChange = (0, react_1.useCallback)((value) => {
+        setValue(value);
+    }, []);
+    const setter = (0, react_1.useCallback)((value) => {
+        if (typeof value === "function") {
+            storeRef.current.set(keyRef.current, value(storeRef.current.get(keyRef.current)));
+        }
+        else {
+            storeRef.current.set(keyRef.current, value);
+        }
+    }, []);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            storeRef.current.onChange(keyRef.current, onChange);
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        storeRef.current.removeOnChange(keyRef.current, onChange);
+        storeRef.current = store;
+        keyRef.current = key;
+        storeRef.current.onChange(keyRef.current, onChange);
+    }, [store, key]);
+    return [value, setter];
+}

package/dist/react.d.ts

@@ -0,0 +1,10 @@
+export * from "./react/useAction";
+export * from "./react/useActionBus";
+export * from "./react/useActionMap";
+export * from "./react/useEvent";
+export * from "./react/useEventBus";
+export * from "./react/useListenToAction";
+export * from "./react/useListenToEvent";
+export * from "./react/useListenToEventBus";
+export * from "./react/useStore";
+export * from "./react/useStoreState";

package/dist/react.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./react/useAction"), exports);
+__exportStar(require("./react/useActionBus"), exports);
+__exportStar(require("./react/useActionMap"), exports);
+__exportStar(require("./react/useEvent"), exports);
+__exportStar(require("./react/useEventBus"), exports);
+__exportStar(require("./react/useListenToAction"), exports);
+__exportStar(require("./react/useListenToEvent"), exports);
+__exportStar(require("./react/useListenToEventBus"), exports);
+__exportStar(require("./react/useStore"), exports);
+__exportStar(require("./react/useStoreState"), exports);

package/dist/store.d.ts

@@ -0,0 +1,54 @@
+import { EventBusDefinitionHelper } from "./eventBus";
+import type { ApiType, ErrorListenerSignature, KeyOf, MapKey } from "./lib/types";
+export interface BasePropMap {
+    [key: MapKey]: any;
+}
+export declare const BeforeChangeEventName = "beforeChange";
+export declare const ChangeEventName = "change";
+export declare const ResetEventName = "reset";
+export declare const ErrorEventName = "error";
+type StoreControlEvents<PropMap extends BasePropMap> = {
+    [BeforeChangeEventName]: <K extends KeyOf<PropMap>, V extends PropMap[K]>(name: K, value: V) => boolean;
+    [ChangeEventName]: (names: KeyOf<PropMap>[]) => void;
+    [ResetEventName]: () => void;
+    [ErrorEventName]: ErrorListenerSignature<any[]>;
+};
+type StoreChangeEvents<PropMap extends BasePropMap> = {
+    [K in KeyOf<PropMap>]: (value: PropMap[K], previousValue?: PropMap[K] | undefined) => void;
+};
+type StorePipeEvents<PropMap extends BasePropMap> = {
+    [K in KeyOf<PropMap>]: (value: PropMap[K]) => PropMap[K];
+};
+export type StoreDefinitionHelper<PropMap extends BasePropMap> = {
+    propTypes: PropMap;
+    controlEvents: StoreControlEvents<PropMap>;
+    changeEvents: StoreChangeEvents<PropMap>;
+    pipeEvents: StorePipeEvents<PropMap>;
+    changeEventBus: EventBusDefinitionHelper<StoreChangeEvents<PropMap>>;
+    pipeEventBus: EventBusDefinitionHelper<StorePipeEvents<PropMap>>;
+    controlEventBus: EventBusDefinitionHelper<StoreControlEvents<PropMap>>;
+};
+export declare function createStore<PropMap extends BasePropMap = BasePropMap>(initialData?: Partial<PropMap>): ApiType<StoreDefinitionHelper<PropMap>, {
+    readonly set: {
+        <K extends KeyOf<PropMap>>(key: K, value: PropMap[K]): void;
+        (key: Partial<PropMap>): void;
+    };
+    readonly get: <K extends (KeyOf<PropMap>) | Array<KeyOf<PropMap>>>(key: K) => K extends KeyOf<PropMap> ? PropMap[K] : K extends KeyOf<PropMap>[] ? { [AK in K[number]]: PropMap[AK]; } : never;
+    readonly getData: () => PropMap;
+    readonly batch: (fn: () => void) => void;
+    readonly asyncSet: {
+        <K extends KeyOf<PropMap>>(key: K, value: PropMap[K]): void;
+        (key: Partial<PropMap>): void;
+    };
+    readonly isEmpty: () => boolean;
+    readonly reset: () => void;
+    readonly onChange: <K extends KeyOf<import("./eventBus").GetEventsMap<StoreChangeEvents<PropMap>>>, H extends import("./eventBus").GetEventsMap<StoreChangeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, options?: import("./event").ListenerOptions) => void;
+    readonly removeOnChange: <K extends KeyOf<import("./eventBus").GetEventsMap<StoreChangeEvents<PropMap>>>, H extends import("./eventBus").GetEventsMap<StoreChangeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly pipe: <K extends KeyOf<import("./eventBus").GetEventsMap<StorePipeEvents<PropMap>>>, H extends import("./eventBus").GetEventsMap<StorePipeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, options?: import("./event").ListenerOptions) => void;
+    readonly removePipe: <K extends KeyOf<import("./eventBus").GetEventsMap<StorePipeEvents<PropMap>>>, H extends import("./eventBus").GetEventsMap<StorePipeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly control: <K extends KeyOf<import("./eventBus").GetEventsMap<StoreControlEvents<PropMap>>>, H extends import("./eventBus").GetEventsMap<StoreControlEvents<PropMap>>[K]["signature"]>(name: K, handler: H, options?: import("./event").ListenerOptions) => void;
+    readonly removeControl: <K extends KeyOf<import("./eventBus").GetEventsMap<StoreControlEvents<PropMap>>>, H extends import("./eventBus").GetEventsMap<StoreControlEvents<PropMap>>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+}>;
+export type BaseStoreDefinition = StoreDefinitionHelper<BasePropMap>;
+export type BaseStore = ReturnType<typeof createStore<any>>;
+export {};

package/dist/store.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorEventName = exports.ResetEventName = exports.ChangeEventName = exports.BeforeChangeEventName = void 0;
+exports.createStore = createStore;
+const eventBus_1 = require("./eventBus");
+exports.BeforeChangeEventName = "beforeChange";
+exports.ChangeEventName = "change";
+exports.ResetEventName = "reset";
+exports.ErrorEventName = "error";
+function createStore(initialData = {}) {
+    const data = new Map(Object.entries(initialData));
+    const changes = (0, eventBus_1.createEventBus)();
+    const pipe = (0, eventBus_1.createEventBus)();
+    const control = (0, eventBus_1.createEventBus)();
+    const _set = (name, value, triggerChange = true) => {
+        var _a, _b, _c;
+        const prev = data.get(name);
+        if (prev !== value) {
+            if (control.firstNonEmpty(exports.BeforeChangeEventName, name, value)
+                === false) {
+                return;
+            }
+            const pipeArgs = [value];
+            let newValue;
+            try {
+                newValue = pipe.pipe(name, ...pipeArgs);
+            }
+            catch (error) {
+                control.trigger(exports.ErrorEventName, {
+                    error: error instanceof Error
+                        ? error
+                        : new Error(String(error)),
+                    args: pipeArgs,
+                    type: "store-pipe",
+                    name,
+                });
+                if ((_a = control.get(exports.ErrorEventName)) === null || _a === void 0 ? void 0 : _a.hasListener()) {
+                    return false;
+                }
+                throw error;
+            }
+            if (newValue !== undefined) {
+                value = newValue;
+            }
+            data.set(name, value);
+            const changeArgs = [
+                value,
+                prev,
+            ];
+            try {
+                changes.trigger(name, ...changeArgs);
+            }
+            catch (error) {
+                control.trigger(exports.ErrorEventName, {
+                    error: error instanceof Error
+                        ? error
+                        : new Error(String(error)),
+                    args: changeArgs,
+                    type: "store-change",
+                    name,
+                });
+                if ((_b = control.get(exports.ErrorEventName)) === null || _b === void 0 ? void 0 : _b.hasListener()) {
+                    return true;
+                }
+                throw error;
+            }
+            if (triggerChange) {
+                try {
+                    control.trigger(exports.ChangeEventName, [name]);
+                }
+                catch (error) {
+                    control.trigger(exports.ErrorEventName, {
+                        error: error instanceof Error
+                            ? error
+                            : new Error(String(error)),
+                        args: [name],
+                        type: "store-control",
+                        name,
+                    });
+                    if ((_c = control.get(exports.ErrorEventName)) === null || _c === void 0 ? void 0 : _c.hasListener()) {
+                        return true;
+                    }
+                    throw error;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+    function asyncSet(name, value) {
+        setTimeout(() => {
+            if ((typeof name === "string")
+                && value !== undefined) {
+                set(name, value);
+            }
+            else if (typeof name === "object") {
+                set(name);
+            }
+        }, 0);
+    }
+    function set(name, value) {
+        if ((typeof name === "string")
+            && value !== undefined) {
+            _set(name, value);
+        }
+        else if (typeof name === "object") {
+            const changedKeys = [];
+            Object.entries(name).forEach(([k, v]) => {
+                if (_set(k, v, false)) {
+                    changedKeys.push(k);
+                }
+            });
+            control.trigger(exports.ChangeEventName, changedKeys);
+        }
+        else {
+            throw new Error(`Invalid key: ${String(name)}`);
+        }
+    }
+    const get = (key) => {
+        if (typeof key === "string") {
+            return data.get(key);
+        }
+        else if (Array.isArray(key)) {
+            // return object with given keys
+            return key.reduce((acc, k) => {
+                acc[k] = data.get(k);
+                return acc;
+            }, {});
+        }
+        else {
+            throw new Error(`Invalid key: ${String(key)}`);
+        }
+    };
+    const isEmpty = () => {
+        if (data.size === 0) {
+            return true;
+        }
+        return Array.from(data.values()).every((value) => value === null || value === undefined);
+    };
+    const getData = () => {
+        return Object.fromEntries(data.entries());
+    };
+    const batch = (fn) => {
+        const allChangedKeys = [];
+        const log = [];
+        const controlInterceptor = function (name, [changedKeys]) {
+            if (name === exports.ChangeEventName) {
+                allChangedKeys.push(...changedKeys);
+                return false;
+            }
+            return true;
+        };
+        const changeInterceptor = function (propName, args) {
+            log.push([propName, args[0], args[1]]);
+            return false;
+        };
+        changes.intercept(changeInterceptor);
+        control.intercept(controlInterceptor);
+        fn();
+        control.stopIntercepting();
+        changes.stopIntercepting();
+        for (const [propName, value, prev] of log) {
+            const changeArgs = [
+                value,
+                prev,
+            ];
+            changes.trigger(propName, ...changeArgs);
+        }
+        if (allChangedKeys.length > 0) {
+            control.trigger(exports.ChangeEventName, allChangedKeys);
+        }
+    };
+    const reset = () => {
+        data.clear();
+        control.trigger(exports.ResetEventName);
+    };
+    const api = {
+        set,
+        get,
+        getData,
+        batch,
+        asyncSet,
+        isEmpty,
+        reset,
+        onChange: changes.addListener,
+        removeOnChange: changes.removeListener,
+        pipe: pipe.addListener,
+        removePipe: pipe.removeListener,
+        control: control.addListener,
+        removeControl: control.removeListener,
+    };
+    return api;
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "@kuindji/reactive",
+    "version": "1.0.0",
+    "description": "A JavaScript/TypeScript utility library for building reactive applications with events, actions, stores, and React hooks",
+    "keywords": [
+        "events",
+        "actions",
+        "store",
+        "state-management",
+        "react-hooks",
+        "typescript",
+        "event-emitter",
+        "observable",
+        "async",
+        "event-bus",
+        "action-bus"
+    ],
+    "homepage": "https://github.com/kuindji/reactive#readme",
+    "bugs": {
+        "url": "https://github.com/kuindji/reactive/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kuindji/reactive.git"
+    },
+    "license": "ISC",
+    "author": "Ivan Kuindzhi",
+    "type": "commonjs",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "require": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./react": {
+            "import": "./dist/react.js",
+            "require": "./dist/react.js",
+            "types": "./dist/react.d.ts"
+        }
+    },
+    "main": "src/index.ts",
+    "types": "dist/index.d.ts",
+    "directories": {
+        "test": "tests"
+    },
+    "files": [
+        "dist/**/*"
+    ],
+    "scripts": {
+        "build": "tsc -p ./tsconfig-build.json",
+        "lint": "bun eslint .",
+        "test": "bun test tests/**/*.spec.ts*"
+    },
+    "devDependencies": {
+        "@happy-dom/global-registrator": "^18.0.1",
+        "@testing-library/dom": "^10.4.1",
+        "@testing-library/jest-dom": "^6.6.4",
+        "@testing-library/react": "^16.3.0",
+        "@types/bun": "^1.2.19",
+        "@types/react": "^19.1.9",
+        "@typescript-eslint/eslint-plugin": "^8.38.0",
+        "react": "^19.1.1",
+        "typescript": "^5",
+        "typescript-eslint": "^8.38.0"
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "sideEffects": false
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./action";
+export * from "./event";
+export * from "./eventBus";
+export * from "./lib/types";
+export * from "./store";