API reference

Reference for stores, subscriptions, lifecycle hooks and TypeScript types.

Main

atom

function atom<Value, StoreExt>(...args): PreinitializedWritableAtom<Value> & StoreExt;

Create store with atomic value. It could be a string or an object, which you will replace completely.

If you want to change keys in the object inside store, use map.

import { atom, onMount } from 'nanostores'

// Initial value
export const $router = atom({ path: '', page: 'home' })

function parse () {
  $router.set({ path: location.pathname, page: parse(location.pathname) })
}

// Listen for URL changes on first store’s listener.
onMount($router, () => {
  parse()
  window.addEventListener('popstate', parse)
  return () => {
    window.removeEventListener('popstate', parse)
  }
})

Type Parameters

Value

Value

StoreExt

StoreExt = object

Parameters

args

…undefined extends Value ? [] | [Value] : [Value]

Returns

PreinitializedWritableAtom<Value> & StoreExt

The store object with methods to subscribe.

map

function map<Value, StoreExt>(value): PreinitializedMapStore<Value> & StoreExt;

Create map store with an initial value. Map store is a store with key-value object as a store value.

Type Parameters

Value

Value extends object

StoreExt

StoreExt extends object = object

Parameters

value

Value

Initial store value.

Returns

PreinitializedMapStore<Value> & StoreExt

The store object with methods to subscribe.

Other overloads

Call Signature

function map<Value, StoreExt>(value?): PreinitializedMapStore<Partial<Value>> & StoreExt;

Create map store with no initial value, or one that may be missing.

Type Parameters

Value

Value extends object

StoreExt

StoreExt extends object = object

Parameters

value?

Value

Initial store value, if there is one.

Returns

PreinitializedMapStore<Partial<Value>> & StoreExt

The store object with methods to subscribe.

computed

computed<Value, OriginStores extends readonly Store[]>(stores: readonly [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Value | Task<Value>): ReadableAtom<Value>

Create derived store, which use generates value from another stores.

import { computed } from 'nanostores'

import { $users } from './users.js'

export const $admins = computed($users, users => {
  return users.filter(user => user.isAdmin)
})

Use @nanostores/async for async function.

Other overloads

Deprecated: Use @nanostores/async.

computed<Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Task<Value>): ReadableAtom<Value | undefined>

Deprecated: Use @nanostores/async.

computed<Value, OriginStores extends readonly Store[]>(stores: readonly [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Task<Value>): ReadableAtom<Value | undefined>

computed<Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Value): ReadableAtom<Value>

batched

batched<Value, OriginStores extends readonly Store[]>(stores: readonly [...OriginStores], cb: (...values: StoreValues<OriginStores>) => Value | Task<Value>): ReadableAtom<Value>

Create derived store, which use generates value from another stores.

import { batched } from 'nanostores'

const $sortBy = atom('id')
const $category = atom('')

export const $link = batched([$sortBy, $category], (sortBy, category) => {
  return `/api/entities?sortBy=${sortBy}&category=${category}`
})

Other overloads

batched<Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Value | Task<Value>): ReadableAtom<Value>

effect

effect<OriginStores extends readonly ListenableStore[]>(stores: readonly [...OriginStores], cb: (...values: StoreValues<OriginStores>) => void | (() => void)): () => void

Subscribe for multiple stores. Also you can define cleanup function to call on stores changes.

const $enabled = atom(true)
const $interval = atom(1000)

const cancelPing = effect([$enabled, $interval], (enabled, interval) => {
  if (!enabled) return
  const intervalId = setInterval(() => {
    sendPing()
  }, interval)
  return () => {
    clearInterval(intervalId)
  }
})

Other overloads

effect<OriginStore extends ListenableStore>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => void | (() => void)): () => void

batch

function batch(fn): void;

Run multiple store changes as a single transaction. While inside batch, listeners are deferred and each listener fires at most once when the outermost batch returns — with the final store values.

Batches can be nested; only the outermost batch triggers the flush.

Synchronous only. The batch closes when fn returns, so writes performed in microtasks, timers, or after await will not be batched. Pass a sync function.

Map#setKey writes are coalesced as well, so the listener’s changed argument is undefined for the batched notification.

import { atom, batch } from 'nanostores'

let $a = atom(0)
let $b = atom(0)

batch(() => {
  $a.set(1)
  $b.set(2)
})

Parameters

fn

() => void

