@lytjs/reactivity 3.1.0

package/dist/index.cjs

@@ -0,0 +1 @@
+var Q=Object.defineProperty;var De=Object.getOwnPropertyDescriptor;var Ge=Object.getOwnPropertyNames;var qe=Object.prototype.hasOwnProperty;var Ne=(e,t)=>{for(var n in t)Q(e,n,{get:t[n],enumerable:!0})},Ue=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of Ge(t))!qe.call(e,r)&&r!==n&&Q(e,r,{get:()=>t[r],enumerable:!(o=De(t,r))||o.enumerable});return e};var Qe=e=>Ue(Q({},"__esModule",{value:!0}),e);var ot={};Ne(ot,{ITERATE_KEY:()=>R,ReactiveEffect:()=>d,activeEffect:()=>c,batch:()=>Fe,clearQueue:()=>_e,computed:()=>Se,computedSignal:()=>Pe,effect:()=>re,enterSignalComponentContext:()=>Je,hasPendingJob:()=>ge,isReactive:()=>w,isReadonly:()=>$,isRef:()=>x,markReadOnly:()=>de,markSkip:()=>be,nextTick:()=>ee,onSignalCleanup:()=>Ie,pauseTracking:()=>I,queueJob:()=>A,queuePostFlushCb:()=>ve,rawSymbol:()=>h,reactive:()=>V,reactiveFlag:()=>S,readonly:()=>q,readonlyFlag:()=>y,ref:()=>ye,refSymbol:()=>g,resetTracking:()=>z,shallowReactive:()=>pe,shallowRef:()=>xe,shallowRefSymbol:()=>B,signal:()=>U,signalEffect:()=>We,stop:()=>ie,toRaw:()=>T,toRef:()=>X,toRefs:()=>me,track:()=>f,trigger:()=>u,triggerRef:()=>Re,unref:()=>Te,untrack:()=>Ke,useSignal:()=>ke,useSignalState:()=>He,watch:()=>Ee,watchEffect:()=>Oe});module.exports=Qe(ot);var c=null,W=[],Ye=0,Y=new WeakMap,d=class{constructor(t,n={}){this.active=!0;this.deps=new Set;this.fn=t,this.scheduler=n.scheduler,this.beforeRun=n.beforeRun,this.afterRun=n.afterRun,this.lazy=n.lazy,this.id=Ye++}run(){var t,n;if(!this.active)return this.fn();if(W.includes(this))return this.fn();try{return(t=this.beforeRun)==null||t.call(this),W.push(this),c=this,ne(this),this.fn()}finally{(n=this.afterRun)==null||n.call(this),W.pop(),c=W[W.length-1]||null}}stop(){this.active&&(ne(this),this.onStop&&this.onStop(),this.active=!1)}},J=!0,oe=[];function I(){oe.push(J),J=!1}function z(){let e=oe.pop();J=e===void 0?!0:e}function ne(e){let{deps:t}=e;for(let n of t)n.delete(e);t.clear()}function f(e,t){if(!J||!c)return;let n=Y.get(e);n||(n=new Map,Y.set(e,n));let o=n.get(t);o||(o=new Set,n.set(t,o)),o.has(c)||(o.add(c),c.deps.add(o))}function u(e,t,n,o){let r=Y.get(e);if(!r)return;let i=new Set,s=a=>{if(a)for(let p of a)(p!==c||p.allowRecurse)&&i.add(p)};if(s(r.get(t)),(n==="add"||n==="delete")&&s(r.get(R)),n==="set"&&Array.isArray(e)){let a=r.get("length");a&&typeof t=="number"&&t<e.length&&s(a)}for(let a of i)a.scheduler?a.scheduler(a):a.run()}var R=Symbol("iterate");function re(e,t={}){let n=new d(e,t);t.lazy||n.run();let o=n.run.bind(n);return o.effect=n,o.stop=()=>n.stop(),o}function ie(e){var t;(t=e==null?void 0:e.effect)==null||t.stop()}var y=Symbol("readonly"),h=Symbol("raw"),S=Symbol("reactive"),ce=Symbol("skip"),se=new WeakMap,ae=new WeakMap,fe=new WeakMap;function F(e){return e!==null&&typeof e=="object"}function ue(e,t){return!Object.is(e,t)}function D(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var G={};["includes","indexOf","lastIndexOf"].forEach(e=>{G[e]=function(...t){let n=T(this);for(let o=0;o<n.length;o++)f(n,String(o));return f(n,"length"),n[e](...t)}});["push","pop","shift","unshift","splice","sort","reverse"].forEach(e=>{G[e]=function(...t){I();let n=Array.prototype[e].apply(this,t);return z(),u(T(this),"length","set",T(this).length),n}});var $e={get(e,t,n){if(t===h)return e;if(t===S)return!0;if(Array.isArray(e)&&G.hasOwnProperty(t))return G[t];f(e,t);let o=Reflect.get(e,t,n);return t===y?e[y]===!0:!F(o)||e[ce]?o:V(o)},set(e,t,n,o){let r=e[t],i=Array.isArray(e)&&le(t)?Number(t)<e.length:D(e,t),s=Reflect.set(e,t,n,o);return(e===(o==null?void 0:o[h])||e===T(o))&&(i?ue(n,r)&&u(e,t,"set",n):u(e,t,"add",n)),s},deleteProperty(e,t){let n=D(e,t),o=Reflect.deleteProperty(e,t);return o&&n&&u(e,t,"delete"),o},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,R),Reflect.ownKeys(e)}},Be={get(e,t,n){if(t===h)return e;if(t===S||t===y)return!0;f(e,t);let o=Reflect.get(e,t,n);return F(o)?q(o):o},set(e,t,n,o){return console.warn(`Set operation on key "${String(t)}" failed: target is readonly.`,e),!0},deleteProperty(e,t){return console.warn(`Delete operation on key "${String(t)}" failed: target is readonly.`,e),!0},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,R),Reflect.ownKeys(e)}},Le={get(e,t,n){return t===h?e:t===S?!0:(f(e,t),Reflect.get(e,t,n))},set(e,t,n,o){let r=e[t],i=Array.isArray(e)&&le(t)?Number(t)<e.length:D(e,t),s=Reflect.set(e,t,n,o);return(e===(o==null?void 0:o[h])||e===T(o))&&(i?ue(n,r)&&u(e,t,"set",n):u(e,t,"add",n)),s},deleteProperty(e,t){let n=D(e,t),o=Reflect.deleteProperty(e,t);return o&&n&&u(e,t,"delete"),o},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,R),Reflect.ownKeys(e)}};function le(e){return typeof e=="string"&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e}function V(e,t={}){if(!F(e)||e[S])return e;if(e[y])return q(e);let n=se.get(e);if(n)return n;let o=new Proxy(e,$e);return se.set(e,o),o}function q(e){if(!F(e))return e;let t=ae.get(e);if(t)return t;e[y]=!0;let n=new Proxy(e,Be);return ae.set(e,n),n}function pe(e){if(!F(e))return e;let t=fe.get(e);if(t)return t;let n=new Proxy(e,Le);return fe.set(e,n),n}function T(e){let t=e&&e[h];return t?T(t):e}function w(e){return $(e)?w(e[h]):!!(e&&e[S])}function $(e){return!!(e&&e[y])}function de(e){return e[y]=!0,e}function be(e){return e[ce]=!0,e}var g=Symbol("ref"),B=Symbol("shallowRef");function Xe(e){return e!==null&&typeof e=="object"}var L=new WeakMap;function Ze(e){return L.get(e)||e}function ye(e){if(x(e))return e;let t={_value:he(e),_rawValue:e,__v_isRef:!0,[g]:!0},n=new Proxy(t,et);return L.set(n,t),n}function he(e){return Xe(e)?V(e):e}var et={get(e,t,n){return t==="value"?(f(e,"value"),e._value):t===g||t==="__v_isRef"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,o){if(t==="value"){let r=e._rawValue;return Object.is(r,n)||(e._rawValue=n,e._value=he(n),u(e,"value","set",n)),!0}return Reflect.set(e,t,n,o)}};function xe(e){if(x(e))return e;let t={_value:e,_rawValue:e,__v_isRef:!0,__v_isShallow:!0,[g]:!0,[B]:!0},n=new Proxy(t,tt);return L.set(n,t),n}var tt={get(e,t,n){return t==="value"?(f(e,"value"),e._value):t===g||t==="__v_isRef"||t==="__v_isShallow"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,o){if(t==="value"){let r=e._rawValue;return Object.is(r,n)||(e._rawValue=n,e._value=n,u(e,"value","set",n)),!0}return Reflect.set(e,t,n,o)}};function x(e){return!!(e&&e.__v_isRef===!0)}function Te(e){return x(e)?e.value:e}function X(e,t){let n=e[t];return x(n)?n:new Proxy({_obj:e,_key:t,__v_isRef:!0},{get(o,r,i){return r==="value"?o._obj[o._key]:r==="__v_isRef"?!0:Reflect.get(o,r,i)},set(o,r,i,s){return r==="value"?(o._obj[o._key]=i,!0):Reflect.set(o,r,i,s)}})}function me(e){let t={};for(let n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=X(e,n));return t}function Re(e){let t=Ze(e);u(t,"value","set",t._rawValue)}var Z=class{constructor(t,n){this._dirty=!0;this.__v_isRef=!0;this.deps=new Set;this._setter=n,this._effect=new d(t,{scheduler:()=>{this._dirty||(this._dirty=!0,this.triggerDep())},lazy:!0}),this._value=void 0}get value(){return f(this,"value"),c&&!this.deps.has(c)&&(this.deps.add(c),c.deps.add(this.deps)),this._dirty&&(this._value=this._effect.run(),this._dirty=!1),this._value}set value(t){this._setter?this._setter(t):console.warn("Computed value is readonly.")}triggerDep(){for(let t of this.deps)t.scheduler?t.scheduler(t):t.run()}};function Se(e){let t,n;return typeof e=="function"?(t=e,n=void 0):(t=e.get,n=e.set),new Z(t,n)}var v=new Set,_=[],N=!1,j=!1,K=null,m=0;function A(e){(!v.has(e)||N&&m<=[...v].indexOf(e))&&(v.add(e),j||(j=!0,K=Promise.resolve().then(we)))}function ve(e){_.includes(e)||(_.push(e),j||(j=!0,K=Promise.resolve().then(we)))}function we(){j=!1,N=!0;let e=[...v].sort((t,n)=>{let o=t.id,r=n.id;return o!=null&&r!=null?o-r:o!=null?-1:r!=null?1:0});for(v.clear(),m=0,m=0;m<e.length;m++){let t=e[m];t()}m=0,nt(),N=!1,K=null}function nt(){if(_.length===0)return;let e=[..._];_.length=0;for(let t=0;t<e.length;t++)e[t]()}function ee(){return(K||Promise.resolve()).then(()=>{})}function ge(e){return v.has(e)}function _e(){v.clear(),_.length=0,N=!1,j=!1,K=null,m=0}function Ce(e){return e!==null&&typeof e=="object"}function M(e,t=1/0,n){if(!Ce(e)||t<=0||(n||(n=new Set),n.has(e)))return e;if(n.add(e),x(e))M(e.value,t-1,n);else if(Array.isArray(e))for(let o=0;o<e.length;o++)M(e[o],t-1,n);else for(let o of Object.keys(e))M(e[o],t-1,n);return e}function je(e){return x(e)?()=>e.value:w(e)?()=>M(e):typeof e=="function"?e:()=>M(e)}function Ee(e,t,n={}){let o,r=!1;if(Array.isArray(e)){r=!0;let l=e.map(P=>je(P));o=()=>l.map(P=>P())}else o=je(e);w(e)&&n.deep!==!1&&(n.deep=!0);let i=r?[]:void 0,s,a=l=>{s=l},p=()=>{s&&(s(),s=void 0);let l=O.run();(r?l.some((P,ze)=>!Object.is(P,i[ze])):!Object.is(l,i)||n.deep&&Ce(l))&&(t(l,r?[...i]:i,a),i=r?[...l]:l)},O=new d(o,{lazy:!0,scheduler:()=>{n.flush==="sync"?p():A(p)}});return n.immediate?p():i=O.run(),()=>{O.stop()}}function Oe(e,t={}){let n,o=()=>{n&&(n(),n=void 0),e(i=>{n=i})},r=new d(o,{scheduler:()=>{t.flush==="sync"?o():A(o)}});return r.run(),()=>{r.stop(),n&&(n(),n=void 0)}}var b=null,k=!1,H=0,C=new Set,te=!1;function U(e){let t=e,n=new Set,o=function(){return b&&!k&&n.add(b),t};return o.set=function(r){Object.is(t,r)||(t=r,Ae(n))},o.update=function(r){o.set(r(t))},o._subscribe=function(r){n.add(r)},o._unsubscribe=function(r){n.delete(r)},o}function Pe(e){let t,n=!0,o=!1,r=new Set,i=new Set,s=function(){if(b&&!k&&i.add(b),n){if(o)throw new Error("[lyt:signal] \u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: computed \u5728\u5176\u81EA\u8EAB\u7684\u8BA1\u7B97\u56FE\u4E2D");o=!0;for(let l of r)l._unsubscribe(s);r.clear();let O=b;b=s;try{t=e()}finally{b=O,o=!1}n=!1}return t},a={_dirty:!1,notify(){n=!0,Ae(i)}};return s.notify=a.notify.bind(a),s._dirty=!1,s._subscribe=function(p){i.add(p)},s._unsubscribe=function(p){i.delete(p)},s}function We(e){let t=null,n=!1,o=new Set,r=()=>{if(n)return;t&&(t(),t=null);for(let a of o)a._unsubscribe(i);o.clear();let s=b;b=i;try{e(a=>{t=a})}finally{b=s}},i={_dirty:!1,notify(){H>0?C.add(i):r()}};return r(),()=>{n=!0,t&&(t(),t=null);for(let s of o)s._unsubscribe(i);o.clear(),C.delete(i)}}function Fe(e){H++;try{e()}finally{H--,H===0&&Ve()}}function Ve(){if(!te){te=!0;try{let e=new Set(C);C.clear();for(let t of e)t.notify();C.size>0&&Ve()}finally{te=!1}}}function Ke(e){let t=k;k=!0;try{return e()}finally{k=t}}function Ae(e){if(H>0)for(let t of e)C.add(t);else for(let t of e)t.notify()}var E=[];function Me(){return E.length>0?E[E.length-1]:null}function ke(e){return e()}function He(e){let t=U(e),n=r=>t.set(r),o=Me();return[t,n]}function Je(){let e={_cleanupFns:[]};return E.push(e),()=>{for(let n of e._cleanupFns)n();e._cleanupFns.length=0;let t=E.indexOf(e);t!==-1&&E.splice(t,1)}}function Ie(e){let t=Me();t&&t._cleanupFns.push(e)}

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+// Type declarations for @lyt/reactivity
+// Auto-generated by bundle.js
+
+export type { ReactiveOptions } from './reactive';
+export type { Ref, UnwrapRef } from './ref';
+export type { SchedulerJob } from './scheduler';

