muya 2.0.0-beta.1 → 2.0.0-beta.3

package/README.md

@@ -32,19 +32,19 @@ This allows you to write derived state as plain functions, making your code more
 ## 📦 Installation
 
 ```bash
-npm install muya
+npm install muya@2.0.0-beta.2
 ```
 
 Or using Yarn:
 
 ```bash
-yarn add muya
+yarn add muya@2.0.0-beta.2
 ```
 
 Or using Bun:
 
 ```bash
-bun add muya
+bun add muya@2.0.0-beta.2
 ```
 
 ---

package/cjs/index.js

@@ -1 +1 @@
-"use strict";var h=Object.defineProperty;var q=Object.getOwnPropertyDescriptor;var X=Object.getOwnPropertyNames;var N=Object.prototype.hasOwnProperty;var K=(e,t)=>{for(var r in t)h(e,r,{get:t[r],enumerable:!0})},Y=(e,t,r,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of X(t))!N.call(e,n)&&n!==r&&h(e,n,{get:()=>t[n],enumerable:!(o=q(t,n))||o.enumerable});return e};var G=e=>Y(h({},"__esModule",{value:!0}),e);var J={};K(J,{EMPTY_SELECTOR:()=>w,create:()=>U,shallow:()=>j,use:()=>H});module.exports=G(J);var w=e=>e;function p(e){return e instanceof Promise}function g(e){return typeof e=="function"}function R(e){return e instanceof Map}function C(e){return e instanceof Set}function P(e){return Array.isArray(e)}function b(e,t){return e===t?!0:!!Object.is(e,t)}function A(e){return typeof e=="function"}function I(e){return e instanceof DOMException&&e.name==="StateAbortError"}function v(e){return e instanceof Error&&e.name!=="StateAbortError"}function l(e){return e===void 0}function M(e,t){t&&t.abort();let r=new AbortController,{signal:o}=r;return{promise:new Promise((i,s)=>{o.addEventListener("abort",()=>{s(new DOMException("Promise was aborted","StateAbortError"))}),e.then(i).catch(s)}),controller:r}}var W=0;function y(){return W++}function E(e,t=(r,o)=>r===o){if(!l(e.current)){if(!l(e.previous)&&t(e.current,e.previous))return!1;e.previous=e.current}return!0}function S(e,t){let r=new Set,o=[];return{clear:()=>{for(let n of o)n();r.clear()},subscribe:n=>(r.add(n),()=>{r.delete(n)}),emit:(...n)=>{for(let i of r)i(...n)},contains:n=>r.has(n),getSnapshot:e,getInitialSnapshot:t,getSize:()=>r.size,subscribeToOtherEmitter(n){let i=n.subscribe(()=>{this.emit()});o.push(i)}}}function D(e){let t=new Set,{onResolveItem:r,onFinish:o}=e,n=performance.now(),i=!1;function s(){let c=performance.now(),f=c-n,{size:m}=t;if(f<.2&&m>0&&m<10){n=c,u();return}i||(i=!0,Promise.resolve().then(()=>{i=!1,n=performance.now(),u()}))}function u(){if(t.size!==0){for(let c of t)r&&r(c),t.delete(c);if(t.size>0){s();return}o()}}function a(c){t.add(c),s()}return a}var $=Symbol("_");function V(e){let t=[];function r(){if(t.length===0)return e;let i=t.at(-1);return i===$?e:i}function o(i,s){t.push(i);let u=s();return p(u)?(async()=>{try{return await u}finally{t.pop()}})():(t.pop(),u)}function n(i){let s=r();return()=>{t.push(s);let u=i();return p(u)?(async()=>{try{return await u}finally{t.pop()}})():(t.pop(),u)}}return{run:o,use:r,wrap:n}}var F=V(void 0);function L(e){let t=[],r={},o={},n=!1,i=S(()=>n?o.current:(n=!0,c()),()=>(n=!0,c()));async function s(){E(o,b)&&(r.controller&&r.controller.abort(),o.current=c(),i.emit())}let u=y(),a={addEmitter(f){let m=f.subscribe(s);t.push(m)},id:u,sub:s},c=function(){let f=F.run(a,e);if(p(f)){let{controller:m,promise:O}=M(f,r.controller);r.controller=m,O?.then(d=>{o.current=d,i.emit()}).catch(d=>{if(!I(d))throw d});let k=O;return o.current=k,k}return o.current=f,f};return c.emitter=i,c.destroy=function(){for(let f of t)f();i.clear()},c.id=u,c.listen=function(f){return i.subscribe(()=>{let m=o.current;if(l(m))throw new Error("The value is undefined");f(m)})},c.abort=function(){r.controller&&r.controller.abort()},c}function U(e,t=b){let r={};function o(){return l(r.current)&&(r.current=g(e)?e():e),r.current}function n(u){let a=o();r.current=A(u)?u(a):u}let i=D({onFinish(){r.current=o(),E(r,t)&&s.emitter.emit()},onResolveItem:n}),s=function(){let u=o(),a=F.use();return a&&!s.emitter.contains(a.sub)&&a.addEmitter(s.emitter),u};return s.listen=function(u){return s.emitter.subscribe(()=>{let a=r.current;if(l(a))throw new Error("The value is undefined");u(a)})},s.emitter=S(()=>s()),s.id=y(),s.set=i,s}var T=require("react");var z=require("react");var x=new WeakMap;function _(e){return{call(){let t=x.get(e);if(t)return t.count++,t.returnType;let o={count:1,returnType:L(e)};return x.set(e,o),o.returnType},destroy(){let t=x.get(e);t&&(t.count--,t.count===0&&(t.returnType.destroy(),x.delete(e)))}}}function H(e,t=w){let r=_(e),o=r.call(),n=o.emitter.getInitialSnapshot??o.emitter.getSnapshot;(0,T.useEffect)(()=>r.destroy,[e]);let i=(0,z.useSyncExternalStore)(o.emitter.subscribe,()=>t(o.emitter.getSnapshot()),()=>t(n()));if((0,T.useDebugValue)(i),p(i))throw i;if(v(i))throw r.destroy(),i;return i}function j(e,t){if(e==t)return!0;if(typeof e!="object"||e==null||typeof t!="object"||t==null)return!1;if(R(e)&&R(t)){if(e.size!==t.size)return!1;for(let[n,i]of e)if(!Object.is(i,t.get(n)))return!1;return!0}if(C(e)&&C(t)){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}if(P(e)&&P(t)){if(e.length!==t.length)return!1;for(let[n,i]of e.entries())if(!Object.is(i,t[n]))return!1;return!0}let r=Object.keys(e),o=Object.keys(t);if(r.length!==o.length)return!1;for(let n of r)if(!Object.prototype.hasOwnProperty.call(t,n)||!Object.is(e[n],t[n]))return!1;return!0}
+"use strict";var C=Object.defineProperty;var X=Object.getOwnPropertyDescriptor;var K=Object.getOwnPropertyNames;var Y=Object.prototype.hasOwnProperty;var W=(e,t)=>{for(var n in t)C(e,n,{get:t[n],enumerable:!0})},$=(e,t,n,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of K(t))!Y.call(e,o)&&o!==n&&C(e,o,{get:()=>t[o],enumerable:!(s=X(t,o))||s.enumerable});return e};var J=e=>$(C({},"__esModule",{value:!0}),e);var ee={};W(ee,{EMPTY_SELECTOR:()=>F,create:()=>z,shallow:()=>q,use:()=>j});module.exports=J(ee);var F=e=>e;function p(e){return e instanceof Promise}function k(e){return typeof e=="function"}function P(e){return e instanceof Map}function g(e){return e instanceof Set}function R(e){return Array.isArray(e)}function b(e,t){return e===t?!0:!!Object.is(e,t)}function O(e){return typeof e=="function"}function v(e){return e instanceof DOMException&&e.name==="StateAbortError"}function A(e){return e instanceof Error&&e.name!=="StateAbortError"}function d(e){return e===void 0}function I(e,t){t&&t.abort();let n=new AbortController,{signal:s}=n;return{promise:new Promise((r,u)=>{s.addEventListener("abort",()=>{u(new DOMException("Promise was aborted","StateAbortError"))}),e.then(r).catch(u)}),controller:n}}var Q=0;function y(){return Q++}function S(e,t=(n,s)=>n===s){if(!d(e.current)){if(!d(e.previous)&&t(e.current,e.previous))return!1;e.previous=e.current}return!0}function h(e,t){let n=new Set,s=[];return{clear:()=>{for(let o of s)o();n.clear()},subscribe:o=>(n.add(o),()=>{n.delete(o)}),emit:(...o)=>{for(let r of n)r(...o)},contains:o=>n.has(o),getSnapshot:e,getInitialSnapshot:t,getSize:()=>n.size,subscribeToOtherEmitter(o){let r=o.subscribe(()=>{this.emit()});s.push(r)}}}var Z=Symbol("_");function D(e){let t=[];function n(){if(t.length===0)return e;let r=t.at(-1);return r===Z?e:r}function s(r,u){t.push(r);let i=u();return p(i)?(async()=>{try{return await i}finally{t.pop()}})():(t.pop(),i)}function o(r){let u=n();return()=>{t.push(u);let i=r();return p(i)?(async()=>{try{return await i}finally{t.pop()}})():(t.pop(),i)}}return{run:s,use:n,wrap:o}}function x(){let e=new Map,t=new Set,n=performance.now(),s=!1;function o(){let u=performance.now(),i=u-n,{size:c}=t;if(i<.2&&c>0&&c<10){n=u,r();return}s||(s=!0,Promise.resolve().then(()=>{s=!1,n=performance.now(),r()}))}function r(){if(t.size===0)return;let u=new Set;for(let i of t){if(e.has(i.id)){u.add(i.id);let{onResolveItem:c}=e.get(i.id);c&&c(i.value)}t.delete(i)}if(t.size>0){o();return}for(let i of u)e.get(i)?.onFinish()}return{add(u,i){return e.set(u,i),()=>{e.delete(u)}},schedule(u,i){t.add({value:i,id:u}),o()}}}var M=x(),E=D(void 0);function V(e){let t={},n=!1,s=[],o={},r=h(()=>n?t.current:(n=!0,f()),()=>(n=!0,f()));async function u(){S(t,b)&&(o.controller&&o.controller.abort(),M.schedule(i,null))}let i=y(),c=M.add(i,{onFinish(){t.current=f(),r.emit()}}),G={addEmitter(a){let l=a.subscribe(u);s.push(l)},id:i,sub:u};function H(a){let l=I(a,o.controller);return o.controller=l.controller,l.promise?.then(m=>{t.current=m,r.emit()}).catch(m=>{v(m)||(t.current=m,r.emit())}),l.promise}let f=function(){let a=E.run(G,e);if(!p(a))return t.current=a,a;let l=E.wrap(()=>H(a))();p(l)&&l.catch(()=>null);let m=l;return t.current=m,m};return f.emitter=r,f.destroy=function(){for(let a of s)a();r.clear(),c()},f.id=i,f.listen=function(a){return r.subscribe(()=>{let l=t.current;if(d(l))throw new Error("The value is undefined");a(l)})},f.abort=function(){o.controller&&o.controller.abort()},f}var L=x();function z(e,t=b){let n={};function s(){return d(n.current)&&(n.current=k(e)?e():e),n.current}function o(i){let c=s();n.current=O(i)?i(c):i}let r=function(){let i=s(),c=E.use();return c&&!r.emitter.contains(c.sub)&&c.addEmitter(r.emitter),i};r.listen=function(i){return r.emitter.subscribe(()=>{let c=n.current;if(d(c))throw new Error("The value is undefined");i(c)})},r.emitter=h(()=>r()),r.id=y();let u=L.add(r.id,{onFinish(){n.current=s(),S(n,t)&&r.emitter.emit()},onResolveItem:o});return r.set=function(i){L.schedule(r.id,i)},r.destroy=function(){n.current=void 0,s(),u(),r.emitter.clear()},r.withName=function(i){return r.stateName=i,r},r}var T=require("react");var N=require("react");var w=new WeakMap,_=0;function B(){_++}function U(e){return _=0,{call(){let t=w.get(e);if(t)return t.count++,t.returnType;B();let s={count:1,returnType:V(e)};return w.set(e,s),s.returnType},destroy(){let t=w.get(e);t&&(t.count--,t.count===0&&(t.returnType.destroy(),w.delete(e)))}}}function j(e,t=F){let n=U(e),s=n.call(),o=s.emitter.getInitialSnapshot??s.emitter.getSnapshot;(0,T.useEffect)(()=>n.destroy,[e,n.destroy]);let r=(0,N.useSyncExternalStore)(s.emitter.subscribe,()=>t(s.emitter.getSnapshot()),()=>t(o()));if((0,T.useDebugValue)(r),p(r))throw r;if(A(r))throw n.destroy(),r;return r}function q(e,t){if(e==t)return!0;if(typeof e!="object"||e==null||typeof t!="object"||t==null)return!1;if(P(e)&&P(t)){if(e.size!==t.size)return!1;for(let[o,r]of e)if(!Object.is(r,t.get(o)))return!1;return!0}if(g(e)&&g(t)){if(e.size!==t.size)return!1;for(let o of e)if(!t.has(o))return!1;return!0}if(R(e)&&R(t)){if(e.length!==t.length)return!1;for(let[o,r]of e.entries())if(!Object.is(r,t[o]))return!1;return!0}let n=Object.keys(e),s=Object.keys(t);if(n.length!==s.length)return!1;for(let o of n)if(!Object.prototype.hasOwnProperty.call(t,o)||!Object.is(e[o],t[o]))return!1;return!0}

