hermes-io 2.11.95 → 2.12.97

package/lib/components/withNotify/withNotify.d.ts

@@ -0,0 +1,11 @@
+import { ComponentType } from "react";
+import type { Context } from "../../context/context";
+import type { Observer } from "../../observer/observer";
+interface WithNotifyConfig {
+    context: Context;
+    observer: Observer;
+}
+export declare function withNotify<P extends Record<string, unknown>>(Component: ComponentType<P & {
+    notify: (value: unknown) => Promise<unknown>;
+}>, { context, observer }: WithNotifyConfig): (props: P) => import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/components/withNotify/withNotify.js

@@ -1 +1,5 @@
-function _extends(){return(_extends=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(t[r]=n[r])}return t}).apply(this,arguments)}import t from"react";export function withNotify(e,n){var r=n.context,o=n.observer,i=function(t){return o.notify({context:r,value:t})};return function(n){return t.createElement(e,_extends({notify:i},n))}}
+import { jsx as _jsx } from "react/jsx-runtime";
+export function withNotify(Component, { context, observer }) {
+    const notify = (value) => observer.notify({ context, value });
+    return (props) => _jsx(Component, { notify: notify, ...props });
+}

package/lib/constants.d.ts

@@ -0,0 +1,10 @@
+declare const CONSTANTS: {
+    readonly CHROME_EXTENSION: "hermes-io-devtools";
+    readonly CONTEXT_SNAPSHOT: "CONTEXT_SNAPSHOT";
+    readonly START_RECORDING: "START_RECORDING";
+    readonly STOP_RECORDING: "STOP_RECORDING";
+    readonly SET_CONTEXT: "SET_CONTEXT";
+    readonly LOAD_RECORDING: "LOAD_RECORDING";
+    readonly RESET_RECORDING: "RESET_RECORDING";
+};
+export default CONSTANTS;

package/lib/constants.js

@@ -1 +1,10 @@
-export default{CHROME_EXTENSION:"hermes-io-devtools",CONTEXT_SNAPSHOT:"CONTEXT_SNAPSHOT",START_RECORDING:"START_RECORDING",STOP_RECORDING:"STOP_RECORDING",SET_CONTEXT:"SET_CONTEXT",LOAD_RECORDING:"LOAD_RECORDING",RESET_RECORDING:"RESET_RECORDING"};
+const CONSTANTS = {
+    CHROME_EXTENSION: "hermes-io-devtools",
+    CONTEXT_SNAPSHOT: "CONTEXT_SNAPSHOT",
+    START_RECORDING: "START_RECORDING",
+    STOP_RECORDING: "STOP_RECORDING",
+    SET_CONTEXT: "SET_CONTEXT",
+    LOAD_RECORDING: "LOAD_RECORDING",
+    RESET_RECORDING: "RESET_RECORDING",
+};
+export default CONSTANTS;

package/lib/context/context.d.ts

@@ -0,0 +1,29 @@
+interface SnapshotItem {
+    _internalId: string;
+    value: unknown;
+    date: Date | null;
+    listener: ((...args: unknown[]) => unknown) | null;
+    stackTrace: string | undefined;
+    isFromExternalRecording?: boolean;
+    id?: string;
+}
+export declare const listenersMap: Map<string, (...args: unknown[]) => unknown>;
+export declare function subscribeDevtools(): void;
+export declare function unsubscribeDevtools(): void;
+export declare class Context {
+    id: symbol;
+    _internalId: string | null;
+    date: Date | null;
+    value: unknown;
+    listener: ((...args: unknown[]) => unknown) | null;
+    stackTrace: string | undefined;
+    constructor(description: string);
+    update: ({ value, listener }: {
+        value: unknown;
+        listener: (...args: unknown[]) => unknown;
+    }) => void;
+    sendSnapshot: () => void;
+    takeSnapshot: () => SnapshotItem;
+    getStackTrace: () => string | undefined;
+}
+export {};

package/lib/context/context.js