Callback that performs the store writes.

Returns

void

Store methods

$store.get()

get(): Value;

Get store value.

In contrast with ReadableAtom#value this value will be always initialized even if store had no listeners.

$store.get()

Returns

Value

Store value.

$store.set()

set(newValue): void;

Change store value.

$router.set({ path: location.pathname, page: parse(location.pathname) })

Parameters

newValue

Value

New store value.

Returns

void

$store.setKey()

setKey<Key>(key, value): void;

Change key in store value.

$settings.setKey('theme', 'dark')

To delete key set undefined.

$settings.setKey('theme', undefined)

Type Parameters

Key

Key extends string | number | symbol

Parameters

key

Key

The key name.

value

ValueWithUndefinedForIndexSignatures<Value, Key>

New value.

Returns

void

$store.listen()

listen(listener): () => void;

Subscribe to store changes.

In contrast with Store#subscribe it do not call listener immediately.

Parameters

listener

(value, oldValue) => void

Callback with store value and old value.

Returns

Function to remove listener.

() => void

subscribe(listener): () => void;

Subscribe to store changes and call listener immediately.

import { $router } from '../store'

$router.subscribe(page => {
  console.log(page)
})

(value, oldValue?) => void

Callback with store value and old value.

Function to remove listener.

() => void

Lifecycle

onMount

function onMount<Shared>($store, initialize): () => void;

Run constructor on first store’s listener and run destructor on last listener unsubscription. It has a debounce to prevent flickering.

A way to reduce memory and CPU usage when you do not need a store.

You can communicate between listeners by payload.shared.

import { onMount } from 'nanostores'

// Listen for URL changes on first store’s listener.
onMount($router, () => {
  parse()
  window.addEventListener('popstate', parse)
  return () => {
    window.removeEventListener('popstate', parse)
  }
})

Type Parameters

Shared

Shared = never

Parameters

$store

Store

Store to listen.

initialize

(payload) => void | (() => void)

Store constructor. Returns store destructor.

Returns

A function to remove constructor and destructor from store.

() => void

STORE_UNMOUNT_DELAY

const STORE_UNMOUNT_DELAY: number;

Map helpers

listenKeys

function listenKeys<SomeStore>(
   $store,
   keys,
   listener
): () => void;

Listen for specific keys of the store.

In contrast with subscribeKeys it do not call listener immediately.

import { listenKeys } from 'nanostores'

listenKeys($page, ['blocked'], (value, oldValue, changed) => {
  if (value.blocked) {
    console.log('You has no access')
  }
})

Type Parameters

SomeStore

SomeStore extends object

Parameters

$store

SomeStore

The store to listen.

keys

readonly MapStoreKeys<SomeStore>[]

The keys to listen.

listener

(value, oldValue, changed) => void

Standard listener.

Returns

() => void

subscribeKeys

function subscribeKeys<SomeStore>(
   $store,
   keys,
   listener
): () => void;

Listen for specific keys of the store and call listener immediately. Note that the oldValue and changed arguments in the listener are undefined during the initial call.

import { subscribeKeys } from 'nanostores'

subscribeKeys($page, ['blocked'], (value, oldValue, changed) => {
  if (value.blocked) {
    console.log('You has no access')
  }
})

Type Parameters

SomeStore

SomeStore extends object

Parameters

$store

SomeStore

The store to listen.

keys

readonly MapStoreKeys<SomeStore>[]

The keys to listen.

listener

(value, oldValue, changed) => void

Standard listener.

Returns

() => void

setPath

function setPath<T, K>(
   obj,
   path,
   value
): T;

Set a deep value by path. Copies are made at each level of path so that no part of the original object is mutated (but it does not do a full deep copy — some sub-objects may still be shared between the old value and the new one). Sparse arrays will be created if you set arbitrary length.

import { setPath } from 'nanostores'

setPath({ a: { b: { c: [] } } }, 'a.b.c[1]', 'hey')
// Returns `{ a: { b: { c: [<empty>, 'hey'] } } }`

Type Parameters

T

T extends BaseDeepMap

K

K extends string

Parameters

obj

T

Any object.

path

K

Path split by dots and []. Like: props.arr[1].nested.

value

FromPath<T, K>

Returns

T

The new object.

getPath

function getPath<T, K>(obj, path): FromPath<T, K>;

Get a value by object path. undefined if key is missing.

import { getPath } from 'nanostores'

