@codeleap/store 6.3.0 → 6.8.0

package/dist/array.d.ts

@@ -0,0 +1,16 @@
+import { WritableAtom } from "nanostores";
+/**
+ * Returns a `Proxy` that mirrors every property access on the atom's current array value.
+ *
+ * When a function property (e.g. `push`, `splice`, `sort`) is accessed, the proxy wraps the call so that after the native method executes it writes the mutated array back to the store with `store.set`.
+ * This makes mutating array methods reactive: callers interact with a familiar `Array` API while nanostores' subscriber notifications fire automatically.
+ *
+ * Non-function properties (indices, `length`, etc.) are forwarded as-is.
+ */
+export declare function arrayHandler<T extends any[]>(store: WritableAtom<T>): never[];
+/**
+ * Complete list of own property names on `Array.prototype`.
+ * Used by the `globalState` proxy to detect when a caller is accessing an array method so it can delegate to `arrayHandler` instead of the raw atom.
+ */
+export declare const arrayOps: string[];
+//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,WAoBnE;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,UAA8C,CAAA"}

package/dist/globalState.d.ts

@@ -0,0 +1,22 @@
+import { setPersistentEngine } from '@nanostores/persistent';
+import { GlobalState, GlobalStateConfig } from './types';
+/**
+ * Registers the storage engine used by all persistent atoms in this process.
+ * Must be called once at app startup — before any `globalState` with a `persistKey` is created — otherwise the persistent atom falls back to an in-memory store.
+ * Thin re-export of `@nanostores/persistent`'s `setPersistentEngine`.
+ */
+export declare const setGlobalStatePersistor: typeof setPersistentEngine;
+/**
+ * Creates a `GlobalState<T>` atom backed by nanostores.
+ *
+ * The returned value is a `Proxy` over the raw atom that intercepts property access to:
+ * - Route `use` / `get` through optional selector functions so components subscribe only to the slice they need.
+ * - Merge partial updates on `set` for object atoms (primitives and arrays are replaced outright).
+ * - Expose `reset` as an alias for the raw `WritableAtom.set`, bypassing merge logic.
+ * - Forward any `Array.prototype` property access to `arrayHandler`, which commits mutations back to the store.
+ *
+ * When `config.persistKey` is provided, the atom is created with `persistentAtom` and serialised via `JSON.stringify` / `JSON.parse`.
+ * Call `setGlobalStatePersistor` before using persistence so the engine is ready.
+ */
+export declare function globalState<T>(value: T, config?: GlobalStateConfig): GlobalState<T>;
+//# sourceMappingURL=globalState.d.ts.map