package/esm/create.js

@@ -1 +1 @@
-import{canUpdate as m,generateId as l}from"./utils/common";import{createEmitter as f}from"./utils/create-emitter";import{isEqualBase as T,isFunction as d,isSetValueFunction as p,isUndefined as o}from"./utils/is";import{createScheduler as S}from"./utils/scheduler";import{context as h}from"./subscriber";function y(i,u=T){const r={};function a(){return o(r.current)&&(r.current=d(i)?i():i),r.current}function c(n){const t=a();r.current=p(n)?n(t):n}const s=S({onFinish(){r.current=a(),m(r,u)&&e.emitter.emit()},onResolveItem:c}),e=function(){const n=a(),t=h.use();return t&&!e.emitter.contains(t.sub)&&t.addEmitter(e.emitter),n};return e.listen=function(n){return e.emitter.subscribe(()=>{const t=r.current;if(o(t))throw new Error("The value is undefined");n(t)})},e.emitter=f(()=>e()),e.id=l(),e.set=s,e}export{y as create};
+import{canUpdate as l,generateId as f}from"./utils/common";import{createEmitter as d}from"./utils/create-emitter";import{isEqualBase as T,isFunction as p,isSetValueFunction as S,isUndefined as o}from"./utils/is";import{context as h}from"./subscriber";import{createGlobalScheduler as w}from"./utils/global-scheduler";const u=w();function R(a,c=T){const r={};function i(){return o(r.current)&&(r.current=p(a)?a():a),r.current}function s(t){const n=i();r.current=S(t)?t(n):t}const e=function(){const t=i(),n=h.use();return n&&!e.emitter.contains(n.sub)&&n.addEmitter(e.emitter),t};e.listen=function(t){return e.emitter.subscribe(()=>{const n=r.current;if(o(n))throw new Error("The value is undefined");t(n)})},e.emitter=d(()=>e()),e.id=f();const m=u.add(e.id,{onFinish(){r.current=i(),l(r,c)&&e.emitter.emit()},onResolveItem:s});return e.set=function(t){u.schedule(e.id,t)},e.destroy=function(){r.current=void 0,i(),m(),e.emitter.clear()},e.withName=function(t){return e.stateName=t,e},e}export{R as create,u as createScheduler};