getPath({ a: { b: { c: ['hey', 'Hi!'] } } }, 'a.b.c[1]') // Returns 'Hi!'

Type Parameters

T

T extends BaseDeepMap

K

K extends string

Parameters

obj

T

Any object.

path

K

Path split by dots and []. Like: props.arr[1].nested.

Returns

FromPath<T, K>

The value for this path. Undefined if key is missing.

setByKey

function setByKey<T>(
   obj,
   splittedKeys,
   value
): T;

Set a deep value by key. Copies are made at each level of path so that no part of the original object is mutated (but it does not do a full deep copy — some sub-objects may still be shared between the old value and the new one). Sparse arrays will be created if you set arbitrary length.

import { setByKey } from 'nanostores'

setByKey({ a: { b: { c: [] } } }, ['a', 'b', 'c', 1], 'hey')
// Returns `{ a: { b: { c: [<empty>, 'hey'] } } }`

Type Parameters

T

T extends BaseDeepMap

Parameters

obj

T

Any object.

splittedKeys

PropertyKey[]

An array of keys representing the path to the value.

value

unknown

New value.

Returns

T

The new object.

Tasks & testing

task

function task<Return>(cb): Task<Return>;

Track store async task by wrapping promise callback. It is useful for test to wait end of the processing.

import { task } from 'nanostores'

async function saveUser () {
  await task(async () => {
    await api.submit('/user', user.get())
    $user.setKey('saved', true)
  })
}

Type Parameters

Return

Return = never

Parameters

cb

() => Return | Promise<Return>

Async callback with task.

Returns

Task<Return>

Return value from callback.

startTask

function startTask(): () => void;

Track store async task by start/end functions. It is useful for test to wait end of the processing.

It you use async/await in task, you can use task.

import { startTask } from 'nanostores'

function saveUser () {
  const endTask = startTask()
  api.submit('/user', user.get(), () => {
    $user.setKey('saved', true)
    endTask()
  })
}

Returns

() => void

allTasks

function allTasks(): Promise<void>;

Return Promise until all current tasks (and tasks created while waiting).

It is useful in tests to wait all async processes in the stores.

import { allTasks } from 'nanostores'

it('saves user', async () => {
  saveUser()
  await allTasks()
  expect($user.get().saved).toBe(true)
})

Returns

Promise<void>

cleanTasks

function cleanTasks(): void;

Forget all tracking tasks. Use it only for tests. cleanStores cleans tasks automatically.

import { cleanTasks } from 'nanostores'

afterEach(() => {
  cleanTasks()
})

Returns

void

keepMount

function keepMount($store): void;

Prevent destructor call for the store.

Together with cleanStores is useful tool for tests.

import { keepMount } from 'nanostores'

keepMount($store)

Parameters

$store

| Store | MapCreator<any, []>

The store.

Returns

void

cleanStores

function cleanStores(...stores): void;

Destroys all cached stores and call

It also reset all tasks by calling cleanTasks.

import { cleanStores } from 'nanostores'

afterEach(() => {
  cleanStores($router, $settings)
})

Parameters

stores

…( | MapCreator<any, any[]> | Store | undefined)[]

Used store classes.

Returns

void

Promise for stores destroying.

clean

const clean: unique symbol;

Advanced

onStart

function onStart<Shared>($store, listener): () => void;

Add listener on first store listener.

We recommend to always use onMount instead to prevent flickering (onMount have small delay before unsubscribe callback). See onMount to add constructor and destructor for the store.

You can communicate between listeners by payload.shared.

Type Parameters

Shared

Shared = never

Parameters

$store

Store

The store to add listener.

listener

(payload) => void

Event callback.

Returns

A function to remove listener.

() => void

onStop

function onStop<Shared>($store, listener): () => void;

Add listener on last store listener unsubscription.

We recommend to always use onMount instead to prevent flickering (onMount have small delay before unsubscribe callback). See onMount to add constructor and destructor for the store.

You can communicate between listeners by payload.shared.

Type Parameters

Shared

Shared = never

Parameters

$store

Store

The store to add listener.

listener

(payload) => void

Event callback.

Returns

A function to remove listener.

() => void

onSet

function onSet<Shared, SomeStore>($store, listener): () => void;

Add listener to store chagings.

import { onSet } from 'nanostores'

onSet($store, ({ newValue, abort }) => {
  if (!validate(newValue)) {
    abort()
  }
})

