reazor-react 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Delpi.Kye
+
+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,582 @@
+# ⚛️⚡ reazor-react
+
+[![NPM](https://img.shields.io/npm/v/reazor-react.svg)](https://www.npmjs.com/package/reazor-react)
+![Downloads](https://img.shields.io/npm/dt/reazor-react.svg)
+
+<a href="https://codesandbox.io/p/sandbox/85f9pd" target="_blank">LIVE EXAMPLE</a>
+
+`reazor-react` brings Solid-style fine-grained reactivity to React 18+.
+
+It provides:
+
+* Deep Proxy-based reactivity
+* Path-level rendering updates
+* Sync computed (derived) values
+* Batched updates
+* Path-based & auto-tracked effects
+* Map / Set / Array support
+* Fully type-safe inference
+* Concurrent-safe React binding
+
+> Fine-grained reactive state without atoms or reducers.
+
+---
+
+## ✨ Why reazor-react?
+
+Unlike reducer or atom-based stores, `reazor-react`:
+
+✅ Mutates state directly  
+✅ Tracks property access automatically  
+✅ Re-renders only components that access changed paths  
+✅ Supports deeply nested Map / Set / Array  
+✅ Supports sync computed  
+✅ Works in React 18 concurrent mode  
+✅ Batches updates to reduce redundant renders  
+
+No boilerplate. No selectors required. No atoms.
+
+---
+
+## 🧠 Mental Model
+
+```txt
+Component render
+        ↓
+Proxy tracks accessed paths
+        ↓
+Mutation triggers exact listeners
+        ↓
+Computed values updated
+        ↓
+Only affected components re-render
+```
+
+Core principle:
+
+> Property access defines dependency automatically.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install reazor-react
+```
+
+---
+
+## 🚀 Quick Start
+
+```ts
+import { createReactive } from "reazor-react"
+
+const counter = createReactive({
+  count: 0,
+  todos: []
+})
+
+// define computed
+counter.computed("double", s => s.count * 2, {
+  cache: true
+})
+```
+
+### React Usage
+
+```tsx
+function Counter() {
+  const state = counter.use()
+
+  return (
+    <div>
+      <h2>{state.count}</h2>
+      <button onClick={() => state.count++}>+</button>
+    </div>
+  )
+}
+```
+
+✔ No dispatch  
+✔ No reducer  
+✔ No setState  
+✔ Direct mutation  
+
+---
+
+## 🎯 useSelector (Ultra Fine-Grained Rendering)
+
+```tsx
+function CountOnly() {
+  const count = counter.useSelector(s => s.count)
+  return <h2>{count}</h2>
+}
+```
+
+✔ Only re-renders when `count` changes  
+✔ Does NOT re-render on unrelated state changes  
+✔ No selector memo needed  
+✔ Auto dependency tracking  
+
+---
+
+## 🎯 useComputed (Ultra Fine-Grained Rendering for Computed)
+
+```tsx
+function Double() {
+  const double = counter.useComputed(s => s.double)
+  return <h2>{double}</h2>
+}
+```
+
+✔ Only re-renders when dependencies of double change
+✔ Does NOT re-render on unrelated state changes
+✔ No memo required
+✔ Uses computed dependency graph
+✔ Supports nested computed
+
+---
+
+# 🧩 Examples
+
+## 1️⃣ Fine-Grained Multiple Components
+
+```ts
+const store = createReactive({
+  count: 0,
+  name: "Vu"
+})
+```
+
+```tsx
+function CountView() {
+  const state = store.use()
+  return <h2>{state.count}</h2>
+}
+
+function NameView() {
+  const state = store.use()
+  return <h2>{state.name}</h2>
+}
+
+function Controls() {
+  const state = store.use()
+  return (
+    <>
+      <button onClick={() => state.count++}>+</button>
+      <button onClick={() => (state.name = "Tung")}>Rename</button>
+    </>
+  )
+}
+```
+
+Changing `count` does NOT re-render `NameView`.
+
+Changing `name` does NOT re-render `CountView`.
+
+---
+
+## 2️⃣ Deep Nested Reactivity
+
+```ts
+const store = createReactive({
+  user: {
+    profile: {
+      name: "Vu",
+      age: 28
+    }
+  }
+})
+```
+
+```tsx
+function Profile() {
+  const state = store.use()
+
+  return (
+    <div>
+      <h3>{state.user.profile.name}</h3>
+      <button onClick={() => state.user.profile.age++}>
+        Age++
+      </button>
+    </div>
+  )
+}
+```
+
+Only components accessing `user.profile.age` re-render.
+
+---
+
+## 3️⃣ Map / Set Support
+
+```ts
+const store = createReactive({
+  settings: new Map([["theme", "light"]]),
+  tags: new Set(["react"])
+})
+```
+
+```tsx
+function ThemeToggle() {
+  const state = store.use()
+  const theme = state.settings.get("theme")
+
+  return (
+    <button
+      onClick={() =>
+        state.settings.set(
+          "theme",
+          theme === "light" ? "dark" : "light"
+        )
+      }
+    >
+      Theme: {theme}
+    </button>
+  )
+}
+```
+
+Mutating `Map` or `Set` triggers exact listeners.
+
+---
+
+## 4️⃣ Transaction (Batch Multiple Mutations)
+
+```ts
+store.transaction(() => {
+  store.state.count++
+  store.state.count++
+  store.state.count++
+})
+```
+
+Only ONE render triggered.
+
+Perfect for:
+
+* Form updates
+* Bulk mutations
+* Async merges
+
+---
+
+## 5️⃣ Computed (Sync)
+
+```ts
+const store = createReactive({
+  price: 10,
+  quantity: 2
+})
+
+store.computed("total", (s) => s.price * s.quantity, {
+  cache: true
+})
+```
+
+```tsx
+function Total() {
+  const state = store.use()
+  return <h3>Total: {state.total}</h3>
+}
+```
+
+✔ Recomputed only when dependencies change  
+✔ Supports nested computed  
+✔ Topological scheduling  
+✔ No stale reads  
+
+---
+
+### Dynamic Dependency Tracking
+
+```ts
+store.computed("displayName", (s) => {
+  return s.user.loggedIn
+    ? s.user.profile.name
+    : "Guest"
+}, { cache: true })
+```
+
+Behavior:
+
+- Initially tracks `user.loggedIn`
+- If `loggedIn` becomes true → also tracks `user.profile.name`
+- If `loggedIn` becomes false → removes profile dependency
+
+---
+
+### Nested Computed Graph
+
+```ts
+store.computed("subtotal", s => s.price * s.qty, { cache: true })
+store.computed("tax", s => s.subtotal * 0.1, { cache: true })
+store.computed("total", s => s.subtotal + s.tax, { cache: true })
+```
+
+Execution order:
+
+```
+price/qty change
+   ↓
+subtotal recomputed
+   ↓
+tax recomputed
+   ↓
+total recomputed
+```
+
+---
+
+## 6️⃣ Effects
+
+Two types:
+
+- **Path-based effects**
+- **Auto-tracked effects**
+
+---
+
+### Path-Based Effect
+
+```ts
+store.effect("count", (newValue, oldValue) => {
+  console.log("Count changed:", oldValue, "→", newValue)
+})
+```
+
+Supports deep paths:
+
+```ts
+store.effect("todos.0.done", (newValue, oldValue) => {
+  console.log("Todo #0 changed:", oldValue, "→", newValue)
+})
+```
+
+Best for:
+
+- Logging
+- Analytics
+- Watching specific field
+
+---
+
+### Auto Effect (Fine-Grained)
+
+```ts
+store.autoEffect(() => {
+  console.log("Count is:", store.state.count)
+})
+```
+
+Automatically tracks dependencies accessed during execution.
+
+---
+
+### Dynamic Dependencies
+
+```ts
+store.autoEffect(() => {
+  if (store.state.user.loggedIn) {
+    console.log(store.state.user.profile.name)
+  }
+})
+```
+
+Dependencies adjust automatically when conditions change.
+
+---
+
+### Cleanup Support
+
+```ts
+store.autoEffect(() => {
+  const id = setInterval(() => {
+    console.log(store.state.count)
+  }, 1000)
+
+  return () => clearInterval(id)
+})
+```
+
+Previous cleanup runs before re-execution.
+
+---
+
+### Infinite Loop Protection
+
+```ts
+store.autoEffect(() => {
+  if (store.state.count < 5) {
+    store.state.count++
+  }
+})
+```
+
+Scheduler prevents runaway recursion.
+
+---
+
+## 7️⃣ Large List Performance
+
+```ts
+const store = createReactive({
+  items: Array.from({ length: 1000 }, (_, i) => ({
+    id: i,
+    done: false
+  }))
+})
+```
+
+```tsx
+function List() {
+  const state = store.use()
+
+  return (
+    <ul>
+      {state.items.map(item => (
+        <Item key={item.id} item={item} />
+      ))}
+    </ul>
+  )
+}
+```
+
+Only modified item re-renders.
+
+---
+
+# 🧠 Advanced Internals
+
+### Dependency Graph
+- Computed tracks exact dependencies
+- Nested computed supported
+- Minimal invalidation graph
+
+### Batched Updates
+- All mutations inside same tick batched
+- Transaction API supported
+- Prevents render thrashing
+
+---
+
+# 🔍 Comparison
+
+| Criteria                       | ⚡ reazor-react   | 🧰 Redux Toolkit | 🐻 Zustand | 🧠 MobX |
+| ------------------------------ | ---------------- | ----------------| ---------- | ------- |
+| Fine-grained rendering         | ✅               | ❌               | ❌         | ✅      |
+| Direct mutation                | ✅               | ❌               | ✅         | ✅      |
+| Deep Map / Set support         | ✅               | ❌               | ❌         | ⚠️      |
+| React 18 concurrent-safe       | ✅               | ✅               | ✅         | ⚠️      |
+| Automatic batching             | ✅               | ❌               | ⚠️         | ⚠️      |
+| Reducer-free                   | ✅               | ❌               | ✅         | ❌      |
+
+---
+
+# 🖼 Reactive Flow Diagram
+
+```txt
+┌─────────────┐
+│ Component   │
+│ Render      │
+└─────┬───────┘
+      │ Access paths
+      ▼
+┌─────────────┐
+│ Proxy       │
+│ Tracks deps │
+└─────┬───────┘
+      │ Mutate
+      ▼
+┌─────────────┐
+│ Computed    │
+│ Sync        │
+└─────┬───────┘
+      │ Batched triggers
+      ▼
+┌─────────────┐
+│ Listener    │
+│ Re-render   │
+└─────────────┘
+```
+
+---
+
+# 🧪 Testing
+
+You can test:
+
+* Direct mutations
+* Computed derivations
+* Transaction batching
+* Nested structures
+* Map / Set behavior
+* Effects
+
+All without mocking React.
+
+## Basic Reactivity
+
+```ts
+import { createReactive } from "reazor-react"
+
+const store = createReactive({ count: 0 })
+
+store.state.count++
+
+expect(store.state.count).toBe(1)
+```
+
+---
+
+## Computed
+
+```ts
+const store = createReactive({
+  price: 10,
+  qty: 2
+})
+
+store.computed("total", s => s.price * s.qty, { cache: true })
+
+expect(store.state.total).toBe(20)
+
+store.state.qty = 3
+
+expect(store.state.total).toBe(30)
+```
+
+---
+
+## Transaction
+
+```ts
+store.transaction(() => {
+  store.state.count++
+  store.state.count++
+})
+
+expect(store.state.count).toBe(2)
+```
+
+---
+
+## Effect
+
+```ts
+let triggered = false
+
+store.effect("count", () => {
+  triggered = true
+})
+
+store.state.count++
+
+expect(triggered).toBe(true)
+```
+
+---
+
+# 📜 License
+
+MIT

package/build/core/batch.d.ts

@@ -0,0 +1,7 @@
+import type { Listener } from "../reaxor/types";
+export declare function createBatch(): {
+    add: (path: string) => void;
+    schedule: (notify: (key: string) => void) => void;
+    transaction: (fn: Listener, notify: (key: string) => void) => void;
+    getVersion: () => number;
+};

package/build/core/effectRuntime.d.ts

@@ -0,0 +1,7 @@
+import type { EffectOptions, ListenerManager } from "../reaxor";
+type EffectFn = () => void | (() => void);
+export declare function createEffectRuntime(listeners: ListenerManager): {
+    effect: (fn: EffectFn, options?: EffectOptions) => () => void;
+    batch: (fn: () => void) => void;
+};
+export {};

package/build/core/effects.d.ts

@@ -0,0 +1,5 @@
+import type { EffectFn } from "../reaxor";
+export declare function createEffects(): {
+    register: (path: string, fn: EffectFn) => () => void;
+    run: (path: string, newValue: any, oldValue: any) => void;
+};

package/build/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./batch";
+export * from "./effectRuntime";
+export * from "./effects";
+export * from "./listeners";
+export * from "./proxy";
+export * from "./tracking";

package/build/core/listeners.d.ts

@@ -0,0 +1,2 @@
+import type { ListenerManager } from "../reaxor";
+export declare function createListeners(): ListenerManager;

package/build/core/proxy.d.ts

@@ -0,0 +1,4 @@
+import type { ReactiveProxy, ProxyOptions } from "../reaxor";
+export declare function createProxy<T extends object>(options: ProxyOptions<T>): {
+    rootProxy: ReactiveProxy<T>;
+};

package/build/core/tracking.d.ts

@@ -0,0 +1,3 @@
+export declare function startTracking(): Set<string>;
+export declare function stopTracking(): void;
+export declare function track(path: string): void;

package/build/index.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("react");function t(){const e=new Set;let t=!1,n=0,r=!1,o=!1;function c(r){n++;for(const t of e)r(t);e.clear(),t=!1}return{add:function(t){e.add(t),e.add("__root__")},schedule:function(e){r?o=!0:t||(t=!0,queueMicrotask(()=>c(e)))},transaction:function(e,t){r=!0,e(),r=!1,o&&(o=!1,c(t))},getVersion:()=>n}}let n=null;function r(){return n=new Set,n}function o(){n=null}function c(e){n&&n.add(e)}function u(e){const t=new Set;let n=!1,c=0;function u(){n||(n=!0,queueMicrotask(s))}function s(){for(;t.size;){const e=Array.from(t).sort(i);t.clear();for(const t of e)f(t)}n=!1}function i(e,t){return e.depth!==t.depth?e.depth-t.depth:e.priority-t.priority}function f(t){if(t.disposed)return;if(t.running)return;if(t.runCount>100)return;t.runCount++,t.running=!0,t.deps.forEach(n=>{e.remove(n,t.scheduler)}),t.cleanup&&(t.cleanup(),t.cleanup=void 0);const n=r(),c=t.fn();o(),t.deps=n,t.deps.forEach(n=>{e.add(n,t.scheduler)}),"function"==typeof c&&(t.cleanup=c),t.running=!1}return{effect:function(r,o){const s={fn:r,deps:new Set,depth:o?.depth??100,priority:o?.priority??10,running:!1,runCount:0,disposed:!1,scheduler:()=>function(e){e.disposed||(e.sync?f(e):(t.add(e),n||0!==c||u()))}(s),sync:o?.sync??!1};return f(s),()=>{s.disposed||(s.disposed=!0,s.deps.forEach(t=>{e.remove(t,s.scheduler)}),s.cleanup&&s.cleanup(),s.deps.clear())}},batch:function(e){c++;try{e()}finally{c--,0===c&&u()}}}}function s(){const e=new Map;return{register:function(t,n){let r=e.get(t);return r||(r=new Set,e.set(t,r)),r.add(n),()=>{const r=e.get(t);r&&(r.delete(n),0===r.size&&e.delete(t))}},run:function(t,n,r){const o=e.get(t);o&&[...o].forEach(e=>e(n,r,t))}}}function i(){const e=new Map;return{add:function(t,n){let r=e.get(t);r||(r=new Set,e.set(t,r)),r.add(n)},remove:function(t,n){e.get(t)?.delete(n)},notify:function(t){e.get(t)?.forEach(e=>e())}}}function f(e){return"symbol"!=typeof e&&("__proto__"!==e&&"constructor"!==e)}function a(e){const{root:t,listeners:n,batch:r,effects:o,computed:u}=e,s=new WeakMap;function i(e,t,c){r.add(e),r.schedule(n.notify),o.run(e,c,t),u.invalidateComputed(e,e=>{r.add(e)})}const a=function e(t,n,r=""){if("object"!=typeof(o=t)||null===o)return t;var o;if(s.has(t))return s.get(t);const d=new Proxy(t,{get(t,o,s){if(!f(o))return Reflect.get(t,o,s);const d=r?`${r}.${o+""}`:o+"";if(""===r&&"string"==typeof o&&u.computedMap.has(o)){const e=u.computedMap.get(o);return u.evaluateComputed(e,a)}u.trackDependency(d),c(d);const p=Reflect.get(t,o,s);if(Array.isArray(t)&&"function"==typeof p){if(["push","pop","splice","shift","unshift","sort","reverse"].includes(o))return(...e)=>{const n=t.slice(),o=p.apply(t,e);return i(r,n,t),o}}return e(p,n,d)},set(e,t,n,o){if(!f(t))return Reflect.set(e,t,n,o);const c=r?`${r}.${t+""}`:t+"",u=e[t];if(Object.is(u,n))return!0;const s=Reflect.set(e,t,n,o);return i(c,u,n),s}});return s.set(t,d),d}(t);return{rootProxy:a}}function d(t,n,r){const o="__root__";function c(e){return n.add(o,e),()=>n.remove(o,e)}function u(n){const r=e.useRef();return e.useSyncExternalStore(c,()=>{const e=n(t);return Object.is(r.current,e)?r.current:(r.current=e,e)},()=>n(t))}return{useReactive:function(){return e.useSyncExternalStore(c,r,r),t},useSelector:u,useComputed:function(e){return u(e)}}}function p(){const e=new Map,t=new Map;let n=null;function r(e,t){n=e;const r=e.getter(t);return n=null,r}return{computedMap:e,register:function(t,n,r){if(e.has(t))throw Error(`Computed key "${t}" already exists`);const o={key:t,getter:n,cache:r?.cache??!1,value:void 0,dirty:!0,deps:new Set};e.set(t,o)},trackDependency:function(e){if(!n)return;n.deps.add(e);let r=t.get(e);r||(r=new Set,t.set(e,r)),r.add(n)},invalidateComputed:function(e,n){const r=t.get(e);if(r)for(const e of r)e.cache&&(e.dirty=!0),n(e.key)},evaluateComputed:function(e,n){if(!e.cache)return r(e,n);if(!e.dirty)return e.value;e.deps.forEach(n=>{t.get(n)?.delete(e)}),e.deps.clear();const o=r(e,n);return e.value=o,e.dirty=!1,e.value}}}exports.createBatch=t,exports.createComputed=p,exports.createEffectRuntime=u,exports.createEffects=s,exports.createListeners=i,exports.createProxy=a,exports.createReactHooks=d,exports.createReactive=function(e){const n=i(),r=t(),o=s(),c=p(),{rootProxy:f}=a({root:e,listeners:n,batch:r,effects:o,computed:c}),{useReactive:l,useSelector:y}=d(f,n,r.getVersion),h=u(n);return{state:f,use:l,useSelector:y,effect:o.register,autoEffect:h.effect,computed:c.register,transaction:e=>r.transaction(e,n.notify),getVersion:r.getVersion}},exports.startTracking=r,exports.stopTracking=o,exports.track=c;

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core";
+export * from "./react";
+export * from "./reaxor";

package/build/index.esm.js

@@ -0,0 +1 @@
+import{useRef as e,useSyncExternalStore as t}from"react";function n(){const e=new Set;let t=!1,n=0,r=!1,o=!1;function c(r){n++;for(const t of e)r(t);e.clear(),t=!1}return{add:function(t){e.add(t),e.add("__root__")},schedule:function(e){r?o=!0:t||(t=!0,queueMicrotask(()=>c(e)))},transaction:function(e,t){r=!0,e(),r=!1,o&&(o=!1,c(t))},getVersion:()=>n}}let r=null;function o(){return r=new Set,r}function c(){r=null}function u(e){r&&r.add(e)}function i(e){const t=new Set;let n=!1,r=0;function u(){n||(n=!0,queueMicrotask(i))}function i(){for(;t.size;){const e=Array.from(t).sort(s);t.clear();for(const t of e)f(t)}n=!1}function s(e,t){return e.depth!==t.depth?e.depth-t.depth:e.priority-t.priority}function f(t){if(t.disposed)return;if(t.running)return;if(t.runCount>100)return;t.runCount++,t.running=!0,t.deps.forEach(n=>{e.remove(n,t.scheduler)}),t.cleanup&&(t.cleanup(),t.cleanup=void 0);const n=o(),r=t.fn();c(),t.deps=n,t.deps.forEach(n=>{e.add(n,t.scheduler)}),"function"==typeof r&&(t.cleanup=r),t.running=!1}return{effect:function(o,c){const i={fn:o,deps:new Set,depth:c?.depth??100,priority:c?.priority??10,running:!1,runCount:0,disposed:!1,scheduler:()=>function(e){e.disposed||(e.sync?f(e):(t.add(e),n||0!==r||u()))}(i),sync:c?.sync??!1};return f(i),()=>{i.disposed||(i.disposed=!0,i.deps.forEach(t=>{e.remove(t,i.scheduler)}),i.cleanup&&i.cleanup(),i.deps.clear())}},batch:function(e){r++;try{e()}finally{r--,0===r&&u()}}}}function s(){const e=new Map;return{register:function(t,n){let r=e.get(t);return r||(r=new Set,e.set(t,r)),r.add(n),()=>{const r=e.get(t);r&&(r.delete(n),0===r.size&&e.delete(t))}},run:function(t,n,r){const o=e.get(t);o&&[...o].forEach(e=>e(n,r,t))}}}function f(){const e=new Map;return{add:function(t,n){let r=e.get(t);r||(r=new Set,e.set(t,r)),r.add(n)},remove:function(t,n){e.get(t)?.delete(n)},notify:function(t){e.get(t)?.forEach(e=>e())}}}function d(e){return"symbol"!=typeof e&&("__proto__"!==e&&"constructor"!==e)}function a(e){const{root:t,listeners:n,batch:r,effects:o,computed:c}=e,i=new WeakMap;function s(e,t,u){r.add(e),r.schedule(n.notify),o.run(e,u,t),c.invalidateComputed(e,e=>{r.add(e)})}const f=function e(t,n,r=""){if("object"!=typeof(o=t)||null===o)return t;var o;if(i.has(t))return i.get(t);const a=new Proxy(t,{get(t,o,i){if(!d(o))return Reflect.get(t,o,i);const a=r?`${r}.${o+""}`:o+"";if(""===r&&"string"==typeof o&&c.computedMap.has(o)){const e=c.computedMap.get(o);return c.evaluateComputed(e,f)}c.trackDependency(a),u(a);const p=Reflect.get(t,o,i);if(Array.isArray(t)&&"function"==typeof p){if(["push","pop","splice","shift","unshift","sort","reverse"].includes(o))return(...e)=>{const n=t.slice(),o=p.apply(t,e);return s(r,n,t),o}}return e(p,n,a)},set(e,t,n,o){if(!d(t))return Reflect.set(e,t,n,o);const c=r?`${r}.${t+""}`:t+"",u=e[t];if(Object.is(u,n))return!0;const i=Reflect.set(e,t,n,o);return s(c,u,n),i}});return i.set(t,a),a}(t);return{rootProxy:f}}function p(n,r,o){const c="__root__";function u(e){return r.add(c,e),()=>r.remove(c,e)}function i(r){const o=e();return t(u,()=>{const e=r(n);return Object.is(o.current,e)?o.current:(o.current=e,e)},()=>r(n))}return{useReactive:function(){return t(u,o,o),n},useSelector:i,useComputed:function(e){return i(e)}}}function l(){const e=new Map,t=new Map;let n=null;function r(e,t){n=e;const r=e.getter(t);return n=null,r}return{computedMap:e,register:function(t,n,r){if(e.has(t))throw Error(`Computed key "${t}" already exists`);const o={key:t,getter:n,cache:r?.cache??!1,value:void 0,dirty:!0,deps:new Set};e.set(t,o)},trackDependency:function(e){if(!n)return;n.deps.add(e);let r=t.get(e);r||(r=new Set,t.set(e,r)),r.add(n)},invalidateComputed:function(e,n){const r=t.get(e);if(r)for(const e of r)e.cache&&(e.dirty=!0),n(e.key)},evaluateComputed:function(e,n){if(!e.cache)return r(e,n);if(!e.dirty)return e.value;e.deps.forEach(n=>{t.get(n)?.delete(e)}),e.deps.clear();const o=r(e,n);return e.value=o,e.dirty=!1,e.value}}}function y(e){const t=f(),r=n(),o=s(),c=l(),{rootProxy:u}=a({root:e,listeners:t,batch:r,effects:o,computed:c}),{useReactive:d,useSelector:y}=p(u,t,r.getVersion),h=i(t);return{state:u,use:d,useSelector:y,effect:o.register,autoEffect:h.effect,computed:c.register,transaction:e=>r.transaction(e,t.notify),getVersion:r.getVersion}}export{n as createBatch,l as createComputed,i as createEffectRuntime,s as createEffects,f as createListeners,a as createProxy,p as createReactHooks,y as createReactive,o as startTracking,c as stopTracking,u as track};

package/build/react/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { ListenerManager } from "../reaxor/types";
+export declare function createReactHooks<T>(rootProxy: T, listeners: ListenerManager, getVersion: () => number): {
+    useReactive: () => T;
+    useSelector: <R>(selector: (state: T) => R) => R;
+    useComputed: <R>(compute: (state: T) => R) => R;
+};

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from "./hooks";

package/build/reaxor/computed.d.ts

@@ -0,0 +1,8 @@
+import type { ComputedNode, ComputedOptions, ReactiveProxy } from "./types";
+export declare function createComputed<T extends object>(): {
+    computedMap: Map<string, ComputedNode>;
+    register: (key: string, getter: (state: ReactiveProxy<T>) => any, options?: ComputedOptions) => void;
+    trackDependency: (path: string) => void;
+    invalidateComputed: (path: string, trigger: (path: string) => void) => void;
+    evaluateComputed: (node: ComputedNode, state: ReactiveProxy<T>) => any;
+};

package/build/reaxor/createReactive.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "./types";
+export declare function createReactive<T extends object>(state: T): Store<T>;

package/build/reaxor/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./computed";
+export * from "./createReactive";
+export * from "./types";

package/build/reaxor/types.d.ts

@@ -0,0 +1,73 @@
+export type Listener = () => void;
+export type EffectFn<T = any> = (newValue: T, oldValue: T, path: string) => void;
+export type EffectOptions = {
+    priority?: number;
+    depth?: number;
+    sync?: boolean;
+};
+export type ReactiveProxy<T> = T extends Array<infer U> ? ReactiveProxyArray<U> : T extends Map<infer K, infer V> ? ReactiveProxyMap<K, V> : T extends Set<infer U> ? ReactiveProxySet<U> : T extends object ? {
+    [K in keyof T]: ReactiveProxy<T[K]>;
+} : T;
+export interface ReactiveProxyArray<T> extends Array<ReactiveProxy<T>> {
+}
+export interface ReactiveProxyMap<K, V> extends Map<K, ReactiveProxy<V>> {
+}
+export interface ReactiveProxySet<T> extends Set<ReactiveProxy<T>> {
+}
+export type ComputedOptions = {
+    cache?: boolean;
+    async?: boolean;
+};
+export type ComputedNode<T = any> = {
+    key: string;
+    getter: (state: any) => T;
+    cache: boolean;
+    value: T;
+    dirty: boolean;
+    deps: Set<string>;
+};
+export interface ListenerManager {
+    add(path: string, listener: Listener): void;
+    remove(path: string, listener: Listener): void;
+    notify(path: string): void;
+}
+export interface BatchManager {
+    add(path: string): void;
+    schedule(notify: (path: string) => void): void;
+    transaction(fn: Listener, notify: (path: string) => void): void;
+    getVersion(): number;
+}
+export interface EffectManager {
+    register(path: string, fn: EffectFn): void;
+    run(path: string, newValue: any, oldValue: any): void;
+}
+export interface ComputedManager<T extends object> {
+    computedMap: Map<string, ComputedNode>;
+    register(key: string, getter: (state: ReactiveProxy<T>) => any, options?: ComputedOptions): void;
+    trackDependency(path: string): void;
+    invalidateComputed(path: string, trigger: (path: string) => void): void;
+    evaluateComputed(node: ComputedNode, state: ReactiveProxy<T>): any;
+}
+export interface ProxyOptions<T extends object> {
+    root: T;
+    listeners: ListenerManager;
+    batch: BatchManager;
+    effects: EffectManager;
+    computed: ComputedManager<T>;
+}
+export type Selector<T, R> = (state: T) => R;
+export interface Store<T extends object> {
+    state: ReactiveProxy<T>;
+    use(): ReactiveProxy<T>;
+    useSelector<R>(selector: (state: ReactiveProxy<T>) => R): R;
+    computed<K extends string, V>(key: K, getter: (state: ReactiveProxy<T>) => V, options?: {
+        cache?: boolean;
+    }): void;
+    effect<K extends keyof T & string>(key: K, callback: (newVal: T[K], oldVal: T[K]) => void): Listener;
+    autoEffect(fn: Listener, options?: {
+        priority?: number;
+        depth?: number;
+    }): Listener;
+    transaction(fn: Listener): void;
+    getVersion(): number;
+}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "reazor-react",
+  "version": "0.0.1",
+  "description": "Fine-grained Solid-style reactivity for React 18+",
+  "license": "MIT",
+  "author": "Delpi.Kye",
+  "sideEffects": false,
+  "type": "module",
+
+  "main": "build/index.cjs.js",
+  "module": "build/index.esm.js",
+  "types": "build/index.d.ts",
+
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.esm.js",
+      "require": "./build/index.cjs.js"
+    }
+  },
+
+  "files": [
+    "build"
+  ],
+
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "rollup -c",
+    "cb": "npm run clean && npm run build",
+    "prepublishOnly": "npm run cb"
+  },
+
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/delpikye-v/reazor-react.git"
+  },
+
+  "homepage": "https://github.com/delpikye-v/reazor-react#readme",
+
+  "bugs": {
+    "url": "https://github.com/delpikye-v/reazor-react/issues"
+  },
+
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/delpikye-v"
+  },
+
+  "keywords": [
+    "react",
+    "react-18",
+    "react-state",
+    "react-solid",
+    "react-store",
+    "fine-grained",
+    "proxy-state",
+    "reactive",
+    "reactivity",
+    "map-support",
+    "set-support",
+    "concurrent-safe",
+    "external-store",
+    "computed-state",
+    "derived-state",
+    "state-management",
+    "solid-style"
+  ],
+
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/react": "^18.2.43",
+    "react": "^18.2.0",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.9.6",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "tslib": "^2.6.2",
+    "typescript": "^5.3.3"
+  }
+}