@@ -1 +1,120 @@
-function _extends(){return(_extends=Object.assign||function(e){for(var n=1;n<arguments.length;n++){var t=arguments[n];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(e[r]=t[r])}return e}).apply(this,arguments)}import e from"../constants.js";var _obj,recording=!1,collection=[];export var listenersMap=new Map;var actions=((_obj={})[e.START_RECORDING]=function(){recording=!0},_obj[e.STOP_RECORDING]=function(){recording=!1},_obj[e.RESET_RECORDING]=function(){collection=[],recording=!1},_obj[e.SET_CONTEXT]=function(e){var n=e.id,t=void 0===n?"":n,r=collection.find(function(e){return e._internalId===t});if(r){if(r.isFromExternalRecording){var i=listenersMap.get(r.listener);return null==i?void 0:i({value:JSON.parse(r.value)})}return r.listener(r.value)}},_obj[e.LOAD_RECORDING]=function(e){collection=e.recording.map(function(e){return void 0===e&&(e={}),_extends({},e,{isFromExternalRecording:!0,_internalId:e.id})})},_obj);"undefined"!=typeof window&&window.addEventListener("message",function(n){try{var t=n.data,r=t.source,i=t.payload;if(r===e.CHROME_EXTENSION){if(null==i?void 0:i.type)return actions[i.type](i);actions[i]()}}catch(e){console.error(e)}});export var Context=function(n){var t=this;this.id=null,this._internalId=null,this.date=null,this.value=null,this.listener=null,this.stackTrace=null,this.update=function(e){var n=e.value,r=e.listener;t.date=new Date,t.value=n,t.stackTrace=t.getStackTrace(),t.listener=r,recording&&t.sendSnapshot()},this.sendSnapshot=function(){var n=t.takeSnapshot(),r=n.listener,i=n.stackTrace,a=n.value,o=n.date,s=n._internalId;collection.push(n),"undefined"!=typeof window&&window.postMessage({type:e.CONTEXT_SNAPSHOT,payload:{value:JSON.stringify(a.value),listener:r.name,stackTrace:i,date:o,id:s},source:"hermes-io"},"*")},this.takeSnapshot=function(){return{_internalId:crypto.randomUUID(),value:t.value,date:t.date,listener:t.listener,stackTrace:t.stackTrace}},this.getStackTrace=function(){return Error().stack},this.id=Symbol(n)};
+import CONSTANTS from "../constants";
+let recording = false;
+let collection = [];
+export const listenersMap = new Map();
+function startRecording() {
+    recording = true;
+}
+function stopRecording() {
+    recording = false;
+}
+function resetRecording() {
+    collection = [];
+    recording = false;
+}
+function setContext({ id = "" }) {
+    const context = collection.find((context) => context._internalId === id);
+    if (context) {
+        if (context.isFromExternalRecording) {
+            const listener = listenersMap.get(context.listener);
+            listener?.({ value: JSON.parse(context.value) });
+            return;
+        }
+        context.listener?.(context.value);
+    }
+}
+function loadRecording(payload) {
+    collection = (payload.recording ?? []).map((item = {}) => ({
+        ...item,
+        isFromExternalRecording: true,
+        _internalId: item.id,
+    }));
+}
+const actions = {
+    [CONSTANTS.START_RECORDING]: startRecording,
+    [CONSTANTS.STOP_RECORDING]: stopRecording,
+    [CONSTANTS.RESET_RECORDING]: resetRecording,
+    [CONSTANTS.SET_CONTEXT]: setContext,
+    [CONSTANTS.LOAD_RECORDING]: loadRecording,
+};
+const handleMessageFromDevtools = (event) => {
+    try {
+        if (event.origin !== window.location.origin)
+            return;
+        const { source, payload } = event.data;
+        if (source === CONSTANTS.CHROME_EXTENSION) {
+            if (payload?.type) {
+                actions[payload.type]?.(payload);
+                return;
+            }
+            actions[payload]?.();
+        }
+    }
+    catch (error) {
+        console.error(error);
+    }
+};
+let listenerRegistered = false;
+export function subscribeDevtools() {
+    if (typeof window === "undefined" || listenerRegistered)
+        return;
+    listenerRegistered = true;
+    window.addEventListener("message", handleMessageFromDevtools);
+}
+export function unsubscribeDevtools() {
+    if (typeof window === "undefined" || !listenerRegistered)
+        return;
+    listenerRegistered = false;
+    window.removeEventListener("message", handleMessageFromDevtools);
+}
+subscribeDevtools();
+export class Context {
+    constructor(description) {
+        this._internalId = null;
+        this.date = null;
+        this.value = null;
+        this.listener = null;
+        this.stackTrace = undefined;
+        this.update = ({ value, listener }) => {
+            this.date = new Date();
+            this.value = value;
+            this.stackTrace = this.getStackTrace();
+            this.listener = listener;
+            if (recording) {
+                this.sendSnapshot();
+            }
+        };
+        this.sendSnapshot = () => {
+            const snapshot = this.takeSnapshot();
+            const { listener, stackTrace, value, date, _internalId } = snapshot;
+            collection.push(snapshot);
+            if (typeof window !== "undefined") {
+                window.postMessage({
+                    type: CONSTANTS.CONTEXT_SNAPSHOT,
+                    payload: {
+                        value: JSON.stringify(value?.value),
+                        listener: listener?.name,
+                        stackTrace,
+                        date,
+                        id: _internalId,
+                    },
+                    source: "hermes-io",
+                }, window.location.origin);
+            }
+        };
+        this.takeSnapshot = () => {
+            return {
+                _internalId: crypto.randomUUID(),
+                value: this.value,
+                date: this.date,
+                listener: this.listener,
+                stackTrace: this.stackTrace,
+            };
+        };
+        this.getStackTrace = () => {
+            const err = new Error();
+            return err.stack;
+        };
+        this.id = Symbol(description);
+    }
+}

