zustand-mutable 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Danilo Britto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# zustand-mutable
+
+[![npm version](https://img.shields.io/npm/v/zustand-mutable.svg)](https://www.npmjs.com/package/zustand-mutable)
+[![test](https://github.com/zustandjs/zustand-mutable/actions/workflows/test.yml/badge.svg)](https://github.com/zustandjs/zustand-mutable/actions/workflows/test.yml)
+[![license](https://img.shields.io/npm/l/zustand-mutable.svg)](https://github.com/zustandjs/zustand-mutable/blob/main/LICENSE)
+
+A sweet way to use immer-like mutable updates with Zustand.
+
+## Introduction
+
+Zustand's immutable state updates can become verbose when dealing with deeply nested state. This middleware lets you write state updates using a mutable API pattern, similar to Immer's draft pattern.
+
+**Key benefit:** You choose your own produce function - use [Immer](https://github.com/immerjs/immer), [Mutative](https://github.com/unadlib/mutative), [Limu](https://github.com/tnfe/limu), or any library that follows the produce pattern.
+
+## Installation
+
+```bash
+npm install zustand-mutable zustand
+
+# Plus your preferred produce library (pick one):
+npm install immer      # Most popular
+npm install mutative   # Faster alternative
+npm install limu       # Another option
+```
+
+## Quick Start
+
+```typescript
+import { create } from 'zustand'
+import { mutable } from 'zustand-mutable'
+import { produce } from 'immer'
+
+type CounterState = {
+  count: number
+  inc: () => void
+}
+
+const useStore = create<CounterState>()(
+  mutable(
+    (set, get) => ({
+      count: 0,
+      inc: () =>
+        set((state) => {
+          state.count = get().count + 1 // Mutate directly!
+        }),
+    }),
+    produce,
+  ),
+)
+```
+
+## API Reference
+
+### `mutable(initializer, produceFn)`
+
+Wraps your Zustand store initializer to enable mutable-style updates.
+
+| Parameter     | Type                                              | Description                                 |
+| ------------- | ------------------------------------------------- | ------------------------------------------- |
+| `initializer` | `StateCreator<T>`                                 | Your standard Zustand store initializer     |
+| `produceFn`   | `(recipe: (state: T) => void) => (state: T) => T` | A produce function from your chosen library |
+
+## Supported Libraries
+
+### Immer
+
+The most popular immutable state library.
+
+```typescript
+import { produce } from 'immer'
+
+const useStore = create<State>()(
+  mutable(
+    (set, get) => ({
+      // your state and actions
+    }),
+    produce,
+  ),
+)
+```
+
+### Mutative
+
+A faster alternative to Immer with similar API.
+
+```typescript
+import { create as mutativeProduce } from 'mutative'
+
+const useStore = create<State>()(
+  mutable(
+    (set, get) => ({
+      // your state and actions
+    }),
+    mutativeProduce,
+  ),
+)
+```
+
+### Limu
+
+Another immutable update library. Requires a wrapper function.
+
+```typescript
+import { produce } from 'limu'
+
+const useStore = create<State>()(
+  mutable(
+    (set, get) => ({
+      // your state and actions
+    }),
+    (recipe) => produce(recipe),
+  ),
+)
+```
+
+## Middleware Composition
+
+`zustand-mutable` works seamlessly with other Zustand middleware.
+
+### With devtools
+
+```typescript
+import { devtools } from 'zustand/middleware'
+
+const useStore = create<CounterState>()(
+  mutable(
+    devtools(
+      (set, get) => ({
+        count: 0,
+        inc: () =>
+          set(
+            (state) => {
+              state.count = get().count + 1
+            },
+            false,
+            { type: 'inc', by: 1 },
+          ),
+      }),
+      { name: 'counter' },
+    ),
+    produce,
+  ),
+)
+```
+
+### With persist
+
+```typescript
+import { persist } from 'zustand/middleware'
+
+const useStore = create<CounterState>()(
+  persist(
+    mutable(
+      (set, get) => ({
+        count: 0,
+        inc: () =>
+          set((state) => {
+            state.count = get().count + 1
+          }),
+      }),
+      produce,
+    ),
+    { name: 'counter-storage' },
+  ),
+)
+```
+
+### Combining Multiple Middleware
+
+You can stack multiple middleware together:
+
+```typescript
+import { devtools, persist, subscribeWithSelector } from 'zustand/middleware'
+
+const useStore = create<CounterState>()(
+  devtools(
+    subscribeWithSelector(
+      persist(
+        mutable(
+          (set, get) => ({
+            count: 0,
+            inc: () =>
+              set((state) => {
+                state.count = get().count + 1
+              }),
+          }),
+          produce,
+        ),
+        { name: 'counter' },
+      ),
+    ),
+    { name: 'counter-devtools' },
+  ),
+)
+```
+
+## TypeScript
+
+This library is written in TypeScript and provides full type safety out of the box.
+
+- The `Draft<T>` type automatically makes your state mutable inside updater functions
+- Proper type inference is maintained through middleware composition
+- Works with strict TypeScript configurations
+
+```typescript
+set((state) => {
+  // `state` is typed as Draft<YourState>
+  // You can mutate it directly with full type safety
+  state.nested.deeply.value = 'new value'
+})
+```
+
+## Requirements
+
+- `zustand` >= 5.0.9 (peer dependency)
+- One of: `immer`, `mutative`, or `limu`
+
+## License
+
+MIT

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "zustand-mutable",
+  "version": "0.1.1",
   "private": false,
   "description": "A sweet way to use immer-like mutable updates",
-  "version": "0.1.0",
   "author": "Danilo Britto",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zustandjs/zustand-mutable.git"
   },
-  "type": "module",
   "source": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.umd.cjs",
   "module": "./dist/index.js",
   "exports": {
@@ -18,12 +22,10 @@
       "require": "./dist/index.umd.cjs"
     }
   },
-  "sideEffects": false,
-  "files": [
-    "dist"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "@biomejs/biome": "2.3.10",
     "@ossjs/release": "^0.10.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.1",
@@ -33,6 +35,9 @@
     "immer": "^11.1.3",
     "limu": "^4.1.1",
     "mutative": "^1.3.0",
+    "oxfmt": "^0.21.0",
+    "oxlint": "^1.36.0",
+    "prettier": "3.7.4",
     "react": "^19.2.3",
     "typescript": "~5.9.3",
     "vite": "npm:rolldown-vite@7.2.5",
@@ -43,14 +48,12 @@
   "peerDependencies": {
     "zustand": "^5.0.9"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
     "build": "vite build",
     "test": "pnpm run \"/^test:.*/\"",
     "test:types": "tsc --noEmit",
-    "test:lintFormat": "biome check ./src",
+    "test:lint": "oxlint",
+    "test:fmt": "oxfmt --check",
     "test:spec": "vitest run",
     "release": "release publish"
   }