mirror of
https://github.com/bitcoinresearchkit/brk.git
synced 2026-04-25 07:09:59 -07:00
1011 lines
25 KiB
JavaScript
1011 lines
25 KiB
JavaScript
// @ts-nocheck
|
|
|
|
// src/error.ts
|
|
var NotReadyError = class extends Error {};
|
|
var NoOwnerError = class extends Error {
|
|
constructor() {
|
|
super("");
|
|
}
|
|
};
|
|
var ContextNotFoundError = class extends Error {
|
|
constructor() {
|
|
super("");
|
|
}
|
|
};
|
|
|
|
// src/constants.ts
|
|
var STATE_CLEAN = 0;
|
|
var STATE_CHECK = 1;
|
|
var STATE_DIRTY = 2;
|
|
var STATE_DISPOSED = 3;
|
|
|
|
// src/utils.ts
|
|
function isUndefined(value) {
|
|
return typeof value === "undefined";
|
|
}
|
|
|
|
// src/owner.ts
|
|
var currentOwner = null;
|
|
var defaultContext = {};
|
|
function getOwner() {
|
|
return currentOwner;
|
|
}
|
|
function setOwner(owner) {
|
|
const out = currentOwner;
|
|
currentOwner = owner;
|
|
return out;
|
|
}
|
|
var Owner = class {
|
|
// We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
|
|
// However, the children are actually added in reverse creation order
|
|
// See comment at the top of the file for an example of the _nextSibling traversal
|
|
o = null;
|
|
k = null;
|
|
n = null;
|
|
a = STATE_CLEAN;
|
|
f = null;
|
|
l = defaultContext;
|
|
g = null;
|
|
constructor(signal = false) {
|
|
if (currentOwner && !signal) currentOwner.append(this);
|
|
}
|
|
append(child) {
|
|
child.o = this;
|
|
child.n = this;
|
|
if (this.k) this.k.n = child;
|
|
child.k = this.k;
|
|
this.k = child;
|
|
if (child.l !== this.l) {
|
|
child.l = { ...this.l, ...child.l };
|
|
}
|
|
if (this.g) {
|
|
child.g = !child.g ? this.g : [...child.g, ...this.g];
|
|
}
|
|
}
|
|
dispose(self = true) {
|
|
if (this.a === STATE_DISPOSED) return;
|
|
let head = self ? this.n || this.o : this,
|
|
current = this.k,
|
|
next = null;
|
|
while (current && current.o === this) {
|
|
current.dispose(true);
|
|
current.t();
|
|
next = current.k;
|
|
current.k = null;
|
|
current = next;
|
|
}
|
|
if (self) this.t();
|
|
if (current) current.n = !self ? this : this.n;
|
|
if (head) head.k = current;
|
|
}
|
|
t() {
|
|
if (this.n) this.n.k = null;
|
|
this.o = null;
|
|
this.n = null;
|
|
this.l = defaultContext;
|
|
this.g = null;
|
|
this.a = STATE_DISPOSED;
|
|
this.emptyDisposal();
|
|
}
|
|
emptyDisposal() {
|
|
if (!this.f) return;
|
|
if (Array.isArray(this.f)) {
|
|
for (let i = 0; i < this.f.length; i++) {
|
|
const callable = this.f[i];
|
|
callable.call(callable);
|
|
}
|
|
} else {
|
|
this.f.call(this.f);
|
|
}
|
|
this.f = null;
|
|
}
|
|
handleError(error) {
|
|
if (!this.g) throw error;
|
|
let i = 0,
|
|
len = this.g.length;
|
|
for (i = 0; i < len; i++) {
|
|
try {
|
|
this.g[i](error);
|
|
break;
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
}
|
|
if (i === len) throw error;
|
|
}
|
|
};
|
|
function createContext(defaultValue, description) {
|
|
return { id: Symbol(description), defaultValue };
|
|
}
|
|
function getContext(context, owner = currentOwner) {
|
|
if (!owner) {
|
|
throw new NoOwnerError();
|
|
}
|
|
const value = hasContext(context, owner)
|
|
? owner.l[context.id]
|
|
: context.defaultValue;
|
|
if (isUndefined(value)) {
|
|
throw new ContextNotFoundError();
|
|
}
|
|
return value;
|
|
}
|
|
function setContext(context, value, owner = currentOwner) {
|
|
if (!owner) {
|
|
throw new NoOwnerError();
|
|
}
|
|
owner.l = {
|
|
...owner.l,
|
|
[context.id]: isUndefined(value) ? context.defaultValue : value,
|
|
};
|
|
}
|
|
function hasContext(context, owner = currentOwner) {
|
|
return !isUndefined(owner?.l[context.id]);
|
|
}
|
|
function onCleanup(disposable) {
|
|
if (!currentOwner) return;
|
|
const node = currentOwner;
|
|
if (!node.f) {
|
|
node.f = disposable;
|
|
} else if (Array.isArray(node.f)) {
|
|
node.f.push(disposable);
|
|
} else {
|
|
node.f = [node.f, disposable];
|
|
}
|
|
}
|
|
|
|
// src/flags.ts
|
|
var ERROR_OFFSET = 0;
|
|
var ERROR_BIT = 1 << ERROR_OFFSET;
|
|
var LOADING_OFFSET = 1;
|
|
var LOADING_BIT = 1 << LOADING_OFFSET;
|
|
var DEFAULT_FLAGS = ERROR_BIT;
|
|
|
|
// src/core.ts
|
|
var currentObserver = null;
|
|
var currentMask = DEFAULT_FLAGS;
|
|
var newSources = null;
|
|
var newSourcesIndex = 0;
|
|
var newFlags = 0;
|
|
function getObserver() {
|
|
return currentObserver;
|
|
}
|
|
var UNCHANGED = Symbol(0);
|
|
var Computation = class extends Owner {
|
|
c = null;
|
|
b = null;
|
|
j;
|
|
v;
|
|
// Used in __DEV__ mode, hopefully removed in production
|
|
D;
|
|
// Using false is an optimization as an alternative to _equals: () => false
|
|
// which could enable more efficient DIRTY notification
|
|
w = isEqual;
|
|
/** Whether the computation is an error or has ancestors that are unresolved */
|
|
m = 0;
|
|
/** Which flags raised by sources are handled, vs. being passed through. */
|
|
u = DEFAULT_FLAGS;
|
|
x = null;
|
|
y = null;
|
|
constructor(initialValue, compute2, options) {
|
|
super(compute2 === null);
|
|
this.v = compute2;
|
|
this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
|
|
this.j = initialValue;
|
|
if (options?.equals !== void 0) this.w = options.equals;
|
|
}
|
|
B() {
|
|
if (this.v) this.p();
|
|
track(this);
|
|
newFlags |= this.m & ~currentMask;
|
|
if (this.m & ERROR_BIT) {
|
|
throw this.j;
|
|
} else {
|
|
return this.j;
|
|
}
|
|
}
|
|
/**
|
|
* Return the current value of this computation
|
|
* Automatically re-executes the surrounding computation when the value changes
|
|
*/
|
|
read() {
|
|
return this.B();
|
|
}
|
|
/**
|
|
* Return the current value of this computation
|
|
* Automatically re-executes the surrounding computation when the value changes
|
|
*
|
|
* If the computation has any unresolved ancestors, this function waits for the value to resolve
|
|
* before continuing
|
|
*/
|
|
wait() {
|
|
if (this.loading()) {
|
|
throw new NotReadyError();
|
|
}
|
|
return this.B();
|
|
}
|
|
/**
|
|
* Return true if the computation is the value is dependent on an unresolved promise
|
|
* Triggers re-execution of the computation when the loading state changes
|
|
*
|
|
* This is useful especially when effects want to re-execute when a computation's
|
|
* loading state changes
|
|
*/
|
|
loading() {
|
|
if (this.y === null) {
|
|
this.y = loadingState(this);
|
|
}
|
|
return this.y.read();
|
|
}
|
|
/**
|
|
* Return true if the computation is the computation threw an error
|
|
* Triggers re-execution of the computation when the error state changes
|
|
*/
|
|
error() {
|
|
if (this.x === null) {
|
|
this.x = errorState(this);
|
|
}
|
|
return this.x.read();
|
|
}
|
|
/** Update the computation with a new value. */
|
|
write(value, flags = 0, raw = false) {
|
|
const newValue =
|
|
!raw && typeof value === "function" ? value(this.j) : value;
|
|
const valueChanged =
|
|
newValue !== UNCHANGED &&
|
|
(!!(flags & ERROR_BIT) || this.w === false || !this.w(this.j, newValue));
|
|
if (valueChanged) this.j = newValue;
|
|
const changedFlagsMask = this.m ^ flags,
|
|
changedFlags = changedFlagsMask & flags;
|
|
this.m = flags;
|
|
if (this.b) {
|
|
for (let i = 0; i < this.b.length; i++) {
|
|
if (valueChanged) {
|
|
this.b[i].q(STATE_DIRTY);
|
|
} else if (changedFlagsMask) {
|
|
this.b[i].C(changedFlagsMask, changedFlags);
|
|
}
|
|
}
|
|
}
|
|
return this.j;
|
|
}
|
|
/**
|
|
* Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
|
|
*/
|
|
q(state) {
|
|
if (this.a >= state) return;
|
|
this.a = state;
|
|
if (this.b) {
|
|
for (let i = 0; i < this.b.length; i++) {
|
|
this.b[i].q(STATE_CHECK);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Notify the computation that one of its sources has changed flags.
|
|
*
|
|
* @param mask A bitmask for which flag(s) were changed.
|
|
* @param newFlags The source's new flags, masked to just the changed ones.
|
|
*/
|
|
C(mask, newFlags2) {
|
|
if (this.a >= STATE_DIRTY) return;
|
|
if (mask & this.u) {
|
|
this.q(STATE_DIRTY);
|
|
return;
|
|
}
|
|
if (this.a >= STATE_CHECK) return;
|
|
const prevFlags = this.m & mask;
|
|
const deltaFlags = prevFlags ^ newFlags2;
|
|
if (newFlags2 === prevFlags);
|
|
else if (deltaFlags & prevFlags & mask) {
|
|
this.q(STATE_CHECK);
|
|
} else {
|
|
this.m ^= deltaFlags;
|
|
if (this.b) {
|
|
for (let i = 0; i < this.b.length; i++) {
|
|
this.b[i].C(mask, newFlags2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
z(error) {
|
|
this.write(error, this.m | ERROR_BIT);
|
|
}
|
|
/**
|
|
* This is the core part of the reactivity system, which makes sure that the values are updated
|
|
* before they are read. We've also adapted it to return the loading state of the computation,
|
|
* so that we can propagate that to the computation's observers.
|
|
*
|
|
* This function will ensure that the value and states we read from the computation are up to date
|
|
*/
|
|
p() {
|
|
if (this.a === STATE_DISPOSED) {
|
|
throw new Error("Tried to read a disposed computation");
|
|
}
|
|
if (this.a === STATE_CLEAN) {
|
|
return;
|
|
}
|
|
let observerFlags = 0;
|
|
if (this.a === STATE_CHECK) {
|
|
for (let i = 0; i < this.c.length; i++) {
|
|
this.c[i].p();
|
|
observerFlags |= this.c[i].m;
|
|
if (this.a === STATE_DIRTY) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (this.a === STATE_DIRTY) {
|
|
update(this);
|
|
} else {
|
|
this.write(UNCHANGED, observerFlags);
|
|
this.a = STATE_CLEAN;
|
|
}
|
|
}
|
|
/**
|
|
* Remove ourselves from the owner graph and the computation graph
|
|
*/
|
|
t() {
|
|
if (this.a === STATE_DISPOSED) return;
|
|
if (this.c) removeSourceObservers(this, 0);
|
|
super.t();
|
|
}
|
|
};
|
|
function loadingState(node) {
|
|
const prevOwner = setOwner(node.o);
|
|
const options = void 0;
|
|
const computation = new Computation(
|
|
void 0,
|
|
() => {
|
|
track(node);
|
|
node.p();
|
|
return !!(node.m & LOADING_BIT);
|
|
},
|
|
options,
|
|
);
|
|
computation.u = ERROR_BIT | LOADING_BIT;
|
|
setOwner(prevOwner);
|
|
return computation;
|
|
}
|
|
function errorState(node) {
|
|
const prevOwner = setOwner(node.o);
|
|
const options = void 0;
|
|
const computation = new Computation(
|
|
void 0,
|
|
() => {
|
|
track(node);
|
|
node.p();
|
|
return !!(node.m & ERROR_BIT);
|
|
},
|
|
options,
|
|
);
|
|
computation.u = ERROR_BIT;
|
|
setOwner(prevOwner);
|
|
return computation;
|
|
}
|
|
function track(computation) {
|
|
if (currentObserver) {
|
|
if (
|
|
!newSources &&
|
|
currentObserver.c &&
|
|
currentObserver.c[newSourcesIndex] === computation
|
|
) {
|
|
newSourcesIndex++;
|
|
} else if (!newSources) newSources = [computation];
|
|
else if (computation !== newSources[newSources.length - 1]) {
|
|
newSources.push(computation);
|
|
}
|
|
}
|
|
}
|
|
function update(node) {
|
|
const prevSources = newSources,
|
|
prevSourcesIndex = newSourcesIndex,
|
|
prevFlags = newFlags;
|
|
newSources = null;
|
|
newSourcesIndex = 0;
|
|
newFlags = 0;
|
|
try {
|
|
node.dispose(false);
|
|
node.emptyDisposal();
|
|
const result = compute(node, node.v, node);
|
|
node.write(result, newFlags, true);
|
|
} catch (error) {
|
|
if (error instanceof NotReadyError) {
|
|
node.write(UNCHANGED, newFlags | LOADING_BIT);
|
|
} else {
|
|
node.z(error);
|
|
}
|
|
} finally {
|
|
if (newSources) {
|
|
if (node.c) removeSourceObservers(node, newSourcesIndex);
|
|
if (node.c && newSourcesIndex > 0) {
|
|
node.c.length = newSourcesIndex + newSources.length;
|
|
for (let i = 0; i < newSources.length; i++) {
|
|
node.c[newSourcesIndex + i] = newSources[i];
|
|
}
|
|
} else {
|
|
node.c = newSources;
|
|
}
|
|
let source;
|
|
for (let i = newSourcesIndex; i < node.c.length; i++) {
|
|
source = node.c[i];
|
|
if (!source.b) source.b = [node];
|
|
else source.b.push(node);
|
|
}
|
|
} else if (node.c && newSourcesIndex < node.c.length) {
|
|
removeSourceObservers(node, newSourcesIndex);
|
|
node.c.length = newSourcesIndex;
|
|
}
|
|
newSources = prevSources;
|
|
newSourcesIndex = prevSourcesIndex;
|
|
newFlags = prevFlags;
|
|
node.a = STATE_CLEAN;
|
|
}
|
|
}
|
|
function removeSourceObservers(node, index) {
|
|
let source;
|
|
let swap;
|
|
for (let i = index; i < node.c.length; i++) {
|
|
source = node.c[i];
|
|
if (source.b) {
|
|
swap = source.b.indexOf(node);
|
|
source.b[swap] = source.b[source.b.length - 1];
|
|
source.b.pop();
|
|
}
|
|
}
|
|
}
|
|
function isEqual(a, b) {
|
|
return a === b;
|
|
}
|
|
function untrack(fn) {
|
|
if (currentObserver === null) return fn();
|
|
return compute(getOwner(), fn, null);
|
|
}
|
|
function compute(owner, compute2, observer) {
|
|
const prevOwner = setOwner(owner),
|
|
prevObserver = currentObserver,
|
|
prevMask = currentMask;
|
|
currentObserver = observer;
|
|
currentMask = observer?.u ?? DEFAULT_FLAGS;
|
|
try {
|
|
return compute2(observer ? observer.j : void 0);
|
|
} finally {
|
|
setOwner(prevOwner);
|
|
currentObserver = prevObserver;
|
|
currentMask = prevMask;
|
|
}
|
|
}
|
|
|
|
// src/effect.ts
|
|
var scheduledEffects = false;
|
|
var runningEffects = false;
|
|
var renderEffects = [];
|
|
var effects = [];
|
|
function flushSync() {
|
|
if (!runningEffects) runEffects();
|
|
}
|
|
function flushEffects() {
|
|
scheduledEffects = true;
|
|
queueMicrotask(runEffects);
|
|
}
|
|
function runTop(node) {
|
|
const ancestors = [];
|
|
for (let current = node; current !== null; current = current.o) {
|
|
if (current.a !== STATE_CLEAN) {
|
|
ancestors.push(current);
|
|
}
|
|
}
|
|
for (let i = ancestors.length - 1; i >= 0; i--) {
|
|
if (ancestors[i].a !== STATE_DISPOSED) ancestors[i].p();
|
|
}
|
|
}
|
|
function runEffects() {
|
|
if (!effects.length) {
|
|
scheduledEffects = false;
|
|
return;
|
|
}
|
|
runningEffects = true;
|
|
try {
|
|
for (let i = 0; i < renderEffects.length; i++) {
|
|
if (renderEffects[i].a !== STATE_CLEAN) {
|
|
renderEffects[i].p();
|
|
}
|
|
}
|
|
for (let i = 0; i < renderEffects.length; i++) {
|
|
if (renderEffects[i].modified) {
|
|
renderEffects[i].effect(renderEffects[i].j);
|
|
renderEffects[i].modified = false;
|
|
}
|
|
}
|
|
for (let i = 0; i < effects.length; i++) {
|
|
if (effects[i].a !== STATE_CLEAN) {
|
|
runTop(effects[i]);
|
|
}
|
|
}
|
|
} finally {
|
|
effects = [];
|
|
renderEffects = [];
|
|
scheduledEffects = false;
|
|
runningEffects = false;
|
|
}
|
|
}
|
|
var Effect = class extends Computation {
|
|
constructor(initialValue, compute2, options) {
|
|
super(initialValue, compute2, options);
|
|
effects.push(this);
|
|
flushEffects();
|
|
}
|
|
q(state) {
|
|
if (this.a >= state) return;
|
|
if (this.a === STATE_CLEAN) {
|
|
effects.push(this);
|
|
if (!scheduledEffects) flushEffects();
|
|
}
|
|
this.a = state;
|
|
}
|
|
write(value) {
|
|
this.j = value;
|
|
return value;
|
|
}
|
|
z(error) {
|
|
this.handleError(error);
|
|
}
|
|
};
|
|
var RenderEffect = class extends Computation {
|
|
effect;
|
|
modified = false;
|
|
constructor(initialValue, compute2, effect, options) {
|
|
super(initialValue, compute2, options);
|
|
this.effect = effect;
|
|
this.p();
|
|
}
|
|
q(state) {
|
|
if (this.a >= state) return;
|
|
if (this.a === STATE_CLEAN) {
|
|
renderEffects.push(this);
|
|
if (!scheduledEffects) flushEffects();
|
|
}
|
|
this.a = state;
|
|
}
|
|
write(value) {
|
|
this.j = value;
|
|
this.modified = true;
|
|
return value;
|
|
}
|
|
z(error) {
|
|
this.handleError(error);
|
|
}
|
|
};
|
|
|
|
// src/signals.ts
|
|
function createSignal(initialValue, options) {
|
|
const node = new Computation(initialValue, null, options);
|
|
return [node.read.bind(node), node.write.bind(node)];
|
|
}
|
|
function createAsync(fn, initial, options) {
|
|
const lhs = new Computation(void 0, () => {
|
|
const promise = Promise.resolve(fn());
|
|
const signal = new Computation(initial, null, options);
|
|
signal.write(UNCHANGED, LOADING_BIT);
|
|
promise.then(
|
|
(value) => {
|
|
signal.write(value, 0);
|
|
},
|
|
(error) => {
|
|
signal.write(error, ERROR_BIT);
|
|
},
|
|
);
|
|
return signal;
|
|
});
|
|
const rhs = new Computation(void 0, () => lhs.read().wait(), options);
|
|
return () => rhs.wait();
|
|
}
|
|
function createMemo(compute2, initialValue, options) {
|
|
const node = new Computation(initialValue, compute2, options);
|
|
return node.read.bind(node);
|
|
}
|
|
function createEffect(effect, initialValue, options) {
|
|
void new Effect(initialValue, effect, void 0);
|
|
}
|
|
function createRenderEffect(compute2, effect, initialValue, options) {
|
|
void new RenderEffect(initialValue, compute2, effect, void 0);
|
|
}
|
|
function createRoot(init) {
|
|
const owner = new Owner();
|
|
return compute(
|
|
owner,
|
|
!init.length ? init : () => init(() => owner.dispose()),
|
|
null,
|
|
);
|
|
}
|
|
function runWithOwner(owner, run) {
|
|
try {
|
|
return compute(owner, run, null);
|
|
} catch (error) {
|
|
owner?.handleError(error);
|
|
return void 0;
|
|
}
|
|
}
|
|
function catchError(fn, handler) {
|
|
const owner = new Owner();
|
|
owner.g = owner.g ? [handler, ...owner.g] : [handler];
|
|
try {
|
|
compute(owner, fn, null);
|
|
} catch (error) {
|
|
owner.handleError(error);
|
|
}
|
|
}
|
|
|
|
// src/map.ts
|
|
function indexArray(list, map, options) {
|
|
return Computation.prototype.read.bind(
|
|
new Computation(
|
|
[],
|
|
updateMap.bind({
|
|
r: new Owner(),
|
|
i: 0,
|
|
A: list,
|
|
h: [],
|
|
s: map,
|
|
d: [],
|
|
e: [],
|
|
}),
|
|
options,
|
|
),
|
|
);
|
|
}
|
|
function updateMap() {
|
|
let i = 0,
|
|
newItems = this.A() || [],
|
|
mapper = () => this.s(Computation.prototype.read.bind(this.e[i]), i);
|
|
runWithOwner(this.r, () => {
|
|
if (newItems.length === 0) {
|
|
if (this.i !== 0) {
|
|
this.r.dispose(false);
|
|
this.h = [];
|
|
this.d = [];
|
|
this.i = 0;
|
|
this.e = [];
|
|
}
|
|
return;
|
|
}
|
|
for (i = 0; i < newItems.length; i++) {
|
|
if (i < this.h.length && this.h[i] !== newItems[i]) {
|
|
this.e[i].write(newItems[i]);
|
|
} else if (i >= this.h.length) {
|
|
this.d[i] = compute(
|
|
(this.e[i] = new Computation(newItems[i], null)),
|
|
mapper,
|
|
null,
|
|
);
|
|
}
|
|
}
|
|
for (; i < this.h.length; i++) this.e[i].dispose();
|
|
this.i = this.e.length = newItems.length;
|
|
this.h = newItems.slice(0);
|
|
this.d = this.d.slice(0, this.i);
|
|
});
|
|
return this.d;
|
|
}
|
|
function mapArray(list, map, options) {
|
|
return Computation.prototype.read.bind(
|
|
new Computation(
|
|
[],
|
|
updateKeyedMap.bind({
|
|
r: new Owner(),
|
|
i: 0,
|
|
A: list,
|
|
h: [],
|
|
s: map,
|
|
d: [],
|
|
e: [],
|
|
}),
|
|
options,
|
|
),
|
|
);
|
|
}
|
|
function updateKeyedMap() {
|
|
const newItems = this.A() || [],
|
|
indexed = this.s.length > 1;
|
|
runWithOwner(this.r, () => {
|
|
let newLen = newItems.length,
|
|
i,
|
|
j,
|
|
mapper = indexed
|
|
? () => this.s(newItems[j], Computation.prototype.read.bind(this.e[j]))
|
|
: () => this.s(newItems[j]);
|
|
if (newLen === 0) {
|
|
if (this.i !== 0) {
|
|
this.r.dispose(false);
|
|
this.e = [];
|
|
this.h = [];
|
|
this.d = [];
|
|
this.i = 0;
|
|
}
|
|
} else if (this.i === 0) {
|
|
this.d = new Array(newLen);
|
|
for (j = 0; j < newLen; j++) {
|
|
this.h[j] = newItems[j];
|
|
this.d[j] = compute(
|
|
(this.e[j] = new Computation(j, null)),
|
|
mapper,
|
|
null,
|
|
);
|
|
}
|
|
this.i = newLen;
|
|
} else {
|
|
let start,
|
|
end,
|
|
newEnd,
|
|
item,
|
|
newIndices,
|
|
newIndicesNext,
|
|
temp = new Array(newLen),
|
|
tempNodes = new Array(newLen);
|
|
for (
|
|
start = 0, end = Math.min(this.i, newLen);
|
|
start < end && this.h[start] === newItems[start];
|
|
start++
|
|
);
|
|
for (
|
|
end = this.i - 1, newEnd = newLen - 1;
|
|
end >= start && newEnd >= start && this.h[end] === newItems[newEnd];
|
|
end--, newEnd--
|
|
) {
|
|
temp[newEnd] = this.d[end];
|
|
tempNodes[newEnd] = this.e[end];
|
|
}
|
|
newIndices = /* @__PURE__ */ new Map();
|
|
newIndicesNext = new Array(newEnd + 1);
|
|
for (j = newEnd; j >= start; j--) {
|
|
item = newItems[j];
|
|
i = newIndices.get(item);
|
|
newIndicesNext[j] = i === void 0 ? -1 : i;
|
|
newIndices.set(item, j);
|
|
}
|
|
for (i = start; i <= end; i++) {
|
|
item = this.h[i];
|
|
j = newIndices.get(item);
|
|
if (j !== void 0 && j !== -1) {
|
|
temp[j] = this.d[i];
|
|
tempNodes[j] = this.e[i];
|
|
j = newIndicesNext[j];
|
|
newIndices.set(item, j);
|
|
} else this.e[i].dispose();
|
|
}
|
|
for (j = start; j < newLen; j++) {
|
|
if (j in temp) {
|
|
this.d[j] = temp[j];
|
|
this.e[j] = tempNodes[j];
|
|
this.e[j].write(j);
|
|
} else {
|
|
this.d[j] = compute(
|
|
(this.e[j] = new Computation(j, null)),
|
|
mapper,
|
|
null,
|
|
);
|
|
}
|
|
}
|
|
this.d = this.d.slice(0, (this.i = newLen));
|
|
this.h = newItems.slice(0);
|
|
}
|
|
});
|
|
return this.d;
|
|
}
|
|
|
|
// src/selector.ts
|
|
function createSelector(source, options) {
|
|
let prevSource,
|
|
subs = /* @__PURE__ */ new Map(),
|
|
equals = options?.equals ?? isEqual;
|
|
const node = new Effect(
|
|
void 0,
|
|
() => {
|
|
const newSource = source();
|
|
for (const [key, val] of subs) {
|
|
if (equals(key, newSource) !== equals(key, prevSource)) {
|
|
for (const c of val.values()) {
|
|
c.q(STATE_DIRTY);
|
|
}
|
|
}
|
|
}
|
|
return (prevSource = newSource);
|
|
},
|
|
void 0,
|
|
);
|
|
return function observeSelector(key) {
|
|
const observer = getObserver();
|
|
if (observer) {
|
|
let l;
|
|
if ((l = subs.get(key))) l.add(observer);
|
|
else subs.set(key, (l = /* @__PURE__ */ new Set([observer])));
|
|
onCleanup(() => {
|
|
l.delete(observer);
|
|
!l.size && subs.delete(key);
|
|
});
|
|
}
|
|
return equals(key, node.read());
|
|
};
|
|
}
|
|
|
|
// src/store.ts
|
|
var $RAW = Symbol(0);
|
|
var $TRACK = Symbol(0);
|
|
var $PROXY = Symbol(0);
|
|
var PROXIES = /* @__PURE__ */ new WeakMap();
|
|
var NODES = [/* @__PURE__ */ new WeakMap(), /* @__PURE__ */ new WeakMap()];
|
|
function wrap(value) {
|
|
let p = PROXIES.get(value);
|
|
if (!p) PROXIES.set(value, (p = new Proxy(value, proxyTraps)));
|
|
return p;
|
|
}
|
|
function isWrappable(obj) {
|
|
let proto;
|
|
return (
|
|
obj != null &&
|
|
typeof obj === "object" &&
|
|
(PROXIES.has(obj) ||
|
|
!(proto = Object.getPrototypeOf(obj)) ||
|
|
proto === Object.prototype ||
|
|
Array.isArray(obj))
|
|
);
|
|
}
|
|
function unwrap(item, set = /* @__PURE__ */ new Set()) {
|
|
let result, unwrapped, v, prop;
|
|
if ((result = item != null && item[$RAW])) return result;
|
|
if (!isWrappable(item) || set.has(item)) return item;
|
|
if (Array.isArray(item)) {
|
|
if (Object.isFrozen(item)) item = item.slice(0);
|
|
else set.add(item);
|
|
for (let i = 0, l = item.length; i < l; i++) {
|
|
v = item[i];
|
|
if ((unwrapped = unwrap(v, set)) !== v) item[i] = unwrapped;
|
|
}
|
|
} else {
|
|
if (Object.isFrozen(item)) item = Object.assign({}, item);
|
|
else set.add(item);
|
|
const keys = Object.keys(item);
|
|
for (let i = 0, l = keys.length; i < l; i++) {
|
|
prop = keys[i];
|
|
const desc = Object.getOwnPropertyDescriptor(item, prop);
|
|
if (desc.get) continue;
|
|
v = item[prop];
|
|
if ((unwrapped = unwrap(v, set)) !== v) item[prop] = unwrapped;
|
|
}
|
|
}
|
|
return item;
|
|
}
|
|
function getNodes(target, type) {
|
|
let nodes = NODES[type].get(target);
|
|
if (!nodes)
|
|
NODES[type].set(target, (nodes = /* @__PURE__ */ Object.create(null)));
|
|
return nodes;
|
|
}
|
|
function getNode(nodes, property, value) {
|
|
if (nodes[property]) return nodes[property];
|
|
return (nodes[property] = new Computation(value, null, {
|
|
equals: false,
|
|
}));
|
|
}
|
|
function proxyDescriptor(target, property) {
|
|
const desc = Reflect.getOwnPropertyDescriptor(target, property);
|
|
if (!desc || desc.get || !desc.configurable || property === $PROXY)
|
|
return desc;
|
|
delete desc.value;
|
|
delete desc.writable;
|
|
desc.get = () => PROXIES.get(target)[property];
|
|
return desc;
|
|
}
|
|
function trackSelf(target) {
|
|
getObserver() && getNode(getNodes(target, 0), $TRACK).read();
|
|
}
|
|
function ownKeys(target) {
|
|
trackSelf(target);
|
|
return Reflect.ownKeys(target);
|
|
}
|
|
var Writing = false;
|
|
var proxyTraps = {
|
|
get(target, property, receiver) {
|
|
if (property === $RAW) return target;
|
|
if (property === $PROXY) return receiver;
|
|
if (property === $TRACK) {
|
|
trackSelf(target);
|
|
return receiver;
|
|
}
|
|
const desc = Object.getOwnPropertyDescriptor(target, property);
|
|
if (desc && desc.get) return desc.get.call(receiver);
|
|
const nodes = getNodes(target, 0);
|
|
const tracked = nodes[property];
|
|
let value = tracked ? nodes[property].read() : target[property];
|
|
if (
|
|
!tracked &&
|
|
getObserver() &&
|
|
(typeof value !== "function" || target.hasOwnProperty(property))
|
|
)
|
|
value = getNode(nodes, property, value).read();
|
|
return isWrappable(value) ? wrap(value) : value;
|
|
},
|
|
has(target, property) {
|
|
if (
|
|
property === $RAW ||
|
|
property === $PROXY ||
|
|
property === $TRACK ||
|
|
property === "__proto__"
|
|
)
|
|
return true;
|
|
getObserver() && getNode(getNodes(target, 1), property).read();
|
|
return property in target;
|
|
},
|
|
set(target, property, value) {
|
|
Writing && setProperty(target, property, unwrap(value));
|
|
return true;
|
|
},
|
|
deleteProperty(target, property) {
|
|
Writing && setProperty(target, property, void 0, true);
|
|
return true;
|
|
},
|
|
ownKeys,
|
|
getOwnPropertyDescriptor: proxyDescriptor,
|
|
};
|
|
function setProperty(state, property, value, deleting = false) {
|
|
if (!deleting && state[property] === value) return;
|
|
const prev = state[property];
|
|
const len = state.length;
|
|
if (deleting) delete state[property];
|
|
else state[property] = value;
|
|
const nodes = getNodes(state, 0);
|
|
let node;
|
|
if ((node = getNode(nodes, property, prev))) node.write(value);
|
|
if (Array.isArray(state) && state.length !== len)
|
|
(node = getNode(nodes, "length", len)) && node.write(state.length);
|
|
(node = nodes[$TRACK]) && node.write(void 0);
|
|
}
|
|
function createStore(store) {
|
|
const unwrappedStore = unwrap(store);
|
|
const wrappedStore = wrap(unwrappedStore);
|
|
const setStore = (fn) => {
|
|
try {
|
|
Writing = true;
|
|
fn(wrappedStore);
|
|
} finally {
|
|
Writing = false;
|
|
}
|
|
};
|
|
return [wrappedStore, setStore];
|
|
}
|
|
|
|
export {
|
|
Computation,
|
|
ContextNotFoundError,
|
|
Effect,
|
|
NoOwnerError,
|
|
NotReadyError,
|
|
Owner,
|
|
RenderEffect,
|
|
catchError,
|
|
compute,
|
|
createAsync,
|
|
createContext,
|
|
createEffect,
|
|
createMemo,
|
|
createRenderEffect,
|
|
createRoot,
|
|
createSelector,
|
|
createSignal,
|
|
createStore,
|
|
flushSync,
|
|
getContext,
|
|
getObserver,
|
|
getOwner,
|
|
hasContext,
|
|
indexArray,
|
|
isEqual,
|
|
isWrappable,
|
|
mapArray,
|
|
onCleanup,
|
|
runWithOwner,
|
|
setContext,
|
|
setOwner,
|
|
untrack,
|
|
unwrap,
|
|
};
|