package/dist/index.mjs

@@ -0,0 +1 @@
+var u=null,O=[],xe=0,G=new WeakMap,b=class{constructor(t,n={}){this.active=!0;this.deps=new Set;this.fn=t,this.scheduler=n.scheduler,this.beforeRun=n.beforeRun,this.afterRun=n.afterRun,this.lazy=n.lazy,this.id=xe++}run(){var t,n;if(!this.active)return this.fn();if(O.includes(this))return this.fn();try{return(t=this.beforeRun)==null||t.call(this),O.push(this),u=this,L(this),this.fn()}finally{(n=this.afterRun)==null||n.call(this),O.pop(),u=O[O.length-1]||null}}stop(){this.active&&(L(this),this.onStop&&this.onStop(),this.active=!1)}},k=!0,X=[];function q(){X.push(k),k=!1}function N(){let e=X.pop();k=e===void 0?!0:e}function L(e){let{deps:t}=e;for(let n of t)n.delete(e);t.clear()}function f(e,t){if(!k||!u)return;let n=G.get(e);n||(n=new Map,G.set(e,n));let o=n.get(t);o||(o=new Set,n.set(t,o)),o.has(u)||(o.add(u),u.deps.add(o))}function l(e,t,n,o){let r=G.get(e);if(!r)return;let i=new Set,s=a=>{if(a)for(let p of a)(p!==u||p.allowRecurse)&&i.add(p)};if(s(r.get(t)),(n==="add"||n==="delete")&&s(r.get(S)),n==="set"&&Array.isArray(e)){let a=r.get("length");a&&typeof t=="number"&&t<e.length&&s(a)}for(let a of i)a.scheduler?a.scheduler(a):a.run()}var S=Symbol("iterate");function Te(e,t={}){let n=new b(e,t);t.lazy||n.run();let o=n.run.bind(n);return o.effect=n,o.stop=()=>n.stop(),o}function me(e){var t;(t=e==null?void 0:e.effect)==null||t.stop()}var y=Symbol("readonly"),h=Symbol("raw"),v=Symbol("reactive"),ne=Symbol("skip"),Z=new WeakMap,ee=new WeakMap,te=new WeakMap;function P(e){return e!==null&&typeof e=="object"}function oe(e,t){return!Object.is(e,t)}function H(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var J={};["includes","indexOf","lastIndexOf"].forEach(e=>{J[e]=function(...t){let n=m(this);for(let o=0;o<n.length;o++)f(n,String(o));return f(n,"length"),n[e](...t)}});["push","pop","shift","unshift","splice","sort","reverse"].forEach(e=>{J[e]=function(...t){q();let n=Array.prototype[e].apply(this,t);return N(),l(m(this),"length","set",m(this).length),n}});var Re={get(e,t,n){if(t===h)return e;if(t===v)return!0;if(Array.isArray(e)&&J.hasOwnProperty(t))return J[t];f(e,t);let o=Reflect.get(e,t,n);return t===y?e[y]===!0:!P(o)||e[ne]?o:I(o)},set(e,t,n,o){let r=e[t],i=Array.isArray(e)&&re(t)?Number(t)<e.length:H(e,t),s=Reflect.set(e,t,n,o);return(e===(o==null?void 0:o[h])||e===m(o))&&(i?oe(n,r)&&l(e,t,"set",n):l(e,t,"add",n)),s},deleteProperty(e,t){let n=H(e,t),o=Reflect.deleteProperty(e,t);return o&&n&&l(e,t,"delete"),o},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,S),Reflect.ownKeys(e)}},Se={get(e,t,n){if(t===h)return e;if(t===v||t===y)return!0;f(e,t);let o=Reflect.get(e,t,n);return P(o)?U(o):o},set(e,t,n,o){return console.warn(`Set operation on key "${String(t)}" failed: target is readonly.`,e),!0},deleteProperty(e,t){return console.warn(`Delete operation on key "${String(t)}" failed: target is readonly.`,e),!0},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,S),Reflect.ownKeys(e)}},ve={get(e,t,n){return t===h?e:t===v?!0:(f(e,t),Reflect.get(e,t,n))},set(e,t,n,o){let r=e[t],i=Array.isArray(e)&&re(t)?Number(t)<e.length:H(e,t),s=Reflect.set(e,t,n,o);return(e===(o==null?void 0:o[h])||e===m(o))&&(i?oe(n,r)&&l(e,t,"set",n):l(e,t,"add",n)),s},deleteProperty(e,t){let n=H(e,t),o=Reflect.deleteProperty(e,t);return o&&n&&l(e,t,"delete"),o},has(e,t){return f(e,t),Reflect.has(e,t)},ownKeys(e){return f(e,S),Reflect.ownKeys(e)}};function re(e){return typeof e=="string"&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e}function I(e,t={}){if(!P(e)||e[v])return e;if(e[y])return U(e);let n=Z.get(e);if(n)return n;let o=new Proxy(e,Re);return Z.set(e,o),o}function U(e){if(!P(e))return e;let t=ee.get(e);if(t)return t;e[y]=!0;let n=new Proxy(e,Se);return ee.set(e,n),n}function we(e){if(!P(e))return e;let t=te.get(e);if(t)return t;let n=new Proxy(e,ve);return te.set(e,n),n}function m(e){let t=e&&e[h];return t?m(t):e}function W(e){return ie(e)?W(e[h]):!!(e&&e[v])}function ie(e){return!!(e&&e[y])}function ge(e){return e[y]=!0,e}function _e(e){return e[ne]=!0,e}var F=Symbol("ref"),se=Symbol("shallowRef");function je(e){return e!==null&&typeof e=="object"}var Q=new WeakMap;function Ce(e){return Q.get(e)||e}function Ee(e){if(x(e))return e;let t={_value:ae(e),_rawValue:e,__v_isRef:!0,[F]:!0},n=new Proxy(t,Oe);return Q.set(n,t),n}function ae(e){return je(e)?I(e):e}var Oe={get(e,t,n){return t==="value"?(f(e,"value"),e._value):t===F||t==="__v_isRef"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,o){if(t==="value"){let r=e._rawValue;return Object.is(r,n)||(e._rawValue=n,e._value=ae(n),l(e,"value","set",n)),!0}return Reflect.set(e,t,n,o)}};function Pe(e){if(x(e))return e;let t={_value:e,_rawValue:e,__v_isRef:!0,__v_isShallow:!0,[F]:!0,[se]:!0},n=new Proxy(t,We);return Q.set(n,t),n}var We={get(e,t,n){return t==="value"?(f(e,"value"),e._value):t===F||t==="__v_isRef"||t==="__v_isShallow"?!0:t==="_rawValue"?e._rawValue:Reflect.get(e,t,n)},set(e,t,n,o){if(t==="value"){let r=e._rawValue;return Object.is(r,n)||(e._rawValue=n,e._value=n,l(e,"value","set",n)),!0}return Reflect.set(e,t,n,o)}};function x(e){return!!(e&&e.__v_isRef===!0)}function Fe(e){return x(e)?e.value:e}function fe(e,t){let n=e[t];return x(n)?n:new Proxy({_obj:e,_key:t,__v_isRef:!0},{get(o,r,i){return r==="value"?o._obj[o._key]:r==="__v_isRef"?!0:Reflect.get(o,r,i)},set(o,r,i,s){return r==="value"?(o._obj[o._key]=i,!0):Reflect.set(o,r,i,s)}})}function Ve(e){let t={};for(let n in e)Object.prototype.hasOwnProperty.call(e,n)&&(t[n]=fe(e,n));return t}function Ke(e){let t=Ce(e);l(t,"value","set",t._rawValue)}var Y=class{constructor(t,n){this._dirty=!0;this.__v_isRef=!0;this.deps=new Set;this._setter=n,this._effect=new b(t,{scheduler:()=>{this._dirty||(this._dirty=!0,this.triggerDep())},lazy:!0}),this._value=void 0}get value(){return f(this,"value"),u&&!this.deps.has(u)&&(this.deps.add(u),u.deps.add(this.deps)),this._dirty&&(this._value=this._effect.run(),this._dirty=!1),this._value}set value(t){this._setter?this._setter(t):console.warn("Computed value is readonly.")}triggerDep(){for(let t of this.deps)t.scheduler?t.scheduler(t):t.run()}};function Ae(e){let t,n;return typeof e=="function"?(t=e,n=void 0):(t=e.get,n=e.set),new Y(t,n)}var R=new Set,w=[],z=!1,g=!1,V=null,T=0;function D(e){(!R.has(e)||z&&T<=[...R].indexOf(e))&&(R.add(e),g||(g=!0,V=Promise.resolve().then(ce)))}function Me(e){w.includes(e)||(w.push(e),g||(g=!0,V=Promise.resolve().then(ce)))}function ce(){g=!1,z=!0;let e=[...R].sort((t,n)=>{let o=t.id,r=n.id;return o!=null&&r!=null?o-r:o!=null?-1:r!=null?1:0});for(R.clear(),T=0,T=0;T<e.length;T++){let t=e[T];t()}T=0,ke(),z=!1,V=null}function ke(){if(w.length===0)return;let e=[...w];w.length=0;for(let t=0;t<e.length;t++)e[t]()}function ue(){return(V||Promise.resolve()).then(()=>{})}function He(e){return R.has(e)}function Je(){R.clear(),w.length=0,z=!1,g=!1,V=null,T=0}function pe(e){return e!==null&&typeof e=="object"}function K(e,t=1/0,n){if(!pe(e)||t<=0||(n||(n=new Set),n.has(e)))return e;if(n.add(e),x(e))K(e.value,t-1,n);else if(Array.isArray(e))for(let o=0;o<e.length;o++)K(e[o],t-1,n);else for(let o of Object.keys(e))K(e[o],t-1,n);return e}function le(e){return x(e)?()=>e.value:W(e)?()=>K(e):typeof e=="function"?e:()=>K(e)}function Ie(e,t,n={}){let o,r=!1;if(Array.isArray(e)){r=!0;let c=e.map(E=>le(E));o=()=>c.map(E=>E())}else o=le(e);W(e)&&n.deep!==!1&&(n.deep=!0);let i=r?[]:void 0,s,a=c=>{s=c},p=()=>{s&&(s(),s=void 0);let c=C.run();(r?c.some((E,he)=>!Object.is(E,i[he])):!Object.is(c,i)||n.deep&&pe(c))&&(t(c,r?[...i]:i,a),i=r?[...c]:c)},C=new b(o,{lazy:!0,scheduler:()=>{n.flush==="sync"?p():D(p)}});return n.immediate?p():i=C.run(),()=>{C.stop()}}function ze(e,t={}){let n,o=()=>{n&&(n(),n=void 0),e(i=>{n=i})},r=new b(o,{scheduler:()=>{t.flush==="sync"?o():D(o)}});return r.run(),()=>{r.stop(),n&&(n(),n=void 0)}}var d=null,A=!1,M=0,_=new Set,$=!1;function B(e){let t=e,n=new Set,o=function(){return d&&!A&&n.add(d),t};return o.set=function(r){Object.is(t,r)||(t=r,be(n))},o.update=function(r){o.set(r(t))},o._subscribe=function(r){n.add(r)},o._unsubscribe=function(r){n.delete(r)},o}function De(e){let t,n=!0,o=!1,r=new Set,i=new Set,s=function(){if(d&&!A&&i.add(d),n){if(o)throw new Error("[lyt:signal] \u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: computed \u5728\u5176\u81EA\u8EAB\u7684\u8BA1\u7B97\u56FE\u4E2D");o=!0;for(let c of r)c._unsubscribe(s);r.clear();let C=d;d=s;try{t=e()}finally{d=C,o=!1}n=!1}return t},a={_dirty:!1,notify(){n=!0,be(i)}};return s.notify=a.notify.bind(a),s._dirty=!1,s._subscribe=function(p){i.add(p)},s._unsubscribe=function(p){i.delete(p)},s}function Ge(e){let t=null,n=!1,o=new Set,r=()=>{if(n)return;t&&(t(),t=null);for(let a of o)a._unsubscribe(i);o.clear();let s=d;d=i;try{e(a=>{t=a})}finally{d=s}},i={_dirty:!1,notify(){M>0?_.add(i):r()}};return r(),()=>{n=!0,t&&(t(),t=null);for(let s of o)s._unsubscribe(i);o.clear(),_.delete(i)}}function qe(e){M++;try{e()}finally{M--,M===0&&de()}}function de(){if(!$){$=!0;try{let e=new Set(_);_.clear();for(let t of e)t.notify();_.size>0&&de()}finally{$=!1}}}function Ne(e){let t=A;A=!0;try{return e()}finally{A=t}}function be(e){if(M>0)for(let t of e)_.add(t);else for(let t of e)t.notify()}var j=[];function ye(){return j.length>0?j[j.length-1]:null}function Ue(e){return e()}function Qe(e){let t=B(e),n=r=>t.set(r),o=ye();return[t,n]}function Ye(){let e={_cleanupFns:[]};return j.push(e),()=>{for(let n of e._cleanupFns)n();e._cleanupFns.length=0;let t=j.indexOf(e);t!==-1&&j.splice(t,1)}}function $e(e){let t=ye();t&&t._cleanupFns.push(e)}export{S as ITERATE_KEY,b as ReactiveEffect,u as activeEffect,qe as batch,Je as clearQueue,Ae as computed,De as computedSignal,Te as effect,Ye as enterSignalComponentContext,He as hasPendingJob,W as isReactive,ie as isReadonly,x as isRef,ge as markReadOnly,_e as markSkip,ue as nextTick,$e as onSignalCleanup,q as pauseTracking,D as queueJob,Me as queuePostFlushCb,h as rawSymbol,I as reactive,v as reactiveFlag,U as readonly,y as readonlyFlag,Ee as ref,F as refSymbol,N as resetTracking,we as shallowReactive,Pe as shallowRef,se as shallowRefSymbol,B as signal,Ge as signalEffect,me as stop,m as toRaw,fe as toRef,Ve as toRefs,f as track,l as trigger,Ke as triggerRef,Fe as unref,Ne as untrack,Ue as useSignal,Qe as useSignalState,Ie as watch,ze as watchEffect};