package/dist/globalState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalState.d.ts","sourceRoot":"","sources":["../src/globalState.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAkB,MAAM,wBAAwB,CAAA;AAE5E,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAA8B,MAAM,SAAS,CAAA;AAQpF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,4BAAsB,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAE,iBAAiC,GAAG,WAAW,CAAC,CAAC,CAAC,CAoDlG"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './globalState';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import { WritableAtom } from 'nanostores';
+import { PersistentStore, PersistentEvents, PersistentEvent } from '@nanostores/persistent';
+/** Derives a value `R` from a state snapshot `S`. Used by `get` and `use` to avoid subscribing to the full atom when only a slice is needed. */
+export type StateSelector<S, R> = (state: S) => R;
+/** Functional form of a setter — receives the current value and returns the next value. Enables relative updates without reading state externally. */
+export type StateSetterFunction<In, Out = In> = (current: In) => Out;
+/** Accepts either a direct value or a function setter. `set` on object atoms only requires the changed keys (`Partial<T>`), so `TOut` defaults to `TIn` but can differ. */
+export type StateSetter<TIn, TOut = TIn> = TOut | StateSetterFunction<TIn, TOut>;
+/**
+ * A nanostores `WritableAtom` extended with a richer API surface.
+ *
+ * - `use` — React hook that subscribes to the atom (or a selector slice) and re-renders only when the selected value changes.
+ * - `set` — Merges partial updates for object atoms; replaces the value for primitives and arrays.
+ * - `get` — Non-reactive snapshot read; accepts an optional selector to avoid allocating an intermediate slice.
+ * - `reset` — Bypasses the merge logic and replaces the entire state, equivalent to calling the underlying `WritableAtom.set` directly.
+ *
+ * When `T` is an array the atom also exposes every `Array.prototype` method directly; mutating methods commit the result back to the store automatically.
+ */
+export type GlobalState<T> = Omit<WritableAtom<T>, 'set' | 'get'> & {
+    use: <Selected = T>(selector?: StateSelector<T, Selected>) => Selected;
+    set: (newValue: T extends Record<string, any> ? StateSetter<T, Partial<T>> : StateSetter<T>) => void;
+    get: <Selected = T>(selector?: StateSelector<T, Selected>) => Selected extends undefined ? T : Selected;
+    reset: WritableAtom<T>['set'];
+} & (T extends any[] ? Array<T[number]> : {});
+/**
+ * Creation options for `globalState`.
+ *
+ * When `persistKey` is provided the atom is backed by a `persistentAtom`, serialised with `JSON.stringify`/`JSON.parse`.
+ * The storage engine must be registered first via `setGlobalStatePersistor`.
+ */
+export type GlobalStateConfig = {
+    persistKey?: string;
+};
+/** The storage engine contract for persistent atoms. Swap implementations (localStorage, AsyncStorage, MMKV, …) via `setGlobalStatePersistor`. */
+export type GlobalStatePersistor = PersistentStore;
+/** Map of lifecycle events emitted by the persistent engine (e.g. `storage` events in a browser environment). */
+export type GlobalStatePersistorEvents = PersistentEvents;
+/** A single event emitted by the persistent engine, carrying the key and updated value. */
+export type GlobalStatePersistorEvent = PersistentEvent;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE3F,gJAAgJ;AAChJ,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAA;AAEjD,sJAAsJ;AACtJ,MAAM,MAAM,mBAAmB,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,GAAG,CAAA;AAEpE,2KAA2K;AAC3K,MAAM,MAAM,WAAW,CAAC,GAAG,EAAE,IAAI,GAAG,GAAG,IAAI,IAAI,GAAG,mBAAmB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,GAAG;IAClE,GAAG,EAAE,CAAC,QAAQ,GAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,QAAQ,CAAA;IAEtE,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IAEpG,GAAG,EAAE,CAAC,QAAQ,GAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,QAAQ,SAAS,SAAS,GAAG,CAAC,GAAG,QAAQ,CAAA;IAEvG,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;CAC9B,GAAG,CACA,CAAC,SAAS,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CACxC,CAAA;AAEH;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,kJAAkJ;AAClJ,MAAM,MAAM,oBAAoB,GAAG,eAAe,CAAA;AAElD,iHAAiH;AACjH,MAAM,MAAM,0BAA0B,GAAG,gBAAgB,CAAA;AAEzD,2FAA2F;AAC3F,MAAM,MAAM,yBAAyB,GAAG,eAAe,CAAA"}

package/dist/utils.d.ts

