reactish-state 1.0.0-alpha.3 → 1.1.0

package/dist/cjs/react/useSelector.cjs

@@ -16,10 +16,10 @@ const useSelector = (selectorParamFactory, deps) => {
     const {
       cache
     } = context;
-    const reactishValues = utils.getReactishValues(items);
-    const args = reactishValues.concat(deps || selectorFunc);
+    const selectorValues = utils.getSelectorValues(items);
+    const args = selectorValues.concat(deps || selectorFunc);
     if (cache && utils.isEqual(args, cache.args)) return cache.val;
-    const val = selectorFunc(...reactishValues);
+    const val = selectorFunc(...selectorValues);
     context.cache = {
       args,
       val

package/dist/cjs/utils.cjs

@@ -10,8 +10,8 @@ const createSubscriber = items => listener => {
   const unsubscribers = items.map(item => item.subscribe(listener));
   return () => unsubscribers.forEach(unsubscribe => unsubscribe());
 };
-const getReactishValues = items => items.map(item => item.get());
+const getSelectorValues = items => items.map(item => item.get());
 
 exports.createSubscriber = createSubscriber;
-exports.getReactishValues = getReactishValues;
+exports.getSelectorValues = getSelectorValues;
 exports.isEqual = isEqual;

package/dist/cjs/vanilla/selector.cjs

@@ -15,7 +15,7 @@ const createSelector = ({
   let cache;
   const selector = {
     get: () => {
-      const args = utils.getReactishValues(items);
+      const args = utils.getSelectorValues(items);
       if (cache && utils.isEqual(args, cache.args)) return cache.val;
       const val = selectorFunc(...args);
       cache = {

package/dist/cjs/vanilla/state.cjs

@@ -9,8 +9,9 @@ const createState = ({
   let set = newValue => {
     const nextValue = typeof newValue === 'function' ? newValue(value) : newValue;
     if (!Object.is(value, nextValue)) {
+      const prevValue = value;
       value = nextValue;
-      listeners.forEach(listener => listener());
+      listeners.forEach(listener => listener(nextValue, prevValue));
     }
   };
   const subscribe = listener => {

package/dist/esm/react/useSelector.mjs

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { createSubscriber, getReactishValues, isEqual } from '../utils.mjs';
+import { createSubscriber, getSelectorValues, isEqual } from '../utils.mjs';
 import { useSnapshot } from './useSnapshot.mjs';
 
 const useSelector = (selectorParamFactory, deps) => {
@@ -14,10 +14,10 @@ const useSelector = (selectorParamFactory, deps) => {
     const {
       cache
     } = context;
-    const reactishValues = getReactishValues(items);
-    const args = reactishValues.concat(deps || selectorFunc);
+    const selectorValues = getSelectorValues(items);
+    const args = selectorValues.concat(deps || selectorFunc);
     if (cache && isEqual(args, cache.args)) return cache.val;
-    const val = selectorFunc(...reactishValues);
+    const val = selectorFunc(...selectorValues);
     context.cache = {
       args,
       val

package/dist/esm/utils.mjs

@@ -8,6 +8,6 @@ const createSubscriber = items => listener => {
   const unsubscribers = items.map(item => item.subscribe(listener));
   return () => unsubscribers.forEach(unsubscribe => unsubscribe());
 };
-const getReactishValues = items => items.map(item => item.get());
+const getSelectorValues = items => items.map(item => item.get());
 
-export { createSubscriber, getReactishValues, isEqual };
+export { createSubscriber, getSelectorValues, isEqual };

package/dist/esm/vanilla/selector.mjs

@@ -1,4 +1,4 @@
-import { createSubscriber, getReactishValues, isEqual } from '../utils.mjs';
+import { createSubscriber, getSelectorValues, isEqual } from '../utils.mjs';
 
 const createSelector = ({
   plugin
@@ -13,7 +13,7 @@ const createSelector = ({
   let cache;
   const selector = {
     get: () => {
-      const args = getReactishValues(items);
+      const args = getSelectorValues(items);
       if (cache && isEqual(args, cache.args)) return cache.val;
       const val = selectorFunc(...args);
       cache = {

package/dist/esm/vanilla/state.mjs

@@ -7,8 +7,9 @@ const createState = ({
   let set = newValue => {
     const nextValue = typeof newValue === 'function' ? newValue(value) : newValue;
     if (!Object.is(value, nextValue)) {
+      const prevValue = value;
       value = nextValue;
-      listeners.forEach(listener => listener());
+      listeners.forEach(listener => listener(nextValue, prevValue));
     }
   };
   const subscribe = listener => {

package/dist/plugin/cjs/applyPlugin.cjs

@@ -1,5 +1,5 @@
 'use strict';
 
-const applyPlugin = plugins => (reactish, config) => plugins.forEach(plugin => plugin?.(reactish, config));
+const applyPlugin = plugins => (selector, config) => plugins.forEach(plugin => plugin?.(selector, config));
 
 exports.applyPlugin = applyPlugin;

package/dist/plugin/esm/applyPlugin.mjs

@@ -1,3 +1,3 @@
-const applyPlugin = plugins => (reactish, config) => plugins.forEach(plugin => plugin?.(reactish, config));
+const applyPlugin = plugins => (selector, config) => plugins.forEach(plugin => plugin?.(selector, config));
 
 export { applyPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactish-state",
-  "version": "1.0.0-alpha.3",
+  "version": "1.1.0",
   "description": "Simple, decentralized (atomic) state management for React.",
   "author": "Zheng Song",
   "license": "MIT",
@@ -80,44 +80,40 @@
     }
   },
   "dependencies": {
-    "use-sync-external-store": "^1.4.0"
+    "use-sync-external-store": "^1.5.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.26.9",
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-react": "^7.26.3",
-    "@babel/preset-typescript": "^7.26.0",
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@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.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@testing-library/jest-dom": "^6.6.3",
-    "@testing-library/react": "^16.2.0",
-    "@types/jest": "^29.5.14",
-    "@types/react": "^19.0.8",
-    "@types/use-sync-external-store": "^0.0.6",
+    "@testing-library/react": "^16.3.0",
+    "@types/jest": "^30.0.0",
+    "@types/react": "^19.1.8",
+    "@types/use-sync-external-store": "^1.5.0",
     "babel-plugin-pure-annotations": "^0.1.2",
-    "eslint": "^9.20.1",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-plugin-jest": "^28.11.0",
-    "eslint-plugin-react": "^7.37.4",
-    "eslint-plugin-react-hooks": "^5.1.0",
-    "eslint-plugin-react-hooks-addons": "^0.4.1",
-    "globals": "^15.15.0",
+    "deplift": "^1.0.1",
+    "eslint": "^9.32.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jest": "^29.0.1",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-hooks-addons": "^0.5.0",
+    "globals": "^16.3.0",
     "immer": "^10.1.1",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
+    "jest": "^30.0.5",
+    "jest-environment-jsdom": "^30.0.5",
     "npm-run-all": "^4.1.5",
-    "prettier": "^3.4.2",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "rollup": "^4.34.2",
-    "typescript": "^5.7.3",
-    "typescript-eslint": "^8.24.0"
-  },
-  "overrides": {
-    "whatwg-url@11.0.0": {
-      "tr46": "^4"
-    }
+    "prettier": "^3.6.2",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "rollup": "^4.45.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.38.0"
   }
 }

package/types/common.d.ts

@@ -3,30 +3,36 @@ export type Setter<T> = (newValue: T | ((value: T) => T), action?: string | {
     type: string;
     [key: string]: unknown;
 }) => void;
-export type Listener = () => void;
-export type Subscriber = (listener: Listener) => () => void;
-export interface Reactish<T> {
+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>;
-    subscribe: Subscriber;
+    set: Setter<T>;
+    subscribe: StateSubscriber<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>(api: Reactish<T> & {
-        set: Setter<T>;
-    }, config?: Config): Setter<T>;
+    <T>(state: State<T>, config?: Config): Setter<T>;
 }
 export interface Plugin {
-    <T>(reactish: Reactish<T>, config?: Config): void;
+    <T>(selector: Selector<T>, config?: Config): void;
 }
-export type ReactishArray = Reactish<unknown>[];
-export type ReactishValueArray<RA extends ReactishArray> = {
-    [index in keyof RA]: ReturnType<RA[index]['get']>;
+export type SelectorArray = Selector<unknown>[];
+export type SelectorValueArray<TArray extends SelectorArray> = {
+    [index in keyof TArray]: ReturnType<TArray[index]['get']>;
 };
-export type SelectorFunc<RA extends ReactishArray, T> = (...args: ReactishValueArray<RA>) => T;
-export type SelectorParams<RA extends ReactishArray, T> = [...RA, SelectorFunc<RA, T>];
-export interface Selector {
-    <RA extends ReactishArray, T>(...items: SelectorParams<RA, T>): Reactish<T>;
-    <RA extends ReactishArray, T>(...items: [...SelectorParams<RA, T>, Config]): Reactish<T>;
+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>;
 }

package/types/react/useSelector.d.ts

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

package/types/react/useSnapshot.d.ts

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

package/types/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Subscriber, ReactishArray, ReactishValueArray } from './common';
+import type { SelectorSubscriber, SelectorArray, SelectorValueArray } from './common';
 export declare const isEqual: (args1: unknown[], args2: unknown[]) => boolean;
-export declare const createSubscriber: (items: ReactishArray) => Subscriber;
-export declare const getReactishValues: <RA extends ReactishArray>(items: ReactishArray) => ReactishValueArray<RA>;
+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,7 +1,6 @@
-import type { Plugin, Selector } from '../common';
+import type { Plugin, SelectorBuilder } from '../common';
 declare const createSelector: ({ plugin }?: {
     plugin?: Plugin;
-}) => Selector;
-declare const selector: Selector;
-export type { Selector };
+}) => SelectorBuilder;
+declare const selector: SelectorBuilder;
 export { selector, createSelector };

package/types/vanilla/state.d.ts

@@ -1,12 +1,9 @@
-import type { Reactish, Setter, Config, Middleware } from '../common';
+import type { State, Setter, Config, Middleware } from '../common';
 type ActionCreator<T, A> = ((set: Setter<T>, get: () => T) => A) | null | undefined;
-type VanillaState<T> = Reactish<T> & {
-    set: Setter<T>;
-};
-type State<T, A> = Omit<A, keyof VanillaState<T>> & VanillaState<T>;
+type StateWithAction<T, A> = Omit<A, keyof State<T>> & State<T>;
 declare const createState: ({ middleware }?: {
     middleware?: Middleware;
-}) => <T, A>(initialValue: T, actionCreator?: ActionCreator<T, A>, config?: Config) => State<T, A>;
-declare const state: <T, A>(initialValue: T, actionCreator?: ActionCreator<T, A>, config?: Config) => State<T, A>;
+}) => <T, A>(initialValue: T, actionCreator?: ActionCreator<T, A>, config?: Config) => StateWithAction<T, A>;
+declare const state: <T, A>(initialValue: T, actionCreator?: ActionCreator<T, A>, config?: Config) => StateWithAction<T, A>;
 export type { State, ActionCreator };
 export { state, createState };