You can communicate between listeners by payload.shared or cancel changes by payload.abort().

New value of the all store will be payload.newValue. On MapStore#setKey() call, changed value will be in payload.changed.

Type Parameters

Shared

Shared = never

SomeStore

SomeStore extends Store = Store

Parameters

$store

SomeStore

The store to add listener.

listener

(payload) => void

Event callback.

Returns

A function to remove listener.

() => void

onNotify

function onNotify<Shared, SomeStore>($store, listener): () => void;

Add listener to notifying about store changes.

You can communicate between listeners by payload.shared or cancel changes by payload.abort().

On MapStore#setKey() call, changed value will be in payload.changed.

Type Parameters

Shared

Shared = never

SomeStore

SomeStore extends Store = Store

Parameters

$store

SomeStore

The store to add listener.

listener

(payload) => void

Event callback.

Returns

A function to remove listener.

() => void

mapCreator

function mapCreator<Value, Args, StoreExt>(init?): MapCreator<Value, Args>;

Create function to create map stores. It will be like a class for store.

Type Parameters

Value

Value extends object

Args

Args extends any[] = []

StoreExt

StoreExt extends object = object

Parameters

init?

(store, id, …args) => void | (() => void)

Store’s initializer. Returns store destructor.

Returns

MapCreator<Value, Args>

readonlyType

function readonlyType<Value>(store): ReadableAtom<Value>;

Change store type for readonly for export.

import { readonlyType } from 'nanostores'

const $storePrivate = atom(0)

export const $store = readonlyType($storePrivate)

Type Parameters

Value

Value

Parameters

store

ReadableAtom<Value>

The store to be exported.

Returns

ReadableAtom<Value>

The readonly store.

Types

ReadableAtom

Store object.

Type details

Extended by

WritableAtom

Type Parameters

Value

Value = any

Properties

init

readonly init: Value | undefined;

Low-level attribute to read store’s initial value.

lc

readonly lc: number;

Listeners count.

value

readonly value: Value | undefined;

Low-level method to read store’s value without calling onStart.

Try to use only ReadableAtom#get. Without subscribers, value can be undefined.

Methods

eq()

eq(oldValue, newValue): boolean;

Compares the previous and next values on every set.

Returning true means the values are the same, so the store keeps the old value and no listener is called.

Parameters

oldValue

ReadonlyIfObject<Value> | undefined

newValue

ReadonlyIfObject<Value>

Returns

boolean

true if the values are equal, false otherwise.

Remarks

Called only by the store’s own writes, so a store that never writes never calls it. Map#setKey uses MapStore#eqKey instead.

Before the first write, oldValue can be undefined, for instance on the first run of a computed store.

Default

Object.is

See $store.get().

See $store.listen().

notify()

notify(oldValue?): void;

Low-level method to notify listeners about changes in the store.

Can cause unexpected behaviour when combined with frontend frameworks that perform equality checks for values, such as React.

Parameters

oldValue?

ReadonlyIfObject<Value>

Returns

void

off()

off(): void;

Unbind all listeners.

Returns

void

See $store.subscribe().

WritableAtom

Store with a way to manually change the value.

Type details

Extends

ReadableAtom<Value>

Extended by

Type Parameters

Value

Value = any

Properties

Methods

See $store.set().

MapStore

Store with a way to manually change the value.

Type details

Extends

WritableAtom<Value>

Extended by

PreinitializedMapStore

Type Parameters

Value

Value extends object = any

Properties

Methods

eqKey()

eqKey<Key>(
   oldValue,
   newValue,
   key
): boolean;

Compares the previous and next values for a key on setKey.

Returning true means the values are the same, so the store keeps the old value and no listener is called.

One function serves every key of the map, so the key name comes as the third argument. The old value is undefined when the key is not in the map yet.

Type Parameters

Key

Key extends string | number | symbol

Parameters

oldValue

Get<Value, Key> | undefined

newValue

Get<Value, Key> | undefined

key

Key

Returns

boolean

true if the values are equal, false otherwise.

Remarks

Deleting an existing key skips the comparison and notifies either way. Whole-value writes use ReadableAtom#eq instead.

Default

Object.is

listen()

listen(listener): () => void;

Subscribe to store changes.

In contrast with Store#subscribe it do not call listener immediately.

Parameters

listener

(value, oldValue, changedKey) => void