package/esm/debug/development-tools.js

@@ -0,0 +1 @@
+import{isPromise as r}from"../utils/is";const t=window?.__REDUX_DEVTOOLS_EXTENSION__?.connect({name:"CustomState",trace:!0});t&&t.init({message:"Initial state"});function a(n){if(!t)return;const{message:o,type:e,value:s,name:i}=n;r(s)||t.send(i,{value:s,type:e,message:o},e)}function m(n,o){return e=>{a({name:n,type:o,value:e,message:"update"})}}export{m as developmentToolsListener,a as sendToDevelopmentTools};

package/esm/subscriber.js

@@ -1 +1 @@
-import{cancelablePromise as p,canUpdate as T,generateId as y}from"./utils/common";import{createContext as F}from"./utils/create-context";import{createEmitter as x}from"./utils/create-emitter";import{isAbortError as h,isEqualBase as C,isPromise as R,isUndefined as E}from"./utils/is";const S=F(void 0);function k(d){const u=[],n={},r={};let s=!1;const o=x(()=>s?r.current:(s=!0,t()),()=>(s=!0,t()));async function a(){T(r,C)&&(n.controller&&n.controller.abort(),r.current=t(),o.emit())}const l=y(),f={addEmitter(e){const i=e.subscribe(a);u.push(i)},id:l,sub:a},t=function(){const e=S.run(f,d);if(R(e)){const{controller:i,promise:m}=p(e,n.controller);n.controller=i,m?.then(c=>{r.current=c,o.emit()}).catch(c=>{if(!h(c))throw c});const b=m;return r.current=b,b}return r.current=e,e};return t.emitter=o,t.destroy=function(){for(const e of u)e();o.clear()},t.id=l,t.listen=function(e){return o.subscribe(()=>{const i=r.current;if(E(i))throw new Error("The value is undefined");e(i)})},t.abort=function(){n.controller&&n.controller.abort()},t}export{S as context,k as subscriber};
+import{cancelablePromise as F,canUpdate as v,generateId as h}from"./utils/common";import{createContext as x}from"./utils/create-context";import{createEmitter as S}from"./utils/create-emitter";import"./debug/development-tools";import{createGlobalScheduler as C}from"./utils/global-scheduler";import{isAbortError as E,isEqualBase as R,isPromise as m,isUndefined as w}from"./utils/is";const d=C(),b=x(void 0);function U(p){const r={};let u=!1;const a=[],i={},s=S(()=>u?r.current:(u=!0,n()),()=>(u=!0,n()));async function l(){v(r,R)&&(i.controller&&i.controller.abort(),d.schedule(c,null))}const c=h(),f=d.add(c,{onFinish(){r.current=n(),s.emit()}}),T={addEmitter(e){const t=e.subscribe(l);a.push(t)},id:c,sub:l};function y(e){const t=F(e,i.controller);return i.controller=t.controller,t.promise?.then(o=>{r.current=o,s.emit()}).catch(o=>{E(o)||(r.current=o,s.emit())}),t.promise}const n=function(){const e=b.run(T,p);if(!m(e))return r.current=e,e;const t=b.wrap(()=>y(e))();m(t)&&t.catch(()=>null);const o=t;return r.current=o,o};return n.emitter=s,n.destroy=function(){for(const e of a)e();s.clear(),f()},n.id=c,n.listen=function(e){return s.subscribe(()=>{const t=r.current;if(w(t))throw new Error("The value is undefined");e(t)})},n.abort=function(){i.controller&&i.controller.abort()},n}export{b as context,U as subscriber};

package/esm/use.js

