muya 1.0.1

package/README.md

@@ -0,0 +1,236 @@
+
+# Muya 🌀
+Welcome to Muya - Making state management a breeze, focused on simplicity and scalability for real-world scenarios.
+
+[![Build](https://github.com/samuelgja/muya/actions/workflows/build.yml/badge.svg)](https://github.com/samuelgja/muya/actions/workflows/build.yml)
+[![Code quality Check](https://github.com/samuelgja/muya/actions/workflows/code-check.yml/badge.svg)](https://github.com/samuelgja/muya/actions/workflows/code-check.yml)
+[![Build Size](https://img.shields.io/bundlephobia/minzip/muya?label=Bundle%20size)](https://bundlephobia.com/result?p=muya)
+
+
+
+## 🚀 Features
+- Easy State Creation: Kickstart your state management with simple and intuitive APIs.
+- Selectors & Merges: Grab exactly what you need from your state and combine multiple states seamlessly.
+- Deep Nesting Support: Handle complex state structures without breaking a sweat.
+- Optimized Rendering: Prevent unnecessary re-renders
+- TypeScript Ready: Fully typed for maximum developer sanity.
+- Small Bundle Size: Lightweight and fast, no bloatware here.
+
+
+## 📦 Installation
+
+```bash
+bun add muya
+```
+or
+```bash
+yarn add muya
+```
+or
+```bash
+npm install muya
+```
+
+## 📝 Quick Start
+
+```typescript
+import { create } from 'muya'
+
+const useCounter = create(0)
+
+function App() {
+  const counter = useCounter()
+  return <div onClick={() => useCounter.setState((prev) => prev + 1)}>{counter}</div>
+}
+```
+
+### Update
+Sugar syntax above the `setState` method for partially updating the state.
+```typescript
+import { create } from 'muya'
+
+const useUser = create({ name: 'John', lastName: 'Doe' })
+
+function App() {
+  const user = useUser()
+  // this will just partially update only the name field, it's sugar syntax for setState.
+  return <div onClick={() => useUser.updateState({ name: 'Nope' })}>{user.name}</div>
+}
+```
+
+
+### Selecting parts of the state globally
+```tsx
+import { create } from 'muya'
+
+const useUser = create({ name: 'John', age: 30 })
+
+// Selecting only the name part of the state
+const useName = useUser.select((user) => user.name)
+
+function App() {
+  const name = useName()
+  return <div onClick={() => useUser.setState((prev) => ({ ...prev, name: 'Jane' }))}>{name}</div>
+}
+
+```
+
+### Merge two states
+```typescript
+import { create, shallow } from 'muya'
+
+const useName = create(() => 'John')
+const useAge = create(() => 30)
+
+const useFullName = useName.merge(useAge, (name, age) => ` ${name} and ${age}`, shallow)
+
+function App() {
+  const fullName = useFullName()
+  return <div onClick={() => useName.setState((prev) => 'Jane')}>{fullName}</div>
+}
+```
+
+
+### Promise based state and lifecycle management working with React Suspense
+This methods are useful for handling async data fetching and lazy loading via React Suspense.
+
+#### Immediate Promise resolution
+```typescript
+import { create } from 'muya';
+ // state will try to resolve the promise immediately, can hit the suspense boundary
+const counterState = create(Promise.resolve(0));
+
+function Counter() {
+  const counter = counterState();
+  return (
+    <div onClick={() => counterState.setState((prev) => prev + 1)}>
+      {counter}
+    </div>
+  );
+}
+```
+
+#### Lazy Promise resolution
+```typescript
+import { create } from 'muya';
+// state will lazy resolve the promise on first access, this will hit the suspense boundary if the first access is from component and via `counterState.getState()` method
+const counterState = create(() => Promise.resolve(0)); 
+
+function Counter() {
+  const counter = counterState();
+  return (
+    <div onClick={() => counterState.setState((prev) => prev + 1)}>
+      {counter}
+    </div>
+  );
+}
+```
+
+
+## 🔍 API Reference
+
+### `create`
+
+Creates a basic atom state.
+
+```typescript
+function create<T>(defaultState: T, options?: StateOptions<T>): StateSetter<T>;
+```
+
+**Example:**
+
+```typescript
+const userState = create({ name: 'John', age: 30 });
+```
+
+### `select`
+
+Selects a slice of an existing state directly or via a selector function.
+
+```typescript
+// userState is ready to use as hook, so you can name it with `use` prefix
+const userState = create({ name: 'John', age: 30 });
+// Direct selection outside the component, is useful for accessing the slices of the state in multiple components
+const userAgeState = userState.select((user) => user.age);
+```
+
+### `merge`
+Merges two states into a single state. 
+```typescript
+const useName = create(() => 'John');
+const useAge = create(() => 30);
+const useFullName = useName.merge(useAge, (name, age) => ` ${name} and ${age}`);
+```
+
+
+### `setState`
+Sets the state to a new value or a function that returns a new value.
+
+```typescript
+const userState = create({ name: 'John', age: 30 });
+userState.setState({ name: 'Jane' });
+```
+
+### `updateState`
+Partially updates the state with a new value.
+
+```typescript
+const userState = create({ name: 'John', age: 30 });
+userState.updateState({ name: 'Jane' });
+```
+
+### `getState`
+Returns the current state value outside the component.
+
+```typescript
+const userState = create({ name: 'John', age: 30 });
+const user = userState.getState();
+```
+
+### `use`
+Creates a hook for the state.
+
+```typescript
+const useCounter = create(0);
+// use inside the component
+const counter = useCounter();
+```
+
+### `subscribe`
+Subscribes to the state changes.
+
+```typescript
+const userState = create({ name: 'John', age: 30 });
+const unsubscribe = userState.subscribe((state) => console.log(state));
+```
+
+
+
+### Access from outside the component
+:warning: Avoid using this method for state management in [React Server Components](https://github.com/reactjs/rfcs/blob/main/text/0188-server-components.md), especially in Next.js 13+. It may cause unexpected behavior or privacy concerns.
+```typescript
+const userState = create({ name: 'John', age: 30 });
+const user = userState.getState();
+```
+---
+
+
+### Slicing new references
+:warning: Slicing data with new references can lead to maximum call stack exceeded error.
+It's recommended to not use new references for the state slices, if you need so, use `shallow` or other custom equality checks.
+```typescript
+import { state, shallow } from 'muya';
+const userState = create({ name: 'John', age: 30 });
+// this slice will create new reference object on each call
+const useName = userState.select((user) => ({newUser: user.name }), shallow);
+```
+
+## 🤖 Contributing
+Contributions are welcome! Please read the [contributing guidelines](CONTRIBUTING.md) before submitting a pull request.
+
+## 🧪 Testing
+Muya comes with a robust testing suite. Check out the state.test.tsx for examples on how to write your own tests.
+
+## 📜 License
+
+Muya is [MIT licensed](LICENSE).

package/cjs/index.js

@@ -0,0 +1 @@
+"use strict";var G=Object.defineProperty;var z=Object.getOwnPropertyDescriptor;var F=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var C=(t,e)=>{for(var r in e)G(t,r,{get:e[r],enumerable:!0})},L=(t,e,r,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of F(e))!M.call(t,n)&&n!==r&&G(t,n,{get:()=>e[n],enumerable:!(a=z(e,n))||a.enumerable});return t};var W=t=>L(G({},"__esModule",{value:!0}),t);var H={};C(H,{StateKeys:()=>_,create:()=>D,getDefaultValue:()=>y,merge:()=>b,select:()=>g,shallow:()=>v,useStateValue:()=>x});module.exports=W(H);function p(t){return t instanceof Promise}function q(t){return typeof t=="function"}function I(t){return typeof t=="function"}function R(t){return typeof t=="object"&&t!==null}function w(t){return t instanceof Map}function k(t){return t instanceof Set}function V(t){return Array.isArray(t)}function c(t,e){return t===e?!0:!!Object.is(t,e)}var _=(r=>(r.IS_STATE="isState",r.IS_SLICE="isSlice",r))(_||{});function y(t){return p(t)?t:q(t)?t():t}function T(t){let e=new Set;return{subscribe:r=>(e.add(r),()=>{e.delete(r)}),emit:(...r)=>{for(let a of e)a(...r)},getSnapshot:t}}var P=require("use-sync-external-store/shim/with-selector"),h=require("react");function O(t){return t}function j(t,e,r){let a=(0,P.useSyncExternalStoreWithSelector)(t.subscribe,t.getSnapshot,t.getSnapshot,e?n=>e(n):O,r);return(0,h.useDebugValue)(a),a}function x(t,e=a=>a,r){let a=j(t.__internal.emitter,n=>e(n),r);if(p(a))throw a;return a}function m(t){let{baseState:e}=t,r=(a,n)=>x(r,a,n);return r.__internal=e.__internal,r.getState=e.getState,r.reset=e.reset,r.select=e.select,r.merge=e.merge,r.subscribe=e.subscribe,r}function b(t,e,r,a=c){let n,o=T(()=>{let f=r(t.getState(),e.getState());return n!==void 0&&a(n,f)?n:(n=f,f)});t.__internal.emitter.subscribe(()=>{o.emit()}),e.__internal.emitter.subscribe(()=>{o.emit()});let s=l({emitter:o,getGetterState:()=>S,getState:()=>r(t.getState(),e.getState()),reset(){t.reset(),e.reset()}}),S=m({baseState:s});return S}function g(t,e,r=c){let a,n=T(()=>{let S=e(t.getState());return a!==void 0&&r(a,S)?a:(a=S,S)});t.__internal.emitter.subscribe(()=>{n.emit()});let o=l({emitter:n,getGetterState:()=>s,getState:()=>e(t.getState()),reset:t.reset}),s=m({baseState:o});return s}function l(t){let{emitter:e,getGetterState:r,reset:a,getState:n}=t;return{getState:n,reset:a,select(o,s){let S=r();return g(S,o,s)},merge(o,s,S){let f=r();return b(f,o,s,S)},__internal:{emitter:e},subscribe(o){return o(n()),e.subscribe(()=>{o(n())})}}}function D(t,e=c){function r(i,u){return I(u)?u(i):u}let a={updateVersion:0,value:void 0};function n(){return a.value===void 0&&(a.value=y(t)),a.value}function o(){let i=n();return p(i)&&i.then(u=>{a.value=u,f.emit()}),i}function s(i){let u=n(),E=r(u,i);e?.(u,E)||E===u||(a.updateVersion++,a.value=E,f.emit())}function S(i){if(R(i))return s(u=>({...u,...i}));s(i)}let f=T(o),U=l({emitter:f,getGetterState:()=>d,getState:o,reset(){let i=y(t);if(p(i)){i.then(u=>{s(u)});return}s(i)}}),d=m({baseState:U});return d.setState=s,d.updateState=S,d}function v(t,e){if(t==e||Object.is(t,e))return!0;if(typeof t!="object"||t==null||typeof e!="object"||e==null)return!1;if(w(t)&&w(e)){if(t.size!==e.size)return!1;for(let[n,o]of t)if(!Object.is(o,e.get(n)))return!1;return!0}if(k(t)&&k(e)){if(t.size!==e.size)return!1;for(let n of t)if(!e.has(n))return!1;return!0}if(V(t)&&V(e)){if(t.length!==e.length)return!1;for(let[n,o]of t.entries())if(!Object.is(o,e[n]))return!1;return!0}let r=Object.keys(t),a=Object.keys(e);if(r.length!==a.length)return!1;for(let n of r)if(!Object.prototype.hasOwnProperty.call(e,n)||!Object.is(t[n],e[n]))return!1;return!0}

package/esm/common.js

@@ -0,0 +1 @@
+import{useSyncExternalStoreWithSelector as u}from"use-sync-external-store/shim/with-selector";import{useDebugValue as s}from"react";function S(e){return e}function i(e,t,r){const n=u(e.subscribe,e.getSnapshot,e.getSnapshot,t?o=>t(o):S,r);return s(n),n}export{S as toType,i as useSyncExternalStore};

package/esm/create-base-state.js

@@ -0,0 +1 @@
+import{merge as c}from"./merge";import{select as p}from"./select";function y(n){const{emitter:o,getGetterState:s,reset:i,getState:e}=n;return{getState:e,reset:i,select(t,r){const a=s();return p(a,t,r)},merge(t,r,a){const m=s();return c(m,t,r,a)},__internal:{emitter:o},subscribe(t){return t(e()),o.subscribe(()=>{t(e())})}}}export{y as createBaseState};

package/esm/create-emitter.js

@@ -0,0 +1 @@
+function n(r){const t=new Set;return{subscribe:e=>(t.add(e),()=>{t.delete(e)}),emit:(...e)=>{for(const i of t)i(...e)},getSnapshot:r}}export{n as createEmitter};

package/esm/create-getter-state.js

@@ -0,0 +1 @@
+import{useStateValue as n}from"./use-state-value";function i(r){const{baseState:t}=r,e=(a,s)=>n(e,a,s);return e.__internal=t.__internal,e.getState=t.getState,e.reset=t.reset,e.select=t.select,e.merge=t.merge,e.subscribe=t.subscribe,e}export{i as createGetterState};

package/esm/create.js

@@ -0,0 +1 @@
+import{createEmitter as d}from"./create-emitter";import{getDefaultValue as S}from"./types";import{isEqualBase as V,isObject as v,isPromise as c,isSetValueFunction as g}from"./is";import{createBaseState as D}from"./create-base-state";import{createGetterState as E}from"./create-getter-state";function y(s,f=V){function T(t,e){return g(e)?e(t):e}const a={updateVersion:0,value:void 0};function o(){return a.value===void 0&&(a.value=S(s)),a.value}function l(){const t=o();return c(t)&&t.then(e=>{a.value=e,n.emit()}),t}function r(t){const e=o(),i=T(e,t);f?.(e,i)||i===e||(a.updateVersion++,a.value=i,n.emit())}function m(t){if(v(t))return r(e=>({...e,...t}));r(t)}const n=d(l),p=D({emitter:n,getGetterState:()=>u,getState:l,reset(){const t=S(s);if(c(t)){t.then(e=>{r(e)});return}r(t)}}),u=E({baseState:p});return u.setState=r,u.updateState=m,u}export{y as create};

package/esm/index.js

@@ -0,0 +1 @@
+export*from"./types";import{create as t}from"./create";import{select as f}from"./select";import{merge as x}from"./merge";import{useStateValue as l}from"./use-state-value";import{shallow as c}from"./shallow";export{t as create,x as merge,f as select,c as shallow,l as useStateValue};

package/esm/is.js

@@ -0,0 +1 @@
+function o(n){return n instanceof Promise}function r(n){return typeof n=="function"}function u(n){return typeof n=="function"}function t(n){return typeof n=="object"&&n!==null}function i(n){return t(n)&&n.isRef===!0}function s(n){return n instanceof Map}function f(n){return n instanceof Set}function a(n){return Array.isArray(n)}function c(n,e){return n===e?!0:!!Object.is(n,e)}export{a as isArray,c as isEqualBase,r as isFunction,s as isMap,t as isObject,o as isPromise,i as isRef,f as isSet,u as isSetValueFunction};

package/esm/merge.js

@@ -0,0 +1 @@
+import{createBaseState as u}from"./create-base-state";import{createEmitter as s}from"./create-emitter";import{createGetterState as c}from"./create-getter-state";import{isEqualBase as f}from"./is";function T(t,e,i,n=f){let r;const a=s(()=>{const S=i(t.getState(),e.getState());return r!==void 0&&n(r,S)?r:(r=S,S)});t.__internal.emitter.subscribe(()=>{a.emit()}),e.__internal.emitter.subscribe(()=>{a.emit()});const o=u({emitter:a,getGetterState:()=>m,getState:()=>i(t.getState(),e.getState()),reset(){t.reset(),e.reset()}}),m=c({baseState:o});return m}export{T as merge};

package/esm/select.js

@@ -0,0 +1 @@
+import{createBaseState as m}from"./create-base-state";import{createEmitter as s}from"./create-emitter";import{createGetterState as u}from"./create-getter-state";import{isEqualBase as c}from"./is";function d(t,a,o=c){let e;const S=s(()=>{const r=a(t.getState());return e!==void 0&&o(e,r)?e:(e=r,r)});t.__internal.emitter.subscribe(()=>{S.emit()});const n=m({emitter:S,getGetterState:()=>i,getState:()=>a(t.getState()),reset:t.reset}),i=u({baseState:n});return i}export{d as select};

package/esm/shallow.js

@@ -0,0 +1 @@
+import{isArray as o,isMap as f,isSet as i}from"./is";function b(t,r){if(t==r||Object.is(t,r))return!0;if(typeof t!="object"||t==null||typeof r!="object"||r==null)return!1;if(f(t)&&f(r)){if(t.size!==r.size)return!1;for(const[n,e]of t)if(!Object.is(e,r.get(n)))return!1;return!0}if(i(t)&&i(r)){if(t.size!==r.size)return!1;for(const n of t)if(!r.has(n))return!1;return!0}if(o(t)&&o(r)){if(t.length!==r.length)return!1;for(const[n,e]of t.entries())if(!Object.is(e,r[n]))return!1;return!0}const s=Object.keys(t),c=Object.keys(r);if(s.length!==c.length)return!1;for(const n of s)if(!Object.prototype.hasOwnProperty.call(r,n)||!Object.is(t[n],r[n]))return!1;return!0}export{b as shallow};

package/esm/types.js

@@ -0,0 +1 @@
+import{isFunction as a,isPromise as r}from"./is";var T=(t=>(t.IS_STATE="isState",t.IS_SLICE="isSlice",t))(T||{});function o(e){return r(e)?e:a(e)?e():e}export{T as StateKeys,o as getDefaultValue};

package/esm/use-state-value.js

@@ -0,0 +1 @@
+import{useSyncExternalStore as n,toType as S}from"./common";import{isPromise as i}from"./is";function m(e,r=t=>S(t),o){const t=n(e.__internal.emitter,a=>r(a),o);if(i(t))throw t;return t}export{m as useStateValue};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "muya",
+  "version": "1.0.1",
+  "author": "samuel.gjabel@gmail.com",
+  "description": "👀 Another React state management library",
+  "license": "MIT",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "react-native": "src/index.ts",
+  "types": "types/index.d.ts",
+  "homepage": "https://github.com/samuelgjabel/muya",
+  "repository": "https://github.com/samuelgjabel/muya",
+  "sideEffects": false,
+  "keywords": [
+    "react",
+    "react-hooks",
+    "react-native",
+    "state",
+    "management",
+    "library",
+    "muya",
+    "redux",
+    "zustand"
+  ],
+  "peerDependencies": {
+    "use-sync-external-store": ">=1.2.0",
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "use-sync-external-store": {
+      "optional": true
+    }
+  }
+}

package/src/common.ts

@@ -0,0 +1,28 @@
+import { useSyncExternalStoreWithSelector as useSync } from 'use-sync-external-store/shim/with-selector'
+import type { Emitter } from './create-emitter'
+import type { IsEqual } from './types'
+import { useDebugValue } from 'react'
+
+/**
+ * Todo need to remove this
+ */
+export function toType<T>(object?: unknown): T {
+  return object as T
+}
+
+export function useSyncExternalStore<T, S>(
+  emitter: Emitter<T>,
+  selector: (stateValue: T) => S,
+  isEqual?: IsEqual<S>,
+): undefined extends S ? T : S {
+  const value = useSync<T, S>(
+    emitter.subscribe,
+    emitter.getSnapshot,
+    emitter.getSnapshot,
+    selector ? (stateValue) => selector(stateValue) : toType,
+    isEqual,
+  ) as undefined extends S ? T : S
+
+  useDebugValue(value)
+  return value
+}

package/src/create-base-state.ts

@@ -0,0 +1,35 @@
+import type { Emitter } from './create-emitter'
+import { merge } from './merge'
+import { select } from './select'
+import type { BaseState, GetterState } from './types'
+
+interface Options<T> {
+  readonly emitter: Emitter<T>
+  readonly reset: () => void
+  readonly getState: () => T
+  readonly getGetterState: () => GetterState<T>
+}
+export function createBaseState<T>(options: Options<T>): BaseState<T> {
+  const { emitter, getGetterState, reset, getState } = options
+  return {
+    getState,
+    reset,
+    select(selector, isSame) {
+      const state = getGetterState()
+      return select(state, selector, isSame)
+    },
+    merge(state2, selector, isEqualHook) {
+      const state = getGetterState()
+      return merge(state, state2, selector, isEqualHook)
+    },
+    __internal: {
+      emitter,
+    },
+    subscribe(listener) {
+      listener(getState())
+      return emitter.subscribe(() => {
+        listener(getState())
+      })
+    },
+  }
+}

package/src/create-emitter.ts

@@ -0,0 +1,24 @@
+export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void
+export interface Emitter<T, R = T, P = undefined> {
+  subscribe: EmitterSubscribe<P>
+  getSnapshot: () => R
+  emit: (...params: P[]) => void
+}
+
+export function createEmitter<T, R = T, P = undefined>(getSnapshot: () => R): Emitter<T, R, P> {
+  const listeners = new Set<(...params: P[]) => void>()
+  return {
+    subscribe: (listener) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    emit: (...params) => {
+      for (const listener of listeners) {
+        listener(...params)
+      }
+    },
+    getSnapshot,
+  }
+}

package/src/create-getter-state.ts

@@ -0,0 +1,19 @@
+import type { BaseState, GetterState } from './types'
+import { useStateValue } from './use-state-value'
+
+interface Options<T> {
+  readonly baseState: BaseState<T>
+}
+export function createGetterState<T>(options: Options<T>): GetterState<T> {
+  const { baseState } = options
+  const useSliceState: GetterState<T> = (useSelector, isEqualHook) => {
+    return useStateValue(useSliceState, useSelector, isEqualHook)
+  }
+  useSliceState.__internal = baseState.__internal
+  useSliceState.getState = baseState.getState
+  useSliceState.reset = baseState.reset
+  useSliceState.select = baseState.select
+  useSliceState.merge = baseState.merge
+  useSliceState.subscribe = baseState.subscribe
+  return useSliceState
+}

package/src/create.ts

@@ -0,0 +1,102 @@
+import { createEmitter } from './create-emitter'
+import type { SetValue, SetterState, StateDataInternal, DefaultValue, GetterState, IsEqual, UpdateValue } from './types'
+import { getDefaultValue } from './types'
+import { isEqualBase, isObject, isPromise, isSetValueFunction } from './is'
+import { createBaseState } from './create-base-state'
+import { createGetterState } from './create-getter-state'
+
+/**
+ * Creates a basic atom state.
+ * @param defaultValue - The initial state value.
+ * @param options - Optional settings for the state (e.g., isEqual, onSet).
+ * @returns A state object that can be used as a hook and provides state management methods.
+ * @example
+ * ```typescript
+ * // Global scope
+ * const counterState = state(0);
+ * const userState = state({ name: 'John', age: 20 });
+ *
+ * // React component
+ * const counter = counterState(); // Use as a hook
+ * const user = userState();
+ *
+ * // Access partial data from the state using slice
+ * const userAge = userState.slice((state) => state.age)();
+ * ```
+ */
+
+export function create<T>(defaultValue: DefaultValue<T>, isEqual: IsEqual<T> = isEqualBase): SetterState<Awaited<T>> {
+  function resolveSetter(value: T, stateSetter: SetValue<T>): T {
+    if (isSetValueFunction(stateSetter)) {
+      return stateSetter(value)
+    }
+    return stateSetter
+  }
+
+  const stateData: StateDataInternal<T> = {
+    updateVersion: 0,
+    value: undefined,
+  }
+
+  function getValue(): T {
+    if (stateData.value === undefined) {
+      stateData.value = getDefaultValue(defaultValue)
+    }
+    return stateData.value
+  }
+  function get(): T {
+    const stateValue = getValue()
+    if (isPromise(stateValue)) {
+      stateValue.then((data) => {
+        stateData.value = data as Awaited<T>
+        emitter.emit()
+      })
+    }
+    return stateValue
+  }
+
+  function set(stateValue: SetValue<T>) {
+    const stateValueData = getValue()
+    const newState = resolveSetter(stateValueData, stateValue)
+    const isEqualResult = isEqual?.(stateValueData, newState)
+    if (isEqualResult || newState === stateValueData) {
+      return
+    }
+    stateData.updateVersion++
+    stateData.value = newState
+    emitter.emit()
+  }
+
+  function update(stateValue: UpdateValue<T>) {
+    if (isObject(stateValue)) {
+      return set((previousState) => {
+        return { ...previousState, ...stateValue }
+      })
+    }
+    set(stateValue as T)
+  }
+
+  const emitter = createEmitter<T>(get)
+
+  const baseState = createBaseState({
+    emitter,
+    getGetterState: () => setterState,
+    getState: get,
+    reset() {
+      const value = getDefaultValue(defaultValue)
+      if (isPromise(value)) {
+        value.then((data) => {
+          set(data as T)
+        })
+        return
+      }
+      set(value)
+    },
+  })
+
+  const getterState: GetterState<T> = createGetterState<T>({ baseState })
+  const setterState: SetterState<T> = getterState as SetterState<T>
+  setterState.setState = set
+  setterState.updateState = update
+  return setterState as SetterState<Awaited<T>>
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './types'
+export { create } from './create'
+export { select } from './select'
+export { merge } from './merge'
+export { useStateValue } from './use-state-value'
+export { shallow } from './shallow'

package/src/is.ts

@@ -0,0 +1,36 @@
+import type { Ref, Setter, SetValue } from './types'
+
+export function isPromise(value: unknown): value is Promise<unknown> {
+  return value instanceof Promise
+}
+export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
+  return typeof value === 'function'
+}
+export function isSetValueFunction<T>(value: SetValue<T>): value is Setter<T> {
+  return typeof value === 'function'
+}
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+export function isRef<T>(value: unknown): value is Ref<T> {
+  return isObject(value) && value.isRef === true
+}
+
+export function isMap(value: unknown): value is Map<unknown, unknown> {
+  return value instanceof Map
+}
+
+export function isSet(value: unknown): value is Set<unknown> {
+  return value instanceof Set
+}
+
+export function isArray(value: unknown): value is Array<unknown> {
+  return Array.isArray(value)
+}
+
+export function isEqualBase<T>(valueA: T, valueB: T): boolean {
+  if (valueA === valueB) {
+    return true
+  }
+  return !!Object.is(valueA, valueB)
+}

package/src/merge.ts

@@ -0,0 +1,41 @@
+import { createBaseState } from './create-base-state'
+import { createEmitter } from './create-emitter'
+import { createGetterState } from './create-getter-state'
+import { isEqualBase } from './is'
+import type { IsEqual, GetterState } from './types'
+
+export function merge<T1, T2, S>(
+  state1: GetterState<T1>,
+  state2: GetterState<T2>,
+  selector: (value1: T1, value2: T2) => S,
+  isEqual: IsEqual<S> = isEqualBase,
+): GetterState<S> {
+  let previousData: S | undefined
+  const emitter = createEmitter(() => {
+    const data = selector(state1.getState(), state2.getState())
+    if (previousData !== undefined && isEqual(previousData, data)) {
+      return previousData
+    }
+    previousData = data
+    return data
+  })
+  state1.__internal.emitter.subscribe(() => {
+    emitter.emit()
+  })
+  state2.__internal.emitter.subscribe(() => {
+    emitter.emit()
+  })
+
+  const baseState = createBaseState<S>({
+    emitter,
+    getGetterState: () => getterState,
+    getState: () => selector(state1.getState(), state2.getState()),
+    reset() {
+      state1.reset()
+      state2.reset()
+    },
+  })
+
+  const getterState: GetterState<S> = createGetterState<S>({ baseState })
+  return getterState
+}

package/src/select.ts

@@ -0,0 +1,33 @@
+import { createBaseState } from './create-base-state'
+import { createEmitter } from './create-emitter'
+import { createGetterState } from './create-getter-state'
+import { isEqualBase } from './is'
+import type { IsEqual, GetterState } from './types'
+
+export function select<T, S>(
+  state: GetterState<T>,
+  selector: (value: T) => S,
+  isEqual: IsEqual<S> = isEqualBase,
+): GetterState<S> {
+  let previousData: S | undefined
+  const emitter = createEmitter(() => {
+    const data = selector(state.getState())
+    if (previousData !== undefined && isEqual(previousData, data)) {
+      return previousData
+    }
+    previousData = data
+    return data
+  })
+  state.__internal.emitter.subscribe(() => {
+    emitter.emit()
+  })
+
+  const baseState = createBaseState<S>({
+    emitter,
+    getGetterState: () => getterState,
+    getState: () => selector(state.getState()),
+    reset: state.reset,
+  })
+  const getterState: GetterState<S> = createGetterState<S>({ baseState })
+  return getterState
+}