package/dist/types/computed.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Lyt.js 响应式系统 — 计算属性（Computed）
+ *
+ * 计算属性是基于响应式依赖进行缓存的派生值。
+ * 只有当依赖发生变化时才会重新计算，否则返回缓存值。
+ *
+ * 核心机制：
+ * 1. dirty 标记：标记计算值是否过期
+ * 2. 惰性求值：只有在访问 .value 时才计算
+ * 3. 缓存：dirty 为 false 时直接返回缓存值
+ * 4. 依赖传播：当计算属性的值变化时，通知依赖它的副作用
+ *
+ * 实现原理：
+ * - 内部维护一个 ReactiveEffect，getter 作为副作用函数
+ * - 当 getter 中的响应式数据变化时，将 dirty 设为 true
+ * - 当访问 .value 且 dirty 为 true 时，重新执行 getter
+ */
+import { Ref } from './ref';
+/** 计算属性的 getter 函数 */
+export type ComputedGetter<T = any> = () => T;
+/** 计算属性的 setter 函数 */
+export type ComputedSetter<T = any> = (value: T) => void;
+/** computed 选项（支持 getter 或 getter+setter） */
+export interface WritableComputedOptions<T = any> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+/** ComputedRef 接口（只读） */
+export interface ComputedRef<T = any> extends Ref<T> {
+    /** 只读标记 */
+    readonly value: T;
+}
+/** WritableComputedRef 接口（可写） */
+export interface WritableComputedRef<T = any> extends Ref<T> {
+    value: T;
+}
+/**
+ * 创建一个计算属性
+ *
+ * 支持两种用法：
+ * 1. 传入 getter 函数：创建只读计算属性
+ * 2. 传入 { get, set } 对象：创建可写计算属性
+ *
+ * @param getterOrOptions - getter 函数或 { get, set } 选项对象
+ * @returns 计算属性 Ref
+ *
+ * @example
+ * ```ts
+ * const count = ref(1)
+ * const double = computed(() => count.value * 2)
+ * console.log(double.value)  // 2
+ * count.value = 5
+ * console.log(double.value)  // 10（自动重新计算）
+ *
+ * // 可写计算属性
+ * const firstName = ref('Lyt')
+ * const lastName = ref('JS')
+ * const fullName = computed({
+ *   get: () => firstName.value + ' ' + lastName.value,
+ *   set: (val) => {
+ *     const [first, last] = val.split(' ')
+ *     firstName.value = first
+ *     lastName.value = last
+ *   }
+ * })
+ * fullName.value = 'Hello World'  // firstName = 'Hello', lastName = 'World'
+ * ```
+ */
+export declare function computed<T = any>(getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>): ComputedRef<T> | WritableComputedRef<T>;
+//# sourceMappingURL=computed.d.ts.map

