@veams/status-quo 1.5.0 → 1.6.0

package/.turbo/turbo-build.log

@@ -0,0 +1,12 @@
+
+> @veams/status-quo@1.5.1 build
+> cross-env NODE_ENV=production npm-run-all compile
+
+
+> @veams/status-quo@1.5.1 compile
+> npm-run-all bundle:ts
+
+
+> @veams/status-quo@1.5.1 bundle:ts
+> tsc --project tsconfig.json
+

package/.turbo/turbo-check$colon$types.log

@@ -0,0 +1,4 @@
+
+> @veams/status-quo@1.5.1 check:types
+> tsc --skipLibCheck --noEmit
+

package/.turbo/turbo-docs$colon$build.log

@@ -0,0 +1,14 @@
+
+> @veams/status-quo@1.5.1 docs:build
+> vite build --config playground/vite.config.ts
+
+vite v5.4.21 building for production...
+transforming...
+✓ 285 modules transformed.
+rendering chunks...
+computing gzip size...
+../docs/index.html                            0.41 kB │ gzip:  0.27 kB
+../docs/assets/statusquo-logo-8GVRbxpc.png   87.06 kB
+../docs/assets/index-BBmpszOW.css             8.73 kB │ gzip:  2.60 kB
+../docs/assets/index-BsFqA6fh.js            268.01 kB │ gzip: 83.23 kB
+✓ built in 1.18s

package/.turbo/turbo-lint.log

@@ -0,0 +1,8 @@
+
+> @veams/status-quo@1.5.1 lint
+> npm run lint:ts
+
+
+> @veams/status-quo@1.5.1 lint:ts
+> eslint --fix "src/**/*.{tsx,ts}"
+

package/.turbo/turbo-test.log

@@ -0,0 +1,15 @@
+
+> @veams/status-quo@1.5.1 test
+> cross-env NODE_ENV=test jest --config jest.config.cjs
+
+PASS src/react/hooks/__tests__/state-selector.spec.tsx
+PASS src/react/hooks/__tests__/state-provider.spec.tsx
+PASS src/react/hooks/__tests__/state-singleton.spec.tsx
+PASS src/store/__tests__/observable-state-handler.spec.ts
+PASS src/store/__tests__/signal-state-handler.spec.ts
+
+Test Suites: 5 passed, 5 total
+Tests:       40 passed, 40 total
+Snapshots:   0 total
+Time:        1.703 s
+Ran all test suites.

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [Unreleased]
+
+### Added
+- `StateProvider` for sharing one handler instance across a scoped React subtree.
+- `useProvidedStateHandler()`, `useProvidedStateActions()`, and `useProvidedStateSubscription()` for provider-scoped composition.
+- `setupStatusQuo({ devTools: { enabled } })` for global Redux DevTools defaults.
+
+### Changed
+- React-specific exports now live under `@veams/status-quo/react`.
+- `options.devTools.namespace` is now optional and falls back to the handler class name.
+- `ObservableStateHandler#getObservable(options?)` is now the canonical API for the full state stream.
+- `ObservableStateHandler#getObservableItem(key)` is now the canonical API for keyed item streams.
+- `makeStateSingleton()` now keeps singleton instances alive by default unless `destroyOnNoConsumers: true` is set.
+
+### Removed
+- React hook and provider exports from the root `@veams/status-quo` entrypoint in favor of `@veams/status-quo/react`.
+- `@veams/status-quo/hooks` in favor of `@veams/status-quo/react`
+- `ObservableStateHandler#getStateAsObservable(options?)`
+- `ObservableStateHandler#getStateItemAsObservable(key)`
+- keyed `ObservableStateHandler#getObservable(key)` in favor of `getObservableItem(key)`
+
 ## [1.3.0] - 2026-02-25
 
 ### Added
@@ -78,6 +99,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   - From: `super({ initialState, devTools: { ... } })`
   - To: `super({ initialState, options: { devTools: { ... } } })`
 
