842 lines
22 KiB
JavaScript
842 lines
22 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
|
|
// src/system.ts
|
|
var DirtyLevels = /* @__PURE__ */ ((DirtyLevels2) => {
|
|
DirtyLevels2[DirtyLevels2["None"] = 0] = "None";
|
|
DirtyLevels2[DirtyLevels2["SideEffectsOnly"] = 1] = "SideEffectsOnly";
|
|
DirtyLevels2[DirtyLevels2["MaybeDirty"] = 2] = "MaybeDirty";
|
|
DirtyLevels2[DirtyLevels2["Dirty"] = 3] = "Dirty";
|
|
DirtyLevels2[DirtyLevels2["Released"] = 4] = "Released";
|
|
return DirtyLevels2;
|
|
})(DirtyLevels || {});
|
|
var System;
|
|
((System2) => {
|
|
System2.activeSub = void 0;
|
|
System2.activeEffectScope = void 0;
|
|
System2.activeTrackId = 0;
|
|
System2.activeEffectScopeTrackId = 0;
|
|
System2.batchDepth = 0;
|
|
System2.lastTrackId = 0;
|
|
System2.queuedEffects = void 0;
|
|
System2.queuedEffectsTail = void 0;
|
|
})(System || (System = {}));
|
|
function startBatch() {
|
|
System.batchDepth++;
|
|
}
|
|
function endBatch() {
|
|
System.batchDepth--;
|
|
if (System.batchDepth === 0) {
|
|
while (System.queuedEffects !== void 0) {
|
|
const effect3 = System.queuedEffects;
|
|
const queuedNext = System.queuedEffects.nextNotify;
|
|
if (queuedNext !== void 0) {
|
|
System.queuedEffects.nextNotify = void 0;
|
|
System.queuedEffects = queuedNext;
|
|
} else {
|
|
System.queuedEffects = void 0;
|
|
System.queuedEffectsTail = void 0;
|
|
}
|
|
effect3.notify();
|
|
}
|
|
}
|
|
}
|
|
var Link;
|
|
((Link2) => {
|
|
Link2.pool = void 0;
|
|
})(Link || (Link = {}));
|
|
var Dependency;
|
|
((Dependency2) => {
|
|
const system = System;
|
|
function linkSubscriber(dep, sub) {
|
|
const depsTail = sub.depsTail;
|
|
const old = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
|
|
if (old === void 0 || old.dep !== dep) {
|
|
let newLink;
|
|
if (Link.pool !== void 0) {
|
|
newLink = Link.pool;
|
|
Link.pool = newLink.nextDep;
|
|
newLink.nextDep = old;
|
|
newLink.dep = dep;
|
|
newLink.sub = sub;
|
|
newLink.trackId = sub.trackId;
|
|
} else {
|
|
newLink = {
|
|
dep,
|
|
sub,
|
|
trackId: sub.trackId,
|
|
nextDep: old,
|
|
prevSub: void 0,
|
|
nextSub: void 0
|
|
};
|
|
}
|
|
if (depsTail === void 0) {
|
|
sub.deps = newLink;
|
|
} else {
|
|
depsTail.nextDep = newLink;
|
|
}
|
|
if (dep.subs === void 0) {
|
|
dep.subs = newLink;
|
|
} else {
|
|
const oldTail = dep.subsTail;
|
|
newLink.prevSub = oldTail;
|
|
oldTail.nextSub = newLink;
|
|
}
|
|
sub.depsTail = newLink;
|
|
dep.subsTail = newLink;
|
|
} else {
|
|
old.trackId = sub.trackId;
|
|
sub.depsTail = old;
|
|
}
|
|
}
|
|
Dependency2.linkSubscriber = linkSubscriber;
|
|
function propagate(subs) {
|
|
let link = subs;
|
|
let dep = subs.dep;
|
|
let dirtyLevel = 3 /* Dirty */;
|
|
let remainingQuantity = 0;
|
|
do {
|
|
if (link !== void 0) {
|
|
const sub = link.sub;
|
|
if (sub.trackId > 0) {
|
|
if (sub.trackId === link.trackId) {
|
|
const subDirtyLevel = sub.dirtyLevel;
|
|
if (subDirtyLevel < dirtyLevel) {
|
|
sub.dirtyLevel = dirtyLevel;
|
|
if (subDirtyLevel === 0 /* None */) {
|
|
sub.canPropagate = true;
|
|
}
|
|
}
|
|
}
|
|
} else if (sub.trackId === -link.trackId) {
|
|
const subDirtyLevel = sub.dirtyLevel;
|
|
const notDirty = subDirtyLevel === 0 /* None */;
|
|
if (subDirtyLevel < dirtyLevel) {
|
|
sub.dirtyLevel = dirtyLevel;
|
|
}
|
|
if (notDirty || sub.canPropagate) {
|
|
if (!notDirty) {
|
|
sub.canPropagate = false;
|
|
}
|
|
const subIsEffect = "notify" in sub;
|
|
if ("subs" in sub && sub.subs !== void 0) {
|
|
sub.depsTail.nextDep = link;
|
|
dep = sub;
|
|
link = sub.subs;
|
|
if (subIsEffect) {
|
|
dirtyLevel = 1 /* SideEffectsOnly */;
|
|
} else {
|
|
dirtyLevel = 2 /* MaybeDirty */;
|
|
}
|
|
remainingQuantity++;
|
|
continue;
|
|
} else if (subIsEffect) {
|
|
const queuedEffectsTail = system.queuedEffectsTail;
|
|
if (queuedEffectsTail !== void 0) {
|
|
queuedEffectsTail.nextNotify = sub;
|
|
} else {
|
|
system.queuedEffects = sub;
|
|
}
|
|
system.queuedEffectsTail = sub;
|
|
}
|
|
}
|
|
}
|
|
link = link.nextSub;
|
|
continue;
|
|
}
|
|
if (remainingQuantity !== 0) {
|
|
const depsTail = dep.depsTail;
|
|
const prevLink = depsTail.nextDep;
|
|
const prevSub = prevLink.sub;
|
|
depsTail.nextDep = void 0;
|
|
dep = prevLink.dep;
|
|
link = prevLink.nextSub;
|
|
remainingQuantity--;
|
|
if (remainingQuantity === 0) {
|
|
dirtyLevel = 3 /* Dirty */;
|
|
} else if ("notify" in dep) {
|
|
dirtyLevel = 1 /* SideEffectsOnly */;
|
|
} else {
|
|
dirtyLevel = 2 /* MaybeDirty */;
|
|
}
|
|
if ("notify" in prevSub) {
|
|
const queuedEffectsTail = system.queuedEffectsTail;
|
|
if (queuedEffectsTail !== void 0) {
|
|
queuedEffectsTail.nextNotify = prevSub;
|
|
} else {
|
|
system.queuedEffects = prevSub;
|
|
}
|
|
system.queuedEffectsTail = prevSub;
|
|
}
|
|
continue;
|
|
}
|
|
break;
|
|
} while (true);
|
|
}
|
|
Dependency2.propagate = propagate;
|
|
})(Dependency || (Dependency = {}));
|
|
var Subscriber;
|
|
((Subscriber2) => {
|
|
const system = System;
|
|
function runInnerEffects(link) {
|
|
while (link !== void 0) {
|
|
const dep = link.dep;
|
|
if ("notify" in dep) {
|
|
dep.notify();
|
|
}
|
|
link = link.nextDep;
|
|
}
|
|
}
|
|
Subscriber2.runInnerEffects = runInnerEffects;
|
|
function resolveMaybeDirty(sub, depth = 0) {
|
|
let link = sub.deps;
|
|
while (link !== void 0) {
|
|
const dep = link.dep;
|
|
if ("update" in dep) {
|
|
const dirtyLevel = dep.dirtyLevel;
|
|
if (dirtyLevel === 2 /* MaybeDirty */) {
|
|
if (depth >= 4) {
|
|
resolveMaybeDirtyNonRecursive(dep);
|
|
} else {
|
|
resolveMaybeDirty(dep, depth + 1);
|
|
}
|
|
if (dep.dirtyLevel === 3 /* Dirty */) {
|
|
dep.update();
|
|
if (sub.dirtyLevel === 3 /* Dirty */) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (dirtyLevel === 3 /* Dirty */) {
|
|
dep.update();
|
|
if (sub.dirtyLevel === 3 /* Dirty */) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
link = link.nextDep;
|
|
}
|
|
if (sub.dirtyLevel === 2 /* MaybeDirty */) {
|
|
sub.dirtyLevel = 0 /* None */;
|
|
}
|
|
}
|
|
Subscriber2.resolveMaybeDirty = resolveMaybeDirty;
|
|
function resolveMaybeDirtyNonRecursive(sub) {
|
|
let link = sub.deps;
|
|
let remaining = 0;
|
|
do {
|
|
if (link !== void 0) {
|
|
const dep = link.dep;
|
|
if ("update" in dep) {
|
|
const depDirtyLevel = dep.dirtyLevel;
|
|
if (depDirtyLevel === 2 /* MaybeDirty */) {
|
|
dep.subs.prevSub = link;
|
|
sub = dep;
|
|
link = dep.deps;
|
|
remaining++;
|
|
continue;
|
|
} else if (depDirtyLevel === 3 /* Dirty */) {
|
|
dep.update();
|
|
if (sub.dirtyLevel === 3 /* Dirty */) {
|
|
if (remaining !== 0) {
|
|
const subSubs = sub.subs;
|
|
const prevLink = subSubs.prevSub;
|
|
sub.update();
|
|
subSubs.prevSub = void 0;
|
|
sub = prevLink.sub;
|
|
link = prevLink.nextDep;
|
|
remaining--;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
link = link.nextDep;
|
|
continue;
|
|
}
|
|
const dirtyLevel = sub.dirtyLevel;
|
|
if (dirtyLevel === 2 /* MaybeDirty */) {
|
|
sub.dirtyLevel = 0 /* None */;
|
|
if (remaining !== 0) {
|
|
const subSubs = sub.subs;
|
|
const prevLink = subSubs.prevSub;
|
|
subSubs.prevSub = void 0;
|
|
sub = prevLink.sub;
|
|
link = prevLink.nextDep;
|
|
remaining--;
|
|
continue;
|
|
}
|
|
} else if (remaining !== 0) {
|
|
if (dirtyLevel === 3 /* Dirty */) {
|
|
sub.update();
|
|
}
|
|
const subSubs = sub.subs;
|
|
const prevLink = subSubs.prevSub;
|
|
subSubs.prevSub = void 0;
|
|
sub = prevLink.sub;
|
|
link = prevLink.nextDep;
|
|
remaining--;
|
|
continue;
|
|
}
|
|
break;
|
|
} while (true);
|
|
}
|
|
Subscriber2.resolveMaybeDirtyNonRecursive = resolveMaybeDirtyNonRecursive;
|
|
function startTrackDependencies(sub) {
|
|
const newVersion = system.lastTrackId + 1;
|
|
const prevSub = system.activeSub;
|
|
system.activeSub = sub;
|
|
system.activeTrackId = newVersion;
|
|
system.lastTrackId = newVersion;
|
|
sub.depsTail = void 0;
|
|
sub.trackId = newVersion;
|
|
sub.dirtyLevel = 0 /* None */;
|
|
return prevSub;
|
|
}
|
|
Subscriber2.startTrackDependencies = startTrackDependencies;
|
|
function endTrackDependencies(sub, prevSub) {
|
|
if (prevSub !== void 0) {
|
|
system.activeSub = prevSub;
|
|
system.activeTrackId = prevSub.trackId;
|
|
} else {
|
|
system.activeSub = void 0;
|
|
system.activeTrackId = 0;
|
|
}
|
|
const depsTail = sub.depsTail;
|
|
if (depsTail !== void 0) {
|
|
if (depsTail.nextDep !== void 0) {
|
|
clearTrack(depsTail.nextDep);
|
|
depsTail.nextDep = void 0;
|
|
}
|
|
} else if (sub.deps !== void 0) {
|
|
clearTrack(sub.deps);
|
|
sub.deps = void 0;
|
|
}
|
|
sub.trackId = -sub.trackId;
|
|
}
|
|
Subscriber2.endTrackDependencies = endTrackDependencies;
|
|
function clearTrack(link) {
|
|
do {
|
|
const nextDep = link.nextDep;
|
|
const dep = link.dep;
|
|
const nextSub = link.nextSub;
|
|
const prevSub = link.prevSub;
|
|
if (nextSub !== void 0) {
|
|
nextSub.prevSub = prevSub;
|
|
}
|
|
if (prevSub !== void 0) {
|
|
prevSub.nextSub = nextSub;
|
|
}
|
|
if (nextSub === void 0) {
|
|
dep.subsTail = prevSub;
|
|
}
|
|
if (prevSub === void 0) {
|
|
dep.subs = nextSub;
|
|
}
|
|
link.dep = void 0;
|
|
link.sub = void 0;
|
|
link.prevSub = void 0;
|
|
link.nextSub = void 0;
|
|
link.nextDep = Link.pool;
|
|
Link.pool = link;
|
|
if (dep.subs === void 0 && "deps" in dep) {
|
|
dep.dirtyLevel = 4 /* Released */;
|
|
if (dep.deps !== void 0) {
|
|
link = dep.deps;
|
|
dep.depsTail.nextDep = nextDep;
|
|
dep.deps = void 0;
|
|
dep.depsTail = void 0;
|
|
continue;
|
|
}
|
|
}
|
|
link = nextDep;
|
|
} while (link !== void 0);
|
|
}
|
|
Subscriber2.clearTrack = clearTrack;
|
|
function startTrackEffects(sub) {
|
|
const newVersion = system.lastTrackId + 1;
|
|
const prevSub = system.activeEffectScope;
|
|
system.activeEffectScope = sub;
|
|
system.activeEffectScopeTrackId = newVersion;
|
|
system.lastTrackId = newVersion;
|
|
sub.depsTail = void 0;
|
|
sub.trackId = newVersion;
|
|
sub.dirtyLevel = 0 /* None */;
|
|
return prevSub;
|
|
}
|
|
Subscriber2.startTrackEffects = startTrackEffects;
|
|
function endTrackEffects(sub, prevSub) {
|
|
if (prevSub !== void 0) {
|
|
system.activeEffectScope = prevSub;
|
|
system.activeEffectScopeTrackId = prevSub.trackId;
|
|
} else {
|
|
system.activeEffectScope = void 0;
|
|
system.activeEffectScopeTrackId = 0;
|
|
}
|
|
const depsTail = sub.depsTail;
|
|
if (depsTail !== void 0) {
|
|
if (depsTail.nextDep !== void 0) {
|
|
clearTrack(depsTail.nextDep);
|
|
depsTail.nextDep = void 0;
|
|
}
|
|
} else if (sub.deps !== void 0) {
|
|
clearTrack(sub.deps);
|
|
sub.deps = void 0;
|
|
}
|
|
sub.trackId = -sub.trackId;
|
|
}
|
|
Subscriber2.endTrackEffects = endTrackEffects;
|
|
})(Subscriber || (Subscriber = {}));
|
|
|
|
// src/computed.ts
|
|
function computed(getter) {
|
|
return new Computed(getter);
|
|
}
|
|
var Computed = class {
|
|
constructor(getter) {
|
|
this.getter = getter;
|
|
this.cachedValue = void 0;
|
|
// Dependency
|
|
this.subs = void 0;
|
|
this.subsTail = void 0;
|
|
this.linkedTrackId = -1;
|
|
// Subscriber
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
this.trackId = 0;
|
|
this.dirtyLevel = 3 /* Dirty */;
|
|
this.canPropagate = false;
|
|
}
|
|
get() {
|
|
const dirtyLevel = this.dirtyLevel;
|
|
if (dirtyLevel === 2 /* MaybeDirty */) {
|
|
Subscriber.resolveMaybeDirty(this);
|
|
if (this.dirtyLevel === 3 /* Dirty */) {
|
|
this.update();
|
|
}
|
|
} else if (dirtyLevel === 3 /* Dirty */ || dirtyLevel === 4 /* Released */) {
|
|
this.update();
|
|
}
|
|
const activeTrackId = System.activeTrackId;
|
|
if (activeTrackId !== 0 && this.linkedTrackId !== activeTrackId) {
|
|
this.linkedTrackId = activeTrackId;
|
|
Dependency.linkSubscriber(this, System.activeSub);
|
|
}
|
|
return this.cachedValue;
|
|
}
|
|
update() {
|
|
const prevSub = Subscriber.startTrackDependencies(this);
|
|
const oldValue = this.cachedValue;
|
|
let newValue;
|
|
try {
|
|
newValue = this.getter(oldValue);
|
|
} finally {
|
|
Subscriber.endTrackDependencies(this, prevSub);
|
|
}
|
|
if (oldValue !== newValue) {
|
|
this.cachedValue = newValue;
|
|
const subs = this.subs;
|
|
if (subs !== void 0) {
|
|
Dependency.propagate(subs);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/effect.ts
|
|
function effect(fn) {
|
|
const e = new Effect(fn);
|
|
e.run();
|
|
return e;
|
|
}
|
|
var Effect = class {
|
|
constructor(fn) {
|
|
this.fn = fn;
|
|
this.nextNotify = void 0;
|
|
// Dependency
|
|
this.subs = void 0;
|
|
this.subsTail = void 0;
|
|
this.linkedTrackId = -1;
|
|
// Subscriber
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
this.trackId = 0;
|
|
this.dirtyLevel = 3 /* Dirty */;
|
|
this.canPropagate = false;
|
|
const subVersion = System.activeTrackId;
|
|
if (subVersion !== 0 && this.linkedTrackId !== subVersion) {
|
|
this.linkedTrackId = subVersion;
|
|
Dependency.linkSubscriber(this, System.activeSub);
|
|
return;
|
|
}
|
|
const activeTrackId = System.activeEffectScopeTrackId;
|
|
if (activeTrackId !== 0 && this.linkedTrackId !== activeTrackId) {
|
|
this.linkedTrackId = activeTrackId;
|
|
Dependency.linkSubscriber(this, System.activeEffectScope);
|
|
}
|
|
}
|
|
notify() {
|
|
const dirtyLevel = this.dirtyLevel;
|
|
if (dirtyLevel === 1 /* SideEffectsOnly */) {
|
|
this.dirtyLevel = 0 /* None */;
|
|
Subscriber.runInnerEffects(this.deps);
|
|
} else {
|
|
if (dirtyLevel === 2 /* MaybeDirty */) {
|
|
Subscriber.resolveMaybeDirty(this);
|
|
}
|
|
if (this.dirtyLevel === 3 /* Dirty */) {
|
|
this.run();
|
|
} else {
|
|
Subscriber.runInnerEffects(this.deps);
|
|
}
|
|
}
|
|
}
|
|
run() {
|
|
const prevSub = Subscriber.startTrackDependencies(this);
|
|
try {
|
|
this.fn();
|
|
} finally {
|
|
Subscriber.endTrackDependencies(this, prevSub);
|
|
}
|
|
}
|
|
stop() {
|
|
if (this.deps !== void 0) {
|
|
Subscriber.clearTrack(this.deps);
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
}
|
|
this.dirtyLevel = 3 /* Dirty */;
|
|
}
|
|
};
|
|
|
|
// src/effectScope.ts
|
|
function effectScope() {
|
|
return new EffectScope();
|
|
}
|
|
var EffectScope = class {
|
|
constructor() {
|
|
this.nextNotify = void 0;
|
|
// Subscriber
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
this.trackId = 0;
|
|
this.dirtyLevel = 0 /* None */;
|
|
this.canPropagate = false;
|
|
}
|
|
notify() {
|
|
if (this.dirtyLevel !== 0 /* None */) {
|
|
this.dirtyLevel = 0 /* None */;
|
|
Subscriber.runInnerEffects(this.deps);
|
|
}
|
|
}
|
|
run(fn) {
|
|
const prevSub = Subscriber.startTrackEffects(this);
|
|
try {
|
|
return fn();
|
|
} finally {
|
|
Subscriber.endTrackEffects(this, prevSub);
|
|
}
|
|
}
|
|
stop() {
|
|
if (this.deps !== void 0) {
|
|
Subscriber.clearTrack(this.deps);
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
}
|
|
this.dirtyLevel = 0 /* None */;
|
|
}
|
|
};
|
|
|
|
// src/signal.ts
|
|
function signal(oldValue) {
|
|
return new Signal(oldValue);
|
|
}
|
|
var Signal = class {
|
|
constructor(currentValue) {
|
|
this.currentValue = currentValue;
|
|
// Dependency
|
|
this.subs = void 0;
|
|
this.subsTail = void 0;
|
|
this.linkedTrackId = -1;
|
|
}
|
|
get() {
|
|
const activeTrackId = System.activeTrackId;
|
|
if (activeTrackId !== 0 && this.linkedTrackId !== activeTrackId) {
|
|
this.linkedTrackId = activeTrackId;
|
|
Dependency.linkSubscriber(this, System.activeSub);
|
|
}
|
|
return this.currentValue;
|
|
}
|
|
set(value) {
|
|
if (this.currentValue !== (this.currentValue = value)) {
|
|
const subs = this.subs;
|
|
if (subs !== void 0) {
|
|
startBatch();
|
|
Dependency.propagate(subs);
|
|
endBatch();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/unstable/index.ts
|
|
var unstable_exports = {};
|
|
__export(unstable_exports, {
|
|
EqualityComputed: () => EqualityComputed,
|
|
Vue: () => vue_exports,
|
|
computedArray: () => computedArray,
|
|
computedSet: () => computedSet,
|
|
equalityComputed: () => equalityComputed
|
|
});
|
|
|
|
// src/unstable/computedArray.ts
|
|
function computedArray(arr, getGetter) {
|
|
const length = computed(() => arr.get().length);
|
|
const keys = computed(
|
|
() => {
|
|
const keys2 = [];
|
|
for (let i = 0; i < length.get(); i++) {
|
|
keys2.push(String(i));
|
|
}
|
|
return keys2;
|
|
}
|
|
);
|
|
const items = computed(
|
|
(array) => {
|
|
array ??= [];
|
|
while (array.length < length.get()) {
|
|
const index = array.length;
|
|
const item = computed(() => arr.get()[index]);
|
|
array.push(computed(getGetter(item, index)));
|
|
}
|
|
if (array.length > length.get()) {
|
|
array.length = length.get();
|
|
}
|
|
return array;
|
|
}
|
|
);
|
|
return new Proxy({}, {
|
|
get(_, p, receiver) {
|
|
if (p === "length") {
|
|
return length.get();
|
|
}
|
|
if (typeof p === "string" && !isNaN(Number(p))) {
|
|
return items.get()[Number(p)]?.get();
|
|
}
|
|
return Reflect.get(items.get(), p, receiver);
|
|
},
|
|
has(_, p) {
|
|
return Reflect.has(items.get(), p);
|
|
},
|
|
ownKeys() {
|
|
return keys.get();
|
|
}
|
|
});
|
|
}
|
|
|
|
// src/unstable/computedSet.ts
|
|
function computedSet(source) {
|
|
return computed(
|
|
(oldValue) => {
|
|
const newValue = source.get();
|
|
if (oldValue?.size === newValue.size && [...oldValue].every((c) => newValue.has(c))) {
|
|
return oldValue;
|
|
}
|
|
return newValue;
|
|
}
|
|
);
|
|
}
|
|
|
|
// src/unstable/equalityComputed.ts
|
|
function equalityComputed(getter) {
|
|
return new EqualityComputed(getter);
|
|
}
|
|
var EqualityComputed = class extends Computed {
|
|
constructor(getter) {
|
|
super((oldValue) => {
|
|
const newValue = getter();
|
|
if (this.equals(oldValue, newValue)) {
|
|
return oldValue;
|
|
}
|
|
return newValue;
|
|
});
|
|
}
|
|
equals(a, b) {
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (a === null || b === null || typeof a !== typeof b) {
|
|
return false;
|
|
}
|
|
if (typeof a === "object") {
|
|
if (Array.isArray(a) && Array.isArray(b)) {
|
|
if (a.length !== b.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < a.length; i++) {
|
|
if (!this.equals(a[i], b[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (!Array.isArray(a) && !Array.isArray(b)) {
|
|
for (const key in a) {
|
|
if (a.hasOwnProperty(key)) {
|
|
if (!b.hasOwnProperty(key) || !this.equals(a[key], b[key])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
for (const key in b) {
|
|
if (b.hasOwnProperty(key) && !a.hasOwnProperty(key)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// src/unstable/vue.ts
|
|
var vue_exports = {};
|
|
__export(vue_exports, {
|
|
EffectScope: () => EffectScope,
|
|
ReactiveEffect: () => ReactiveEffect,
|
|
ShallowRef: () => ShallowRef,
|
|
computed: () => computed2,
|
|
effect: () => effect2,
|
|
effectScope: () => effectScope2,
|
|
getCurrentScope: () => getCurrentScope,
|
|
onScopeDispose: () => onScopeDispose,
|
|
pauseTracking: () => pauseTracking,
|
|
resetTracking: () => resetTracking,
|
|
shallowRef: () => shallowRef,
|
|
triggerRef: () => triggerRef
|
|
});
|
|
function effect2(fn) {
|
|
const e = new ReactiveEffect(fn);
|
|
e.run();
|
|
return e;
|
|
}
|
|
var currentEffectScope = void 0;
|
|
var VueEffectScope = class extends EffectScope {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.onDispose = [];
|
|
}
|
|
run(fn) {
|
|
const prevScope = currentEffectScope;
|
|
currentEffectScope = this;
|
|
const res = super.run(fn);
|
|
currentEffectScope = prevScope;
|
|
return res;
|
|
}
|
|
stop() {
|
|
super.stop();
|
|
this.onDispose.forEach((cb) => cb());
|
|
}
|
|
};
|
|
function effectScope2() {
|
|
return new VueEffectScope();
|
|
}
|
|
function triggerRef(ref) {
|
|
if (ref.subs !== void 0) {
|
|
startBatch();
|
|
Dependency.propagate(ref.subs);
|
|
endBatch();
|
|
}
|
|
}
|
|
var pausedSubs = [];
|
|
function pauseTracking() {
|
|
pausedSubs.push(System.activeSub);
|
|
System.activeSub = void 0;
|
|
System.activeTrackId = -1;
|
|
}
|
|
function resetTracking() {
|
|
const prevSub = pausedSubs.pop();
|
|
System.activeSub = prevSub;
|
|
System.activeTrackId = prevSub.trackId;
|
|
}
|
|
function shallowRef(value) {
|
|
return new ShallowRef(value);
|
|
}
|
|
function computed2(fn) {
|
|
if (typeof fn === "function") {
|
|
return new VueComputed(fn);
|
|
} else {
|
|
const { get, set } = fn;
|
|
const c = new VueComputed(get);
|
|
return {
|
|
get value() {
|
|
return c.get();
|
|
},
|
|
set value(value) {
|
|
set(value);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function getCurrentScope() {
|
|
return currentEffectScope;
|
|
}
|
|
var ShallowRef = class extends Signal {
|
|
get value() {
|
|
return this.get();
|
|
}
|
|
set value(value) {
|
|
this.set(value);
|
|
}
|
|
};
|
|
var VueComputed = class extends Computed {
|
|
get value() {
|
|
return this.get();
|
|
}
|
|
};
|
|
var ReactiveEffect = class extends Effect {
|
|
get dirty() {
|
|
if (this.dirtyLevel === 2 /* MaybeDirty */) {
|
|
Subscriber.resolveMaybeDirty(this);
|
|
}
|
|
return this.dirtyLevel === 3 /* Dirty */;
|
|
}
|
|
set scheduler(fn) {
|
|
this.notify = fn;
|
|
}
|
|
stop() {
|
|
if (this.deps !== void 0) {
|
|
Subscriber.clearTrack(this.deps);
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
}
|
|
this.dirtyLevel = 0 /* None */;
|
|
}
|
|
};
|
|
function onScopeDispose(cb) {
|
|
currentEffectScope?.onDispose.push(cb);
|
|
}
|
|
export {
|
|
Computed,
|
|
Dependency,
|
|
DirtyLevels,
|
|
Effect,
|
|
EffectScope,
|
|
Link,
|
|
Signal,
|
|
Subscriber,
|
|
System,
|
|
unstable_exports as Unstable,
|
|
computed,
|
|
effect,
|
|
effectScope,
|
|
endBatch,
|
|
signal,
|
|
startBatch
|
|
};
|