package/dist/types/computed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/computed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,OAAO,EAAE,GAAG,EAAoB,MAAM,OAAO,CAAC;AAI9C,sBAAsB;AACtB,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,MAAM,CAAC,CAAC;AAE9C,sBAAsB;AACtB,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAEzD,6CAA6C;AAC7C,MAAM,WAAW,uBAAuB,CAAC,CAAC,GAAG,GAAG;IAC9C,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACvB,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;CACxB;AAED,yBAAyB;AACzB,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAClD,WAAW;IACX,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,iCAAiC;AACjC,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,CAAC,CAAC;CACV;AA4GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,GAAG,EAC9B,eAAe,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,GAC9D,WAAW,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAmBzC"}

package/dist/types/effect.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Lyt.js 响应式系统 — 副作用系统（Effect）
+ *
+ * 核心机制：
+ * 1. 依赖收集（track）：当读取响应式属性时，记录当前正在执行的副作用
+ * 2. 触发更新（trigger）：当修改响应式属性时，通知所有依赖该属性的副作用重新执行
+ *
+ * 数据结构：
+ *   targetMap: WeakMap<target, Map<key, Set<ReactiveEffect>>>
+ *   - 第一层 WeakMap：以目标对象为 key，value 是该对象所有属性的依赖映射
+ *   - 第二层 Map：以属性名为 key，value 是依赖该属性的所有副作用集合
+ *   - 第三层 Set：存储具体的 ReactiveEffect 实例（自动去重）
+ */
+/** 副作用函数类型 */
+export type EffectFn = () => any;
+/** trigger 触发类型 */
+export type TriggerOpTypes = 'add' | 'delete' | 'set';
+/** effect 选项 */
+export interface ReactiveEffectOptions {
+    /** 调度器函数：自定义副作用的执行时机 */
+    scheduler?: (effect: ReactiveEffect) => void;
+    /** 副作用执行前的回调 */
+    beforeRun?: () => void;
+    /** 副作用执行后的回调 */
+    afterRun?: () => void;
+    /** 是否在首次运行时就停止（用于 computed） */
+    lazy?: boolean;
+    /** 是否允许在 stop 后重新激活 */
+    allowRecurse?: boolean;
+    /** 副作用唯一标识（用于调试和排序） */
+    id?: number;
+}
+/**
+ * 当前正在运行的副作用
+ * 在依赖收集时使用，用于将副作用与响应式属性关联
+ */
+export declare let activeEffect: ReactiveEffect | null;
+/**
+ * 响应式副作用类
+ * 封装一个副作用函数，管理其依赖关系和执行生命周期
+ */
+export declare class ReactiveEffect {
+    /** 副作用函数 */
+    fn: EffectFn;
+    /** 调度器（可选） */
+    scheduler?: (effect: ReactiveEffect) => void;
+    /** 副作用执行前的回调 */
+    beforeRun?: () => void;
+    /** 副作用执行后的回调 */
+    afterRun?: () => void;
+    /** 是否惰性执行（首次不自动执行） */
+    lazy?: boolean;
+    /** 是否允许递归 */
+    allowRecurse?: boolean;
+    /** 副作用唯一 ID */
+    id: number;
+    /** 是否处于活跃状态 */
+    active: boolean;
+    /**
+     * 该副作用依赖的所有 dep 集合
+     * 用于在 stop 时从所有 dep 中移除自身
+     * 每个 dep 是一个 Set<ReactiveEffect>
+     */
+    deps: Set<Set<ReactiveEffect>>;
+    constructor(fn: EffectFn, options?: ReactiveEffectOptions);
+    /**
+     * 执行副作用函数
+     * - 将自身压入 effectStack 并设为 activeEffect
+     * - 执行前清理旧依赖（每次执行重新收集依赖）
+     * - 执行完毕后弹出栈
+     *
+     * @returns 副作用函数的返回值
+     */
+    run(): any;
+    /**
+     * 停止该副作用
+     * - 从所有依赖集合中移除自身
+     * - 标记为非活跃状态
+     */
+    stop(): void;
+    /** 停止时的回调（可由外部设置） */
+    onStop?: () => void;
+}
+/**
+ * 暂停依赖收集
+ * 将当前 shouldTrack 状态压入栈中，并设置为 false
+ */
+export declare function pauseTracking(): void;
+/**
+ * 恢复依赖收集
+ * 从栈中弹出上一次的 shouldTrack 状态
+ */
+export declare function resetTracking(): void;
+/**
+ * 依赖收集
+ * 当响应式对象的属性被读取时调用
+ * 将当前活跃的副作用（activeEffect）添加到对应属性的依赖集合中
+ *
+ * @param target - 被读取的目标对象
+ * @param key - 被读取的属性名
+ */
+export declare function track(target: object, key: unknown): void;
+/**
+ * 触发依赖更新
+ * 当响应式对象的属性被修改时调用
+ * 通知所有依赖该属性的副作用重新执行
+ *
+ * @param target - 被修改的目标对象
+ * @param key - 被修改的属性名
+ * @param type - 操作类型：'set'（修改）、'add'（新增）、'delete'（删除）
+ * @param newValue - 新值（可选，用于某些特殊场景）
+ */
+export declare function trigger(target: object, key: unknown, type: TriggerOpTypes, newValue?: any): void;
+/**
+ * 迭代器依赖的 key
+ * 当对象新增或删除属性时，需要触发依赖 ITERATE_KEY 的副作用
+ * （例如 for...in 循环、Object.keys() 等）
+ */
+export declare const ITERATE_KEY: unique symbol;
+/**
+ * 创建响应式副作用
+ *
+ * @param fn - 副作用函数
+ * @param options - 配置选项
+ * @returns 副作用对象（ReactiveEffect 实例）
+ *
+ * @example
+ * ```ts
+ * const obj = reactive({ count: 0 })
+ * const runner = effect(() => {
+ *   console.log(obj.count)
+ * })
+ * obj.count++ // 自动触发副作用重新执行
+ * runner.effect.stop() // 停止副作用
+ * ```
+ */
+export declare function effect(fn: EffectFn, options?: ReactiveEffectOptions): {
+    effect: ReactiveEffect;
+    (): any;
+};
+/**
+ * 停止一个副作用
+ *
+ * @param runner - effect() 返回的 runner 对象
+ */
+export declare function stop(runner: any): void;
+/**
+ * 获取当前 targetMap 的引用（用于调试）
+ * @internal
+ */
+export declare function getTargetMap(): WeakMap<object, Map<any, Set<ReactiveEffect>>>;
+//# sourceMappingURL=effect.d.ts.map