@@ -0,0 +1,29 @@
+import { WritableAtom } from 'nanostores';
+import { StateSetter } from './types';
+/**
+ * Resolves `newValue` against `stateValue` and returns the next state.
+ *
+ * For object atoms the resolved value is shallow-merged onto the existing state, so callers only need to supply changed keys.
+ * For primitives and arrays the resolved value replaces the current state entirely.
+ */
+export declare function stateAssign<T>(newValue: StateSetter<Partial<T>>, stateValue: T): T;
+/**
+ * Derives a virtual `WritableAtom<R>` that projects a slice of a parent atom through `selector`.
+ *
+ * - `get` — applies `selector` to the parent snapshot without subscribing.
+ * - `listen` — subscribes to the parent atom and calls `listener` with the projected value on every change.
+ * - `set` — requires a `deselector` to map the slice value back to a `Partial<T>`, then merges it into the parent atom via `stateAssign`. Throws if `deselector` is absent.
+ *
+ * The returned object satisfies the `WritableAtom<R>` interface so it can be passed anywhere a nanostores atom is expected, including `useStore`.
+ */
+export declare const createStateSlice: <T, R, S extends WritableAtom<T>>(store: S, selector: (state: T) => R, deselector?: (result: R) => Partial<T>) => WritableAtom<R>;
+/**
+ * React hook that subscribes a component to a derived slice of an atom.
+ *
+ * Internally it memoises a `createStateSlice` projection keyed on `selector` identity, then passes the virtual atom to `useStore`.
+ * Components re-render only when the selected value changes — not on every atom update — which avoids the cost of subscribing to the full atom shape.
+ *
+ * Caution: because the slice is memoised on `selector` reference, prefer stable (module-level or `useCallback`) selector functions to avoid unnecessary slice recreation.
+ */
+export declare function useStateSelector<T, R, S extends WritableAtom<T>>(store: S, selector: (state: T) => R): R;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC,OAAO,EAAE,WAAW,EAAuB,MAAM,SAAS,CAAA;AAgB1D;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAYlF;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,EAC9D,OAAO,CAAC,EACR,UAAU,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EACzB,aAAa,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAsBjC,YAAY,CAAC,CAAC,CAAE,CAAA;AAEvB;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,EAC9D,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GACxB,CAAC,CAIH"}

package/package.json

@@ -1,7 +1,20 @@
 {
   "name": "@codeleap/store",
-  "version": "6.3.0",
+  "version": "6.8.0",
   "main": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "license": "UNLICENSED",
   "repository": {
     "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
@@ -9,17 +22,18 @@
     "directory": "packages/store"
   },
   "devDependencies": {
-    "@codeleap/config": "6.3.0",
+    "@codeleap/config": "6.8.0",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {
-    "build": "echo 'No build needed'"
+    "build": "tsc --build tsconfig.build.json",
+    "typecheck": "bun tsc --noEmit -p ./tsconfig.json"
   },
   "peerDependencies": {
-    "typescript": "5.5.2",
+    "typescript": "6.0.3",
     "react": "19.1.0",
     "nanostores": "*",
     "@nanostores/react": "*",
     "@nanostores/persistent": "*"
   }
-}
+}

package/src/array.ts

@@ -1,18 +1,26 @@
 import { WritableAtom } from "nanostores"
 