@@ -1 +1 @@
-import{useDebugValue as u,useEffect as s,useRef as m}from"react";import{EMPTY_SELECTOR as a}from"./types";import{isAnyOtherError as c,isPromise as T}from"./utils/is";import{useSyncExternalStore as d}from"react";import{subMemo as p}from"./utils/sub-memo";const f=10,E=3;function b(t){const e=m({renders:0,startTime:performance.now()});s(()=>{e.current.renders++,!(performance.now()-e.current.startTime<f)&&(e.current.renders<E||(e.current.startTime=performance.now(),e.current.renders=0,console.warn(`Function ${t.name.length>0?t.name:t} seems to be not memoized, wrap the function to the useCallback or use global defined functions.`)))},[t])}function y(t,e=a){const n=p(t),o=n.call(),i=o.emitter.getInitialSnapshot??o.emitter.getSnapshot;s(()=>n.destroy,[t]);const r=d(o.emitter.subscribe,()=>e(o.emitter.getSnapshot()),()=>e(i()));if(u(r),T(r))throw r;if(c(r))throw n.destroy(),r;return r}export{y as use};
+import{useDebugValue as u,useEffect as s,useRef as m}from"react";import{EMPTY_SELECTOR as a}from"./types";import{isAnyOtherError as c,isPromise as T}from"./utils/is";import{useSyncExternalStore as d}from"react";import{subMemo as p}from"./utils/sub-memo";const f=10,E=3;function R(t){const e=m({renders:0,startTime:performance.now()});s(()=>{e.current.renders++,!(performance.now()-e.current.startTime<f)&&(e.current.renders<E||(e.current.startTime=performance.now(),e.current.renders=0,console.warn(`Function ${t.name.length>0?t.name:t} seems to be not memoized, wrap the function to the useCallback or use global defined functions.`)))},[t])}function b(t,e=a){const n=p(t),o=n.call(),i=o.emitter.getInitialSnapshot??o.emitter.getSnapshot;s(()=>n.destroy,[t,n.destroy]);const r=d(o.emitter.subscribe,()=>e(o.emitter.getSnapshot()),()=>e(i()));if(u(r),T(r))throw r;if(c(r))throw n.destroy(),r;return r}export{b as use};

package/esm/utils/global-scheduler.js

@@ -0,0 +1 @@
+import{RESCHEDULE_COUNT as l,THRESHOLD as f,THRESHOLD_ITEMS as d}from"./scheduler";function m(){const t=new Map,r=new Set;let s=performance.now(),u=!1;function c(){const n=performance.now(),e=n-s,{size:o}=r;if(e<f&&o>0&&o<d){s=n,i();return}u||(u=!0,Promise.resolve().then(()=>{u=!1,s=performance.now(),i()}))}function i(){if(r.size===0)return;const n=new Set;for(const e of r){if(t.has(e.id)){n.add(e.id);const{onResolveItem:o}=t.get(e.id);o&&o(e.value)}r.delete(e)}if(r.size>l){c();return}for(const e of n)t.get(e)?.onFinish()}return{add(n,e){return t.set(n,e),()=>{t.delete(n)}},schedule(n,e){r.add({value:e,id:n}),c()}}}export{m as createGlobalScheduler};

package/esm/utils/is.js

@@ -1 +1 @@
-import{Abort as e}from"./common";function o(n){return n instanceof Promise}function i(n){return typeof n=="function"}function u(n){return n instanceof Map}function s(n){return n instanceof Set}function a(n){return Array.isArray(n)}function f(n,r){return n===r?!0:!!Object.is(n,r)}function c(n){return typeof n=="function"}function p(n){return n instanceof DOMException&&n.name===e.Error}function k(n){return n instanceof Error&&n.name!==e.Error}function w(n){return n===void 0}export{p as isAbortError,k as isAnyOtherError,a as isArray,f as isEqualBase,i as isFunction,u as isMap,o as isPromise,s as isSet,c as isSetValueFunction,w as isUndefined};
+import{Abort as t}from"./common";function i(n){return n instanceof Promise}function r(n){return typeof n=="function"}function u(n){return n instanceof Map}function s(n){return n instanceof Set}function a(n){return Array.isArray(n)}function f(n,e){return n===e?!0:!!Object.is(n,e)}function c(n){return typeof n=="function"}function p(n){return n instanceof DOMException&&n.name===t.Error}function k(n){return n instanceof Error&&n.name!==t.Error}function w(n){return n===void 0}function x(n){return r(n)&&n.set!==void 0}export{p as isAbortError,k as isAnyOtherError,a as isArray,x as isCreate,f as isEqualBase,r as isFunction,u as isMap,i as isPromise,s as isSet,c as isSetValueFunction,w as isUndefined};

package/esm/utils/scheduler.js

@@ -1 +1 @@
-const T=.2,d=10,E=0;function S(f){const n=new Set,{onResolveItem:r,onFinish:a}=f;let o=performance.now(),t=!1;function s(){const e=performance.now(),u=e-o,{size:c}=n;if(u<.2&&c>0&&c<10){o=e,i();return}t||(t=!0,Promise.resolve().then(()=>{t=!1,o=performance.now(),i()}))}function i(){if(n.size!==0){for(const e of n)r&&r(e),n.delete(e);if(n.size>0){s();return}a()}}function l(e){n.add(e),s()}return l}export{S as createScheduler};
+const d=.2,T=10,S=0;function E(f){const n=new Set,{onResolveItem:r,onFinish:a}=f;let o=performance.now(),t=!1;function s(){const e=performance.now(),u=e-o,{size:c}=n;if(u<.2&&c>0&&c<10){o=e,i();return}t||(t=!0,Promise.resolve().then(()=>{t=!1,o=performance.now(),i()}))}function i(){if(n.size!==0){for(const e of n)r&&r(e),n.delete(e);if(n.size>0){s();return}a()}}function l(e){n.add(e),s()}return l}export{S as RESCHEDULE_COUNT,d as THRESHOLD,T as THRESHOLD_ITEMS,E as createScheduler};

package/esm/utils/sub-memo.js

@@ -1 +1 @@
-import{subscriber as c}from"../subscriber";const r=new WeakMap;function s(t){return{call(){const e=r.get(t);if(e)return e.count++,e.returnType;const n={count:1,returnType:c(t)};return r.set(t,n),n.returnType},destroy(){const e=r.get(t);e&&(e.count--,e.count===0&&(e.returnType.destroy(),r.delete(t)))}}}export{s as subMemo};
+import{subscriber as c}from"../subscriber";const n=new WeakMap;let r=0;function p(){return r}function o(){r++}function b(t){return r=0,{call(){const e=n.get(t);if(e)return e.count++,e.returnType;o();const u={count:1,returnType:c(t)};return n.set(t,u),u.returnType},destroy(){const e=n.get(t);e&&(e.count--,e.count===0&&(e.returnType.destroy(),n.delete(t)))}}}export{p as getDebugCacheCreation,b as subMemo};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muya",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "author": "samuel.gjabel@gmail.com",
   "description": "👀 Another React state management library",
   "license": "MIT",

package/{packages/core → src}/__tests__/bench.test.tsx

@@ -1,5 +1,10 @@
+/**
+ * This is not optimal, so for now just ignore. Its just for view and compare if the state is at least similar to others
+ * but this tests are not consider as a real benchmark
+ */
 /* eslint-disable unicorn/consistent-function-scoping */
 /* eslint-disable no-console */
+
 import { act, renderHook } from '@testing-library/react-hooks'
 import { useStore, create as zustand } from 'zustand'
 import { useEffect, useState } from 'react'