package/lib/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useObserver';
+export * from './useMutations';
+export * from './useStore';

package/lib/hooks/index.js

@@ -1 +1,3 @@
-export*from"./useObserver.js";export*from"./useMutations.js";export*from"./useStore.js";export*from"./useObservableStore.js";
+export * from './useObserver';
+export * from './useMutations';
+export * from './useStore';

package/lib/hooks/useMutations.d.ts

@@ -0,0 +1,23 @@
+import type { Store } from "../store/store";
+type OnChangeCallback = (value: unknown, resolver: (value?: unknown) => void, setNoUpdate: (value: boolean) => void, prevState: Record<string, unknown>) => Record<string, unknown> | void;
+interface CustomEvent {
+    event: string;
+    onChange: OnChangeCallback;
+}
+interface MutationRef {
+    id: string;
+    state: Record<string, unknown>;
+    events: CustomEvent[];
+    onEvent: (event: string, onChange: OnChangeCallback) => void;
+}
+export interface UseMutationsProps {
+    events?: string[];
+    onChange?: OnChangeCallback;
+    store?: Store;
+    id?: string;
+    initialState?: Record<string, unknown>;
+    name?: string;
+    noUpdate?: boolean;
+}
+export declare const useMutations: (props?: UseMutationsProps) => MutationRef;
+export {};

package/lib/hooks/useMutations.js

