@kuindji/reactive 1.0.24 → 1.1.0

package/dist/react/useListenToStoreChanges.js

@@ -1,14 +1,16 @@
-import { useCallback, useEffect, useRef } from "react";
+import { useCallback, useRef } from "react";
+import { useReconciledListener } from "./useReconciledListener.js";
 export function useListenToStoreChanges(store, key, listener, options) {
     const listenerRef = useRef(listener);
     listenerRef.current = listener;
     const genericHandler = useCallback((value, previousValue) => {
         return listenerRef.current(value, previousValue);
     }, []);
-    useEffect(() => {
-        store.onChange(key, genericHandler, options);
-        return () => {
-            store.removeOnChange(key, genericHandler);
-        };
-    }, [store, key, genericHandler]);
+    useReconciledListener({
+        keyDeps: [store, key],
+        options,
+        subscribe: (opts) => store.onChange(key, genericHandler, opts !== null && opts !== void 0 ? opts : undefined),
+        unsubscribe: (ctx) => store.removeOnChange(key, genericHandler, ctx),
+        update: (ctx, opts) => store.updateOnChangeOptions(key, genericHandler, ctx, opts !== null && opts !== void 0 ? opts : undefined),
+    });
 }

package/dist/react/useReconciledListener.d.ts

@@ -0,0 +1,33 @@
+import type { ListenerOptions } from "../event.js";
+type ListenerOps = {
+    /**
+     * Identity dependencies. When any element changes (reference equality) the
+     * listener is fully resubscribed: the old registration is removed using the
+     * previous closure (previous target + previous context) and a fresh one is
+     * added. `context` is appended automatically because it is part of listener
+     * identity. The array length must stay constant across renders.
+     */
+    keyDeps: ReadonlyArray<unknown>;
+    options?: ListenerOptions | null;
+    /** Add the listener to the current target with the given options. */
+    subscribe: (options?: ListenerOptions | null) => void;
+    /** Remove the listener from the current target using the given context. */
+    unsubscribe: (context: object | null) => void;
+    /** Update soft options on the live listener in place (counters preserved). */
+    update: (context: object | null, options?: ListenerOptions | null) => void;
+};
+/**
+ * Reconciles a single reactive listener across renders without relying on the
+ * identity of the options object.
+ *
+ * Two effects cooperate:
+ *  - an identity effect keyed by `[...keyDeps, context]` performs the classic
+ *    add-on-mount / remove-on-cleanup cycle, so target/context changes (and
+ *    React StrictMode remounts) resubscribe correctly using the OLD context on
+ *    cleanup;
+ *  - a reconciliation effect runs every render and, when only soft options
+ *    changed, updates the live listener in place instead of resubscribing, so
+ *    per-listener counters are preserved.
+ */
+export declare function useReconciledListener({ keyDeps, options, subscribe, unsubscribe, update, }: ListenerOps): void;
+export {};

package/dist/react/useReconciledListener.js

@@ -0,0 +1,44 @@
+import { useEffect, useRef } from "react";
+import { areListenerOptionsEqual } from "./listenerOptionsEqual.js";
+/**
+ * Reconciles a single reactive listener across renders without relying on the
+ * identity of the options object.
+ *
+ * Two effects cooperate:
+ *  - an identity effect keyed by `[...keyDeps, context]` performs the classic
+ *    add-on-mount / remove-on-cleanup cycle, so target/context changes (and
+ *    React StrictMode remounts) resubscribe correctly using the OLD context on
+ *    cleanup;
+ *  - a reconciliation effect runs every render and, when only soft options
+ *    changed, updates the live listener in place instead of resubscribing, so
+ *    per-listener counters are preserved.
+ */
+export function useReconciledListener({ keyDeps, options, subscribe, unsubscribe, update, }) {
+    var _a;
+    const context = (_a = options === null || options === void 0 ? void 0 : options.context) !== null && _a !== void 0 ? _a : null;
+    const committedRef = useRef(undefined);
+    const registeredRef = useRef(false);
+    // Identity effect: (re)subscribe on target/context change.
+    useEffect(() => {
+        subscribe(options);
+        committedRef.current = options;
+        registeredRef.current = true;
+        return () => {
+            unsubscribe(context);
+            registeredRef.current = false;
+        };
+    }, [...keyDeps, context]);
+    // Reconciliation effect: in-place soft-option updates every render.
+    useEffect(() => {
+        if (!registeredRef.current) {
+            return;
+        }
+        if (committedRef.current === options) {
+            return;
+        }
+        if (!areListenerOptionsEqual(committedRef.current, options)) {
+            update(context, options);
+        }
+        committedRef.current = options;
+    });
+}

