+1 -2

src/build.vto

reviewed

··· 90 90 {{ echo -}}await foundation.orchestrator.scrobbleAudio(){{- /echo }} 91 91 {{ echo -}}await foundation.orchestrator.sources(){{- /echo }} 92 92 93 93 - {{ echo -}}await foundation.orchestrator.artwork(){{- /echo }} 94 94 - {{ echo -}}await foundation.processor.search(){{- /echo -}} 93 93 + {{ echo -}}await foundation.orchestrator.artwork(){{- /echo -}} 95 94 </code> 96 95 </div> 97 96 </section>

+6 -33

src/common/foundation.js

reviewed

··· 79 79 ), 80 80 }, 81 81 82 82 - processor: { 83 83 - search: signal( 84 84 - /** @type {import("~/components/processor/search/element.js").CLASS | null} */ (null), 85 85 - ), 86 86 - }, 87 82 }; 88 83 89 84 /** ··· 121 116 sources, 122 117 }, 123 118 124 124 - processor: { 125 125 - search, 126 126 - }, 127 127 - 128 119 /** 129 120 * Element signals 130 121 */ ··· 157 148 sources: signals.orchestrator.sources.get, 158 149 }, 159 150 160 160 - processor: { 161 161 - search: signals.processor.search.get, 162 162 - }, 163 151 }, 164 152 165 153 // Utilities ··· 313 301 } 314 302 315 303 316 316 - async function search() { 317 317 - const { default: SearchProcessor } = await import( 318 318 - "~/components/processor/search/element.js" 319 319 - ); 320 320 - 321 321 - const s = new SearchProcessor(); 322 322 - s.setAttribute("group", GROUP); 323 323 - 324 324 - return findExistingOrAdd(s, signals.processor.search); 325 325 - } 326 326 - 327 304 // Orchestrators 328 305 async function autoQueue() { 329 306 const [{ default: AutoQueueOrchestrator }, q, r, t] = await Promise.all([ ··· 435 412 } 436 413 437 414 async function scopedTracks() { 438 438 - const [{ default: ScopedTracksOrchestrator }, i, o, e, s] = await Promise.all( 439 439 - [ 440 440 - import("~/components/orchestrator/scoped-tracks/element.js"), 441 441 - input(), 442 442 - output(), 443 443 - scope(), 444 444 - search(), 445 445 - ], 446 446 - ); 415 415 + const [{ default: ScopedTracksOrchestrator }, i, o, e] = await Promise.all([ 416 416 + import("~/components/orchestrator/scoped-tracks/element.js"), 417 417 + input(), 418 418 + output(), 419 419 + scope(), 420 420 + ]); 447 421 448 422 const sto = new ScopedTracksOrchestrator(); 449 423 sto.setAttribute("group", GROUP); 450 424 sto.setAttribute("input-selector", i.selector); 451 425 sto.setAttribute("output-selector", o.selector); 452 426 sto.setAttribute("scope-engine-selector", e.selector); 453 453 - sto.setAttribute("search-processor-selector", s.selector); 454 427 455 428 return findExistingOrAdd(sto, signals.orchestrator.scopedTracks); 456 429 }

+22 -10

src/components/orchestrator/scoped-tracks/element.js

reviewed

