forked from
tokono.ma/diffuse
A music player that connects to your cloud/distributed storage.
refactor: eager signals by default
+27
-30
+1
-1
src/common/element.js
+1
-1
src/common/element.js
···
287
287
this.broadcast = this.broadcast.bind(this);
288
288
289
289
/** @type {Signal<Promise<BroadcastingStatus>>} */
290
-
this.#broadcastingStatus = signal(this.#status.promise, { eager: true });
290
+
this.#broadcastingStatus = signal(this.#status.promise);
291
291
this.broadcastingStatus = this.#broadcastingStatus.get;
292
292
}
293
293
+9
-9
src/common/signal.js
+9
-9
src/common/signal.js
···
1
-
import deepDiff from "@fry69/deep-diff";
2
1
import {
3
2
endBatch,
4
3
setActiveSub,
···
27
26
/**
28
27
* @template T
29
28
* @param {T} initialValue
30
-
* @param {{ eager?: boolean }} [options]
29
+
* @param {{ compare?: (a: T, b: T) => boolean }} [options]
31
30
* @returns {Signal<T>}
32
31
*/
33
32
export function signal(initialValue, options) {
34
33
const s = alienSignal(initialValue);
35
-
if (options?.eager === true) {
34
+
if (options?.compare) {
35
+
const compare = options.compare;
36
+
36
37
return _signal({
37
38
get: () => s(),
38
-
set: (v) => s(v),
39
+
set: (b) => {
40
+
const a = untracked(() => s());
41
+
if (!compare(a, b)) s(b);
42
+
},
39
43
});
40
44
}
41
45
42
46
return _signal({
43
47
get: () => s(),
44
-
set: (b) => {
45
-
const a = untracked(() => s());
46
-
const diff = deepDiff(a, b);
47
-
if (diff) s(b);
48
-
},
48
+
set: (v) => s(v),
49
49
});
50
50
}
51
51
+1
-1
src/components/configurator/output/element.js
+1
-1
src/components/configurator/output/element.js
-1
src/components/orchestrator/process-tracks/element.js
-1
src/components/orchestrator/process-tracks/element.js
+3
-1
src/components/orchestrator/process-tracks/worker.js
+3
-1
src/components/orchestrator/process-tracks/worker.js
···
17
17
////////////////////////////////////////////
18
18
19
19
/** @type {import("@common/signal.d.ts").Signal<{processed: number, total: number}>} */
20
-
const $progress = signal({ processed: 0, total: 0 });
20
+
const $progress = signal({ processed: 0, total: 0 }, {
21
+
compare: (a, b) => !deepDiff(a, b),
22
+
});
21
23
22
24
////////////////////////////////////////////
23
25
// ACTIONS
-2
src/components/output/bytes/s3/element.js
-2
src/components/output/bytes/s3/element.js
+10
-5
src/components/output/common.js
+10
-5
src/components/output/common.js
···
1
+
import deepDiff from "@fry69/deep-diff";
1
2
import { batch, computed, signal, untracked } from "@common/signal.js";
2
3
3
4
/**
···
8
9
/**
9
10
* @template [Encoding=null]
10
11
* @param {OutputManagerProperties<Encoding>} _
11
-
* @param {{ eager?: boolean }} [signalOpts]
12
+
* @param {{ compare?: boolean }} [signalOpts]
12
13
* @returns {OutputManager<Encoding>}
13
14
*/
14
15
export function outputManager(
15
16
{ init, facets, playlistItems, themes, tracks },
16
17
signalOpts,
17
18
) {
19
+
const compareOpt = signalOpts?.compare
20
+
? { compare: (a, b) => !deepDiff(a, b) }
21
+
: undefined;
22
+
18
23
const c = signal(
19
24
/** @type {Encoding extends null ? Facet[] : Encoding} */ (facets
20
25
.empty()),
21
-
{ eager: signalOpts?.eager ?? false },
26
+
compareOpt,
22
27
);
23
28
const cs = signal(
24
29
/** @type {"loading" | "loaded" | "sleeping"} */ ("sleeping"),
···
27
32
const pl = signal(
28
33
/** @type {Encoding extends null ? PlaylistItem[] : Encoding} */ (playlistItems
29
34
.empty()),
30
-
{ eager: signalOpts?.eager ?? false },
35
+
compareOpt,
31
36
);
32
37
const pls = signal(
33
38
/** @type {"loading" | "loaded" | "sleeping"} */ ("sleeping"),
···
35
40
36
41
const th = signal(
37
42
/** @type {Encoding extends null ? Theme[] : Encoding} */ (themes.empty()),
38
-
{ eager: signalOpts?.eager ?? false },
43
+
compareOpt,
39
44
);
40
45
const ths = signal(
41
46
/** @type {"loading" | "loaded" | "sleeping"} */ ("sleeping"),
···
43
48
44
49
const t = signal(
45
50
/** @type {Encoding extends null ? Track[] : Encoding} */ (tracks.empty()),
46
-
{ eager: signalOpts?.eager ?? false },
51
+
compareOpt,
47
52
);
48
53
const ts = signal(
49
54
/** @type {"loading" | "loaded" | "sleeping"} */ ("sleeping"),
+1
-3
src/components/transformer/output/base.js
+1
-3
src/components/transformer/output/base.js
···
11
11
export class OutputTransformer extends BroadcastableDiffuseElement {
12
12
// SIGNALS
13
13
14
-
#output = signal(/** @type {OutputElement<T> | undefined} */ (undefined), {
15
-
eager: true,
16
-
});
14
+
#output = signal(/** @type {OutputElement<T> | undefined} */ (undefined));
17
15
#outputWhenDefined = Promise.withResolvers();
18
16
19
17
output = {
+2
-6
src/components/transformer/output/bytes/dasl-sync/element.js
+2
-6
src/components/transformer/output/bytes/dasl-sync/element.js
···
46
46
remoteState,
47
47
{ saveLocal, saveRemote },
48
48
) => {
49
-
const container = signal(/** @type {Container<T>} */ (EMPTY), {
50
-
eager: true,
51
-
});
49
+
const container = signal(/** @type {Container<T>} */ (EMPTY));
52
50
53
51
const isReady = signal(false);
54
52
const isMerging = signal(false);
···
395
393
* @param {string} name
396
394
*/
397
395
local(name) {
398
-
const s = signal(/** @type {Uint8Array | undefined} */ (undefined), {
399
-
eager: true,
400
-
});
396
+
const s = signal(/** @type {Uint8Array | undefined} */ (undefined));
401
397
402
398
this.getLocal(name).then(s.set);
403
399