package/dist/react/useStore.d.ts

@@ -1,5 +1,5 @@
-import { createStore } from "../store";
-import type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper } from "../store";
+import { createStore } from "../store.js";
+import type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper } from "../store.js";
 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"]>;

package/dist/react/useStore.js

@@ -1,26 +1,78 @@
-import { useMemo } from "react";
-import { createStore } from "../store";
+import { useEffect, useMemo, useRef } from "react";
+import { createStore } from "../store.js";
 export function useStore(initialData = {}, config) {
-    const store = useMemo(() => {
-        const store = createStore(initialData);
-        if (config === null || config === void 0 ? void 0 : config.onChange) {
-            for (const key in config.onChange) {
-                store.onChange(key, config.onChange[key]);
-            }
+    // initialData is seed-only (captured once); later changes are ignored.
+    const store = useMemo(() => createStore(initialData), []);
+    // Track only the handlers we added (per category + key) and compare by
+    // reference, so consumer listeners added outside the hook are never
+    // touched and inline-equal config maps do not duplicate or churn
+    // subscriptions.
+    const appliedRef = useRef({
+        onChange: {},
+        pipes: {},
+        control: {},
+    });
+    const add = (category, key, fn) => {
+        if (category === "onChange") {
+            store.onChange(key, fn);
         }
-        if (config === null || config === void 0 ? void 0 : config.pipes) {
-            for (const key in config.pipes) {
-                // @ts-expect-error - TS widens for-in key to string; types are correct
-                store.pipe(key, config.pipes[key]);
-            }
+        else if (category === "pipes") {
+            store.pipe(key, fn);
         }
-        if (config === null || config === void 0 ? void 0 : config.control) {
-            for (const key in config.control) {
-                // @ts-expect-error - TS widens for-in key to string; types are correct
-                store.control(key, config.control[key]);
-            }
+        else {
+            store.control(key, fn);
+        }
+    };
+    const remove = (category, key, fn) => {
+        if (category === "onChange") {
+            store.removeOnChange(key, fn);
         }
-        return store;
+        else if (category === "pipes") {
+            store.removePipe(key, fn);
+        }
+        else {
+            store.removeControl(key, fn);
+        }
+    };
+    // Reconcile config handlers every render (no cleanup here, so equal config
+    // never causes remove/add churn).
+    useEffect(() => {
+        const categories = {
+            onChange: config === null || config === void 0 ? void 0 : config.onChange,
+            pipes: config === null || config === void 0 ? void 0 : config.pipes,
+            control: config === null || config === void 0 ? void 0 : config.control,
+        };
+        Object.keys(categories).forEach((category) => {
+            var _a;
+            const next = (_a = categories[category]) !== null && _a !== void 0 ? _a : {};
+            const prev = appliedRef.current[category];
+            // Remove stale/changed handlers before adding (matters for pipes).
+            for (const key in prev) {
+                if (next[key] !== prev[key]) {
+                    remove(category, key, prev[key]);
+                }
+            }
+            for (const key in next) {
+                if (next[key] !== prev[key]) {
+                    add(category, key, next[key]);
+                }
+            }
+            appliedRef.current[category] = Object.assign({}, next);
+        });
+    });
+    // Unmount cleanup: detach everything we applied (also makes StrictMode
+    // remount re-subscribe cleanly via the reconcile effect above).
+    useEffect(() => {
+        return () => {
+            const applied = appliedRef.current;
+            Object.keys(applied).forEach((category) => {
+                const map = applied[category];
+                for (const key in map) {
+                    remove(category, key, map[key]);
+                }
+                applied[category] = {};
+            });
+        };
     }, []);
     return store;
 }

package/dist/react/useStoreState.d.ts

@@ -1,3 +1,3 @@
-import { KeyOf } from "../lib/types";
-import { BaseStore } from "../store";
+import { KeyOf } from "../lib/types.js";
+import { BaseStore } from "../store.js";
 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]) => TStore["__type"]["propTypes"][TKey])) => void];