package/dist/types/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/effect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,cAAc;AACd,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC;AAEjC,mBAAmB;AACnB,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEtD,gBAAgB;AAChB,MAAM,WAAW,qBAAqB;IACpC,wBAAwB;IACxB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC7C,gBAAgB;IAChB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,gBAAgB;IAChB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,+BAA+B;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uBAAuB;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uBAAuB;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAID;;;GAGG;AACH,eAAO,IAAI,YAAY,EAAE,cAAc,GAAG,IAAW,CAAC;AAwBtD;;;GAGG;AACH,qBAAa,cAAc;IACzB,YAAY;IACZ,EAAE,EAAE,QAAQ,CAAC;IAEb,cAAc;IACd,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAE7C,gBAAgB;IAChB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IAEvB,gBAAgB;IAChB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAEtB,sBAAsB;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,aAAa;IACb,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB,eAAe;IACf,EAAE,EAAE,MAAM,CAAC;IAEX,eAAe;IACf,MAAM,EAAE,OAAO,CAAQ;IAEvB;;;;OAIG;IACH,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAa;gBAE/B,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAE,qBAA0B;IAS7D;;;;;;;OAOG;IACH,GAAG,IAAI,GAAG;IAkCV;;;;OAIG;IACH,IAAI,IAAI,IAAI;IAYZ,qBAAqB;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAgBD;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAGpC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAGpC;AAqBD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CA2BxD;AAID;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,cAAc,EACpB,QAAQ,CAAC,EAAE,GAAG,GACb,IAAI,CAiDN;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,eAAoB,CAAC;AAI7C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CACpB,EAAE,EAAE,QAAQ,EACZ,OAAO,GAAE,qBAA0B,GAClC;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,IAAI,GAAG,CAAA;CAAE,CAerC;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAEtC;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAE7E"}

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lyt.js 响应式系统 — 统一导出入口
+ *
+ * 导出所有公共 API，供外部使用。
+ * 纯原生零依赖实现。
+ */
+export { effect, stop, ReactiveEffect, track, trigger, ITERATE_KEY, activeEffect, pauseTracking, resetTracking, } from './effect';
+export type { EffectFn, ReactiveEffectOptions, TriggerOpTypes, } from './effect';
+export { reactive, readonly, shallowReactive, toRaw, isReactive, isReadonly, markReadOnly, markSkip, reactiveFlag, readonlyFlag, rawSymbol, } from './reactive';
+export type { ReactiveOptions } from './reactive';
+export { ref, shallowRef, isRef, unref, toRef, toRefs, triggerRef, refSymbol, shallowRefSymbol, } from './ref';
+export type { Ref, UnwrapRef } from './ref';
+export { computed } from './computed';
+export type { ComputedRef, WritableComputedRef, ComputedGetter, ComputedSetter, WritableComputedOptions, } from './computed';
+export { watch, watchEffect, nextTick } from './watch';
+export type { WatchCallback, WatchSource, WatchOptions, WatchEffectOptions, WatchStopHandle, } from './watch';
+export { queueJob, queuePostFlushCb, hasPendingJob, clearQueue, } from './scheduler';
+export type { SchedulerJob } from './scheduler';
+export { signal, computed as computedSignal, effect as signalEffect, batch, untrack, } from './signal';
+export type { Signal, WritableSignal, ComputedSignal, EffectCleanup, } from './signal';
+export { useSignal, useSignalState, enterSignalComponentContext, onSignalCleanup, } from './signal-component';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,MAAM,EACN,IAAI,EACJ,cAAc,EACd,KAAK,EACL,OAAO,EACP,WAAW,EACX,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,QAAQ,EACR,qBAAqB,EACrB,cAAc,GACf,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,KAAK,EACL,UAAU,EACV,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,OAAO,EACL,GAAG,EACH,UAAU,EACV,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,UAAU,EACV,SAAS,EACT,gBAAgB,GACjB,MAAM,OAAO,CAAC;AAEf,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEvD,YAAY,EACV,aAAa,EACb,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,eAAe,GAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EACL,MAAM,EACN,QAAQ,IAAI,cAAc,EAC1B,MAAM,IAAI,YAAY,EACtB,KAAK,EACL,OAAO,GACR,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,MAAM,EACN,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,SAAS,EACT,cAAc,EACd,2BAA2B,EAC3B,eAAe,GAChB,MAAM,oBAAoB,CAAC"}

