@codeleap/store 4.2.18

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@codeleap/store",
+  "version": "4.2.18",
+  "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": "4.3.0",
+    "ts-node-dev": "1.1.8"
+  },
+  "scripts": {
+    "build": "echo 'No build needed'"
+  },
+  "peerDependencies": {
+    "typescript": "5.0.4",
+    "react": "18.1.0",
+    "nanostores": "*",
+    "@nanostores/react": "*",
+    "@nanostores/persistent": "*"
+  }
+}

package/package.json.bak

@@ -0,0 +1,25 @@
+{
+  "name": "@codeleap/store",
+  "version": "4.2.18",
+  "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.0.4",
+    "react": "18.1.0",
+    "nanostores": "*",
+    "@nanostores/react": "*",
+    "@nanostores/persistent": "*"
+  }
+}

package/src/globalState.ts

@@ -0,0 +1,42 @@
+import { useStore } from '@nanostores/react'
+import { setPersistentEngine, persistentAtom } from '@nanostores/persistent'
+import { atom } from 'nanostores'
+import { GlobalState, GlobalStateConfig, StateSelector } from './types'
+import { stateAssign, useStateSelector } from './utils'
+
+const defaultConfig: GlobalStateConfig = {
+  persistKey: null,
+}
+
+export const setGlobalStatePersistor = setPersistentEngine
+
+export function globalState<T>(value: T, config: GlobalStateConfig = defaultConfig): GlobalState<T> {
+  const { persistKey } = config
+
+  const isPersistState = typeof persistKey === 'string'
+
+  const store = isPersistState ? persistentAtom<T>(persistKey, value, {
+    encode: JSON.stringify,
+    decode: JSON.parse,
+  }) : atom(value)
+
+  return new Proxy(store, {
+    get(target, prop, receiver) {
+      if (prop === 'use') {
+        return (selector?: StateSelector<T, any>) => {
+          if (!selector) return useStore(target)
+          return useStateSelector(target, selector)
+        }
+      }
+
+      if (prop === 'set') {
+        return (newValue: Partial<T>) => {
+          const value = stateAssign(newValue, target.get())
+          target.set(value)
+        }
+      }
+
+      return Reflect.get(target, prop, receiver)
+    }
+  }) as unknown as GlobalState<T>
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './globalState'
+export * from './types'
+export * from './utils'

package/src/types.ts

@@ -0,0 +1,19 @@
+import { WritableAtom } from 'nanostores'
+import { PersistentStore, PersistentEvents, PersistentEvent } from '@nanostores/persistent'
+
+export type StateSelector<S, R> = (state: S) => R
+
+export type GlobalState<T> = Omit<WritableAtom<T>, 'set'> & {
+  use: <Selected = T>(selector?: StateSelector<T, Selected>) => Selected
+  set: (newValue: Partial<T>) => T
+}
+
+export type GlobalStateConfig = {
+  persistKey?: string
+}
+
+export type GlobalStatePersistor = PersistentStore
+
+export type GlobalStatePersistorEvents = PersistentEvents
+
+export type GlobalStatePersistorEvent = PersistentEvent

package/src/utils.ts

@@ -0,0 +1,37 @@
+import { useStore } from '@nanostores/react'
+import { Store } from 'nanostores'
+
+export const createStateSelector = <T, R>(
+  store: Store<T>,
+  selector: (state: T) => R
+) => ({
+  get: () => selector(store.get()),
+  listen: (listener: (value: R) => void) => {
+    return store.listen((state) => {
+      listener(selector(state))
+    })
+  }
+} as Store)
+
+export function useStateSelector<T, R>(
+  store: Store<T>,
+  selector: (state: T) => R
+): R {
+  return useStore(createStateSelector(store, selector))
+}
+
+export function stateAssign<T>(newValue: Partial<T>, stateValue: T): T {
+  if (Array.isArray(stateValue)) {
+    return [
+      ...stateValue,
+      ...(Array.isArray(newValue) ? newValue : [newValue]),
+    ] as T
+  } else if (typeof stateValue === "object" && stateValue !== null) {
+    return {
+      ...stateValue,
+      ...newValue,
+    } as T
+  } else {
+    return newValue as T
+  }
+}