package/dist/react/useStoreState.js

@@ -1,30 +1,23 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useSyncExternalStore } from "react";
 export function useStoreState(store, key) {
-    const [value, setValue] = useState(store.get(key));
-    const storeRef = useRef(store);
-    const keyRef = useRef(key);
-    const onChange = useCallback((value) => {
-        setValue(value);
-    }, []);
+    const subscribe = useCallback((onStoreChange) => {
+        const listener = () => {
+            onStoreChange();
+        };
+        store.onChange(key, listener);
+        return () => {
+            store.removeOnChange(key, listener);
+        };
+    }, [store, key]);
+    const getSnapshot = useCallback(() => store.get(key), [store, key]);
+    const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
     const setter = useCallback((value) => {
         if (typeof value === "function") {
-            storeRef.current.set(keyRef.current, value(storeRef.current.get(keyRef.current)));
+            store.set(key, value(store.get(key)));
         }
         else {
-            storeRef.current.set(keyRef.current, value);
+            store.set(key, value);
         }
-    }, []);
-    useEffect(() => {
-        return () => {
-            storeRef.current.removeOnChange(keyRef.current, onChange);
-        };
-    }, []);
-    useEffect(() => {
-        storeRef.current.removeOnChange(keyRef.current, onChange);
-        storeRef.current = store;
-        keyRef.current = key;
-        storeRef.current.onChange(keyRef.current, onChange);
-        setValue(store.get(key));
     }, [store, key]);
     return [value, setter];
 }

package/dist/react.d.ts

@@ -1,13 +1,13 @@
-export * from "./react/ErrorBoundary";
-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/useListenToActionBus";
-export * from "./react/useListenToEvent";
-export * from "./react/useListenToEventBus";
-export * from "./react/useListenToStoreChanges";
-export * from "./react/useStore";
-export * from "./react/useStoreState";
+export * from "./react/ErrorBoundary.js";
+export * from "./react/useAction.js";
+export * from "./react/useActionBus.js";
+export * from "./react/useActionMap.js";
+export * from "./react/useEvent.js";
+export * from "./react/useEventBus.js";
+export * from "./react/useListenToAction.js";
+export * from "./react/useListenToActionBus.js";
+export * from "./react/useListenToEvent.js";
+export * from "./react/useListenToEventBus.js";
+export * from "./react/useListenToStoreChanges.js";
+export * from "./react/useStore.js";
+export * from "./react/useStoreState.js";

package/dist/react.js

@@ -1,13 +1,13 @@
-export * from "./react/ErrorBoundary";
-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/useListenToActionBus";
-export * from "./react/useListenToEvent";
-export * from "./react/useListenToEventBus";
-export * from "./react/useListenToStoreChanges";
-export * from "./react/useStore";
-export * from "./react/useStoreState";
+export * from "./react/ErrorBoundary.js";
+export * from "./react/useAction.js";
+export * from "./react/useActionBus.js";
+export * from "./react/useActionMap.js";
+export * from "./react/useEvent.js";
+export * from "./react/useEventBus.js";
+export * from "./react/useListenToAction.js";
+export * from "./react/useListenToActionBus.js";
+export * from "./react/useListenToEvent.js";
+export * from "./react/useListenToEventBus.js";
+export * from "./react/useListenToStoreChanges.js";
+export * from "./react/useStore.js";
+export * from "./react/useStoreState.js";

package/dist/store.d.ts

@@ -1,5 +1,5 @@
-import { EventBusDefinitionHelper } from "./eventBus";
-import type { ApiType, ErrorListenerSignature, KeyOf, MapKey } from "./lib/types";
+import { EventBusDefinitionHelper } from "./eventBus.js";
+import type { ApiType, ErrorListenerSignature, KeyOf, MapKey } from "./lib/types.js";
 export interface BasePropMap {
     [key: MapKey]: any;
 }