package/dist/types/reactive.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Lyt.js 响应式系统 — 响应式代理（Reactive）
+ *
+ * 基于 ES6 Proxy 实现的深层响应式代理。
+ * - 拦截 get 进行依赖收集，并对嵌套对象递归代理
+ * - 拦截 set 进行值比较后触发更新
+ * - 拦截 deleteProperty 处理属性删除
+ * - 支持 readonly 和 shallow 模式
+ */
+/** reactive 配置选项 */
+export interface ReactiveOptions {
+    /** 是否深层响应式（默认 true） */
+    deep?: boolean;
+    /** 是否只读（默认 false） */
+    readonly?: boolean;
+}
+/** 只读标记 Symbol */
+export declare const readonlyFlag: unique symbol;
+/** 原始对象标记 Symbol（存储在代理对象上，指向原始对象） */
+export declare const rawSymbol: unique symbol;
+/** 响应式标记 Symbol（存储在原始对象上，标记已被代理） */
+export declare const reactiveFlag: unique symbol;
+/** 跳过代理标记 Symbol */
+export declare const skipFlag: unique symbol;
+/**
+ * 判断值是否为对象（非 null）
+ */
+export declare function isObject(val: unknown): val is object;
+/**
+ * 创建深层响应式代理
+ *
+ * @param target - 要代理的目标对象（必须是对象类型）
+ * @param options - 配置选项
+ * @returns 响应式代理对象
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, nested: { foo: 'bar' } })
+ * effect(() => console.log(state.count))  // 0
+ * state.count++  // 触发 effect，输出 1
+ * ```
+ */
+export declare function reactive<T extends object>(target: T, options?: ReactiveOptions): T;
+/**
+ * 创建只读响应式代理
+ * 所有修改操作都会被阻止并发出警告
+ *
+ * @param target - 要代理的目标对象
+ * @returns 只读代理对象
+ */
+export declare function readonly<T extends object>(target: T): T;
+/**
+ * 创建浅层响应式代理
+ * 只有第一层属性是响应式的，嵌套对象不会被代理
+ *
+ * @param target - 要代理的目标对象
+ * @returns 浅层响应式代理对象
+ */
+export declare function shallowReactive<T extends object>(target: T): T;
+/**
+ * 获取代理对象对应的原始对象
+ * 如果传入的不是代理对象，则原样返回
+ *
+ * @param observed - 代理对象或普通对象
+ * @returns 原始对象
+ */
+export declare function toRaw<T>(observed: T): T;
+/**
+ * 判断一个值是否是响应式代理对象
+ *
+ * @param value - 要检查的值
+ * @returns 是否是响应式代理
+ */
+export declare function isReactive(value: unknown): boolean;
+/**
+ * 判断一个值是否是只读代理对象
+ *
+ * @param value - 要检查的值
+ * @returns 是否是只读代理
+ */
+export declare function isReadonly(value: unknown): boolean;
+/**
+ * 标记一个对象为只读
+ * 用于在 reactive 内部标记嵌套对象
+ *
+ * @param obj - 要标记的对象
+ * @returns 标记后的对象
+ */
+export declare function markReadOnly(obj: object): object;
+/**
+ * 标记一个对象跳过代理
+ * 当 reactive 遇到标记了 skip 的对象时，不会对其子属性进行代理
+ *
+ * @param obj - 要标记的对象
+ * @returns 标记后的对象
+ */
+export declare function markSkip(obj: object): object;
+//# sourceMappingURL=reactive.d.ts.map

package/dist/types/reactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.d.ts","sourceRoot":"","sources":["../../src/reactive.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,oBAAoB;AACpB,MAAM,WAAW,eAAe;IAC9B,uBAAuB;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,qBAAqB;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,kBAAkB;AAClB,eAAO,MAAM,YAAY,eAAqB,CAAC;AAE/C,qCAAqC;AACrC,eAAO,MAAM,SAAS,eAAgB,CAAC;AAEvC,oCAAoC;AACpC,eAAO,MAAM,YAAY,eAAqB,CAAC;AAE/C,oBAAoB;AACpB,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAwBvC;;GAEG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAgVD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,eAAoB,GAC5B,CAAC,CA2BH;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAmBvD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAgB9D;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAIvC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMlD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG5C"}