··· 5 5 } from "~/common/element.js"; 6 6 import { batch, computed, signal } from "~/common/signal.js"; 7 7 import { filterByPlaylist } from "~/common/playlist.js"; 8 8 + import { listen } from "~/common/worker.js"; 8 9 9 10 /** 11 11 + * @import {ProxiedActions} from "~/common/worker.d.ts" 10 12 * @import {Track} from "~/definitions/types.d.ts" 11 13 * @import {InputElement} from "~/components/input/types.d.ts" 12 14 * @import {OutputElement} from "~/components/output/types.d.ts" 15 15 + * @import {Actions, State} from "./types.d.ts" 13 16 */ 14 17 15 18 //////////////////////////////////////////// ··· 18 21 19 22 class ScopedTracksOrchestrator extends BroadcastableDiffuseElement { 20 23 static NAME = "diffuse/orchestrator/scoped-tracks"; 24 24 + static WORKER_URL = "components/orchestrator/scoped-tracks/worker.js"; 25 25 + 26 26 + /** @type {ProxiedActions<Actions & State>} */ 27 27 + #proxy; 28 28 + 29 29 + constructor() { 30 30 + super(); 31 31 + this.#proxy = this.workerProxy(); 32 32 + } 21 33 22 34 // SIGNALS 23 35 ··· 28 40 /** @type {import("~/components/engine/scope/element.js").CLASS | null} */ (null), 29 41 ); 30 42 31 31 - #search = signal( 32 32 - /** @type {import("~/components/processor/search/element.js").CLASS | null} */ (null), 33 33 - ); 43 43 + #supplyFingerprint = signal(/** @type {string | undefined} */ (undefined)); 34 44 35 45 #selectedPlaylistItems = computed(() => { 36 46 const playlist = this.#scope.value?.playlist(); ··· 47 57 48 58 // STATE 49 59 60 60 + supplyFingerprint = this.#supplyFingerprint.get; 50 61 tracks = this.#tracksFinal.get; 51 62 52 63 // LIFECYCLE ··· 113 124 /** @type {OutputElement} */ 114 125 const output = query(this, "output-selector"); 115 126 116 116 - /** @type {import("~/components/processor/search/element.js").CLASS} */ 117 117 - const search = query(this, "search-processor-selector"); 118 118 - 119 127 /** @type {import("~/components/engine/scope/element.js").CLASS | null} */ 120 128 const scope = queryOptional(this, "scope-engine-selector"); 121 129 122 130 // Assign to self 123 131 this.#input.value = input; 124 132 this.#output.value = output; 125 125 - this.#search.value = search; 126 133 if (scope) this.#scope.value = scope; 134 134 + 135 135 + // Sync supply fingerprint with worker 136 136 + const link = this.workerLink(); 137 137 + listen("supplyFingerprint", this.#supplyFingerprint.set, link); 138 138 + this.#proxy.supplyFingerprint().then(this.#supplyFingerprint.set); 127 139 128 140 // When defined 129 141 await customElements.whenDefined(input.localName); ··· 161 173 }); 162 174 163 175 // Set pool 164 164 - search.supply({ tracks: availableTracks }); 176 176 + this.#proxy.supply({ tracks: availableTracks }); 165 177 166 178 this.#tracksAvailable.set(availableTracks); 167 179 }); 168 180 169 181 // Watch search supply 170 182 this.effect(async () => { 171 171 - const _trigger = search.supplyFingerprint(); 183 183 + const _trigger = this.#supplyFingerprint.value; 172 184 const availableTracks = this.#tracksAvailable.value; 173 185 const searchTerm = this.#scope.value?.searchTerm(); 174 186 175 187 if ((await this.isLeader()) === false) return; 176 188 177 189 if (searchTerm?.length) { 178 178 - const searchResults = await search.search({ 190 190 + const searchResults = await this.#proxy.search({ 179 191 term: searchTerm, 180 192 }); 181 193 this.#tracksSearch.set(searchResults);

src/components/processor/search/constants.js src/components/orchestrator/scoped-tracks/constants.js

reviewed

-67

src/components/processor/search/element.js

reviewed