Callback with store value and old value.

Returns

Function to remove listener.

() => void

Overrides

WritableAtom.listen

notify()

notify(oldValue?, changedKey?): void;

Low-level method to notify listeners about changes in the store.

Can cause unexpected behaviour when combined with frontend frameworks that perform equality checks for values, such as React.

Parameters

oldValue?

ReadonlyIfObject<Value>

changedKey?

AllKeys<Value>

Returns

void

Overrides

WritableAtom.notify

set()

set(newValue): void;

Change store value.

$settings.set({ theme: 'dark' })

Operation is atomic, subscribers will be notified once with the new value. changedKey will be undefined

Parameters

newValue

Value

New store value.

Returns

void

Overrides

WritableAtom.set

See $store.setKey().

subscribe(listener): () => void;

Subscribe to store changes and call listener immediately.

import { $router } from '../store'

$router.subscribe(page => {
  console.log(page)
})

Parameters

listener

(value, oldValue, changedKey) => void

Callback with store value and old value.

Returns

Function to remove listener.

() => void

Overrides

WritableAtom.subscribe

Task

Type details

Extends

Promise<Value>

Type Parameters

Value

Value

Properties

[toStringTag]

readonly [toStringTag]: string;

Inherited from

Promise.[toStringTag]

t

t: true;

Methods

catch()

catch<TResult>(onrejected?): Promise<Value | TResult>;

Attaches a callback for only the rejection of the Promise.

Type Parameters

TResult

TResult = never

Parameters

onrejected?

((reason) => TResult | PromiseLike<TResult>) | null

The callback to execute when the Promise is rejected.

Returns

Promise<Value | TResult>

A Promise for the completion of the callback.

Inherited from

Promise.catch

finally()

finally(onfinally?): Promise<Value>;

Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The resolved value cannot be modified from the callback.

Parameters

onfinally?

(() => void) | null

The callback to execute when the Promise is settled (fulfilled or rejected).

Returns

Promise<Value>

A Promise for the completion of the callback.

Inherited from

Promise.finally

then()

then<TResult1, TResult2>(onfulfilled?, onrejected?): Promise<TResult1 | TResult2>;

Attaches callbacks for the resolution and/or rejection of the Promise.

Type Parameters

TResult1

TResult1 = Value

TResult2

TResult2 = never

Parameters

onfulfilled?

((value) => TResult1 | PromiseLike<TResult1>) | null

The callback to execute when the Promise is resolved.

onrejected?

((reason) => TResult2 | PromiseLike<TResult2>) | null

The callback to execute when the Promise is rejected.

Returns

Promise<TResult1 | TResult2>

A Promise for the completion of which ever callback is executed.

Inherited from

Promise.then

PreinitializedWritableAtom

Store with a way to manually change the value.

Type details

Extends

WritableAtom<Value>

Type Parameters

Value

Value

Properties

value

readonly value: Value;

Low-level method to read store’s value without calling onStart.

Try to use only ReadableAtom#get. Without subscribers, value can be undefined.

Overrides

WritableAtom.value

Methods

PreinitializedMapStore

Store with a way to manually change the value.

Type details

Extends

MapStore<Value>

Type Parameters

Value

Value extends object = any

Properties

value

readonly value: Value;

Low-level method to read store’s value without calling onStart.

Try to use only ReadableAtom#get. Without subscribers, value can be undefined.

Overrides

MapStore.value

Methods

MapCreator

Type details

Type Parameters

Value

Value extends object = any

Args

Args extends any[] = []

MapCreator(id, ...args): MapStore<object & Value>;

Parameters

id

string

args

…Args

Returns

MapStore<object & Value>

Properties

cache

cache: object;

Index Signature

[id: string]: MapStore<object & Value>

Methods

build()

build(id, ...args): MapStore<object & Value>;

Parameters

id

string

args

…Args

Returns

MapStore<object & Value>

Store

type Store<Value> =
  | ReadableAtom<Value>
| WritableStore<Value>;

Type details

Type Parameters

Value

Value = any

WritableStore

type WritableStore<Value> =
  | Value extends object ? MapStore<Value> : never
| WritableAtom<Value>;

Type details

Type Parameters

Value

Value = any

AnyStore

type AnyStore<Value> = Gettable<Value> & object;

Type details

Type Parameters

Value

Value = any

Type Declaration

value

readonly value: undefined | Value;

