reactish-state 1.1.1 → 1.2.0

package/README.md

@@ -648,8 +648,6 @@ const myTodos = state<string[], { add: (newTodo: string) => void }>(
 );
 ```
 
-However, if you choose this method, you need to specify the types for both the state value and actions.
-
 # Examples
 
 - Counter – [sandbox](https://codesandbox.io/p/sandbox/reactish-counter-z42qt7) | [source](https://github.com/szhsin/reactish-state/tree/master/examples/examples/counter)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactish-state",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Simple, decentralized (atomic) state management for React.",
   "author": "Zheng Song",
   "license": "MIT",
@@ -83,22 +83,22 @@
     "use-sync-external-store": "^1.5.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
+    "@babel/core": "^7.28.3",
+    "@babel/preset-env": "^7.28.3",
     "@babel/preset-react": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
     "@redux-devtools/extension": "^3.3.0",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
-    "@testing-library/jest-dom": "^6.6.4",
+    "@testing-library/jest-dom": "^6.7.0",
     "@testing-library/react": "^16.3.0",
     "@types/jest": "^30.0.0",
-    "@types/react": "^19.1.9",
+    "@types/react": "^19.1.10",
     "@types/use-sync-external-store": "^1.5.0",
     "babel-plugin-pure-annotations": "^0.1.2",
     "deplift": "^1.0.1",
-    "eslint": "^9.32.0",
+    "eslint": "^9.33.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-jest": "^29.0.1",
     "eslint-plugin-react": "^7.37.5",
@@ -113,7 +113,7 @@
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
     "rollup": "^4.46.2",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.38.0"
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1"
   }
 }

package/types/index.d.ts

@@ -1,4 +1,4 @@
-export * from './common';
+export * from './types';
 export * from './vanilla/state';
 export * from './vanilla/selector';
 export * from './react/useSnapshot';

package/types/middleware/applyMiddleware.d.ts

@@ -1,5 +1,5 @@
-import type { Middleware } from '../common';
-declare const applyMiddleware: (middlewares: (Middleware | undefined)[], options?: {
+import type { Middleware } from '../types';
+declare const applyMiddleware: <TConfig>(middlewares: (Middleware<TConfig> | undefined)[], options?: {
     fromRight?: boolean;
-}) => Middleware;
+}) => Middleware<TConfig>;
 export { applyMiddleware };

package/types/middleware/immer.d.ts

@@ -1,3 +1,3 @@
-import type { Middleware } from '../common';
+import type { Middleware } from '../types';
 declare const immer: Middleware;
 export { immer };

package/types/middleware/persist.d.ts

@@ -1,5 +1,5 @@
-import type { Middleware } from '../common';
-interface PersistMiddleware extends Middleware {
+import type { Middleware, Config } from '../types';
+interface PersistMiddleware extends Middleware<Config> {
     hydrate(this: void): void;
 }
 type Persist = (options?: {

package/types/middleware/reduxDevtools.d.ts

@@ -1,7 +1,7 @@
-import type { Middleware } from '../common';
+import type { Middleware, Config } from '../types';
 type ReduxDevtools = (options?: {
     name?: string;
-}) => Middleware | undefined;
+}) => Middleware<Config> | undefined;
 declare const reduxDevtools: ReduxDevtools;
 export type { ReduxDevtools };
 export { reduxDevtools };

package/types/plugin/applyPlugin.d.ts

@@ -1,3 +1,3 @@
-import type { Plugin } from '../common';
-declare const applyPlugin: (plugins: (Plugin | undefined)[]) => Plugin;
+import type { Plugin } from '../types';
+declare const applyPlugin: <TConfig>(plugins: (Plugin<TConfig> | undefined)[]) => Plugin<TConfig>;
 export { applyPlugin };

package/types/plugin/reduxDevtools.d.ts

@@ -1,7 +1,7 @@
-import type { Plugin } from '../common';
+import type { Plugin, Config } from '../types';
 type ReduxDevtools = (options?: {
     name?: string;
-}) => Plugin | undefined;
+}) => Plugin<Config> | undefined;
 declare const reduxDevtools: ReduxDevtools;
 export type { ReduxDevtools };
 export { reduxDevtools };

package/types/react/useSelector.d.ts

@@ -1,3 +1,3 @@
-import type { SelectorArray, SelectorParams } from '../common';
-declare const useSelector: <TArray extends SelectorArray, T>(selectorParamFactory: () => SelectorParams<TArray, T>, deps?: unknown[]) => T;
+import type { SelectorArray, SelectorParams } from '../types';
+declare const useSelector: <TArray extends SelectorArray, TValue>(selectorParamFactory: () => SelectorParams<TArray, TValue>, deps?: unknown[]) => TValue;
 export { useSelector };

package/types/react/useSnapshot.d.ts

@@ -1,3 +1,3 @@
-import type { Selector } from '../common';
-declare const useSnapshot: <T>({ subscribe, get }: Selector<T>) => T;
+import type { Selector } from '../types';
+declare const useSnapshot: <TValue>({ subscribe, get }: Selector<TValue>) => TValue;
 export { useSnapshot };

package/types/types.d.ts

@@ -0,0 +1,46 @@
+export type Getter<TValue> = () => TValue;
+export type Setter<TValue, TContext = unknown> = (newValue: TValue | ((value: TValue) => TValue), context?: TContext) => void;
+export type Unsubscriber = () => void;
+export type StateListener<TValue> = (nextValue: TValue, prevValue: TValue) => void;
+export type StateSubscriber<TValue> = (listener: StateListener<TValue>) => Unsubscriber;
+export interface State<TValue, TContext = unknown> {
+    get: Getter<TValue>;
+    set: Setter<TValue, TContext>;
+    subscribe: StateSubscriber<TValue>;
+}
+export type StateWithAction<TValue, TAction, TContext = unknown> = Omit<TAction, keyof State<TValue, TContext>> & State<TValue, TContext>;
+export type ActionBuilder<TValue, TAction, TContext = unknown> = (set: Setter<TValue, TContext>, get: () => TValue) => TAction;
+export interface StateBuilder<TConfig = unknown> {
+    <TValue, TContext = unknown>(): State<TValue | undefined, TContext>;
+    <TValue, TContext = unknown>(initialValue: TValue): State<TValue, TContext>;
+    <TValue, TContext = unknown>(initialValue: TValue, actionBuilder: null | undefined, config?: TConfig): State<TValue, TContext>;
+    <TValue, TAction, TContext = unknown>(initialValue: TValue, actionBuilder: ActionBuilder<TValue, TAction, TContext>, config?: TConfig): StateWithAction<TValue, TAction, TContext>;
+}
+export type SelectorListener = () => void;
+export type SelectorSubscriber = (listener: SelectorListener) => Unsubscriber;
+export interface Selector<TValue> {
+    get: Getter<TValue>;
+    subscribe: SelectorSubscriber;
+}
+export interface Config {
+    key?: string;
+}
+export interface Middleware<TConfig = unknown> {
+    <TValue, TContext = unknown>(state: State<TValue, TContext>, config?: TConfig): Setter<TValue, TContext>;
+}
+export interface Plugin<TConfig = unknown> {
+    <TValue>(selector: Selector<TValue>, config?: TConfig): void;
+}
+export type SelectorArray = Selector<unknown>[];
+export type SelectorValueArray<TArray extends SelectorArray> = {
+    [index in keyof TArray]: ReturnType<TArray[index]['get']>;
+};
+export type SelectorFunc<TArray extends SelectorArray, TValue> = (...args: SelectorValueArray<TArray>) => TValue;
+export type SelectorParams<TArray extends SelectorArray, TValue> = [
+    ...TArray,
+    SelectorFunc<TArray, TValue>
+];
+export interface SelectorBuilder<TConfig = unknown> {
+    <TArray extends SelectorArray, TValue>(...items: SelectorParams<TArray, TValue>): Selector<TValue>;
+    <TArray extends SelectorArray, TValue>(...items: [...SelectorParams<TArray, TValue>, TConfig]): Selector<TValue>;
+}

package/types/utils.d.ts

@@ -1,4 +1,4 @@
-import type { SelectorSubscriber, SelectorArray, SelectorValueArray } from './common';
+import type { SelectorSubscriber, SelectorArray, SelectorValueArray } from './types';
 export declare const isEqual: (args1: unknown[], args2: unknown[]) => boolean;
 export declare const createSubscriber: (items: SelectorArray) => SelectorSubscriber;
 export declare const getSelectorValues: <RA extends SelectorArray>(items: SelectorArray) => SelectorValueArray<RA>;

package/types/vanilla/selector.d.ts

@@ -1,6 +1,6 @@
-import type { Plugin, SelectorBuilder } from '../common';
-declare const createSelector: ({ plugin }?: {
-    plugin?: Plugin;
-}) => SelectorBuilder;
-declare const selector: SelectorBuilder;
+import type { Plugin, SelectorBuilder } from '../types';
+declare const createSelector: <TConfig>({ plugin }?: {
+    plugin?: Plugin<TConfig>;
+}) => SelectorBuilder<TConfig>;
+declare const selector: SelectorBuilder<unknown>;
 export { selector, createSelector };

package/types/vanilla/state.d.ts

@@ -1,7 +1,6 @@
-import type { ActionBuilder, StateWithAction, Config, Middleware } from '../common';
-declare const createState: ({ middleware }?: {
-    middleware?: Middleware;
-}) => <T, A>(initialValue: T, actionBuilder?: ActionBuilder<T, A>, config?: Config) => StateWithAction<T, A>;
-declare const state: <T, A>(initialValue: T, actionBuilder?: ActionBuilder<T, A>, config?: Config) => StateWithAction<T, A>;
-type StateBuilder = typeof state;
-export { state, createState, type StateBuilder };
+import type { StateBuilder, Middleware } from '../types';
+declare const createState: <TConfig>({ middleware }?: {
+    middleware?: Middleware<TConfig>;
+}) => StateBuilder<TConfig>;
+declare const state: StateBuilder<unknown>;
+export { state, createState };

package/types/common.d.ts

@@ -1,37 +0,0 @@
-export type Getter<T> = () => T;
-export type Setter<T> = (newValue: T | ((value: T) => T), context?: unknown) => void;
-export type Unsubscriber = () => void;
-export type StateListener<T> = (nextValue: T, prevValue: T) => void;
-export type StateSubscriber<T> = (listener: StateListener<T>) => Unsubscriber;
-export interface State<T> {
-    get: Getter<T>;
-    set: Setter<T>;
-    subscribe: StateSubscriber<T>;
-}
-export type ActionBuilder<T, A> = ((set: Setter<T>, get: () => T) => A) | null | undefined;
-export type StateWithAction<T, A> = Omit<A, keyof State<T>> & State<T>;
-export type SelectorListener = () => void;
-export type SelectorSubscriber = (listener: SelectorListener) => Unsubscriber;
-export interface Selector<T> {
-    get: Getter<T>;
-    subscribe: SelectorSubscriber;
-}
-export interface Config {
-    key?: string;
-}
-export interface Middleware {
-    <T>(state: State<T>, config?: Config): Setter<T>;
-}
-export interface Plugin {
-    <T>(selector: Selector<T>, config?: Config): void;
-}
-export type SelectorArray = Selector<unknown>[];
-export type SelectorValueArray<TArray extends SelectorArray> = {
-    [index in keyof TArray]: ReturnType<TArray[index]['get']>;
-};
-export type SelectorFunc<TArray extends SelectorArray, T> = (...args: SelectorValueArray<TArray>) => T;
-export type SelectorParams<TArray extends SelectorArray, T> = [...TArray, SelectorFunc<TArray, T>];
-export interface SelectorBuilder {
-    <RA extends SelectorArray, T>(...items: SelectorParams<RA, T>): Selector<T>;
-    <RA extends SelectorArray, T>(...items: [...SelectorParams<RA, T>, Config]): Selector<T>;
-}