··· 1 1 - import { DiffuseElement } from "~/common/element.js"; 2 2 - import { signal } from "~/common/signal.js"; 3 3 - import { listen } from "~/common/worker.js"; 4 4 - 5 5 - /** 6 6 - * @import {ProxiedActions} from "~/common/worker.d.ts"; 7 7 - * @import {Actions, State} from "./types.d.ts" 8 8 - */ 9 9 - 10 10 - //////////////////////////////////////////// 11 11 - // ELEMENT 12 12 - //////////////////////////////////////////// 13 13 - 14 14 - /** 15 15 - * @implements {ProxiedActions<Actions>} 16 16 - */ 17 17 - class SearchProcessor extends DiffuseElement { 18 18 - static NAME = "diffuse/processor/search"; 19 19 - static WORKER_URL = "components/processor/search/worker.js"; 20 20 - 21 21 - constructor() { 22 22 - super(); 23 23 - 24 24 - /** @type {ProxiedActions<Actions & State>} */ 25 25 - this.proxy = this.workerProxy(); 26 26 - 27 27 - this.search = this.proxy.search; 28 28 - this.supply = this.proxy.supply; 29 29 - } 30 30 - 31 31 - // SIGNALS 32 32 - 33 33 - #supplyFingerprint = signal(/** @type {string | undefined} */ (undefined)); 34 34 - 35 35 - // STATE 36 36 - 37 37 - supplyFingerprint = this.#supplyFingerprint.get; 38 38 - 39 39 - // LIFECYCLE 40 40 - 41 41 - /** 42 42 - * @override 43 43 - */ 44 44 - connectedCallback() { 45 45 - super.connectedCallback(); 46 46 - 47 47 - // Sync data with worker 48 48 - const link = this.workerLink(); 49 49 - 50 50 - // Listen for remote data changes 51 51 - listen("supplyFingerprint", this.#supplyFingerprint.set, link); 52 52 - 53 53 - // Fetch current data state 54 54 - this.proxy.supplyFingerprint().then(this.#supplyFingerprint.set); 55 55 - } 56 56 - } 57 57 - 58 58 - export default SearchProcessor; 59 59 - 60 60 - //////////////////////////////////////////// 61 61 - // REGISTER 62 62 - //////////////////////////////////////////// 63 63 - 64 64 - export const CLASS = SearchProcessor; 65 65 - export const NAME = "dp-search"; 66 66 - 67 67 - customElements.define(NAME, SearchProcessor);

src/components/processor/search/types.d.ts src/components/orchestrator/scoped-tracks/types.d.ts

reviewed

src/components/processor/search/worker.js src/components/orchestrator/scoped-tracks/worker.js

reviewed

+1 -15

src/elements.vto

reviewed

··· 128 128 desc: "Fetches cover art for a given set of tracks, stored locally in indexedDB. Uses the artwork configurator to try each configured source in sequence." 129 129 - url: "components/orchestrator/scoped-tracks/element.js" 130 130 title: "Scoped Tracks" 131 131 - desc: "Supplies the tracks from the given output to the given search processor whenever the tracks collection changes. Additionally it can perform a search and other ways to reduce the scope of tracks based on the given scope engine. Provides a `tracks` signal similar to `output.tracks.collection`" 131 131 + desc: "Watches the given output's tracks collection and runs them through a built-in search index. Can perform a search and other ways to reduce the scope of tracks based on the given scope engine. Provides a `tracks` signal similar to `output.tracks.collection`" 132 132 133 133 output: 134 134 - url: "components/output/polymorphic/indexed-db/element.js" ··· 147 147 - url: "components/metadata/audio-file/element.js" 148 148 title: "Audio File" 149 149 desc: "Extracts tags and audio stats from audio files using the music-metadata library." 150 150 - 151 151 - processors: 152 152 - - url: "components/processor/search/element.js" 153 153 - title: "Search" 154 154 - desc: "Provides a way to search through a collection of tracks, powered by orama.js" 155 150 156 151 supplements: 157 152 - url: "components/supplement/last.fm/element.js" ··· 245 240 <li><a href="elements/#metadata">Metadata</a></li> 246 241 <li><a href="elements/#orchestrators">Orchestrators</a></li> 247 242 <li><a href="elements/#output">Output</a></li> 248 248 - <li><a href="elements/#processors">Processors</a></li> 249 243 <li><a href="elements/#supplements">Supplements</a></li> 250 244 <li><a href="elements/#transformers">Transformers</a></li> 251 245 <!----> ··· 311 305 items: output, 312 306 content: ` 313 307 Output is application-derived data such as playlists. These elements can receive such data and keep it around. These are categorised by the type of data they ingest, or many types in the case of polymorphic. Optionally use transformers to convert output into the expected format. 314 314 - ` 315 315 - }) }} 316 316 - 317 317 - {{ await comp.element({ 318 318 - title: "Processors", 319 319 - items: processors, 320 320 - content: ` 321 321 - These elements work with the output generated by the input elements to add more data to them, or process them in some other way. 322 308 ` 323 309 }) }} 324 310

