Skip to content

Commit d0baa92

Browse files
committed
wip #2
1 parent e5692ed commit d0baa92

5 files changed

Lines changed: 93 additions & 58 deletions

File tree

‎packages/solid-signals/src/core/core.ts‎

Lines changed: 70 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -10,13 +10,12 @@ import {
1010
import {
1111
activeTransition,
1212
clock,
13-
dirty,
13+
dirtyQueue,
1414
flush,
1515
globalQueue,
16-
pending,
16+
pendingQueue,
1717
Queue,
1818
schedule,
19-
transitionComplete,
2019
type IQueue,
2120
type Transition
2221
} from "./scheduler.js";
@@ -54,6 +53,7 @@ export interface RawSignal<T> {
5453
_time: number;
5554
_pendingValue: T | typeof NOT_PENDING;
5655
_pendingCheck?: Signal<boolean> & { _set: (v: boolean) => void };
56+
_pendingSignal?: Signal<T> & { _set: (v: T) => void };
5757
_transition?: Transition;
5858
}
5959

@@ -97,12 +97,13 @@ Queue._update = recompute;
9797
Queue._dispose = disposeChildren;
9898
let tracking = true;
9999
let stale = false;
100-
let staleCheck: null | { _value: boolean } = null;
100+
let pendingValueCheck = false;
101+
let pendingCheck: null | { _value: boolean } = null;
101102
let context: Owner | null = null;
102103
const defaultContext = {};
103104

104105
function recompute(el: Computed<any>, create: boolean = false): void {
105-
deleteFromHeap(el, el._flags & ReactiveFlags.Zombie ? pending : dirty);
106+
deleteFromHeap(el, el._flags & ReactiveFlags.Zombie ? pendingQueue : dirtyQueue);
106107
if (el._pendingValue !== NOT_PENDING || el._pendingFirstChild || el._pendingDisposal)
107108
disposeChildren(el);
108109
else {
@@ -122,6 +123,7 @@ function recompute(el: Computed<any>, create: boolean = false): void {
122123
let oldHeight = el._height;
123124
el._time = clock;
124125
let prevStatusFlags = el._statusFlags;
126+
let prevError = el._error;
125127
clearStatusFlags(el);
126128
try {
127129
value = el._fn(value);
@@ -151,23 +153,24 @@ function recompute(el: Computed<any>, create: boolean = false): void {
151153
const valueChanged =
152154
!el._equals ||
153155
!el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, value);
154-
const statusFlagsChanged = el._statusFlags !== prevStatusFlags;
156+
const statusFlagsChanged = el._statusFlags !== prevStatusFlags || el._error !== prevError;
155157

156158
if (valueChanged || statusFlagsChanged) {
157159
if (valueChanged) {
158-
if (create || (el as any)._type) el._value = value;
160+
if (create || (el as any)._optimistic || (el as any)._type) el._value = value;
159161
else {
160162
if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
161163
el._pendingValue = value;
162164
}
165+
if (el._pendingSignal) el._pendingSignal._set(value);
163166
}
164167

165168
for (let s = el._subs; s !== null; s = s._nextSub) {
166-
insertIntoHeap(s._sub, s._sub._flags & ReactiveFlags.Zombie ? pending : dirty);
169+
insertIntoHeap(s._sub, s._sub._flags & ReactiveFlags.Zombie ? pendingQueue : dirtyQueue);
167170
}
168171
} else if (el._height != oldHeight) {
169172
for (let s = el._subs; s !== null; s = s._nextSub) {
170-
insertIntoHeapHeight(s._sub, s._sub._flags & ReactiveFlags.Zombie ? pending : dirty);
173+
insertIntoHeapHeight(s._sub, s._sub._flags & ReactiveFlags.Zombie ? pendingQueue : dirtyQueue);
171174
}
172175
}
173176
}
@@ -291,8 +294,8 @@ function markDisposal(el: Owner): void {
291294
(child as Computed<unknown>)._flags |= ReactiveFlags.Zombie;
292295
const inHeap = (child as Computed<unknown>)._flags & ReactiveFlags.InHeap;
293296
if (inHeap) {
294-
deleteFromHeap(child as Computed<unknown>, dirty);
295-
insertIntoHeap(child as Computed<unknown>, pending);
297+
deleteFromHeap(child as Computed<unknown>, dirtyQueue);
298+
insertIntoHeap(child as Computed<unknown>, pendingQueue);
296299
}
297300
markDisposal(child);
298301
child = child._nextSibling;
@@ -305,7 +308,7 @@ function disposeChildren(node: Owner, zombie?: boolean): void {
305308
const nextChild = child._nextSibling;
306309
if ((child as Computed<unknown>)._deps) {
307310
const n = child as Computed<unknown>;
308-
deleteFromHeap(n, n._flags & ReactiveFlags.Zombie ? pending : dirty);
311+
deleteFromHeap(n, n._flags & ReactiveFlags.Zombie ? pendingQueue : dirtyQueue);
309312
let toRemove = n._deps;
310313
do {
311314
toRemove = unlinkSubs(toRemove!);
@@ -348,7 +351,7 @@ function withOptions<T>(obj: T, options?: SignalOptions<any> & { _internal?: any
348351
(obj as any)._equals = options?.equals !== undefined ? options.equals : isEqual;
349352
(obj as any)._pureWrite = !!options?.pureWrite;
350353
(obj as any)._unobserved = options?.unobserved;
351-
if (options?._internal) Object.assign((obj as any), options._internal);
354+
if (options?._internal) Object.assign(obj as any, options._internal);
352355
return obj as T & {
353356
_id?: string;
354357
_name?: string;
@@ -428,7 +431,7 @@ export function computed<T>(
428431
recompute(self, true);
429432
} else {
430433
self._height = parent._height + 1;
431-
insertIntoHeap(self, dirty);
434+
insertIntoHeap(self, dirtyQueue);
432435
}
433436
}
434437
} else {
@@ -572,9 +575,9 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
572575
const owner = ("_owner" in el ? el._owner : el) as Computed<any>;
573576
if ("_fn" in owner) {
574577
const isZombie = (el as Computed<unknown>)._flags & ReactiveFlags.Zombie;
575-
if (owner._height >= (isZombie ? pending._min : dirty._min)) {
578+
if (owner._height >= (isZombie ? pendingQueue._min : dirtyQueue._min)) {
576579
markNode(c as Computed<any>);
577-
markHeap(isZombie ? pending : dirty);
580+
markHeap(isZombie ? pendingQueue : dirtyQueue);
578581
updateIfNecessary(owner);
579582
}
580583
const height = owner._height;
@@ -583,21 +586,39 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
583586
}
584587
}
585588
}
586-
if (staleCheck) {
589+
if (pendingCheck) {
587590
if (!el._pendingCheck) {
588-
el._pendingCheck = signal<boolean>((el._statusFlags & StatusFlags.Pending) !== 0 || !!el._transition || false) as Signal<boolean> & { _set: (v: boolean) => void };
591+
el._pendingCheck = signal<boolean>(
592+
(el._statusFlags & StatusFlags.Pending) !== 0 || !!el._transition || false
593+
) as Signal<boolean> & { _set: (v: boolean) => void };
594+
(el._pendingCheck as any)._optimistic = true;
589595
el._pendingCheck._set = v => setSignal(el._pendingCheck!, v);
590596
}
591-
const prev = staleCheck;
592-
staleCheck = null;
597+
const prev = pendingCheck;
598+
pendingCheck = null;
593599
prev._value = read(el._pendingCheck) || prev._value;
594-
staleCheck = prev;
600+
pendingCheck = prev;
601+
}
602+
if (pendingValueCheck) {
603+
if (!el._pendingSignal) {
604+
el._pendingSignal = signal<T>(
605+
el._pendingValue === NOT_PENDING ? el._value : (el._pendingValue as T)
606+
) as Signal<T> & { _set: (v: T) => void };
607+
(el._pendingSignal as any)._optimistic = true;
608+
el._pendingSignal._set = v => queueMicrotask(() => queueMicrotask(() => setSignal(el._pendingSignal!, v)));
609+
}
610+
pendingValueCheck = false;
611+
try {
612+
return read(el._pendingSignal);
613+
} finally {
614+
pendingValueCheck = true;
615+
}
595616
}
596617
if (el._statusFlags & StatusFlags.Pending) {
597618
if ((c && !stale) || el._statusFlags & StatusFlags.Uninitialized) throw el._error;
598-
else if (c && stale && !staleCheck) {
619+
else if (c && stale && !pendingCheck) {
599620
setStatusFlags(
600-
(c as Computed<any>),
621+
c as Computed<any>,
601622
(c as Computed<any>)._statusFlags | 1 /* Pending */,
602623
el._error as Error
603624
);
@@ -613,10 +634,8 @@ export function read<T>(el: Signal<T> | Computed<T>): T {
613634
}
614635
}
615636
return !c ||
616-
(stale &&
617-
(el._transition || activeTransition?.pendingNodes.includes(el)) &&
618-
!transitionComplete(el._transition || activeTransition!)) ||
619-
el._pendingValue === NOT_PENDING
637+
el._pendingValue === NOT_PENDING ||
638+
(stale && !pendingCheck && el._transition && activeTransition !== el._transition)
620639
? el._value
621640
: (el._pendingValue as T);
622641
}
@@ -627,17 +646,23 @@ export function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T
627646
el._pendingValue === NOT_PENDING ? el._value : (el._pendingValue as T)
628647
);
629648
}
630-
const valueChanged = el._pendingValue === NOT_PENDING ? el._value !== v : el._pendingValue !== v;
649+
const valueChanged =
650+
!el._equals ||
651+
!el._equals(el._pendingValue === NOT_PENDING ? el._value : (el._pendingValue as T), v);
631652
if (!valueChanged && !el._statusFlags) return;
632653
if (valueChanged) {
633-
if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
634-
el._pendingValue = v;
654+
if ((el as any)._optimistic) el._value = v;
655+
else {
656+
if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
657+
el._pendingValue = v;
658+
}
659+
if (el._pendingSignal) el._pendingSignal._set(v);
635660
}
636661
clearStatusFlags(el);
637662
el._time = clock;
638663

639664
for (let link = el._subs; link !== null; link = link._nextSub) {
640-
insertIntoHeap(link._sub, link._sub._flags & ReactiveFlags.Zombie ? pending : dirty);
665+
insertIntoHeap(link._sub, link._sub._flags & ReactiveFlags.Zombie ? pendingQueue : dirtyQueue);
641666
}
642667
if (el._subs) schedule();
643668
}
@@ -722,10 +747,6 @@ export function runWithOwner<T>(owner: Owner | null, fn: () => T): T {
722747
}
723748
}
724749

725-
export function latest<T>(fn: () => T): T {
726-
return staleValues(fn, false);
727-
}
728-
729750
export function staleValues<T>(fn: () => T, set = true): T {
730751
const prevStale = stale;
731752
stale = set;
@@ -736,19 +757,29 @@ export function staleValues<T>(fn: () => T, set = true): T {
736757
}
737758
}
738759

760+
export function pending<T>(fn: () => T): T {
761+
const prevLatest = pendingValueCheck;
762+
pendingValueCheck = true;
763+
try {
764+
return staleValues(fn, false);
765+
} finally {
766+
pendingValueCheck = prevLatest;
767+
}
768+
}
769+
739770
export function isPending(fn: () => any): boolean;
740771
export function isPending(fn: () => any, loadingValue: boolean): boolean;
741772
export function isPending(fn: () => any, loadingValue?: boolean): boolean {
742-
const current = staleCheck;
743-
staleCheck = { _value: false };
773+
const current = pendingCheck;
774+
pendingCheck = { _value: false };
744775
try {
745776
staleValues(fn);
746-
return staleCheck._value;
777+
return pendingCheck._value;
747778
} catch (err) {
748779
if (!(err instanceof NotReadyError)) return false;
749780
if (loadingValue !== undefined) return loadingValue!;
750781
throw err;
751782
} finally {
752-
staleCheck = current;
783+
pendingCheck = current;
753784
}
754785
}

‎packages/solid-signals/src/core/effect.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ export function effect<T>(
4747
return equal;
4848
},
4949
_internal: {
50-
_modified: false,
50+
_modified: true,
5151
_prevValue: initialValue,
5252
_effectFn: effect,
5353
_errorFn: error,

‎packages/solid-signals/src/core/index.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ export {
2020
onCleanup,
2121
getNextChildId,
2222
isPending,
23-
latest,
23+
pending,
2424
type Owner,
2525
type Computed,
2626
type SignalOptions

‎packages/solid-signals/src/core/scheduler.ts‎

Lines changed: 20 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ export interface Transition {
1111
time: number;
1212
asyncNodes: Computed<any>[];
1313
pendingNodes: Signal<any>[];
14-
effects: QueueCallback[];
14+
queues: [QueueCallback[], QueueCallback[]];
1515
}
1616

1717
let scheduled = false;
@@ -21,13 +21,13 @@ export function schedule() {
2121
if (!globalQueue._running) queueMicrotask(flush);
2222
}
2323

24-
export const dirty: Heap = {
24+
export const dirtyQueue: Heap = {
2525
_heap: new Array(2000).fill(undefined),
2626
_marked: false,
2727
_min: 0,
2828
_max: 0
2929
};
30-
export const pending: Heap = {
30+
export const pendingQueue: Heap = {
3131
_heap: new Array(2000).fill(undefined),
3232
_marked: false,
3333
_min: 0,
@@ -74,26 +74,27 @@ export class Queue implements IQueue {
7474
if (this._running) return;
7575
this._running = true;
7676
try {
77-
runHeap(dirty, Queue._update);
77+
runHeap(dirtyQueue, Queue._update);
7878
if (activeTransition) {
7979
if (!transitionComplete(activeTransition)) {
80-
runHeap(pending, Queue._update);
80+
runHeap(pendingQueue, Queue._update);
8181
globalQueue._pendingNodes = [];
82-
activeTransition!.effects.push(...globalQueue._queues[1]);
83-
globalQueue._queues = [globalQueue._queues[0], []];
82+
activeTransition!.queues[0].push(...globalQueue._queues[0]);
83+
activeTransition!.queues[1].push(...globalQueue._queues[1]);
84+
globalQueue._queues = [[], []];
8485
clock++;
8586
scheduled = false;
86-
runIsPending(activeTransition!.pendingNodes, true);
87+
runPending(activeTransition!.pendingNodes, true);
8788
activeTransition = null;
88-
this.run(EffectType.Render);
8989
return;
9090
}
9191
globalQueue._pendingNodes.push(...activeTransition.pendingNodes);
92-
globalQueue._queues[1].push(...activeTransition.effects);
92+
globalQueue._queues[0].push(...activeTransition.queues[0]);
93+
globalQueue._queues[1].push(...activeTransition.queues[1]);
9394
transitions.delete(activeTransition);
9495
activeTransition = null;
95-
if (runIsPending(globalQueue._pendingNodes, false)) runHeap(dirty, Queue._update);
96-
} else if (transitions.size) runHeap(pending, Queue._update);
96+
if (runPending(globalQueue._pendingNodes, false)) runHeap(dirtyQueue, Queue._update);
97+
} else if (transitions.size) runHeap(pendingQueue, Queue._update);
9798
for (let i = 0; i < globalQueue._pendingNodes.length; i++) {
9899
const n = globalQueue._pendingNodes[i];
99100
if (n._pendingValue !== NOT_PENDING) {
@@ -144,17 +145,21 @@ export class Queue implements IQueue {
144145
time: clock,
145146
pendingNodes: [],
146147
asyncNodes: [],
147-
effects: []
148+
queues: [[], []]
148149
};
149150
}
150151
transitions.add(activeTransition);
151152
activeTransition.time = clock;
152-
activeTransition.pendingNodes.push(...globalQueue._pendingNodes);
153+
for (let i = 0; i < globalQueue._pendingNodes.length; i++) {
154+
const n = globalQueue._pendingNodes[i];
155+
n._transition = activeTransition;
156+
activeTransition.pendingNodes.push(n);
157+
}
153158
globalQueue._pendingNodes = activeTransition.pendingNodes;
154159
}
155160
}
156161

157-
function runIsPending(pendingNodes, value: boolean) {
162+
function runPending(pendingNodes, value: boolean) {
158163
let needsReset = false;
159164
const p = pendingNodes.slice();
160165
for (let i = 0; i < p.length; i++) {
@@ -188,7 +193,6 @@ function runQueue(queue: QueueCallback[], type: number): void {
188193
}
189194

190195
export function transitionComplete(transition: Transition): boolean {
191-
if (transition?.time === clock && !transition.asyncNodes.length) return false;
192196
let done = true;
193197
for (let i = 0; i < transition.asyncNodes.length; i++) {
194198
if (transition.asyncNodes[i]._statusFlags & StatusFlags.Pending) {

‎packages/solid-signals/src/index.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ export {
1313
isEqual,
1414
untrack,
1515
isPending,
16-
latest,
16+
pending,
1717
SUPPORTS_PROXY
1818
} from "./core/index.js";
1919
export type { Owner, SignalOptions, Context, ContextRecord, IQueue } from "./core/index.js";

0 commit comments

Comments
 (0)