package/dist/types/ref.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Lyt.js 响应式系统 — Ref（引用类型响应式）
+ *
+ * Ref 用于将基本类型值（string/number/boolean）变为响应式。
+ * 也可以包装对象，此时行为类似 reactive。
+ *
+ * 实现方式：
+ * - 使用一个普通对象 { _value, __v_isRef } 存储值
+ * - 通过 Proxy 拦截 get/set 来实现依赖收集和触发更新
+ * - 当值是对象时，自动用 reactive 进行深层代理
+ */
+/** Ref 标记 Symbol */
+export declare const refSymbol: unique symbol;
+/** ShallowRef 标记 Symbol */
+export declare const shallowRefSymbol: unique symbol;
+/** Ref 接口 */
+export interface Ref<T = any> {
+    /** 存储的值 */
+    value: T;
+    /** Ref 标记 */
+    [refSymbol]: true;
+}
+/** Ref 类型守卫 */
+export type UnwrapRef<T> = T extends Ref<infer V> ? V : T;
+/**
+ * 创建一个 Ref
+ *
+ * - 如果传入的值已经是 Ref，直接返回
+ * - 如果传入的是对象，内部用 reactive 包装
+ * - 返回一个 Proxy，拦截 .value 的读写
+ *
+ * @param value - 初始值
+ * @returns Ref 对象
+ *
+ * @example
+ * ```ts
+ * const count = ref(0)
+ * effect(() => console.log(count.value))  // 0
+ * count.value++  // 触发 effect，输出 1
+ *
+ * const obj = ref({ name: 'lyt' })
+ * effect(() => console.log(obj.value.name))  // 'lyt'
+ * obj.value.name = 'new'  // 触发 effect（深层响应式）
+ * ```
+ */
+export declare function ref<T = any>(value: T): Ref<T>;
+/**
+ * 创建一个浅层 Ref
+ * 与 ref 的区别：当值是对象时，不会用 reactive 包装
+ * 只有 .value 本身的替换会触发更新，对象内部的变化不会触发
+ *
+ * @param value - 初始值
+ * @returns ShallowRef 对象
+ *
+ * @example
+ * ```ts
+ * const state = shallowRef({ count: 0 })
+ * effect(() => console.log(state.value.count))  // 0
+ * state.value.count++  // 不会触发 effect（浅层）
+ * state.value = { count: 1 }  // 触发 effect（替换了 .value）
+ * ```
+ */
+export declare function shallowRef<T = any>(value: T): Ref<T>;
+/**
+ * 判断一个值是否是 Ref
+ *
+ * @param value - 要检查的值
+ * @returns 是否是 Ref
+ */
+export declare function isRef(value: unknown): value is Ref;
+/**
+ * 如果值是 Ref，返回 .value；否则返回值本身
+ * 用于在模板或函数中自动解包 Ref
+ *
+ * @param value - Ref 或普通值
+ * @returns 解包后的值
+ *
+ * @example
+ * ```ts
+ * const count = ref(5)
+ * unref(count)  // 5
+ * unref(10)     // 10
+ * ```
+ */
+export declare function unref<T>(value: T | Ref<T>): T;
+/**
+ * 为响应式对象的某个属性创建一个 Ref
+ * 创建的 Ref 与原始对象的属性保持双向同步
+ *
+ * @param object - 响应式对象
+ * @param key - 属性名
+ * @returns 与属性关联的 Ref
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 })
+ * const countRef = toRef(state, 'count')
+ * countRef.value++  // state.count 也变为 1
+ * state.count++     // countRef.value 也变为 2
+ * ```
+ */
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): Ref<T[K]>;
+/**
+ * 将响应式对象的所有属性转换为 Ref
+ * 返回一个与原始对象结构相同的普通对象，每个属性都是 Ref
+ *
+ * @param object - 响应式对象
+ * @returns 属性全部为 Ref 的普通对象
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, name: 'lyt' })
+ * const refs = toRefs(state)
+ * refs.count.value++  // state.count 也变为 1
+ * refs.name.value = 'new'  // state.name 也变为 'new'
+ * ```
+ */
+export declare function toRefs<T extends object>(object: T): {
+    [K in keyof T]: Ref<T[K]>;
+};
+/**
+ * 触发 Ref 的更新（手动触发）
+ * 主要用于 shallowRef 中修改对象内部属性后手动触发更新
+ *
+ * @param ref - 要触发的 Ref
+ */
+export declare function triggerRef(ref: Ref): void;
+//# sourceMappingURL=ref.d.ts.map

package/dist/types/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,oBAAoB;AACpB,eAAO,MAAM,SAAS,eAAgB,CAAC;AAEvC,2BAA2B;AAC3B,eAAO,MAAM,gBAAgB,eAAuB,CAAC;AAErD,aAAa;AACb,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,GAAG;IAC1B,WAAW;IACX,KAAK,EAAE,CAAC,CAAC;IACT,aAAa;IACb,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;CACnB;AAED,eAAe;AACf,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AA4B1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAkB7C;AA8DD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAkBpD;AA6CD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAElD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACvD,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,CAAC,GACL,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAyBX;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG;KAClD,CAAC,IAAI,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC1B,CAUA;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAIzC"}

package/dist/types/scheduler.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Lyt.js 响应式系统 — 调度器（Scheduler）
+ *
+ * 基于 Promise 微任务实现异步批量更新队列。
+ * 当响应式数据变化时，副作用函数不会立即执行，
+ * 而是被推入队列，在下一个微任务中统一批量执行，
+ * 避免同一个 tick 内重复执行相同的副作用。
+ */
+/** 调度任务（副作用函数）类型 */
+export type SchedulerJob = (...args: any[]) => void;
+/**
+ * 将一个 job 加入调度队列
+ * - 使用 Set 自动去重，同一个 job 只会被执行一次
+ * - 如果队列尚未安排刷新，则通过 Promise.resolve 安排微任务
+ *
+ * @param job - 要调度的副作用函数
+ */
+export declare function queueJob(job: SchedulerJob): void;
+/**
+ * 将回调加入 post-flush 队列
+ * 这些回调会在主队列刷新完毕后执行
+ *
+ * @param cb - 要在队列刷新后执行的回调
+ */
+export declare function queuePostFlushCb(cb: SchedulerJob): void;
+/**
+ * 获取当前刷新 Promise
+ * 可用于等待当前队列刷新完毕
+ *
+ * @returns 当前微任务的 Promise，如果没有则返回已 resolved 的 Promise
+ */
+export declare function nextTick(): Promise<void>;
+/**
+ * 查询队列中是否包含指定的 job
+ *
+ * @param job - 要查询的 job
+ * @returns 是否在队列中
+ */
+export declare function hasPendingJob(job: SchedulerJob): boolean;
+/**
+ * 清空队列中的所有待执行 job（主要用于测试）
+ */
+export declare function clearQueue(): void;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/types/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,oBAAoB;AACpB,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAwBpD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI,CAchD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAWvD;AA2DD;;;;;GAKG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAGxC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAOjC"}

package/dist/types/signal-component.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Lyt.js Signal 组件集成辅助模块
+ *
+ * 提供 Signal 与组件渲染函数之间的桥接工具。
+ * 纯原生零依赖实现，无 DOM / 浏览器 API 依赖。
+ */
+import { type Signal, type WritableSignal } from './signal';
+/**
+ * 在组件渲染函数中追踪 Signal 依赖
+ *
+ * 读取 Signal 的值并自动建立依赖追踪。
+ * 当 Signal 变化时，会触发关联的 effect 重新执行。
+ *
+ * @param sig 要追踪的 Signal
+ * @returns Signal 的当前值
+ */
+export declare function useSignal<T>(sig: Signal<T>): T;
+/**
+ * 创建一个与组件生命周期绑定的 Signal 状态
+ *
+ * 返回一个元组 [signal, setter]：
+ *   - signal: WritableSignal 实例
+ *   - setter: 便捷的值设置函数
+ *
+ * 当组件卸载时，关联的 effect 会自动清理。
+ *
+ * @param initialValue 初始值
+ * @returns [WritableSignal, setter] 元组
+ */
+export declare function useSignalState<T>(initialValue: T): [WritableSignal<T>, (value: T) => void];
+/**
+ * 进入组件 Signal 上下文
+ *
+ * 在组件渲染/挂载时调用，用于追踪组件级别的 Signal effect。
+ *
+ * @returns 退出上下文的函数
+ */
+export declare function enterSignalComponentContext(): () => void;
+/**
+ * 在当前组件上下文中注册清理函数
+ *
+ * @param cleanup 清理函数
+ */
+export declare function onSignalCleanup(cleanup: () => void): void;
+//# sourceMappingURL=signal-component.d.ts.map

package/dist/types/signal-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-component.d.ts","sourceRoot":"","sources":["../../src/signal-component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAkB,KAAK,MAAM,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AA4B3E;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAG9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAYzC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAmBxD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAKzD"}

package/dist/types/signal.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Lyt.js Signal 响应式系统
+ *
+ * 基于 Signal 的细粒度响应式实现（类似 Solid.js / Angular Signals / Preact Signals）。
+ * 纯原生零依赖实现，无 DOM / 浏览器 API 依赖。
+ *
+ * 核心概念：
+ *   - Signal: 可写信号，存储值并在变化时通知订阅者
+ *   - ComputedSignal: 只读计算信号，自动追踪依赖并惰性求值
+ *   - Effect: 副作用，自动追踪依赖并在变化时重新执行
+ *   - Batch: 批量更新，延迟通知直到最外层 batch 完成
+ *   - Untrack: 在不创建订阅的情况下读取信号
+ */
+/** Signal 只读接口 — 调用即读取值 */
+export interface Signal<T> {
+    (): T;
+}
+/** WritableSignal — 可写信号，支持 set / update */
+export interface WritableSignal<T> extends Signal<T> {
+    set(value: T): void;
+    update(fn: (prev: T) => T): void;
+}
+/** ComputedSignal — 只读计算信号 */
+export interface ComputedSignal<T> extends Signal<T> {
+}
+/** Effect 清理回调 */
+export type EffectCleanup = () => void;
+/**
+ * 创建一个可写信号
+ *
+ * @param initialValue 初始值
+ * @returns WritableSignal 实例
+ */
+export declare function signal<T>(initialValue: T): WritableSignal<T>;
+/**
+ * 创建一个计算信号（只读、惰性求值）
+ *
+ * @param fn 计算函数
+ * @returns ComputedSignal 实例
+ */
+export declare function computed<T>(fn: () => T): ComputedSignal<T>;
+/**
+ * 创建副作用
+ *
+ * @param fn 副作用函数，接收 onCleanup 回调
+ * @returns dispose 函数，调用后停止副作用
+ */
+export declare function effect(fn: (onCleanup: (cleanup: EffectCleanup) => void) => void): () => void;
+/**
+ * 批量更新
+ *
+ * 在 batch 内的 signal 更新不会立即触发 effect，
+ * 而是延迟到最外层 batch 完成后统一执行。
+ *
+ * @param fn 批量操作函数
+ */
+export declare function batch(fn: () => void): void;
+/**
+ * 在不创建订阅的情况下执行函数
+ *
+ * @param fn 要执行的函数
+ * @returns 函数返回值
+ */
+export declare function untrack<T>(fn: () => T): T;
+//# sourceMappingURL=signal.d.ts.map