+/**
+ * Returns a `Proxy` that mirrors every property access on the atom's current array value.
+ *
+ * When a function property (e.g. `push`, `splice`, `sort`) is accessed, the proxy wraps the call so that after the native method executes it writes the mutated array back to the store with `store.set`.
+ * This makes mutating array methods reactive: callers interact with a familiar `Array` API while nanostores' subscriber notifications fire automatically.
+ *
+ * Non-function properties (indices, `length`, etc.) are forwarded as-is.
+ */
 export function arrayHandler<T extends any[]>(store: WritableAtom<T>) {
   return new Proxy([], {
     get(target, p, receiver){
-      const val = store.get()
+      const val = store.get() as Record<string | symbol, any>
 
       const property = val[p]
 
       if(typeof property == 'function') {
-        return (...args) => {
+        return (...args: unknown[]) => {
           const r =  val[p](...args)
 
-          store.set(val)
-          
+          store.set(val as T)
+
           return r
         }
       }
@@ -22,5 +30,8 @@ export function arrayHandler<T extends any[]>(store: WritableAtom<T>) {
   })
 }
 
-
+/**
+ * Complete list of own property names on `Array.prototype`.
+ * Used by the `globalState` proxy to detect when a caller is accessing an array method so it can delegate to `arrayHandler` instead of the raw atom.
+ */
 export const arrayOps = Object.getOwnPropertyNames(Array.prototype)

package/src/globalState.ts

@@ -6,11 +6,28 @@ import { stateAssign, useStateSelector } from './utils'
 import { arrayHandler, arrayOps } from './array'
 
 const defaultConfig: GlobalStateConfig = {
-  persistKey: null,
+  persistKey: undefined,
 }
 
+/**
+ * Registers the storage engine used by all persistent atoms in this process.
+ * Must be called once at app startup — before any `globalState` with a `persistKey` is created — otherwise the persistent atom falls back to an in-memory store.
+ * Thin re-export of `@nanostores/persistent`'s `setPersistentEngine`.
+ */
 export const setGlobalStatePersistor = setPersistentEngine
 
+/**
+ * Creates a `GlobalState<T>` atom backed by nanostores.
+ *
+ * The returned value is a `Proxy` over the raw atom that intercepts property access to:
+ * - Route `use` / `get` through optional selector functions so components subscribe only to the slice they need.
+ * - Merge partial updates on `set` for object atoms (primitives and arrays are replaced outright).
+ * - Expose `reset` as an alias for the raw `WritableAtom.set`, bypassing merge logic.
+ * - Forward any `Array.prototype` property access to `arrayHandler`, which commits mutations back to the store.
+ *
+ * When `config.persistKey` is provided, the atom is created with `persistentAtom` and serialised via `JSON.stringify` / `JSON.parse`.
+ * Call `setGlobalStatePersistor` before using persistence so the engine is ready.
+ */
 export function globalState<T>(value: T, config: GlobalStateConfig = defaultConfig): GlobalState<T> {
   const { persistKey } = config
 

package/src/types.ts

@@ -1,11 +1,25 @@
 import { WritableAtom } from 'nanostores'
 import { PersistentStore, PersistentEvents, PersistentEvent } from '@nanostores/persistent'
 
+/** Derives a value `R` from a state snapshot `S`. Used by `get` and `use` to avoid subscribing to the full atom when only a slice is needed. */
 export type StateSelector<S, R> = (state: S) => R
 
+/** Functional form of a setter — receives the current value and returns the next value. Enables relative updates without reading state externally. */
 export type StateSetterFunction<In, Out = In> = (current: In) => Out
+
+/** Accepts either a direct value or a function setter. `set` on object atoms only requires the changed keys (`Partial<T>`), so `TOut` defaults to `TIn` but can differ. */
 export type StateSetter<TIn, TOut = TIn> = TOut | StateSetterFunction<TIn, TOut>
 
+/**
+ * A nanostores `WritableAtom` extended with a richer API surface.
+ *
+ * - `use` — React hook that subscribes to the atom (or a selector slice) and re-renders only when the selected value changes.
+ * - `set` — Merges partial updates for object atoms; replaces the value for primitives and arrays.
+ * - `get` — Non-reactive snapshot read; accepts an optional selector to avoid allocating an intermediate slice.
+ * - `reset` — Bypasses the merge logic and replaces the entire state, equivalent to calling the underlying `WritableAtom.set` directly.
+ *
+ * When `T` is an array the atom also exposes every `Array.prototype` method directly; mutating methods commit the result back to the store automatically.
+ */
 export type GlobalState<T> = Omit<WritableAtom<T>, 'set' | 'get'> & {
   use: <Selected = T>(selector?: StateSelector<T, Selected>) => Selected
 
@@ -18,12 +32,21 @@ export type GlobalState<T> = Omit<WritableAtom<T>, 'set' | 'get'> & {
     T extends any[] ? Array<T[number]> : {}
   )
 
+/**
+ * Creation options for `globalState`.
+ *
+ * When `persistKey` is provided the atom is backed by a `persistentAtom`, serialised with `JSON.stringify`/`JSON.parse`.
+ * The storage engine must be registered first via `setGlobalStatePersistor`.
+ */
 export type GlobalStateConfig = {
   persistKey?: string
 }
 
+/** The storage engine contract for persistent atoms. Swap implementations (localStorage, AsyncStorage, MMKV, …) via `setGlobalStatePersistor`. */
 export type GlobalStatePersistor = PersistentStore
 
+/** Map of lifecycle events emitted by the persistent engine (e.g. `storage` events in a browser environment). */
 export type GlobalStatePersistorEvents = PersistentEvents
 
+/** A single event emitted by the persistent engine, carrying the key and updated value. */
 export type GlobalStatePersistorEvent = PersistentEvent

package/src/utils.ts

@@ -3,18 +3,26 @@ import { WritableAtom } from 'nanostores'
 import { useMemo } from 'react'
 import { StateSetter, StateSetterFunction } from './types'
 
+/** Type guard that distinguishes a functional setter from a plain value so `resolveSetter` can call it correctly. */
 function isFunctionSetter<T>(x: any): x is StateSetterFunction<T> {
   return typeof x === 'function'
 }
 
+/** Evaluates a `StateSetter`: calls it with `currentValue` if it is a function, otherwise returns it as-is. */
 function resolveSetter<T>(setter: StateSetter<T>, currentValue:T):T {
-  if (isFunctionSetter(setter)) {
+  if (isFunctionSetter<T>(setter)) {
     return setter(currentValue)
   }
 
-  return setter
+  return setter as T
 }
 
+/**
+ * Resolves `newValue` against `stateValue` and returns the next state.
+ *
+ * For object atoms the resolved value is shallow-merged onto the existing state, so callers only need to supply changed keys.
+ * For primitives and arrays the resolved value replaces the current state entirely.
+ */
 export function stateAssign<T>(newValue: StateSetter<Partial<T>>, stateValue: T): T {
   const resolvedValue = resolveSetter(newValue, stateValue)
   if (
@@ -29,6 +37,15 @@ export function stateAssign<T>(newValue: StateSetter<Partial<T>>, stateValue: T)
   return resolvedValue as T
 }
 
+/**
+ * Derives a virtual `WritableAtom<R>` that projects a slice of a parent atom through `selector`.
+ *
+ * - `get` — applies `selector` to the parent snapshot without subscribing.
+ * - `listen` — subscribes to the parent atom and calls `listener` with the projected value on every change.
+ * - `set` — requires a `deselector` to map the slice value back to a `Partial<T>`, then merges it into the parent atom via `stateAssign`. Throws if `deselector` is absent.
+ *
+ * The returned object satisfies the `WritableAtom<R>` interface so it can be passed anywhere a nanostores atom is expected, including `useStore`.
+ */
 export const createStateSlice = <T, R, S extends WritableAtom<T>>(
   store: S,
   selector: (state: T) => R,
@@ -51,8 +68,19 @@ export const createStateSlice = <T, R, S extends WritableAtom<T>>(
 
       store.set(newValue)
     },
+    get value(){
+      return store.value
+    }
   } as WritableAtom<R>)
 
+/**
+ * React hook that subscribes a component to a derived slice of an atom.
+ *
+ * Internally it memoises a `createStateSlice` projection keyed on `selector` identity, then passes the virtual atom to `useStore`.
+ * Components re-render only when the selected value changes — not on every atom update — which avoids the cost of subscribing to the full atom shape.
+ *
+ * Caution: because the slice is memoised on `selector` reference, prefer stable (module-level or `useCallback`) selector functions to avoid unnecessary slice recreation.
+ */
 export function useStateSelector<T, R, S extends WritableAtom<T>>(
   store: S,
   selector: (state: T) => R,

package/package.json.bak

@@ -1,25 +0,0 @@
-{
-  "name": "@codeleap/store",
-  "version": "6.3.0",
-  "main": "src/index.ts",
-  "license": "UNLICENSED",
-  "repository": {
-    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
-    "type": "git",
-    "directory": "packages/store"
-  },
-  "devDependencies": {
-    "@codeleap/config": "workspace:*",
-    "ts-node-dev": "1.1.8"
-  },
-  "scripts": {
-    "build": "echo 'No build needed'"
-  },
-  "peerDependencies": {
-    "typescript": "5.5.2",
-    "react": "19.1.0",
-    "nanostores": "*",
-    "@nanostores/react": "*",
-    "@nanostores/persistent": "*"
-  }
-}