@@ -33,7 +38,7 @@ describe('benchmarks comparison measure', () => {
   beforeEach(() => {
     jest.clearAllMocks()
   })
-  const counts = [1000, 10_000]
+  const counts = [10_000]
   for (const count of counts) {
     describe(`Count ${count}`, () => {
       it(`should benchmark ${count} muya first run - idk slow`, async () => {

package/src/__tests__/subscriber.test.tsx

@@ -0,0 +1,89 @@
+import { waitFor } from '@testing-library/react'
+import { create } from '../create'
+import { subscriber } from '../subscriber'
+import { longPromise } from './test-utils'
+
+describe('subscriber', () => {
+  it('should test subscriber and cleaning the emitters', () => {
+    const state1 = create(1)
+    const sub = subscriber(state1)
+    // at this point, the emitter is not subscribed yet, as it need to be called first.
+    expect(state1.emitter.getSize()).toBe(0)
+
+    // check if the value is correct
+    expect(sub()).toBe(1)
+
+    // now we can check if the value is subscribed
+    expect(state1.emitter.getSize()).toBe(1)
+    // we destroy the subscriber, meaning that the emitter should be cleaned
+
+    sub.destroy()
+
+    expect(state1.emitter.getSize()).toBe(0)
+
+    // and test re-aligning the subscriber
+    expect(sub()).toBe(1)
+    expect(state1.emitter.getSize()).toBe(1)
+  })
+  it('should test how many events are emitter via singleton state', async () => {
+    const state1 = create(1)
+    const sub = subscriber(state1)
+
+    let updateCount = 0
+
+    sub.listen(() => {
+      updateCount++
+    })
+    sub()
+    await waitFor(() => {})
+    // we do not received initial value as it is not changed
+    expect(updateCount).toBe(0)
+
+    state1.set(2)
+    await waitFor(() => {})
+    expect(updateCount).toBe(1)
+  })
+  it('should test how many events are emitter via singleton async state', async () => {
+    const state1 = create(longPromise())
+    const sub = subscriber(state1)
+
+    let updateCount = 0
+
+    sub.listen(() => {
+      updateCount++
+    })
+    sub()
+    await waitFor(() => {})
+    // we do not received initial value as it is not changed
+    expect(updateCount).toBe(0)
+
+    state1.set(2)
+    await waitFor(() => {})
+    expect(updateCount).toBe(1)
+  })
+
+  it('should test how many events are emitter via derived state', async () => {
+    const state1 = create(longPromise())
+
+    async function derived() {
+      //   await longPromise()
+      return await state1()
+    }
+    const sub = subscriber(derived)
+
+    let updateCount = 0
+
+    sub.listen(() => {
+      updateCount++
+    })
+    await sub()
+    await waitFor(() => {})
+    expect(await sub()).toBe(0)
+    // // we do not received initial value as it is not changed
+    expect(updateCount).toBe(2)
+
+    // state1.set(2)
+    // await waitFor(() => {})
+    // expect(updateCount).toBe(1)
+  })
+})

package/{packages/core → src}/__tests__/use-async.test.tsx

@@ -3,7 +3,7 @@ import { renderHook } from '@testing-library/react-hooks'
 import { create } from '../create'
 import { use } from '../use'
 import { Suspense } from 'react'
-import { longPromise } from './test-utils'
+import { waitFor } from '@testing-library/react'
 
 describe('use-create', () => {
   const reRendersBefore = jest.fn()
@@ -26,7 +26,7 @@ describe('use-create', () => {
       return <div>Loading...</div>
     }
 
-    const { result, waitFor } = renderHook(
+    const { result } = renderHook(
       () => {
         reRendersBefore()
         const data = use(getDataWithUser)
@@ -36,8 +36,9 @@ describe('use-create', () => {
       { wrapper: ({ children }) => <Suspense fallback={<Loading />}>{children}</Suspense> },
     )
 
-    await longPromise(1000)
-    await waitFor(() => {})
+    await waitFor(() => {
+      expect(result.current).toEqual({ userId: 1, id: 1, title: 'delectus aut autem', completed: false, age: 30 })
+    })
     expect(suspenseFunction).toHaveBeenCalledTimes(1)
     expect(result.current).toEqual({ userId: 1, id: 1, title: 'delectus aut autem', completed: false, age: 30 })
   })

package/src/__tests__/use.test.tsx

@@ -0,0 +1,125 @@
+import { act, renderHook } from '@testing-library/react-hooks'
+import { create } from '../create'
+import { use } from '../use'
+import { waitFor } from '@testing-library/react'
+import { useCallback } from 'react'
+import { getDebugCacheCreation } from '../utils/sub-memo'
+
+describe('use-create', () => {
+  const reRendersBefore = jest.fn()
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should test use hook', async () => {
+    const state = create(1)
+
+    const { result } = renderHook(() => {
+      reRendersBefore()
+      return use(state)
+    })
+
+    state.set(2)
+
+    await waitFor(() => {})
+    expect(result.current).toBe(2)
+    expect(reRendersBefore).toHaveBeenCalledTimes(2)
+
+    state.set(3)
+
+    await waitFor(() => {})
+    expect(result.current).toBe(3)
+    expect(reRendersBefore).toHaveBeenCalledTimes(3)
+  })
+
+  it('should test derived state with multiple states', async () => {
+    const state1 = create(1)
+    const state2 = create(2)
+
+    function derivedBefore(plusValue: number) {
+      return state1() + state2() + plusValue
+    }
+
+    function derived() {
+      return state1() + state2() + derivedBefore(10)
+    }
+
+    const { result } = renderHook(() => {
+      reRendersBefore()
+      return use(derived)
+    })
+
+    await waitFor(() => {})
+    expect(reRendersBefore).toHaveBeenCalledTimes(1)
+    act(() => {
+      state1.set(2)
+      state2.set(3)
+    })
+
+    await waitFor(() => {})
+    expect(result.current).toBe(20)
+    expect(reRendersBefore).toHaveBeenCalledTimes(2)
+  })
+
+  it('should test use hook without memoize fn', async () => {
+    const state1 = create(1)
+    const state2 = create(2)
+
+    function derivedBefore(plusValue: number) {
+      return state1() + state2() + plusValue
+    }
+
+    function derived(add: number) {
+      return state1() + state2() + derivedBefore(add)
+    }
+
+    const { result } = renderHook(() => {
+      reRendersBefore()
+      return use(() => derived(10))
+    })
+    expect(getDebugCacheCreation()).toBe(1)
+
+    await waitFor(() => {})
+    expect(reRendersBefore).toHaveBeenCalledTimes(1)
+    act(() => {
+      state1.set(2)
+      state2.set(3)
+    })
+    expect(getDebugCacheCreation()).toBe(1)
+    await waitFor(() => {})
+    expect(result.current).toBe(20)
+    expect(reRendersBefore).toHaveBeenCalledTimes(2)
+  })
+
+  it('should test use hook with memoize fn', async () => {
+    const state1 = create(1)
+    const state2 = create(2)
+
+    function derivedBefore(plusValue: number) {
+      return state1() + state2() + plusValue
+    }
+
+    function derived(add: number) {
+      return state1() + state2() + derivedBefore(add)
+    }
+
+    const { result } = renderHook(() => {
+      reRendersBefore()
+      const memoized = useCallback(() => derived(10), [])
+      return use(memoized)
+    })
+    expect(getDebugCacheCreation()).toBe(1)
+
+    await waitFor(() => {})
+    expect(reRendersBefore).toHaveBeenCalledTimes(1)
+    act(() => {
+      state1.set(2)
+      state2.set(3)
+    })
+    expect(getDebugCacheCreation()).toBe(1)
+    await waitFor(() => {})
+    expect(result.current).toBe(20)
+    expect(reRendersBefore).toHaveBeenCalledTimes(2)
+  })
+})

package/{packages/core → src}/create.ts

@@ -2,16 +2,21 @@ import { canUpdate, generateId } from './utils/common'
 import type { Emitter } from './utils/create-emitter'
 import { createEmitter } from './utils/create-emitter'
 import { isEqualBase, isFunction, isSetValueFunction, isUndefined } from './utils/is'
-import { createScheduler } from './utils/scheduler'
+// import { createScheduler } from './utils/scheduler'
 import type { Cache, Callable, DefaultValue, IsEqual, Listener, SetValue } from './types'
 import { context } from './subscriber'
+import { createGlobalScheduler } from './utils/global-scheduler'
 
+export const createScheduler = createGlobalScheduler()
 interface RawState<T> {
   (): T
   id: number
   set: (value: SetValue<T>) => void
   emitter: Emitter<T>
   listen: Listener<T>
+  destroy: () => void
+  withName: (name: string) => RawState<T>
+  stateName?: string
 }
 
 export type State<T> = {
@@ -32,20 +37,21 @@ export function create<T>(initialValue: DefaultValue<T>, isEqual: IsEqual<T> = i
     cache.current = isSetValueFunction(value) ? value(previous) : value
   }
 
-  const schedule = createScheduler<SetValue<T>>({
-    onFinish() {
-      cache.current = getValue()
-      if (!canUpdate(cache, isEqual)) {
-        return
-      }
-      state.emitter.emit()
-    },
-    onResolveItem: resolveValue,
-  })
+  // const schedule = createScheduler<SetValue<T>>({
+  //   onFinish() {
+  //     cache.current = getValue()
+  //     if (!canUpdate(cache, isEqual)) {
+  //       return
+  //     }
+  //     state.emitter.emit()
+  //   },
+  //   onResolveItem: resolveValue,
+  // })
 
   const state: RawState<T> = function () {
     const stateValue = getValue()
     const ctx = context.use()
+    // console.log('CTX', ctx?.id, 'STATE', state.id)
     if (ctx && !state.emitter.contains(ctx.sub)) {
       ctx.addEmitter(state.emitter)
     }
@@ -62,6 +68,31 @@ export function create<T>(initialValue: DefaultValue<T>, isEqual: IsEqual<T> = i
   }
   state.emitter = createEmitter<T>(() => state())
   state.id = generateId()
-  state.set = schedule
+
+  const clearScheduler = createScheduler.add(state.id, {
+    onFinish() {
+      cache.current = getValue()
+      if (!canUpdate(cache, isEqual)) {
+        return
+      }
+      state.emitter.emit()
+    },
+    onResolveItem: resolveValue,
+  })
+  state.set = function (value) {
+    createScheduler.schedule(state.id, value)
+  }
+
+  state.destroy = function () {
+    cache.current = undefined
+    getValue()
+    clearScheduler()
+    state.emitter.clear()
+  }
+  state.withName = function (name: string) {
+    state.stateName = name
+    return state
+  }
+
   return state
 }

package/src/debug/development-tools.ts

@@ -0,0 +1,37 @@
+import { isPromise } from '../utils/is'
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
+const reduxDevelopmentTools = window?.__REDUX_DEVTOOLS_EXTENSION__?.connect({
+  name: 'CustomState', // This will name your instance in the DevTools
+  trace: true, // Enables trace if needed
+})
+
+if (reduxDevelopmentTools) {
+  reduxDevelopmentTools.init({ message: 'Initial state' })
+}
+
+export type StateType = 'state' | 'derived'
+
+interface SendOptions {
+  message?: string
+  type: StateType
+  value: unknown
+  name: string
+}
+export function sendToDevelopmentTools(options: SendOptions) {
+  if (!reduxDevelopmentTools) {
+    return
+  }
+  const { message, type, value, name } = options
+  if (isPromise(value)) {
+    return
+  }
+  reduxDevelopmentTools.send(name, { value, type, message }, type)
+}
+
+export function developmentToolsListener(name: string, type: StateType) {
+  return (value: unknown) => {
+    sendToDevelopmentTools({ name, type, value, message: 'update' })
+  }
+}

package/{packages/core → src}/subscriber.ts

@@ -4,8 +4,12 @@ import { cancelablePromise, canUpdate, generateId } from './utils/common'
 import { createContext } from './utils/create-context'
 import type { Emitter } from './utils/create-emitter'
 import { createEmitter } from './utils/create-emitter'
-import { isAbortError, isEqualBase, isPromise, isUndefined } from './utils/is'
+import type { StateType } from './debug/development-tools'
+import { developmentToolsListener, sendToDevelopmentTools } from './debug/development-tools'
+import { createGlobalScheduler } from './utils/global-scheduler'
+import { isAbortError, isCreate, isEqualBase, isPromise, isUndefined } from './utils/is'
 
+const subscriberScheduler = createGlobalScheduler()
 interface SubscribeContext<T = unknown> {
   addEmitter: (emitter: Emitter<T>) => void
   id: number
@@ -29,11 +33,11 @@ export const context = createContext<SubscribeContext | undefined>(undefined)
 export function subscriber<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>>(
   anyFunction: () => T,
 ): Subscribe<F, T> {
+  const cache: Cache<T> = {}
+  let isInitialized = false
   const cleaners: Array<() => void> = []
   const promiseData: CancelablePromise<T> = {}
 
-  const cache: Cache<T> = {}
-  let isInitialized = false
   const emitter = createEmitter(
     () => {
       if (!isInitialized) {
@@ -56,10 +60,17 @@ export function subscriber<F extends AnyFunction, T extends ReturnType<F> = Retu
       promiseData.controller.abort()
     }
 
-    cache.current = subscribe()
-    emitter.emit()
+    subscriberScheduler.schedule(id, null)
   }
+
   const id = generateId()
+
+  const clearScheduler = subscriberScheduler.add(id, {
+    onFinish() {
+      cache.current = subscribe()
+      emitter.emit()
+    },
+  })
   const ctx: SubscribeContext = {
     addEmitter(stateEmitter) {
       const clean = stateEmitter.subscribe(sub)
@@ -69,30 +80,40 @@ export function subscriber<F extends AnyFunction, T extends ReturnType<F> = Retu
     sub,
   }
 
+  function asyncSub(resultValue: Promise<T>): Promise<T> | undefined {
+    const cancel = cancelablePromise<T>(resultValue, promiseData.controller)
+    promiseData.controller = cancel.controller
+    cancel.promise
+      ?.then((value) => {
+        cache.current = value
+        emitter.emit()
+      })
+      .catch((error) => {
+        if (isAbortError(error)) {
+          return
+        }
+        cache.current = error
+        emitter.emit()
+      })
+    return cancel.promise
+  }
+
   const subscribe = function (): T {
     const resultValue = context.run(ctx, anyFunction)
 
-    if (isPromise(resultValue)) {
-      const { controller, promise: promiseWithSelector } = cancelablePromise<T>(resultValue, promiseData.controller)
-      promiseData.controller = controller
-      promiseWithSelector
-        ?.then((value) => {
-          cache.current = value
-          emitter.emit()
-        })
-        .catch((error) => {
-          if (isAbortError(error)) {
-            return
-          }
-
-          throw error
-        })
-      const promiseResult = promiseWithSelector as T
-      cache.current = promiseResult
-      return promiseResult
+    if (!isPromise(resultValue)) {
+      cache.current = resultValue
+      return resultValue
     }
-    cache.current = resultValue
-    return resultValue
+
+    const promise = context.wrap(() => asyncSub(resultValue))()
+    if (isPromise(promise)) {
+      // we do not do anything with the promise, because it is already handled in asyncSub
+      promise.catch(() => null)
+    }
+    const promiseAsT = promise as T
+    cache.current = promiseAsT
+    return promiseAsT
   }
 
   subscribe.emitter = emitter
@@ -101,6 +122,7 @@ export function subscriber<F extends AnyFunction, T extends ReturnType<F> = Retu
       cleaner()
     }
     emitter.clear()
+    clearScheduler()
   }
   subscribe.id = id
   subscribe.listen = function (listener: (value: T) => void) {
@@ -112,6 +134,28 @@ export function subscriber<F extends AnyFunction, T extends ReturnType<F> = Retu
       listener(final)
     })
   }
+
+  if (process.env.NODE_ENV === 'development') {
+    let name: string | undefined
+    let type: StateType = 'derived'
+    if (isCreate(anyFunction)) {
+      type = 'state'
+      name = anyFunction.stateName
+    }
+
+    if (!name) {
+      name = anyFunction.name.length > 0 ? anyFunction.name : anyFunction.toString()
+    }
+
+    sendToDevelopmentTools({
+      name,
+      type,
+      value: subscribe(),
+      message: 'init',
+    })
+    const listener = developmentToolsListener(name, type)
+    subscribe.listen(listener)
+  }
   subscribe.abort = function () {
     if (promiseData.controller) {
       promiseData.controller.abort()

package/{packages/core → src}/use.ts

@@ -37,10 +37,8 @@ export function use<F extends AnyFunction, T extends ReturnType<F>, S extends Re
   const sub = memo.call()
   const initialSnapshot = sub.emitter.getInitialSnapshot ?? sub.emitter.getSnapshot
   useEffect(() => {
-    // memo.call()
     return memo.destroy
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [anyFunction])
+  }, [anyFunction, memo.destroy])
 
   const value = useSyncExternalStore<S>(
     sub.emitter.subscribe,

package/{packages/core → src}/utils/create-emitter.ts

@@ -20,12 +20,14 @@ export interface Emitter<T, P = undefined> {
  */
 export function createEmitter<T, P = undefined>(getSnapshot: () => T, getInitialSnapshot?: () => T): Emitter<T, P> {
   const listeners = new Set<(...params: P[]) => void>()
+  // const listeners = new WeakSet<(...params: P[]) => void>()
   const otherCleaners: Array<() => void> = []
   return {
     clear: () => {
       for (const cleaner of otherCleaners) {
         cleaner()
       }
+
       listeners.clear()
     },
     subscribe: (listener) => {

package/src/utils/global-scheduler.ts

@@ -0,0 +1,75 @@
+import type { SchedulerOptions } from './scheduler'
+import { RESCHEDULE_COUNT, THRESHOLD, THRESHOLD_ITEMS } from './scheduler'
+
+interface GlobalSchedulerItem<T> {
+  value: T
+  id: number
+}
+
+export function createGlobalScheduler() {
+  const listeners = new Map<number, SchedulerOptions<unknown>>()
+  const batches = new Set<GlobalSchedulerItem<unknown>>()
+
+  let frame = performance.now()
+  let scheduled = false
+
+  function schedule() {
+    const startFrame = performance.now()
+    const frameSizeDiffIn = startFrame - frame
+    const { size } = batches
+    if (frameSizeDiffIn < THRESHOLD && size > 0 && size < THRESHOLD_ITEMS) {
+      frame = startFrame
+      flush()
+      return
+    }
+
+    if (!scheduled) {
+      scheduled = true
+      Promise.resolve().then(() => {
+        scheduled = false
+        frame = performance.now()
+        flush()
+      })
+    }
+  }
+
+  function flush() {
+    if (batches.size === 0) {
+      return
+    }
+
+    const effectedListeners = new Set<number>()
+    for (const value of batches) {
+      if (listeners.has(value.id)) {
+        effectedListeners.add(value.id)
+        const { onResolveItem } = listeners.get(value.id)!
+        if (onResolveItem) {
+          onResolveItem(value.value)
+        }
+      }
+      batches.delete(value)
+    }
+
+    if (batches.size > RESCHEDULE_COUNT) {
+      schedule()
+      return
+    }
+
+    for (const id of effectedListeners) {
+      listeners.get(id)?.onFinish()
+    }
+  }
+
+  return {
+    add<T>(id: number, option: SchedulerOptions<T>) {
+      listeners.set(id, option as SchedulerOptions<unknown>)
+      return () => {
+        listeners.delete(id)
+      }
+    },
+    schedule<T>(id: number, value: T) {
+      batches.add({ value, id })
+      schedule()
+    },
+  }
+}

package/{packages/core → src}/utils/is.ts

@@ -1,5 +1,6 @@
 import { Abort } from './common'
 import type { SetStateCb, SetValue } from '../types'
+import type { State } from '../create'
 
 export function isPromise<T>(value: unknown): value is Promise<T> {
   return value instanceof Promise
@@ -41,3 +42,9 @@ export function isAnyOtherError(value: unknown): value is Error {
 export function isUndefined(value: unknown): value is undefined {
   return value === undefined
 }
+
+export function isCreate(value: unknown): value is State<unknown> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  return isFunction(value) && value.set !== undefined
+}

package/{packages/core → src}/utils/scheduler.ts

@@ -1,13 +1,13 @@
-const THRESHOLD = 0.2
-const THRESHOLD_ITEMS = 10
-const RESCHEDULE_COUNT = 0
+export const THRESHOLD = 0.2
+export const THRESHOLD_ITEMS = 10
+export const RESCHEDULE_COUNT = 0
 
-interface Options<T> {
+export interface SchedulerOptions<T> {
   readonly onResolveItem?: (item: T) => void
   readonly onFinish: () => void
 }
 
-export function createScheduler<T>(options: Options<T>) {
+export function createScheduler<T>(options: SchedulerOptions<T>) {
   const batches = new Set<T>()
   const { onResolveItem, onFinish } = options
   let frame = performance.now()

package/{packages/core → src}/utils/sub-memo.ts

@@ -8,15 +8,27 @@ interface CacheItem<T extends AnyFunction> {
 }
 
 const cache = new WeakMap<AnyFunction, CacheItem<AnyFunction>>()
+let cacheCount = 0
+
+export function getDebugCacheCreation() {
+  return cacheCount
+}
+function incrementDebugFunctionCreationCount() {
+  cacheCount++
+}
 
 export function subMemo<F extends AnyFunction>(anyFunction: F) {
+  cacheCount = 0
   return {
     call(): Subscribe<F> {
       const item = cache.get(anyFunction)
       if (item) {
         item.count++
+
         return item.returnType
       }
+
+      incrementDebugFunctionCreationCount()
       const returnType = subscriber(anyFunction)
       const newItem = { count: 1, returnType }
       cache.set(anyFunction, newItem)

package/types/create.d.ts

@@ -1,11 +1,18 @@
 import type { Emitter } from './utils/create-emitter';
 import type { Callable, DefaultValue, IsEqual, Listener, SetValue } from './types';
+export declare const createScheduler: {
+    add<T>(id: number, option: import("./utils/scheduler").SchedulerOptions<T>): () => void;
+    schedule<T>(id: number, value: T): void;
+};
 interface RawState<T> {
     (): T;
     id: number;
     set: (value: SetValue<T>) => void;
     emitter: Emitter<T>;
     listen: Listener<T>;
+    destroy: () => void;
+    withName: (name: string) => RawState<T>;
+    stateName?: string;
 }
 export type State<T> = {
     readonly [K in keyof RawState<T>]: RawState<T>[K];

package/types/debug/development-tools.d.ts

@@ -0,0 +1,10 @@
+export type StateType = 'state' | 'derived';
+interface SendOptions {
+    message?: string;
+    type: StateType;
+    value: unknown;
+    name: string;
+}
+export declare function sendToDevelopmentTools(options: SendOptions): void;
+export declare function developmentToolsListener(name: string, type: StateType): (value: unknown) => void;
+export {};

package/types/utils/global-scheduler.d.ts

@@ -0,0 +1,5 @@
+import type { SchedulerOptions } from './scheduler';
+export declare function createGlobalScheduler(): {
+    add<T>(id: number, option: SchedulerOptions<T>): () => void;
+    schedule<T>(id: number, value: T): void;
+};

package/types/utils/is.d.ts

@@ -1,4 +1,5 @@
 import type { SetStateCb, SetValue } from '../types';
+import type { State } from '../create';
 export declare function isPromise<T>(value: unknown): value is Promise<T>;
 export declare function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T;
 export declare function isMap(value: unknown): value is Map<unknown, unknown>;
@@ -9,3 +10,4 @@ export declare function isSetValueFunction<T>(value: SetValue<T>): value is SetS
 export declare function isAbortError(value: unknown): value is DOMException;
 export declare function isAnyOtherError(value: unknown): value is Error;
 export declare function isUndefined(value: unknown): value is undefined;
+export declare function isCreate(value: unknown): value is State<unknown>;

package/types/utils/scheduler.d.ts

@@ -1,6 +1,8 @@
-interface Options<T> {
+export declare const THRESHOLD = 0.2;
+export declare const THRESHOLD_ITEMS = 10;
+export declare const RESCHEDULE_COUNT = 0;
+export interface SchedulerOptions<T> {
     readonly onResolveItem?: (item: T) => void;
     readonly onFinish: () => void;
 }
-export declare function createScheduler<T>(options: Options<T>): (value: T) => void;
-export {};
+export declare function createScheduler<T>(options: SchedulerOptions<T>): (value: T) => void;

package/types/utils/sub-memo.d.ts

@@ -1,5 +1,6 @@
 import type { Subscribe } from '../subscriber';
 import type { AnyFunction } from '../types';
+export declare function getDebugCacheCreation(): number;
 export declare function subMemo<F extends AnyFunction>(anyFunction: F): {
     call(): Subscribe<F>;
     destroy(): void;

package/packages/core/__tests__/use.test.tsx

@@ -1,76 +0,0 @@
-/* eslint-disable @typescript-eslint/no-shadow */
-/* eslint-disable no-shadow */
-import { act, renderHook } from '@testing-library/react-hooks'
-import { create } from '../create'
-import { use } from '../use'
-import { subscriber } from '../subscriber'
-import { waitFor } from '@testing-library/react'
-
-describe('use-create', () => {
-  const reRendersBefore = jest.fn()
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should test sub hook', async () => {
-    const state = create(1)
-
-    const sub = subscriber(state)
-    expect(sub()).toBe(1)
-
-    act(() => {
-      state.set(2)
-    })
-
-    await waitFor(() => {})
-    expect(sub()).toBe(2)
-  })
-  it('should test use hook', async () => {
-    const state = create(1)
-
-    const { result, waitFor } = renderHook(() => {
-      reRendersBefore()
-      return use(state)
-    })
-
-    state.set(2)
-
-    await waitFor(() => {})
-    expect(result.current).toBe(2)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-
-    state.set(3)
-
-    await waitFor(() => {})
-    expect(result.current).toBe(3)
-    expect(reRendersBefore).toHaveBeenCalledTimes(3)
-  })
-
-  it('should test derived state', async () => {
-    const state1 = create(1)
-    const state2 = create(2)
-
-    function derivedBefore(plusValue: number) {
-      return state1() + state2() + plusValue
-    }
-
-    function derived() {
-      return state1() + state2() + derivedBefore(10)
-    }
-
-    const { result, waitFor } = renderHook(() => {
-      reRendersBefore()
-      return use(derived)
-    })
-
-    act(() => {
-      state1.set(2)
-      state2.set(3)
-    })
-
-    await waitFor(() => {})
-    expect(result.current).toBe(20)
-    expect(reRendersBefore).toHaveBeenCalledTimes(2)
-  })
-})