-[1.3.0]: https://github.com/Veams/status-quo/compare/v1.2.0...v1.3.0
-[1.2.0]: https://github.com/Veams/status-quo/compare/v1.0.0...v1.2.0
-[1.0.0]: https://github.com/Veams/status-quo/releases/tag/v1.0.0
+[1.3.0]: https://github.com/Veams/veams/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/Veams/veams/compare/v1.0.0...v1.2.0
+[1.0.0]: https://github.com/Veams/veams/releases/tag/v1.0.0

package/README.md

@@ -7,23 +7,24 @@
 
 The manager to rule your state.
 
-This page mirrors the demo content and adds a full API reference.
+This README summarizes the package API. The full routed documentation lives in VEAMS Documentation.
 
 ## Table of Contents
 
 1. [Overview](#overview)
 2. [Philosophy](#philosophy)
-3. [Demo](#demo)
+3. [Docs](#docs)
 4. [Quickstart](#quickstart)
 5. [Handlers](#handlers)
 6. [Hooks](#hooks)
-7. [Singletons](#singletons)
-8. [Composition](#composition)
-9. [API Guide](#api-guide)
-10. [Devtools](#devtools)
-11. [Cleanup](#cleanup)
-12. [API Reference](#api-reference)
-13. [Migration](#migration)
+7. [Providers](#providers)
+8. [Singletons](#singletons)
+9. [Composition](#composition)
+10. [API Guide](#api-guide)
+11. [Devtools](#devtools)
+12. [Cleanup](#cleanup)
+13. [API Reference](#api-reference)
+14. [Migration](#migration)
 
 ## Overview
 
@@ -35,11 +36,11 @@ StatusQuo is a small, framework-agnostic state layer that focuses on explicit li
 - Separate view and state. Handlers own transitions and expose actions; views subscribe to snapshots.
 - Framework-agnostic core. Business logic lives outside the UI library; hooks provide the glue.
 
-## Demo
+## Docs
 
-Live docs and demo:
+Live docs:
 
-[https://veams.github.io/status-quo/](https://veams.github.io/status-quo/)
+[https://veams.github.io/status-quo/packages/status-quo/getting-started](https://veams.github.io/status-quo/packages/status-quo/getting-started)
 
 ## Quickstart
 
@@ -52,7 +53,8 @@ npm install @veams/status-quo rxjs @preact/signals-core
 Create a store and use it in a component:
 
 ```ts
-import { ObservableStateHandler, useStateFactory } from '@veams/status-quo';
+import { ObservableStateHandler } from '@veams/status-quo';
+import { useStateFactory } from '@veams/status-quo/react';
 
 type CounterState = { count: number };
 
@@ -77,13 +79,16 @@ class CounterStore extends ObservableStateHandler<CounterState, CounterActions>
 const [state, actions] = useStateFactory(() => new CounterStore(), []);
 ```
 
-Optional global setup (e.g. with a custom deep-equality comparator):
+Optional global setup for shared defaults such as distinct behavior and Redux DevTools:
 
 ```ts
 import equal from 'fast-deep-equal';
 import { setupStatusQuo } from '@veams/status-quo';
 
 setupStatusQuo({
+  devTools: {
+    enabled: true,
+  },
   distinct: {
     comparator: equal,
   },
@@ -101,12 +106,22 @@ Both are built on `BaseStateHandler`, which provides the shared lifecycle and de
 
 ## Hooks
 
+The React layer lives under `@veams/status-quo/react`.
+
 Use `useStateHandler + useStateActions + useStateSubscription` as the base composition.
 `useStateFactory` and `useStateSingleton` are shortcut APIs over that composition.
 For full signatures and practical examples, see [API Guide](#api-guide).
 
 - `useStateHandler(factory, params)`
   - Creates and memoizes one handler instance per component.
+- `StateProvider({ instance })`
+  - Shares one handler instance with a subtree through React context.
+- `useProvidedStateHandler()`
+  - Reads the nearest provider-scoped handler instance.
+- `useProvidedStateActions()`
+  - Returns provider-scoped actions without subscribing to state.
+- `useProvidedStateSubscription(selector?, isEqual?)`
+  - Subscribes to provider-scoped state and returns `[state, actions]`.
 - `useStateActions(handler)`
   - Returns actions without subscribing to state.
 - `useStateSubscription(handlerOrSingleton, selector?, isEqual?)`
@@ -119,6 +134,12 @@ For full signatures and practical examples, see [API Guide](#api-guide).
 Recommended composition:
 
 ```ts
+import {
+  useStateActions,
+  useStateHandler,
+  useStateSubscription,
+} from '@veams/status-quo/react';
+
 const handler = useStateHandler(createUserStore, []);
 const actions = useStateActions(handler);
 const [name] = useStateSubscription(handler, (state) => state.user.name);
@@ -126,28 +147,72 @@ const [name] = useStateSubscription(handler, (state) => state.user.name);
 const [singletonName] = useStateSubscription(UserSingleton, (state) => state.user.name);
 ```
 
+## Providers
+
+Use provider scope when a parent should own one local handler instance and several descendants need access to that same instance.
+
+```tsx
+import {
+  StateProvider,
+  useProvidedStateActions,
+  useProvidedStateSubscription,
+  useStateHandler,
+} from '@veams/status-quo/react';
+
+function CounterScope() {
+  const handler = useStateHandler(createCounterStore, []);
+
+  return (
+    <StateProvider instance={handler}>
+      <CounterValue />
+      <CounterButtons />
+    </StateProvider>
+  );
+}
+
+function CounterValue() {
+  const [count] = useProvidedStateSubscription((state: CounterState) => state.count);
+
+  return <strong>{count}</strong>;
+}
+
+function CounterButtons() {
+  const actions = useProvidedStateActions<CounterState, CounterActions>();
+
+  return <button onClick={actions.increase}>Increase</button>;
+}
+```
+
+This is the scoped-sharing option between a local handler and a singleton:
+
+- parent owns lifecycle once
+- children choose whether they need state, actions, or the raw handler
+- action-only components stay out of rerender fanout
+- no prop drilling just to move a handler through the tree
+
 ## Singletons
 
 Use singletons for shared state across multiple components.
 
 ```ts
-import { makeStateSingleton, useStateSingleton } from '@veams/status-quo';
+import { makeStateSingleton } from '@veams/status-quo';
+import { useStateSingleton } from '@veams/status-quo/react';
 
-// Default behavior: singleton is destroyed when the last consumer unmounts.
+// Default behavior: singleton stays alive across unmounts.
 const CounterSingleton = makeStateSingleton(() => new CounterStore());
 
 const [state, actions] = useStateSingleton(CounterSingleton);
 ```
 
-Keep a singleton instance alive across unmounts:
+Destroy a singleton instance when the last consumer unmounts:
 
 ```ts
-const PersistentCounterSingleton = makeStateSingleton(() => new CounterStore(), {
-  destroyOnNoConsumers: false,
+const RouteScopedCounterSingleton = makeStateSingleton(() => new CounterStore(), {
+  destroyOnNoConsumers: true,
 });
 ```
 
-Use this for app-level stores that should survive route/component unmounts. Keep the default for stores that should release resources when unused.
+Keep the default for app-level shared state that should survive route/component unmounts. Use `destroyOnNoConsumers: true` when the shared handler should behave more like a mounted resource.
 
 ## Composition
 
@@ -158,7 +223,7 @@ import { combineLatest } from 'rxjs';
 
 // RxJS: combine handler streams (RxJS shines here)
 class AppSignalStore extends SignalStateHandler<AppState, AppActions> {
-  private counter$ = CounterObservableStore.getInstance().getStateAsObservable();
+  private counter$ = CounterObservableStore.getInstance().getObservable();
   private card$ = new CardObservableHandler();
 
   constructor() {
@@ -207,11 +272,14 @@ This section documents the primary public API with behavior notes and usage exam
 
 ### `setupStatusQuo(config?)`
 
-Sets global runtime defaults for distinct update behavior.
+Sets global runtime defaults for distinct update behavior and Redux DevTools enablement.
 Per-handler options still override the global setup.
 
 ```ts
 type StatusQuoConfig = {
+  devTools?: {
+    enabled?: boolean; // default: false
+  };
   distinct?: {
     enabled?: boolean; // default: true
     comparator?: (previous: unknown, next: unknown) => boolean; // default: JSON compare
@@ -224,6 +292,9 @@ import equal from 'fast-deep-equal';
 import { setupStatusQuo } from '@veams/status-quo';
 
 setupStatusQuo({
+  devTools: {
+    enabled: true,
+  },
   distinct: {
     comparator: equal,
   },
@@ -239,19 +310,58 @@ Creates one handler instance per component mount and returns it.
 - lifecycle note: params are applied when the handler instance is created for that mount
 
 ```ts
+import { useStateHandler } from '@veams/status-quo/react';
+
 const handler = useStateHandler(createUserStore, []);
 ```
 
+### `StateProvider`
+
+Shares one existing handler instance with a subtree through React context.
+Use this when a parent owns lifecycle and descendants should consume the same local instance without prop drilling.
+
+```tsx
+import { StateProvider, useStateHandler } from '@veams/status-quo/react';
+
+const handler = useStateHandler(createUserStore, []);
+
+return <StateProvider instance={handler}>{children}</StateProvider>;
+```
+
+### `useProvidedStateHandler()`
+
+Reads the nearest provider-scoped handler instance.
+Use this as the low-level entry point when a descendant needs the raw handler for manual composition.
+
+```ts
+import { useProvidedStateHandler } from '@veams/status-quo/react';
+
+const handler = useProvidedStateHandler<UserState, UserActions>();
+```
+
 ### `useStateActions(handler)`
 
 Returns actions from a handler without subscribing to state changes.
 Use this in action-only components to avoid rerenders from state updates.
 
 ```ts
+import { useStateActions, useStateHandler } from '@veams/status-quo/react';
+
 const handler = useStateHandler(createUserStore, []);
 const actions = useStateActions(handler);
 ```
 
+### `useProvidedStateActions()`
+
+Returns actions from the nearest `StateProvider` without subscribing to state.
+Use this for command-only components inside a provider scope.
+
+```ts
+import { useProvidedStateActions } from '@veams/status-quo/react';
+
+const actions = useProvidedStateActions<UserState, UserActions>();
+```
+
 ### `useStateSubscription(source, selector?, isEqual?)`
 
 Subscribes to either a handler instance or a singleton and returns `[selectedState, actions]`.
@@ -263,6 +373,8 @@ Subscribes to either a handler instance or a singleton and returns `[selectedSta
 Full snapshot subscription:
 
 ```ts
+import { useStateHandler, useStateSubscription } from '@veams/status-quo/react';
+
 const handler = useStateHandler(createUserStore, []);
 const [state, actions] = useStateSubscription(handler);
 ```
@@ -270,6 +382,8 @@ const [state, actions] = useStateSubscription(handler);
 Selector subscription:
 
 ```ts
+import { useStateSubscription } from '@veams/status-quo/react';
+
 const [name, actions] = useStateSubscription(
   handler,
   (state) => state.user.name
@@ -279,6 +393,8 @@ const [name, actions] = useStateSubscription(
 Selector with custom equality:
 
 ```ts
+import { useStateSubscription } from '@veams/status-quo/react';
+
 const [profile] = useStateSubscription(
   handler,
   (state) => state.user.profile,
@@ -289,12 +405,26 @@ const [profile] = useStateSubscription(
 Singleton source:
 
 ```ts
+import { useStateSubscription } from '@veams/status-quo/react';
+
 const [session, actions] = useStateSubscription(SessionSingleton);
 ```
 
 Lifecycle note for singleton sources:
 - Consumers are ref-counted.
-- The singleton instance is only destroyed when the last consumer unmounts and `destroyOnNoConsumers !== false`.
+- The singleton instance is only destroyed when the last consumer unmounts and `destroyOnNoConsumers === true`.
+
+### `useProvidedStateSubscription(selector?, isEqual?)`
+
+Subscribes to the nearest `StateProvider` instead of taking a source argument.
+It supports full snapshots, selectors, and custom equality the same way `useStateSubscription` does.
+
+```ts
+import { useProvidedStateSubscription } from '@veams/status-quo/react';
+
+const [state, actions] = useProvidedStateSubscription<UserState, UserActions>();
+const [name] = useProvidedStateSubscription((state: UserState) => state.user.name);
+```
 
 ### `useStateFactory(factory, selector?, isEqual?, params?)`
 
@@ -305,6 +435,8 @@ Shortcut API for `useStateHandler + useStateSubscription`.
 - `useStateFactory(factory, selector, isEqual, params)`
 
 ```ts
+import { useStateFactory } from '@veams/status-quo/react';
+
 const [state, actions] = useStateFactory(createUserStore, []);
 const [name] = useStateFactory(createUserStore, (state) => state.user.name, []);
 const [profile] = useStateFactory(
@@ -320,6 +452,8 @@ const [profile] = useStateFactory(
 Creates a shared singleton provider for a handler instance.
 
 ```ts
+import { makeStateSingleton } from '@veams/status-quo';
+
 const UserSingleton = makeStateSingleton(() => new UserStore());
 ```
 
@@ -327,16 +461,18 @@ Options:
 
 ```ts
 type StateSingletonOptions = {
-  destroyOnNoConsumers?: boolean; // default: true
+  destroyOnNoConsumers?: boolean; // default: false
 };
 ```
 
-- `true` (default): destroy instance after last consumer unmounts
-- `false`: keep instance alive across periods with zero consumers
+- `false` (default): keep instance alive across periods with zero consumers
+- `true`: destroy instance after last consumer unmounts
 
 ```ts
-const PersistentUserSingleton = makeStateSingleton(() => new UserStore(), {
-  destroyOnNoConsumers: false,
+import { makeStateSingleton } from '@veams/status-quo';
+
+const RouteScopedUserSingleton = makeStateSingleton(() => new UserStore(), {
+  destroyOnNoConsumers: true,
 });
 ```
 
@@ -345,25 +481,50 @@ const PersistentUserSingleton = makeStateSingleton(() => new UserStore(), {
 Shortcut API for `useStateSubscription(singleton, selector?, isEqual?)`.
 
 ```ts
+import { useStateSingleton } from '@veams/status-quo/react';
+
 const [state, actions] = useStateSingleton(UserSingleton);
 const [name] = useStateSingleton(UserSingleton, (state) => state.user.name);
 ```
 
 ## Devtools
 
-Enable Redux Devtools integration with `options.devTools`:
+Status Quo supports the Redux DevTools browser extension on both `ObservableStateHandler` and `SignalStateHandler`.
+
+Turn it on globally:
+
+```ts
+import { setupStatusQuo } from '@veams/status-quo';
+
+setupStatusQuo({
+  devTools: {
+    enabled: true,
+  },
+});
+```
+
+Override it per handler when needed:
 
 ```ts
 class CounterStore extends ObservableStateHandler<CounterState, CounterActions> {
   constructor() {
     super({
       initialState: { count: 0 },
-      options: { devTools: { enabled: true, namespace: 'Counter' } },
+      options: { devTools: { namespace: 'Counter' } },
     });
   }
 }
 ```
 
+Notes:
+
+- `setupStatusQuo({ devTools: { enabled: true } })` enables Redux DevTools by default for handlers.
+- `options.devTools` still overrides the global default per handler.
+- `namespace` is optional. When omitted, Status Quo uses the handler class name.
+- `setState(nextState, actionName)` sends the `actionName` to the Redux DevTools timeline.
+- The current integration supports reset, commit, jump to state, and jump to action from the extension UI.
+- If the extension is not installed, Status Quo logs that and continues without a devtools connection.
+
 ## Cleanup
 
 Handlers expose `subscribe`, `getSnapshot`, and `destroy` for custom integrations:
@@ -419,7 +580,7 @@ Protected helpers:
 
 - `getStateValue(): S` (abstract)
 - `setStateValue(next: S): void` (abstract)
-- `initDevTools(options?: { enabled?: boolean; namespace: string }): void`
+- `initDevTools(options?: { enabled?: boolean; namespace?: string }): void`
 - `bindSubscribable<T>(service: { subscribe: (listener: (value: T) => void) => () => void; getSnapshot?: () => T }, onChange: (value: T) => void, selector?: (value: T) => T, isEqual?: (current: T, next: T) => boolean): void`
 - `bindSubscribable<T, Sel>(service: { subscribe: (listener: (value: T) => void) => () => void; getSnapshot?: () => T }, onChange: (value: Sel) => void, selector: (value: T) => Sel, isEqual?: (current: Sel, next: Sel) => boolean): void`
   - Registers the subscription on `this.subscriptions` and invokes `onChange` with the current snapshot when available.
@@ -439,7 +600,7 @@ protected constructor({
 }: {
   initialState: S;
   options?: {
-    devTools?: { enabled?: boolean; namespace: string };
+    devTools?: { enabled?: boolean; namespace?: string };
     distinct?: {
       enabled?: boolean;
       comparator?: (previous: S, next: S) => boolean;
@@ -451,15 +612,15 @@ protected constructor({
 
 Public methods:
 
-- `getStateAsObservable(options?: { useDistinctUntilChanged?: boolean }): Observable<S>`
-- `getStateItemAsObservable(key: keyof S): Observable<S[keyof S]>`
-- `getObservable(key: keyof S): Observable<S[keyof S]>`
+- `getObservable(options?: { useDistinctUntilChanged?: boolean }): Observable<S>`
+- `getObservableItem(key: keyof S): Observable<S[keyof S]>`
 - `subscribe(listener: () => void): () => void`
 - `subscribe(listener: (value: S) => void): () => void`
 
 Notes:
 - The observable stream uses `distinctUntilChanged` by default.
 - Distinct behavior can be configured globally via `setupStatusQuo` or per handler via `options.distinct`.
+- Devtools can be enabled globally via `setupStatusQuo({ devTools: { enabled: true } })` or overridden per handler via `options.devTools`.
 - `subscribe` fires immediately with the current snapshot and then on subsequent changes.
 - Subscribers receive the next state snapshot as a callback argument.
 
@@ -476,7 +637,7 @@ protected constructor({
 }: {
   initialState: S;
   options?: {
-    devTools?: { enabled?: boolean; namespace: string };
+    devTools?: { enabled?: boolean; namespace?: string };
     distinct?: {
       enabled?: boolean;
       comparator?: (previous: S, next: S) => boolean;
@@ -495,12 +656,16 @@ Public methods:
 Notes:
 - Distinct behavior defaults to enabled.
 - Configure it globally via `setupStatusQuo` or per handler via `options.distinct`.
+- Devtools can be enabled globally via `setupStatusQuo({ devTools: { enabled: true } })` or overridden per handler via `options.devTools`.
 - `useDistinctUntilChanged` remains available as a shorthand enable/disable override.
 
 ### `setupStatusQuo`
 
 ```ts
 type StatusQuoConfig = {
+  devTools?: {
+    enabled?: boolean;
+  };
   distinct?: {
     enabled?: boolean;
     comparator?: (previous: unknown, next: unknown) => boolean;
@@ -514,7 +679,7 @@ function setupStatusQuo(config?: StatusQuoConfig): void
 
 ```ts
 type StateSingletonOptions = {
-  destroyOnNoConsumers?: boolean; // default: true
+  destroyOnNoConsumers?: boolean; // default: false
 };
 
 function makeStateSingleton<S, A>(
@@ -526,13 +691,22 @@ function makeStateSingleton<S, A>(
 ```
 
 Lifecycle behavior:
-- `destroyOnNoConsumers: true` (default): destroy and recreate singleton instances with mount lifecycle.
-- `destroyOnNoConsumers: false`: keep the same singleton instance alive when no component is subscribed.
+- `destroyOnNoConsumers: false` (default): keep the same singleton instance alive when no component is subscribed.
+- `destroyOnNoConsumers: true`: destroy and recreate singleton instances with mount lifecycle.
 
 ### Hooks
 
+- React entrypoint: `@veams/status-quo/react`
 - `useStateHandler<V, A, P extends unknown[]>(factory: (...args: P) => StateSubscriptionHandler<V, A>, params?: P)`
   - Returns `StateSubscriptionHandler<V, A>`.
+- `StateProvider<V, A>({ instance }: { instance: StateSubscriptionHandler<V, A> })`
+  - Shares a handler instance with a subtree.
+- `useProvidedStateHandler<V, A>()`
+  - Returns `StateSubscriptionHandler<V, A>`.
+- `useProvidedStateActions<V, A>()`
+  - Returns `A`.
+- `useProvidedStateSubscription<V, A, Sel = V>(selector?: (state: V) => Sel, isEqual?: (current: Sel, next: Sel) => boolean)`
+  - Returns `[state, actions]`.
 - `useStateActions<V, A>(handler: StateSubscriptionHandler<V, A>)`
   - Returns `A`.
 - `useStateSubscription<V, A, Sel = V>(source: StateSubscriptionHandler<V, A> | StateSingleton<V, A>, selector?: (state: V) => Sel, isEqual?: (current: Sel, next: Sel) => boolean)`
@@ -548,7 +722,9 @@ From pre-1.0 releases:
 
 1. Rename `StateHandler` -> `ObservableStateHandler`.
 2. Implement `subscribe()` and `getSnapshot()` on custom handlers.
-3. Replace `getObservable()` usage with `subscribe()` in custom integrations.
-4. Update devtools config:
+3. Replace `getStateAsObservable()` with `getObservable()`.
+4. Replace `getStateItemAsObservable()` and keyed `getObservable(key)` with `getObservableItem(key)`.
+5. Move React hooks and `StateProvider` imports from `@veams/status-quo` or `@veams/status-quo/hooks` to `@veams/status-quo/react`.
+6. Update devtools config:
    - From: `super({ initialState, devTools: { ... } })`
    - To: `super({ initialState, options: { devTools: { ... } } })`

package/dist/config/status-quo-config.d.ts

@@ -3,18 +3,31 @@ export type DistinctOptions<T = unknown> = {
     enabled?: boolean;
     comparator?: DistinctComparator<T>;
 };
+export type DevToolsOptions = {
+    enabled?: boolean;
+    namespace?: string;
+};
+export type GlobalDevToolsOptions = {
+    enabled?: boolean;
+};
 export type StatusQuoConfig<T = unknown> = {
+    devTools?: GlobalDevToolsOptions;
     distinct?: DistinctOptions<T>;
 };
 type ResolvedDistinctOptions<T = unknown> = {
     enabled: boolean;
     comparator: DistinctComparator<T>;
 };
+type ResolvedDevToolsOptions = {
+    enabled: boolean;
+};
 type ResolvedStatusQuoConfig = {
+    devTools: ResolvedDevToolsOptions;
     distinct: ResolvedDistinctOptions;
 };
 export declare function setupStatusQuo<T = unknown>(config?: StatusQuoConfig<T>): void;
 export declare function resolveDistinctOptions<T>(options?: DistinctOptions<T>, useDistinctUntilChanged?: boolean): ResolvedDistinctOptions<T>;
+export declare function resolveDevToolsOptions(options?: DevToolsOptions): ResolvedDevToolsOptions;
 export declare function getStatusQuoConfig(): ResolvedStatusQuoConfig;
 /** @internal testing helper */
 export declare function resetStatusQuoForTests(): void;