package/dist/types/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,2BAA2B;AAC3B,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,IAAI,CAAC,CAAA;CACN;AAED,4CAA4C;AAC5C,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAClD,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAA;IACnB,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;CACjC;AAED,8BAA8B;AAC9B,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;CAEnD;AAED,kBAAkB;AAClB,MAAM,MAAM,aAAa,GAAG,MAAM,IAAI,CAAA;AAyCtC;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAiC5D;AAMD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAgE1D;AAMD;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,KAAK,IAAI,GACxD,MAAM,IAAI,CA6DZ;AAMD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAU1C;AA4BD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzC"}

package/dist/types/watch.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Lyt.js 响应式系统 — 侦听器（Watch）
+ *
+ * watch 和 watchEffect 用于观察响应式数据的变化并执行副作用。
+ *
+ * watch:
+ *   - 显式指定侦听源（ref/reactive/getter/数组）
+ *   - 回调接收新值和旧值
+ *   - 默认懒执行（不会立即执行回调）
+ *
+ * watchEffect:
+ *   - 自动收集依赖（不需要显式指定源）
+ *   - 立即执行一次
+ *   - 回调不接收参数
+ *
+ * nextTick:
+ *   - 在下一个微任务中执行回调
+ *   - 等待 DOM 更新后执行
+ */
+import { Ref } from './ref';
+import { nextTick as schedulerNextTick } from './scheduler';
+/** watch 回调函数类型 */
+export type WatchCallback<T = any, O = T> = (newValue: T, oldValue: O, onCleanup: (cleanupFn: () => void) => void) => void;
+/** watch 源类型：可以是 ref、reactive 对象、getter 函数或它们的数组 */
+export type WatchSource<T = any> = Ref<T> | (() => T) | {
+    [key: string]: any;
+};
+/** watch 选项 */
+export interface WatchOptions {
+    /** 是否立即执行回调（默认 false） */
+    immediate?: boolean;
+    /** 是否深度侦听（默认 true，对 reactive 对象自动开启） */
+    deep?: boolean;
+    /** 是否在组件卸载时自动停止（预留） */
+    flush?: 'pre' | 'post' | 'sync';
+}
+/** watchEffect 选项 */
+export interface WatchEffectOptions {
+    /** 副作用执行前的回调 */
+    onTrack?: (event: any) => void;
+    /** 副作用触发时的回调 */
+    onTrigger?: (event: any) => void;
+    /** 刷新时机 */
+    flush?: 'pre' | 'post' | 'sync';
+}
+/** watch 停止句柄 */
+export type WatchStopHandle = () => void;
+/**
+ * 侦听一个或多个响应式数据源，并在数据变化时执行回调
+ *
+ * @param source - 侦听源（ref / reactive / getter / 数组）
+ * @param cb - 变化时的回调函数，接收 (newValue, oldValue, onCleanup)
+ * @param options - 配置选项
+ * @returns 停止侦听的函数
+ *
+ * @example
+ * ```ts
+ * // 侦听 ref
+ * const count = ref(0)
+ * const stop = watch(count, (newVal, oldVal) => {
+ *   console.log(`count: ${oldVal} -> ${newVal}`)
+ * })
+ * count.value++  // 输出: count: 0 -> 1
+ * stop()  // 停止侦听
+ *
+ * // 侦听 getter
+ * watch(
+ *   () => state.count + state.name,
+ *   (newVal, oldVal) => console.log(newVal, oldVal)
+ * )
+ *
+ * // 侦听多个源
+ * watch([count, name], ([newCount, newName], [oldCount, oldName]) => {
+ *   console.log(newCount, newName)
+ * })
+ *
+ * // 立即执行
+ * watch(count, (val) => console.log(val), { immediate: true })
+ * ```
+ */
+export declare function watch<T = any>(source: WatchSource<T> | WatchSource<T>[], cb: WatchCallback<T>, options?: WatchOptions): WatchStopHandle;
+/**
+ * 立即运行一个函数，同时响应式地追踪其依赖
+ * 当依赖变化时自动重新执行
+ *
+ * @param fn - 要执行的副作用函数
+ * @param options - 配置选项
+ * @returns 停止侦听的函数
+ *
+ * @example
+ * ```ts
+ * const count = ref(0)
+ * const stop = watchEffect(() => {
+ *   console.log(`count is: ${count.value}`)
+ * })
+ * // 立即输出: count is: 0
+ * count.value++  // 输出: count is: 1
+ * stop()  // 停止侦听
+ *
+ * // 带清理函数
+ * watchEffect((onCleanup) => {
+ *   const timer = setInterval(() => console.log('tick'), 1000)
+ *   onCleanup(() => clearInterval(timer))  // 依赖变化时清理
+ * })
+ * ```
+ */
+export declare function watchEffect(fn: (onCleanup: (cleanupFn: () => void) => void) => void, options?: WatchEffectOptions): WatchStopHandle;
+/**
+ * 在下一个微任务中执行回调
+ * 等待当前所有响应式更新完成后再执行
+ *
+ * @returns Promise
+ *
+ * @example
+ * ```ts
+ * await nextTick()
+ * // 此时 DOM 已更新完毕
+ *
+ * nextTick().then(() => {
+ *   console.log('更新完成')
+ * })
+ * ```
+ */
+export { schedulerNextTick as nextTick };
+//# sourceMappingURL=watch.d.ts.map

package/dist/types/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/watch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,EAAS,GAAG,EAAS,MAAM,OAAO,CAAC;AAE1C,OAAO,EAAY,QAAQ,IAAI,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAItE,mBAAmB;AACnB,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAC1C,QAAQ,EAAE,CAAC,EACX,QAAQ,EAAE,CAAC,EACX,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,IAAI,KAAK,IAAI,KACvC,IAAI,CAAC;AAEV,oDAAoD;AACpD,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,GAAG,IAC3B,GAAG,CAAC,CAAC,CAAC,GACN,CAAC,MAAM,CAAC,CAAC,GACT;IACE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAEN,eAAe;AACf,MAAM,WAAW,YAAY;IAC3B,yBAAyB;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wCAAwC;IACxC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uBAAuB;IACvB,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;CACjC;AAED,qBAAqB;AACrB,MAAM,WAAW,kBAAkB;IACjC,gBAAgB;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,gBAAgB;IAChB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACjC,WAAW;IACX,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;CACjC;AAED,iBAAiB;AACjB,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC;AA8EzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,GAAG,EAC3B,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,EACzC,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,YAAiB,GACzB,eAAe,CAqFjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,EACxD,OAAO,GAAE,kBAAuB,GAC/B,eAAe,CAuCjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lytjs/reactivity",
+  "version": "3.1.0",
+  "description": "Lyt.js 响应式系统 - 提供响应式数据、计算属性、侦听器等核心响应式能力",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "sideEffects": false,
+  "files": ["dist"],
+  "license": "MIT",
+  "author": "lytjs",
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/@lytjs/lytjs"
+  },
+  "homepage": "https://gitee.com/@lytjs/lytjs",
+  "keywords": [
+    "lyt",
+    "lytjs",
+    "javascript",
+    "framework",
+    "frontend",
+    "vue-like",
+    "lightweight",
+    "zero-dependency",
+    "reactivity",
+    "reactive",
+    "ref",
+    "computed",
+    "watch",
+    "effect",
+    "响应式"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}