A music player that connects to your cloud/distributed storage.
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

refactor: eager signals by default

+27 -30
+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
··· 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
··· 205 205 206 206 // SIGNALS 207 207 208 - #activated = signal(/** @type {Set<string>} */ (new Set()), { eager: true }); 208 + #activated = signal(/** @type {Set<string>} */ (new Set())); 209 209 210 210 #defaultOutput = signal( 211 211 /** @type {Output | null | undefined} */ (undefined),
-1
src/components/orchestrator/process-tracks/element.js
··· 158 158 console.log("🪵 Processing initiated"); 159 159 160 160 const cachedTracks = this.output.tracks.collection(); 161 - console.log(cachedTracks); 162 161 const result = await this.#proxy.process(cachedTracks); 163 162 164 163 // Save if collection changed
+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
··· 56 56 get: () => this.#get("tracks"), 57 57 put: (data) => this.#put("tracks", data), 58 58 }, 59 - }, { 60 - eager: true, 61 59 }); 62 60 63 61 this.facets = this.#manager.facets;
+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
··· 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
··· 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
-1
src/themes/blur/artwork-controller/element.js
··· 44 44 current: null, 45 45 previous: null, 46 46 }), 47 - { eager: true }, 48 47 ); 49 48 50 49 #artworkColor = signal(/** @type {string | undefined} */ (undefined));