@@ -44,12 +44,13 @@ export declare function createStore<PropMap extends BasePropMap = BasePropMap>(i
     };
     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 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;
-    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 onChange: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StoreChangeEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StoreChangeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, options?: import("./event.js").ListenerOptions) => void;
+    readonly removeOnChange: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StoreChangeEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StoreChangeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly updateOnChangeOptions: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StoreChangeEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StoreChangeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, context?: object | null, nextOptions?: import("./event.js").ListenerOptions) => boolean;
+    readonly control: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StoreControlEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StoreControlEvents<PropMap>>[K]["signature"]>(name: K, handler: H, options?: import("./event.js").ListenerOptions) => void;
+    readonly removeControl: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StoreControlEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StoreControlEvents<PropMap>>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly pipe: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StorePipeEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StorePipeEvents<PropMap>>[K]["signature"]>(name: K, handler: H, options?: import("./event.js").ListenerOptions) => void;
+    readonly removePipe: <K extends KeyOf<import("./eventBus.js").GetEventsMap<StorePipeEvents<PropMap>>>, H extends import("./eventBus.js").GetEventsMap<StorePipeEvents<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>>;

package/dist/store.js

@@ -1,4 +1,4 @@
-import { createEventBus } from "./eventBus";
+import { createEventBus } from "./eventBus.js";
 export const BeforeChangeEventName = "before";
 export const ChangeEventName = "change";
 export const ResetEventName = "reset";