+1 -2

src/themes/winamp/facet/index.inline.js

reviewed

··· 17 17 const queue = await foundation.engine.queue(); 18 18 const repeatShuffle = await foundation.engine.repeatShuffle(); 19 19 const scopedTracks = await foundation.orchestrator.scopedTracks(); 20 20 - const search = await foundation.processor.search(); 21 20 22 21 await foundation.orchestrator.sources(); 23 22 await foundation.orchestrator.processTracks({ disableWhenReady: true }); ··· 65 64 const col = output.tracks.collection(); 66 65 if (col.state !== "loaded") return; 67 66 68 68 - const fingerprintSearch = search.supplyFingerprint(); 67 67 + const fingerprintSearch = scopedTracks.supplyFingerprint(); 69 68 if (fingerprintSearch === undefined) return; 70 69 71 70 const fingerprintQueue = queue.supplyFingerprint();

-258

tests/components/processor/search/test.ts

reviewed

··· 1 1 - import { describe, it } from "@std/testing/bdd"; 2 2 - import { expect } from "@std/expect"; 3 3 - 4 4 - import { testWeb } from "@tests/common/index.ts"; 5 5 - import { trackA, trackB, tracks } from "~/testing/sample/tracks.js"; 6 6 - 7 7 - describe("components/processor/search", () => { 8 8 - it("finds tracks by album", async () => { 9 9 - const results = await testWeb(async () => { 10 10 - const SearchProcessor = await import( 11 11 - "~/components/processor/search/element.js" 12 12 - ); 13 13 - const processor = new SearchProcessor.CLASS(); 14 14 - 15 15 - document.body.append(processor); 16 16 - 17 17 - // Add sample tracks to the supply first 18 18 - const { tracks } = await import("~/testing/sample/tracks.js"); 19 19 - await processor.supply({ tracks }); 20 20 - 21 21 - // Search for a specific term 22 22 - return processor.search({ term: tracks[1]?.tags?.album }); 23 23 - }); 24 24 - 25 25 - expect(results[0]?.id).toBe(trackB.id); 26 26 - }); 27 27 - 28 28 - it("finds tracks by artist", async () => { 29 29 - const results = await testWeb(async () => { 30 30 - const SearchProcessor = await import( 31 31 - "~/components/processor/search/element.js" 32 32 - ); 33 33 - const processor = new SearchProcessor.CLASS(); 34 34 - 35 35 - document.body.append(processor); 36 36 - 37 37 - // Add sample tracks to the supply first 38 38 - const { tracks } = await import("~/testing/sample/tracks.js"); 39 39 - await processor.supply({ tracks }); 40 40 - 41 41 - // Search for a specific term 42 42 - return processor.search({ term: tracks[0]?.tags?.artist }); 43 43 - }); 44 44 - 45 45 - expect(results[0]?.id).toBe(trackA.id); 46 46 - }); 47 47 - 48 48 - it("finds tracks by title", async () => { 49 49 - const results = await testWeb(async () => { 50 50 - const SearchProcessor = await import( 51 51 - "~/components/processor/search/element.js" 52 52 - ); 53 53 - const processor = new SearchProcessor.CLASS(); 54 54 - 55 55 - document.body.append(processor); 56 56 - 57 57 - // Add sample tracks to the supply first 58 58 - const { tracks } = await import("~/testing/sample/tracks.js"); 59 59 - await processor.supply({ tracks }); 60 60 - 61 61 - // Search for a specific term 62 62 - return processor.search({ term: tracks[1]?.tags?.title }); 63 63 - }); 64 64 - 65 65 - expect(results[0]?.id).toBe(trackB.id); 66 66 - }); 67 67 - 68 68 - it("returns empty array when no tracks match the search term", async () => { 69 69 - const results = await testWeb(async () => { 70 70 - const SearchProcessor = await import( 71 71 - "~/components/processor/search/element.js" 72 72 - ); 73 73 - const processor = new SearchProcessor.CLASS(); 74 74 - 75 75 - document.body.append(processor); 76 76 - 77 77 - const { tracks } = await import("~/testing/sample/tracks.js"); 78 78 - await processor.supply({ tracks }); 79 79 - 80 80 - return processor.search({ term: "zzz-no-match-zzz" }); 81 81 - }); 82 82 - 83 83 - expect(results).toEqual([]); 84 84 - }); 85 85 - 86 86 - it("supplyFingerprint is undefined before first supply", async () => { 87 87 - const fp = await testWeb(async () => { 88 88 - const SearchProcessor = await import( 89 89 - "~/components/processor/search/element.js" 90 90 - ); 91 91 - const processor = new SearchProcessor.CLASS(); 92 92 - 93 93 - document.body.append(processor); 94 94 - 95 95 - return (await processor.supplyFingerprint()) ?? null; 96 96 - }); 97 97 - 98 98 - expect(fp).toBe(null); 99 99 - }); 100 100 - 101 101 - it("supplyFingerprint is set after supply", async () => { 102 102 - const fp = await testWeb(async () => { 103 103 - const SearchProcessor = await import( 104 104 - "~/components/processor/search/element.js" 105 105 - ); 106 106 - const processor = new SearchProcessor.CLASS(); 107 107 - 108 108 - document.body.append(processor); 109 109 - 110 110 - const { tracks } = await import("~/testing/sample/tracks.js"); 111 111 - await processor.supply({ tracks }); 112 112 - 113 113 - return processor.supplyFingerprint() ?? null; 114 114 - }); 115 115 - 116 116 - expect(fp).not.toBe(null); 117 117 - expect(typeof fp).toBe("string"); 118 118 - }); 119 119 - 120 120 - it("supply with same tracks does not change the fingerprint", async () => { 121 121 - const [fp1, fp2] = await testWeb(async () => { 122 122 - const SearchProcessor = await import( 123 123 - "~/components/processor/search/element.js" 124 124 - ); 125 125 - const processor = new SearchProcessor.CLASS(); 126 126 - 127 127 - document.body.append(processor); 128 128 - 129 129 - const { tracks } = await import("~/testing/sample/tracks.js"); 130 130 - await processor.supply({ tracks }); 131 131 - const fp1 = processor.supplyFingerprint(); 132 132 - 133 133 - await processor.supply({ tracks }); 134 134 - const fp2 = processor.supplyFingerprint(); 135 135 - 136 136 - return [fp1, fp2]; 137 137 - }); 138 138 - 139 139 - expect(fp1).toBe(fp2); 140 140 - }); 141 141 - 142 142 - it("supply removes tracks no longer in the list", async () => { 143 143 - const results = await testWeb(async () => { 144 144 - const SearchProcessor = await import( 145 145 - "~/components/processor/search/element.js" 146 146 - ); 147 147 - const processor = new SearchProcessor.CLASS(); 148 148 - 149 149 - document.body.append(processor); 150 150 - 151 151 - const { trackA, trackB } = await import("~/testing/sample/tracks.js"); 152 152 - 153 153 - // Supply both tracks then narrow to only trackB 154 154 - await processor.supply({ tracks: [trackA, trackB] }); 155 155 - await processor.supply({ tracks: [trackB] }); 156 156 - 157 157 - // trackA's artist "Artist" is absent from trackB — must return empty 158 158 - return processor.search({ term: "Artist" }); 159 159 - }); 160 160 - 161 161 - expect(results).toEqual([]); 162 162 - }); 163 163 - 164 164 - it("supply with empty list clears all tracks from the index", async () => { 165 165 - const results = await testWeb(async () => { 166 166 - const SearchProcessor = await import( 167 167 - "~/components/processor/search/element.js" 168 168 - ); 169 169 - const processor = new SearchProcessor.CLASS(); 170 170 - 171 171 - document.body.append(processor); 172 172 - 173 173 - const { tracks } = await import("~/testing/sample/tracks.js"); 174 174 - await processor.supply({ tracks }); 175 175 - await processor.supply({ tracks: [] }); 176 176 - 177 177 - return processor.search({ term: "Sample" }); 178 178 - }); 179 179 - 180 180 - expect(results).toEqual([]); 181 181 - }); 182 182 - 183 183 - it("sorts results by artist alphabetically", async () => { 184 184 - const ids = await testWeb(async () => { 185 185 - const SearchProcessor = await import( 186 186 - "~/components/processor/search/element.js" 187 187 - ); 188 188 - const processor = new SearchProcessor.CLASS(); 189 189 - 190 190 - document.body.append(processor); 191 191 - 192 192 - const testTracks = [ 193 193 - { 194 194 - $type: "sh.diffuse.output.track" as const, 195 195 - id: "sort-zebra", 196 196 - uri: "diffuse://sort-zebra", 197 197 - tags: { artist: "Zebra", title: "Sort Test" }, 198 198 - }, 199 199 - { 200 200 - $type: "sh.diffuse.output.track" as const, 201 201 - id: "sort-apple", 202 202 - uri: "diffuse://sort-apple", 203 203 - tags: { artist: "Apple", title: "Sort Test" }, 204 204 - }, 205 205 - { 206 206 - $type: "sh.diffuse.output.track" as const, 207 207 - id: "sort-mango", 208 208 - uri: "diffuse://sort-mango", 209 209 - tags: { artist: "Mango", title: "Sort Test" }, 210 210 - }, 211 211 - ]; 212 212 - 213 213 - await processor.supply({ tracks: testTracks }); 214 214 - const results = await processor.search({ term: "Sort Test" }); 215 215 - return results.map((t) => t.id); 216 216 - }); 217 217 - 218 218 - expect(ids).toEqual(["sort-apple", "sort-mango", "sort-zebra"]); 219 219 - }); 220 220 - 221 221 - it("sorts results by track number within the same album", async () => { 222 222 - const ids = await testWeb(async () => { 223 223 - const SearchProcessor = await import( 224 224 - "~/components/processor/search/element.js" 225 225 - ); 226 226 - const processor = new SearchProcessor.CLASS(); 227 227 - 228 228 - document.body.append(processor); 229 229 - 230 230 - const testTracks = [ 231 231 - { 232 232 - $type: "sh.diffuse.output.track" as const, 233 233 - id: "track-03", 234 234 - uri: "diffuse://track-03", 235 235 - tags: { artist: "Band", album: "Album", track: { no: 3 }, title: "C" }, 236 236 - }, 237 237 - { 238 238 - $type: "sh.diffuse.output.track" as const, 239 239 - id: "track-01", 240 240 - uri: "diffuse://track-01", 241 241 - tags: { artist: "Band", album: "Album", track: { no: 1 }, title: "A" }, 242 242 - }, 243 243 - { 244 244 - $type: "sh.diffuse.output.track" as const, 245 245 - id: "track-02", 246 246 - uri: "diffuse://track-02", 247 247 - tags: { artist: "Band", album: "Album", track: { no: 2 }, title: "B" }, 248 248 - }, 249 249 - ]; 250 250 - 251 251 - await processor.supply({ tracks: testTracks }); 252 252 - const results = await processor.search({ term: "Band" }); 253 253 - return results.map((t) => t.id); 254 254 - }); 255 255 - 256 256 - expect(ids).toEqual(["track-01", "track-02", "track-03"]); 257 257 - }); 258 258 - });