Atom

type Atom<Value> =
  | ReadableAtom<Value>
| WritableAtom<Value>;

Type details

Type Parameters

Value

Value = any

ListenableStore

type ListenableStore<Value> = Gettable<Value> & object;

Type details

Type Parameters

Value

Value = any

Type Declaration

listen()

listen(listener): () => void;

Parameters

listener

() => void

Returns

() => void

Gettable

type Gettable<Value> = object;

Type details

Type Parameters

Value

Value = any

Methods

get()

get(): Value;

Returns

Value

StoreValue

type StoreValue<SomeStore> = SomeStore extends Gettable<infer Value> ? Value : any;

Type details

Type Parameters

SomeStore

SomeStore

StoreValues

type StoreValues<Stores> = { -readonly [Index in keyof Stores]: StoreValue<Stores[Index]> };

Type details

Type Parameters

Stores

Stores extends readonly Gettable[]

MapStoreKeys

type MapStoreKeys<SomeStore> = SomeStore extends MapStore ? AllKeys<StoreValue<SomeStore>> : SomeStore extends object ? K : AllKeys<StoreValue<SomeStore>>;

Type details

Type Parameters

SomeStore

SomeStore

DeepMapStore

type DeepMapStore<T> = object & Omit<WritableAtom<T>, "listen" | "notify" | "setKey" | "subscribe">;

Type details

Type Parameters

T

T extends BaseDeepMap

Type Declaration

setKey

setKey: <K>(key, value) => void;

Change key in store value. Copies are made at each level of key so that no part of the original object is mutated (but it does not do a full deep copy — some sub-objects may still be shared between the old value and the new one).

$settings.setKey('visuals.theme', 'dark')

Type Parameters

K

K extends AllPaths<T>

Parameters

key

K

The key name. Attributes can be split with a dot . and [].

value

FromPathWithIndexSignatureUndefined<T, K>

New value.

Returns

void

listen()

listen(listener): () => void;

Subscribe to store changes.

In contrast with Store#subscribe it do not call listener immediately.

Parameters

listener

(value, oldValue, changedKey) => void

Callback with store value and old value.

Returns

Function to remove listener.

() => void

notify()

notify(oldValue?, changedKey?): void;

Low-level method to notify listeners about changes in the store.

Can cause unexpected behaviour when combined with frontend frameworks doing equality checks for values, e.g. React.

Parameters

oldValue?

T

changedKey?

AllPaths<T>

Returns

void

subscribe(listener): () => void;

Subscribe to store changes and call listener immediately.

import { $settings } from '../store'

$settings.subscribe(settings => {
  console.log(settings)
})

Parameters

listener

(value, oldValue, changedKey) => void

Callback with store value and old value.

Returns

Function to remove listener.

() => void

BaseDeepMap

type BaseDeepMap = Record<string, unknown>;

AllPaths

type AllPaths<T, P, MaxDepth> = T extends infer U[] ?
  | `${P}[${number}]`
  | AllPaths<U, `${P}[${number}]`, Subtract<MaxDepth, 1>>
  | P : T extends BaseDeepMap ? MaxDepth extends 0 ? never : { [K in keyof T]-?: K extends number | string ? AllPaths<T[K], ConcatPath<P, `${K}`>, Subtract<MaxDepth, 1>> | (P extends "" ? never : P) : never }[keyof T] : P;

Type details

Type Parameters

T

T

P

P extends string = ""

MaxDepth

MaxDepth extends number = 10

FromPath

type FromPath<T, P> = T extends unknown ? NestedArrKey<T, P> extends never ? NestedObjKey<T, P> extends never ? P extends keyof T ? T[P] : never : NestedObjKey<T, P> : NestedArrKey<T, P> : never;

Type details

Type Parameters

T

T

P

P

Deprecated

deepMap

function deepMap<T>(init?): DeepMapStore<T>;

Create deep map store. Deep map store is a store with an object as store value, that supports fine-grained reactivity for deeply nested properties.

Type Parameters

T

T extends BaseDeepMap

Parameters

init?

T

Initialize store and return store destructor.

Returns

DeepMapStore<T>

The store object with methods to subscribe.

getKey

function getKey<T, K>(store, key): FromPath<T, K>;

Type Parameters

T

T extends Record<string, unknown>

K

K extends string

Parameters

store

AnyStore<T>

key

K

Returns

FromPath<T, K>