@@ -21,8 +21,8 @@ export function createStore(initialData = {}) {
         var _a, _b, _c, _d, _e;
         const prev = data.get(name);
         if (prev !== value) {
-            if (control.firstNonEmpty(BeforeChangeEventName, name, value)
-                === false) {
+            const beforeChangeResults = control.all(BeforeChangeEventName, name, value);
+            if (beforeChangeResults.some((result) => result === false)) {
                 return;
             }
             const pipeArgs = [value];
@@ -73,12 +73,16 @@ export function createStore(initialData = {}) {
             if ((_c = control.get(EffectEventName)) === null || _c === void 0 ? void 0 : _c.hasListener()) {
                 try {
                     const isIntercepting = control.isIntercepting();
-                    if (!isIntercepting) {
-                        control.intercept(effectInterceptor);
+                    try {
+                        if (!isIntercepting) {
+                            control.intercept(effectInterceptor);
+                        }
+                        control.trigger(EffectEventName, name, value);
                     }
-                    control.trigger(EffectEventName, name, value);
-                    if (!isIntercepting) {
-                        control.stopIntercepting();
+                    finally {
+                        if (!isIntercepting) {
+                            control.stopIntercepting();
+                        }
                     }
                 }
                 catch (error) {
@@ -143,36 +147,48 @@ export function createStore(initialData = {}) {
             const changedKeys = [];
             const isIntercepting = control.isIntercepting();
             const hasEffectListener = (_a = control.get(EffectEventName)) === null || _a === void 0 ? void 0 : _a.hasListener();
-            if (hasEffectListener && !isIntercepting) {
+            const shouldInterceptEffects = hasEffectListener && !isIntercepting;
+            let controlError = null;
+            if (shouldInterceptEffects) {
                 control.intercept(effectInterceptor);
             }
-            Object.entries(name).forEach(([k, v]) => {
-                if (_set(k, v, false)) {
-                    changedKeys.push(k);
-                }
-            });
             try {
-                control.trigger(ChangeEventName, [
+                Object.entries(name).forEach(([k, v]) => {
+                    if (_set(k, v, false)) {
+                        changedKeys.push(k);
+                    }
+                });
+                const allChangedKeys = [
                     ...changedKeys,
                     ...effectKeys,
-                ]);
-                if (hasEffectListener && !isIntercepting) {
+                ];
+                if (allChangedKeys.length > 0) {
+                    try {
+                        control.trigger(ChangeEventName, allChangedKeys);
+                    }
+                    catch (error) {
+                        controlError = error instanceof Error
+                            ? error
+                            : new Error(String(error));
+                    }
+                }
+            }
+            finally {
+                if (shouldInterceptEffects) {
                     effectKeys = [];
                     control.stopIntercepting();
                 }
             }
-            catch (error) {
+            if (controlError) {
                 control.trigger(ErrorEventName, {
-                    error: error instanceof Error
-                        ? error
-                        : new Error(String(error)),
+                    error: controlError,
                     args: [name],
                     type: "store-control",
                 });
                 if ((_b = control.get(ErrorEventName)) === null || _b === void 0 ? void 0 : _b.hasListener()) {
                     return;
                 }
-                throw error;
+                throw controlError;
             }
         }
         else {
@@ -207,6 +223,7 @@ export function createStore(initialData = {}) {
     };
     let batching = false;
     const batch = (fn) => {
+        var _a, _b;
         if (batching) {
             throw new Error("Nested batch() calls are not supported");
         }
@@ -226,9 +243,15 @@ export function createStore(initialData = {}) {
         };
         changes.intercept(changeInterceptor);
         control.intercept(controlInterceptor);
+        let callbackError;
+        let hasCallbackError = false;
         try {
             fn();
         }
+        catch (error) {
+            callbackError = error;
+            hasCallbackError = true;
+        }
         finally {
             control.stopIntercepting();
             changes.stopIntercepting();
@@ -239,10 +262,53 @@ export function createStore(initialData = {}) {
                 value,
                 prev,
             ];
-            changes.trigger(propName, ...changeArgs);
+            try {
+                changes.trigger(propName, ...changeArgs);
+            }
+            catch (error) {
+                control.trigger(ErrorEventName, {
+                    error: error instanceof Error
+                        ? error
+                        : new Error(String(error)),
+                    args: changeArgs,
+                    type: "store-change",
+                    name: propName,
+                });
+                if ((_a = control.get(ErrorEventName)) === null || _a === void 0 ? void 0 : _a.hasListener()) {
+                    continue;
+                }
+                if (hasCallbackError) {
+                    continue;
+                }
+                throw error;
+            }
         }
         if (allChangedKeys.length > 0) {
-            control.trigger(ChangeEventName, allChangedKeys);
+            try {
+                control.trigger(ChangeEventName, allChangedKeys);
+            }
+            catch (error) {
+                control.trigger(ErrorEventName, {
+                    error: error instanceof Error
+                        ? error
+                        : new Error(String(error)),
+                    args: [allChangedKeys],
+                    type: "store-control",
+                });
+                if ((_b = control.get(ErrorEventName)) === null || _b === void 0 ? void 0 : _b.hasListener()) {
+                    if (hasCallbackError) {
+                        throw callbackError;
+                    }
+                    return;
+                }
+                if (hasCallbackError) {
+                    throw callbackError;
+                }
+                throw error;
+            }
+        }
+        if (hasCallbackError) {
+            throw callbackError;
         }
     };
     const reset = () => {
@@ -259,6 +325,7 @@ export function createStore(initialData = {}) {
         reset,
         onChange: changes.addListener,
         removeOnChange: changes.removeListener,
+        updateOnChangeOptions: changes.updateListenerOptions,
         control: control.addListener,
         removeControl: control.removeListener,
         pipe: pipe.addListener,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kuindji/reactive",
-    "version": "1.0.24",
+    "version": "1.1.0",
     "author": "Ivan Kuindzhi",
     "type": "module",
     "repository": {
@@ -22,6 +22,14 @@
         "typescript": "^5.9.3",
         "typescript-eslint": "^8.48.0"
     },
+    "peerDependencies": {
+        "react": ">=18.0.0"
+    },
+    "peerDependenciesMeta": {
+        "react": {
+            "optional": true
+        }
+    },
     "exports": {
         ".": {
             "types": "./dist/index.d.ts",
@@ -62,11 +70,13 @@
     "license": "ISC",
     "scripts": {
         "build": "tsc -p ./tsconfig-build.json",
+        "prepublishOnly": "bun run build",
         "lint": "bun eslint .",
+        "type-check": "tsc --noEmit",
         "test": "bun test tests/**/*.spec.ts*",
         "test:types": "tsc -p ./tests/types/tsconfig.json",
-        "test:all": "bun run test:types && bun run test"
+        "test:all": "bun run type-check && bun run test:types && bun run test"
     },
     "sideEffects": false,
     "types": "dist/index.d.ts"
-}
+}