@@ -1 +1,93 @@
-function _array_like_to_array(e,r){(null==r||r>e.length)&&(r=e.length);for(var t=0,n=Array(r);t<r;t++)n[t]=e[t];return n}function _extends(){return(_extends=Object.assign||function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])}return e}).apply(this,arguments)}function _create_for_of_iterator_helper_loose(e,r){var t="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(t)return(t=t.call(e)).next.bind(t);if(Array.isArray(e)||(t=function(e,r){if(e){if("string"==typeof e)return _array_like_to_array(e,void 0);var t=Object.prototype.toString.call(e).slice(8,-1);if("Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t)return Array.from(t);if("Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t))return _array_like_to_array(e,void 0)}}(e))||r&&e&&"number"==typeof e.length){t&&(e=t);var n=0;return function(){return n>=e.length?{done:!0}:{done:!1,value:e[n++]}}}throw TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}import{useState as e,useEffect as r,useRef as t,useCallback as n}from"react";import{useObserver as o}from"./useObserver.js";import{MicroStore as a}from"../store/store.js";import{getStackTrace as i,randomId as l}from"../utils.js";export var useMutations=function(u){void 0===u&&(u={});var s,v=u.events,c=void 0===v?[]:v,f=u.onChange,d=u.store,_=u.id,p=u.initialState,y=u.name,m=void 0===y?"":y,h=e(l()),b=(h[0],h[1]),g=t({id:i()+"_"+(null!=_?_:""),state:_extends({},void 0===p?{}:p),events:[],onEvent:function(e,r){var t=g.current.events;t.some(function(r){return r.event===e})||t.push({event:e,onChange:r})}}),S=function(e){return u.noUpdate=e},x=function(e,r,t,n){var o=!e,a=!1;if(null==e||null==(i=e.forEach)||i.call(e,function(e){if(e===u.id){a=!0;var o,i=null!=(o=null==n?void 0:n(r,t,S,g.current.state))?o:{};u.noUpdate&&(i={}),g.current.state=_extends({},g.current.state,i)}}),o){var i,s,v=null!=(s=null==n?void 0:n(r,t,S,g.current.state))?s:{};u.noUpdate&&(v={}),g.current.state=_extends({},g.current.state,v)}!0!==u.noUpdate&&!1!==a&&b(l())},j=n(function(e,r){var t=null==(i=e.value)?void 0:null==(a=i.payload)?void 0:a.value,n=null==(l=e.value)?void 0:l.targets,o=null==(u=g.current)?void 0:u.events;if(o.length>0){for(var a,i,l,u,s,v=_create_for_of_iterator_helper_loose(o);!(s=v()).done;){var d=s.value;e.value.type===d.event&&x(n,t,r,d.onChange)}return}for(var _,p=_create_for_of_iterator_helper_loose(c);!(_=p()).done;){var y=_.value;e.value.type===y&&x(n,t,r,f)}},[c,null==(s=g.current)?void 0:s.events]);return r(function(){var e=null!=a&&"undefined"!=typeof Symbol&&a[Symbol.hasInstance]?!!a[Symbol.hasInstance](d):d instanceof a;if(e){var r=g.current.id;j.id=r;var t=d.has(_);d.hasListener(r)||d.registerListener(_,j),t&&!d.get(_).observer.has(r)&&d.subscribeStore(_,d.get(_),m)}return function(){e&&d.remove(_,g.current.id)}},[]),o({store:d,listener:j,contexts:[null==d?void 0:d.context],observer:null==d?void 0:d.observer}),g.current};
+import { useState, useEffect, useRef, useCallback } from "react";
+import { useObserver } from "./useObserver";
+import { MicroStore } from "../store/store";
+import { getStackTrace, randomId } from "../utils";
+export const useMutations = (props = {}) => {
+    const { events = [], onChange, store, id, initialState = {}, name = "", noUpdate: initialNoUpdate, } = props;
+    const [_renderId, setReRenderId] = useState(randomId());
+    const noUpdateRef = useRef(initialNoUpdate);
+    const mutationRef = useRef({
+        id: `${getStackTrace()}_${id ?? ""}`,
+        state: { ...initialState },
+        events: [],
+        onEvent: (event, onChange) => {
+            const events = mutationRef.current.events;
+            const isAlreadyIn = events.some((item) => item.event === event);
+            if (!isAlreadyIn)
+                events.push({ event, onChange });
+        },
+    });
+    const setNoUpdate = (value) => {
+        noUpdateRef.current = value;
+    };
+    const executeEvent = (targets, value, resolver, onChange) => {
+        const hasNotTargets = !targets;
+        let match = false;
+        targets?.forEach?.((target) => {
+            if (target === id) {
+                match = true;
+                let result = onChange?.(value, resolver, setNoUpdate, mutationRef.current.state) ??
+                    {};
+                if (noUpdateRef.current)
+                    result = {};
+                mutationRef.current.state = { ...mutationRef.current.state, ...result };
+            }
+        });
+        if (hasNotTargets) {
+            let result = onChange?.(value, resolver, setNoUpdate, mutationRef.current.state) ??
+                {};
+            if (noUpdateRef.current)
+                result = {};
+            mutationRef.current.state = { ...mutationRef.current.state, ...result };
+        }
+        if (noUpdateRef.current === true || match === false)
+            return;
+        setReRenderId(randomId());
+    };
+    const handleNotification = useCallback(((e, resolver) => {
+        const payload = e.value?.payload;
+        const value = payload?.value;
+        const targets = e.value?.targets;
+        const customs = mutationRef.current?.events;
+        const hasCustomEvents = customs.length > 0;
+        if (hasCustomEvents) {
+            for (const custom of customs) {
+                if (e.value.type !== custom.event)
+                    continue;
+                executeEvent(targets, value, resolver, custom.onChange);
+            }
+            return;
+        }
+        for (const event of events) {
+            if (e.value.type !== event)
+                continue;
+            executeEvent(targets, value, resolver, onChange);
+        }
+    }), [events, mutationRef.current?.events]);
+    useEffect(() => {
+        const isMicroStore = store instanceof MicroStore;
+        if (isMicroStore) {
+            const microStore = store;
+            const { id: mutationId } = mutationRef.current;
+            handleNotification.id = mutationId;
+            const isPopulated = microStore.has(id);
+            if (!microStore.hasListener(mutationId)) {
+                microStore.registerListener(id, handleNotification);
+            }
+            if (isPopulated && !microStore.get(id).observer.has(mutationId)) {
+                microStore.subscribeStore(id, microStore.get(id));
+            }
+        }
+        return () => {
+            if (isMicroStore)
+                store.remove(id, mutationRef.current.id);
+        };
+    }, []);
+    useObserver({
+        store,
+        listener: handleNotification,
+        contexts: store?.context ? [store.context] : [],
+        observer: store?.observer,
+    });
+    return mutationRef.current;
+};

package/lib/hooks/useObserver.d.ts

@@ -0,0 +1,11 @@
+import { Store } from "../store/store";
+import type { Context } from "../context/context";
+import type { Observer, Subscriber } from "../observer/observer";
+export declare const hasValidList: (contexts: Context[] | undefined, payload: Record<string, unknown>) => Context | undefined;
+export interface UseObserverProps {
+    store?: Store;
+    listener?: Subscriber;
+    contexts?: Context[];
+    observer?: Observer;
+}
+export declare const useObserver: (props: UseObserverProps) => void;

package/lib/hooks/useObserver.js

@@ -1 +1,25 @@
-import{useEffect as n}from"react";import{Store as l}from"../store/store.js";export var hasValidList=function(n,l){var e;return void 0===n&&(n=[]),null==n?void 0:null==(e=n.find)?void 0:e.call(n,function(n){var e;return n.id===(null==l?void 0:null==(e=l.context)?void 0:e.id)})};export var useObserver=function(e){n(function(){var n,r,t=function(n,l){var e;hasValidList(u,n)&&(null==n||null==(e=n.context)||e.update({value:n,listener:o}),null==o||o(n,l))},o=e.listener,i=e.observer,u=e.contexts,s=(n=e.store,null!=l&&"undefined"!=typeof Symbol&&l[Symbol.hasInstance]?!!l[Symbol.hasInstance](n):n instanceof l);return s&&(null==i||null==(r=i.subscribe)||r.call(i,t)),function(){var n;return s&&(null==i?void 0:null==(n=i.unsubscribe)?void 0:n.call(i,t))}},[e.listener,e.observer,e.contexts])};
+import { useEffect } from "react";
+import { Store } from "../store/store";
+export const hasValidList = (contexts = [], payload) => contexts?.find?.((ctx) => ctx.id === payload?.context?.id);
+export const useObserver = (props) => {
+    useEffect(() => {
+        const { listener, observer, contexts, store } = props;
+        const isStore = store instanceof Store;
+        const subscriber = function (payload, resolve) {
+            if (!hasValidList(contexts, payload))
+                return;
+            payload?.context &&
+                payload.context.update?.({
+                    value: payload,
+                    listener: listener,
+                });
+            listener?.(payload, resolve);
+        };
+        if (isStore)
+            observer?.subscribe?.(subscriber);
+        return () => {
+            if (isStore)
+                observer?.unsubscribe?.(subscriber);
+        };
+    }, [props.listener, props.observer, props.contexts]);
+};

package/lib/hooks/useStore.d.ts

@@ -0,0 +1,22 @@
+import type { Store } from "../store/store";
+import type { MicroStore } from "../store/store";
+export interface UseStoreProps {
+    store: Store;
+    reducer: (state: unknown, action: {
+        type: string;
+        payload?: unknown;
+    }) => unknown;
+    data?: unknown;
+    microStore?: MicroStore;
+    id?: string;
+    name?: string;
+}
+export declare function useStore(props: UseStoreProps): {
+    query: (cb: (store: Store) => unknown, defaultValue?: unknown) => unknown;
+    mutate: ({ type, payload, targets }: {
+        type: string;
+        payload?: unknown;
+        targets?: string[];
+    }) => Promise<unknown>;
+    store: Store;
+};

package/lib/hooks/useStore.js

@@ -1 +1,24 @@
-import{useCallback as t,useRef as r}from"react";import{useMicroStore as e}from"./useMicroStore";export function useStore(a){var o=a.name,u=a.reducer,n=a.data,i=a.microStore,s=a.id,m=r(a.store).current,c=m.mutate=t(function(t){var r=t.type,e=t.payload,a=t.targets,o=u(m.state,{type:r,payload:e});return m.notify({type:r,payload:e,state:o,targets:a})},[]),p=m.query=t(function(t,r){var e;return null!=(e=t(m))?e:r},[]);return m.state||(m.state=n),e({id:s,microStore:i,store:m,name:o}),{query:p,mutate:c,store:m}}
+import { useCallback, useEffect, useRef } from "react";
+export function useStore(props) {
+    const { name, reducer, data, microStore, id } = props;
+    const storeRef = useRef(props.store);
+    const store = storeRef.current;
+    const reducerRef = useRef(reducer);
+    reducerRef.current = reducer;
+    const mutate = (store.mutate = useCallback(({ type, payload, targets }) => {
+        const newState = reducerRef.current(store.state, { type, payload });
+        return store.notify({ type, payload, state: newState, targets });
+    }, [store]));
+    const query = (store.query = useCallback((cb, defaultValue) => cb(store) ?? defaultValue, [store]));
+    if (!store.state)
+        store.state = data;
+    useEffect(() => {
+        if (!id || !microStore || microStore.has?.(id))
+            return;
+        microStore.add?.(id, store, name);
+        return () => {
+            microStore.removeAll?.(id);
+        };
+    }, [microStore, store, id]);
+    return { query, mutate, store };
+}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./hooks/index";
+export * from "./observer/observer";
+export * from "./context/context";
+export * from "./store/store";
+export * from "./components/withNotify/withNotify";

package/lib/index.js

@@ -1 +1,5 @@
-export*from"./hooks/index.js";export*from"./observer/observer.js";export*from"./context/context.js";export*from"./store/store.js";export*from"./components/withNotify/withNotify.js";
+export * from "./hooks/index";
+export * from "./observer/observer";
+export * from "./context/context";
+export * from "./store/store";
+export * from "./components/withNotify/withNotify";

package/lib/observer/observer.d.ts

@@ -0,0 +1,14 @@
+export type Subscriber = {
+    (args: Record<string, unknown>, resolve: (value?: unknown) => void): void;
+    id?: string;
+};
+export interface NotifyOptions {
+    timeout?: number;
+}
+export declare class Observer {
+    subscriptors: Subscriber[];
+    subscribe(callback: Subscriber): void;
+    unsubscribe(callback: Subscriber): void;
+    has: (id: string) => boolean;
+    notify(args?: Record<string, unknown>, { timeout }?: NotifyOptions): Promise<unknown>;
+}

package/lib/observer/observer.js

@@ -1 +1,25 @@
-export var Observer=function(){function r(){var r=this;this.subscriptors=[],this.has=function(s){return r.subscriptors.some(function(r){return s===r.id})}}var s=r.prototype;return s.subscribe=function(r){this.subscriptors.push(r)},s.unsubscribe=function(r){this.subscriptors.splice(this.subscriptors.findIndex(function(s){return s===r}),1)},s.notify=function(r){var s=this;return void 0===r&&(r={}),new Promise(function(t){s.subscriptors.forEach(function(s){return s(r,t)})})},r}();
+export class Observer {
+    constructor() {
+        this.subscriptors = [];
+        this.has = (id) => this.subscriptors.some((subscriber) => id === subscriber.id);
+    }
+    subscribe(callback) {
+        this.subscriptors.push(callback);
+    }
+    unsubscribe(callback) {
+        const index = this.subscriptors.findIndex((cb) => cb === callback);
+        if (index > -1)
+            this.subscriptors.splice(index, 1);
+    }
+    notify(args = {}, { timeout = 30000 } = {}) {
+        return new Promise((resolve) => {
+            const timer = timeout > 0 ? setTimeout(() => resolve(null), timeout) : null;
+            const wrappedResolve = (value) => {
+                if (timer)
+                    clearTimeout(timer);
+                resolve(value);
+            };
+            this.subscriptors.forEach((callback) => callback(args, wrappedResolve));
+        });
+    }
+}

package/lib/store/store.d.ts

@@ -0,0 +1,34 @@
+import type { Observer, Subscriber } from "../observer/observer";
+import type { Context } from "../context/context";
+export interface StoreConfig {
+    context: Context;
+    observer: Observer;
+    id?: string;
+}
+export declare class Store {
+    context: Context;
+    observer: Observer;
+    id: string | undefined;
+    state: unknown;
+    constructor({ context, observer, id }: StoreConfig);
+    notify: (value: Record<string, unknown>) => Promise<unknown>;
+    query: (cb: (store: Store) => unknown, defaultValue?: unknown) => unknown;
+    mutate: (action: {
+        type: string;
+        payload?: unknown;
+        targets?: string[];
+    }) => unknown;
+}
+export type ListenerCallback = Subscriber;
+export declare class MicroStore {
+    collection: Map<string, Store>;
+    listeners: Map<string, Subscriber[]>;
+    subscribeStore: (id: string, store: Store) => void;
+    add: (id: string, store: Store, _name?: string) => Store;
+    registerListener: (id: string, cb: ListenerCallback) => void;
+    hasListener: (id: string) => boolean;
+    remove: (id: string, mutationId: string) => void;
+    removeAll: (id: string) => void;
+    get: (id: string) => Store | undefined;
+    has: (id: string) => boolean;
+}

package/lib/store/store.js

@@ -1 +1,95 @@
-function _array_like_to_array(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,o=Array(t);r<t;r++)o[r]=e[r];return o}function _create_for_of_iterator_helper_loose(e,t){var r="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(r)return(r=r.call(e)).next.bind(r);if(Array.isArray(e)||(r=function(e,t){if(e){if("string"==typeof e)return _array_like_to_array(e,void 0);var r=Object.prototype.toString.call(e).slice(8,-1);if("Object"===r&&e.constructor&&(r=e.constructor.name),"Map"===r||"Set"===r)return Array.from(r);if("Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return _array_like_to_array(e,void 0)}}(e))||t&&e&&"number"==typeof e.length){r&&(e=r);var o=0;return function(){return o>=e.length?{done:!0}:{done:!1,value:e[o++]}}}throw TypeError("Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}import{hasValidList as e}from"../hooks/useObserver.js";export var Store=function(e){var t=this,r=e.context,o=e.observer,n=e.id;this.context=null,this.observer=null,this.id=null,this.notify=function(e){return t.observer.notify({context:t.context,value:e})},this.query=function(){return console.log("method is not conencted to the reducer, please call useStore first")},this.mutate=function(){return console.log("method is not connected to the store, you need call useStore first")},this.id=n,this.context=r,this.observer=o};export var MicroStore=function(){var t=this;this.collection=new Map,this.listeners=new Map,this.subscribeStore=function(r,o){for(var n,i,s=o.observer,l=o.context,a=null!=(n=t.listeners.get(r))?n:[],u=_create_for_of_iterator_helper_loose(a);!(i=u()).done;)!function(){var t=i.value,r=function(r,o){var n;e([l],r)&&(null==r||null==(n=r.context)||n.update({value:r,listener:t}),null==t||t(r,o))};r.id=t.id,s.has(t.id)||s.subscribe(r)}()},this.add=function(e,r){return t.subscribeStore(e,r),t.collection.set(e,r),r},this.registerListener=function(e,r){if(t.listeners.has(e)){var o=t.listeners.get(e);o.push(r),t.listeners.set(e,o)}else t.listeners.set(e,[r])},this.hasListener=function(e){for(var r,o=!1,n=_create_for_of_iterator_helper_loose(t.listeners);!(r=n()).done;){var i=r.value;if(o=(i[0],i[1]).some(function(t){return t.id===e}))break}return o},this.remove=function(e,r){for(var o,n,i=t.collection.get(e),s=null!=(o=t.listeners.get(e))?o:[],l=_create_for_of_iterator_helper_loose(s);!(n=l()).done;){var a=n.value;if(a.id===r){i.observer.has(a.id)&&i.observer.unsubscribe(a);var u=s.indexOf(a);u>-1&&s.splice(u,1)}}},this.removeAll=function(e){for(var r,o,n=t.collection.get(e),i=null!=(r=t.listeners.get(e))?r:[],s=_create_for_of_iterator_helper_loose(i);!(o=s()).done;){var l=o.value;n.observer.has(l.id)&&n.observer.unsubscribe(l);var a=i.indexOf(l);a>-1&&i.splice(a,1)}},this.get=function(e){return t.collection.get(e)},this.has=function(e){return t.collection.has(e)}};
+import { hasValidList } from "../hooks/useObserver";
+export class Store {
+    constructor({ context, observer, id }) {
+        this.notify = (value) => this.observer.notify({ context: this.context, value });
+        this.query = () => console.log("method is not connected to the reducer, please call useStore first");
+        this.mutate = () => console.log("method is not connected to the store, you need call useStore first");
+        this.id = id;
+        this.context = context;
+        this.observer = observer;
+    }
+}
+export class MicroStore {
+    constructor() {
+        this.collection = new Map();
+        this.listeners = new Map();
+        this.subscribeStore = (id, store) => {
+            const { observer, context } = store;
+            const listeners = this.listeners.get(id) ?? [];
+            for (const listener of listeners) {
+                if (observer.has(listener.id))
+                    continue;
+                const subscriber = function (payload, resolve) {
+                    const isInvalidContext = !hasValidList([context], payload);
+                    if (isInvalidContext)
+                        return;
+                    payload?.context &&
+                        payload.context.update?.({
+                            value: payload,
+                            listener: listener,
+                        });
+                    listener?.(payload, resolve);
+                };
+                subscriber.id = listener.id;
+                if (!observer.has(listener.id))
+                    observer.subscribe(subscriber);
+            }
+        };
+        this.add = (id, store, _name) => {
+            this.subscribeStore(id, store);
+            this.collection.set(id, store);
+            return store;
+        };
+        this.registerListener = (id, cb) => {
+            if (this.listeners.has(id)) {
+                const listeners = this.listeners.get(id);
+                listeners.push(cb);
+                this.listeners.set(id, listeners);
+            }
+            else {
+                this.listeners.set(id, [cb]);
+            }
+        };
+        this.hasListener = (id) => {
+            let result = false;
+            for (const [, listener] of this.listeners) {
+                result = listener.some((cb) => cb.id === id);
+                if (result)
+                    break;
+            }
+            return result;
+        };
+        this.remove = (id, mutationId) => {
+            const store = this.collection.get(id);
+            if (!store)
+                return;
+            const listeners = this.listeners.get(id) ?? [];
+            for (const listener of listeners) {
+                if (listener.id !== mutationId)
+                    continue;
+                if (store.observer.has(listener.id)) {
+                    store.observer.unsubscribe(listener);
+                }
+                const index = listeners.indexOf(listener);
+                if (index > -1)
+                    listeners.splice(index, 1);
+            }
+        };
+        this.removeAll = (id) => {
+            const store = this.collection.get(id);
+            if (!store)
+                return;
+            const listeners = this.listeners.get(id) ?? [];
+            for (const listener of listeners) {
+                if (store.observer.has(listener.id)) {
+                    store.observer.unsubscribe(listener);
+                }
+                const index = listeners.indexOf(listener);
+                if (index > -1)
+                    listeners.splice(index, 1);
+            }
+        };
+        this.get = (id) => this.collection.get(id);
+        this.has = (id) => this.collection.has(id);
+    }
+}

package/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getStackTrace: () => string | undefined;
+export declare const randomId: () => string;

package/lib/utils.js

@@ -1 +1,5 @@
-export var getStackTrace=function(){return Error().stack};export var randomId=function(){return Math.random().toString(36).substring(2,16)};
+export const getStackTrace = () => {
+    const error = new Error();
+    return error.stack;
+};
+export const randomId = () => Math.random().toString(36).substring(2, 16);

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "hermes-io",
-  "version": "2.11.95",
+  "version": "2.12.97",
   "type": "module",
   "description": "A lightweight React library that allows communication between Reactjs components by using the observer pattern and the hook api",
   "main": "./lib/index.js",
   "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "scripts": {
     "test": "vitest __test__",
-    "prepare": "swc ./src -d ./lib"
+    "build": "tsc",
+    "prepare": "tsc"
   },
   "exports": {
     ".": {
+      "types": "./lib/index.d.ts",
       "import": "./lib/index.js",
       "require": "./lib/index.js"
     }
@@ -27,21 +30,19 @@
     "react": "^18.2.0"
   },
   "devDependencies": {
-    "@sveltejs/vite-plugin-svelte": "^3.0.2",
-    "@swc/cli": "^0.1.62",
-    "@swc/core": "^1.3.71",
     "@testing-library/dom": "^9.3.4",
     "@testing-library/jest-dom": "^6.4.2",
     "@testing-library/react": "^14.2.1",
     "@testing-library/react-hooks": "^8.0.1",
-    "@testing-library/svelte": "^4.1.0",
     "@testing-library/user-event": "^14.5.2",
-    "@vitejs/plugin-react": "^4.2.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react-swc": "^3.6.0",
     "happy-dom": "^13.3.8",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
+    "typescript": "^6.0.2",
     "vite": "^5.1.0",
-    "vitest": "^1.2.2",
-    "@vitejs/plugin-react-swc": "^3.6.0"
+    "vitest": "^1.2.2"
   }
 }

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationDir": "./lib",
+    "outDir": "./lib",
+    "rootDir": "./src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "lib", "__test__", "src/setupTests.ts"]
+}

package/lib/components/withNotify/withNotify.jsx

@@ -1,6 +0,0 @@
-import React from 'react';
-
-export function withNotify(Component, { context, observer }) {
-  const notify = (value) => observer.notify({ context, value });
-  return (props) => <Component notify={notify} {...props} />;
-}

package/lib/hooks/useMicroStore.js

@@ -1 +0,0 @@
-import{useEffect as l}from"react";export var useMicroStore=function(r){var n=r.name,o=r.id,a=r.microStore,u=r.store;l(function(){var l,r;if(!(!o||(null==a?void 0:null==(l=a.has)?void 0:l.call(a,o))))return null==a||null==(r=a.add)||r.call(a,o,u,n),function(){var l;null==a||null==(l=a.removeAll)||l.call(a,o)}},[a,u,o])};

package/lib/hooks/useObservableStore.js

@@ -1 +0,0 @@
-import{useStore as r}from"./useStore.js";import{Context as e}from"../context/context.js";import{Observer as o}from"../observer/observer.js";import{Store as t}from"../store/store.js";import{useMicroStore as s}from"./useMicroStore.js";export var useObservableStore=function(m,i,n,c,a){var f=r({microStore:c,store:new t({id:m,context:new e("Context_"+m),observer:new o}),reducer:n,data:i}).store;return s({id:m,microStore:c,store:f,name:a}),{store:f}};

package/lib/hooks/useStoreFactory.js

@@ -1 +0,0 @@
-import{useStore as r}from"./useStore";import{Context as e}from"../context/context";import{Observer as o}from"../observer/observer";import{Store as t}from"../store/store";export var useStoreFactory=function(n,s,m,c){var i={store:new t({id:n,context:new e("Context_"+n),observer:new o}),reducer:m,data:s};return c&&(i.microStore=c),{store:r(i).store}};