A music player that connects to your cloud/distributed storage.
chore: dynamic imports for foundation
+293
-183
+195
-90
src/common/facets/foundation.js
+195
-90
src/common/facets/foundation.js
···
1
-
import ArtworkProcessor from "~/components/processor/artwork/element.js";
2
-
import AudioEngine from "~/components/engine/audio/element.js";
3
-
import AutoQueueOrchestrator from "~/components/orchestrator/auto-queue/element.js";
4
-
import Queue from "~/components/engine/queue/element.js";
5
-
import InputOrchestrator from "~/components/orchestrator/input/element.js";
6
-
import OutputOrchestrator from "~/components/orchestrator/output/element.js";
7
-
import MetadataProcessor from "~/components/processor/metadata/element.js";
8
-
import ProcessTracksOrchestrator from "~/components/orchestrator/process-tracks/element.js";
9
-
import QueueAudioOrchestrator from "~/components/orchestrator/queue-audio/element.js";
10
-
import RepeatShuffleEngine from "~/components/engine/repeat-shuffle/element.js";
11
-
import SearchProcessor from "~/components/processor/search/element.js";
12
-
import ScopeEngine from "~/components/engine/scope/element.js";
13
-
import ScopedTracksOrchestrator from "~/components/orchestrator/scoped-tracks/element.js";
14
-
import FavouritesOrchestrator from "~/components/orchestrator/favourites/element.js";
15
-
import MediaSessionOrchestrator from "~/components/orchestrator/media-session/element.js";
16
-
import ScrobbleAudioOrchestrator from "~/components/orchestrator/scrobble-audio/element.js";
17
-
import SourcesOrchestrator from "~/components/orchestrator/sources/element.js";
18
-
import ScrobblesConfigurator from "~/components/configurator/scrobbles/element.js";
19
-
import LastFmScrobbler from "../../components/supplement/last.fm/element.js";
20
-
21
1
/**
22
-
* @import { DiffuseElement } from "@toko/diffuse/common/element.js";
2
+
* @import { DiffuseElement } from "~/common/element.js";
3
+
* @import { ScrobbleElement } from "~/components/supplement/types.d.ts";
23
4
*/
24
5
25
6
const url = new URL(document.location.href);
···
71
52
72
53
// 📦️
73
54
74
-
function fillQueueAutomatically() {
55
+
async function fillQueueAutomatically() {
56
+
const [q, rs, sc, aq, i, o, st] = await Promise.all([
57
+
// engine
58
+
queue(),
59
+
repeatShuffle(),
60
+
scope(),
61
+
62
+
// orchestrator
63
+
autoQueue(),
64
+
input(),
65
+
output(),
66
+
scopedTracks(),
67
+
]);
68
+
75
69
return {
76
70
engine: {
77
-
queue: queue(),
78
-
repeatShuffle: repeatShuffle(),
79
-
scope: scope(),
71
+
queue: q,
72
+
repeatShuffle: rs,
73
+
scope: sc,
80
74
},
81
75
orchestrator: {
82
-
autoQueue: autoQueue(),
83
-
input: input(),
84
-
output: output(),
85
-
scopedTracks: scopedTracks(),
76
+
autoQueue: aq,
77
+
input: i,
78
+
output: o,
79
+
scopedTracks: st,
86
80
},
87
81
};
88
82
}
89
83
90
-
function playAudioFromQueue() {
84
+
async function playAudioFromQueue() {
85
+
const [sc, a, q, ms, qa, sca] = await Promise.all([
86
+
// configurator
87
+
scrobbles(),
88
+
89
+
// engine
90
+
audio(),
91
+
queue(),
92
+
93
+
// orchestrator
94
+
mediaSession(),
95
+
queueAudio(),
96
+
scrobbleAudio(),
97
+
]);
98
+
91
99
return {
92
100
configurator: {
93
-
scrobbles: scrobbles(),
101
+
scrobbles: sc,
94
102
},
95
103
engine: {
96
-
audio: audio(),
97
-
queue: queue(),
104
+
audio: a,
105
+
queue: q,
98
106
},
99
107
orchestrator: {
100
-
mediaSession: mediaSession(),
101
-
queueAudio: queueAudio(),
102
-
scrobbleAudio: scrobbleAudio(),
108
+
mediaSession: ms,
109
+
queueAudio: qa,
110
+
scrobbleAudio: sca,
103
111
},
104
112
};
105
113
}
106
114
107
-
function processInputs() {
115
+
async function processInputs() {
116
+
const [i, o, pt, m] = await Promise.all([
117
+
// orchestrator
118
+
input(),
119
+
output(),
120
+
processTracks(),
121
+
122
+
// processor
123
+
metadata(),
124
+
]);
125
+
108
126
return {
109
127
orchestrator: {
110
-
input: input(),
111
-
output: output(),
112
-
processTracks: processTracks(),
128
+
input: i,
129
+
output: o,
130
+
processTracks: pt,
113
131
},
114
132
processor: {
115
-
metadata: metadata(),
133
+
metadata: m,
116
134
},
117
135
};
118
136
}
119
137
120
-
function searchThroughCollection() {
138
+
async function searchThroughCollection() {
139
+
const [sc, o, st, s] = await Promise.all([
140
+
// engine
141
+
scope(),
142
+
143
+
// orchestrator
144
+
output(),
145
+
scopedTracks(),
146
+
147
+
// processor
148
+
search(),
149
+
]);
150
+
121
151
return {
122
152
engine: {
123
-
scope: scope(),
153
+
scope: sc,
124
154
},
125
155
orchestrator: {
126
-
output: output(),
127
-
scopedTracks: scopedTracks(),
156
+
output: o,
157
+
scopedTracks: st,
128
158
},
129
159
processor: {
130
-
search: search(),
160
+
search: s,
131
161
},
132
162
};
133
163
}
···
135
165
// 🥡
136
166
137
167
// Configurators
138
-
function scrobbles() {
168
+
169
+
/**
170
+
* @returns {Promise<ScrobbleElement>}
171
+
*/
172
+
async function scrobbles() {
173
+
const [{ default: ScrobblesConfigurator }, { default: LastFmScrobbler }] =
174
+
await Promise.all([
175
+
import("~/components/configurator/scrobbles/element.js"),
176
+
import("~/components/supplement/last.fm/element.js"),
177
+
]);
178
+
139
179
const sc = new ScrobblesConfigurator();
140
180
sc.setAttribute("group", GROUP);
141
181
sc.setAttribute("id", "scrobbles");
···
143
183
const existing = document.body.querySelector(sc.selector);
144
184
145
185
if (existing) {
146
-
return /** @type {ScrobblesConfigurator} */ (existing);
186
+
return /** @type {ScrobbleElement} */ (existing);
147
187
}
148
188
149
189
const lastFm = new LastFmScrobbler();
···
152
192
sc.append(lastFm);
153
193
154
194
document.body.append(sc);
155
-
return sc;
195
+
return /** @type {ScrobbleElement} */ (/** @type {unknown} */ (sc));
156
196
}
157
197
158
198
// Engines
159
-
function audio() {
199
+
async function audio() {
200
+
const { default: AudioEngine } = await import(
201
+
"~/components/engine/audio/element.js"
202
+
);
203
+
160
204
const a = new AudioEngine();
161
205
a.setAttribute("group", GROUP);
162
206
163
207
return findExistingOrAdd(a);
164
208
}
165
209
166
-
function queue() {
210
+
async function queue() {
211
+
const { default: Queue } = await import(
212
+
"~/components/engine/queue/element.js"
213
+
);
214
+
167
215
const q = new Queue();
168
216
q.setAttribute("group", GROUP);
169
217
170
218
return findExistingOrAdd(q);
171
219
}
172
220
173
-
function repeatShuffle() {
221
+
async function repeatShuffle() {
222
+
const { default: RepeatShuffleEngine } = await import(
223
+
"~/components/engine/repeat-shuffle/element.js"
224
+
);
225
+
174
226
const r = new RepeatShuffleEngine();
175
227
r.setAttribute("group", GROUP);
176
228
177
229
return findExistingOrAdd(r);
178
230
}
179
231
180
-
function scope() {
232
+
async function scope() {
233
+
const { default: ScopeEngine } = await import(
234
+
"~/components/engine/scope/element.js"
235
+
);
236
+
181
237
const s = new ScopeEngine();
182
238
s.setAttribute("group", GROUP);
183
239
···
185
241
}
186
242
187
243
// Processors
188
-
function artwork() {
244
+
async function artwork() {
245
+
const { default: ArtworkProcessor } = await import(
246
+
"~/components/processor/artwork/element.js"
247
+
);
248
+
189
249
const a = new ArtworkProcessor();
190
250
a.setAttribute("group", GROUP);
191
251
192
252
return findExistingOrAdd(a);
193
253
}
194
254
195
-
function metadata() {
255
+
async function metadata() {
256
+
const { default: MetadataProcessor } = await import(
257
+
"~/components/processor/metadata/element.js"
258
+
);
259
+
196
260
const m = new MetadataProcessor();
197
261
m.setAttribute("group", GROUP);
198
262
199
263
return findExistingOrAdd(m);
200
264
}
201
265
202
-
function search() {
266
+
async function search() {
267
+
const { default: SearchProcessor } = await import(
268
+
"~/components/processor/search/element.js"
269
+
);
270
+
203
271
const s = new SearchProcessor();
204
272
s.setAttribute("group", GROUP);
205
273
···
207
275
}
208
276
209
277
// Orchestrators
210
-
function autoQueue() {
211
-
const q = queue();
212
-
const r = repeatShuffle();
213
-
const t = scopedTracks();
278
+
async function autoQueue() {
279
+
const [{ default: AutoQueueOrchestrator }, q, r, t] = await Promise.all([
280
+
import("~/components/orchestrator/auto-queue/element.js"),
281
+
queue(),
282
+
repeatShuffle(),
283
+
scopedTracks(),
284
+
]);
214
285
215
286
const aqo = new AutoQueueOrchestrator();
216
287
aqo.setAttribute("group", GROUP);
···
221
292
return findExistingOrAdd(aqo);
222
293
}
223
294
224
-
function favourites() {
225
-
const o = output();
295
+
async function favourites() {
296
+
const [{ default: FavouritesOrchestrator }, o] = await Promise.all([
297
+
import("~/components/orchestrator/favourites/element.js"),
298
+
output(),
299
+
]);
226
300
227
301
const fo = new FavouritesOrchestrator();
228
302
fo.setAttribute("group", GROUP);
···
231
305
return findExistingOrAdd(fo);
232
306
}
233
307
234
-
function input() {
308
+
async function input() {
309
+
const { default: InputOrchestrator } = await import(
310
+
"~/components/orchestrator/input/element.js"
311
+
);
312
+
235
313
const i = new InputOrchestrator();
236
314
i.setAttribute("group", GROUP);
237
315
i.setAttribute("id", "input");
···
239
317
return findExistingOrAdd(i);
240
318
}
241
319
242
-
function mediaSession() {
243
-
const a = audio();
244
-
const aw = artwork();
245
-
const o = output();
246
-
const q = queue();
320
+
async function mediaSession() {
321
+
const [{ default: MediaSessionOrchestrator }, a, aw, o, q] = await Promise
322
+
.all([
323
+
import("~/components/orchestrator/media-session/element.js"),
324
+
audio(),
325
+
artwork(),
326
+
output(),
327
+
queue(),
328
+
]);
247
329
248
330
const mso = new MediaSessionOrchestrator();
249
331
mso.setAttribute("group", GROUP);
···
255
337
return findExistingOrAdd(mso);
256
338
}
257
339
258
-
function output() {
340
+
async function output() {
341
+
const { default: OutputOrchestrator } = await import(
342
+
"~/components/orchestrator/output/element.js"
343
+
);
344
+
259
345
const o = new OutputOrchestrator();
260
346
o.setAttribute("group", GROUP);
261
347
o.setAttribute("id", "output");
···
267
353
* @param {Object} opts - Options
268
354
* @param {boolean} [opts.disableWhenReady] - Whether to disable processing when ready.
269
355
*/
270
-
function processTracks(opts = { disableWhenReady: false }) {
271
-
const i = input();
272
-
const o = output();
273
-
const m = metadata();
356
+
async function processTracks(opts = { disableWhenReady: false }) {
357
+
const [{ default: ProcessTracksOrchestrator }, i, o, m] = await Promise.all([
358
+
import("~/components/orchestrator/process-tracks/element.js"),
359
+
input(),
360
+
output(),
361
+
metadata(),
362
+
]);
274
363
275
364
const opt = new ProcessTracksOrchestrator();
276
365
opt.setAttribute("group", GROUP);
···
285
374
return findExistingOrAdd(opt);
286
375
}
287
376
288
-
function queueAudio() {
289
-
const a = audio();
290
-
const i = input();
291
-
const o = output();
292
-
const q = queue();
293
-
const r = repeatShuffle();
377
+
async function queueAudio() {
378
+
const [{ default: QueueAudioOrchestrator }, a, i, o, q, r] = await Promise
379
+
.all([
380
+
import("~/components/orchestrator/queue-audio/element.js"),
381
+
audio(),
382
+
input(),
383
+
output(),
384
+
queue(),
385
+
repeatShuffle(),
386
+
]);
294
387
295
388
const oqa = new QueueAudioOrchestrator();
296
389
oqa.setAttribute("group", GROUP);
···
303
396
return findExistingOrAdd(oqa);
304
397
}
305
398
306
-
function scopedTracks() {
307
-
const i = input();
308
-
const o = output();
309
-
const e = scope();
310
-
const s = search();
399
+
async function scopedTracks() {
400
+
const [{ default: ScopedTracksOrchestrator }, i, o, e, s] = await Promise.all(
401
+
[
402
+
import("~/components/orchestrator/scoped-tracks/element.js"),
403
+
input(),
404
+
output(),
405
+
scope(),
406
+
search(),
407
+
],
408
+
);
311
409
312
410
const sto = new ScopedTracksOrchestrator();
313
411
sto.setAttribute("group", GROUP);
···
319
417
return findExistingOrAdd(sto);
320
418
}
321
419
322
-
function scrobbleAudio() {
323
-
const a = audio();
324
-
const sc = scrobbles();
420
+
async function scrobbleAudio() {
421
+
const [{ default: ScrobbleAudioOrchestrator }, a, sc] = await Promise.all([
422
+
import("~/components/orchestrator/scrobble-audio/element.js"),
423
+
audio(),
424
+
scrobbles(),
425
+
]);
325
426
326
427
const sao = new ScrobbleAudioOrchestrator();
327
428
sao.setAttribute("group", GROUP);
···
331
432
return findExistingOrAdd(sao);
332
433
}
333
434
334
-
function sources() {
335
-
const i = input();
336
-
const o = output();
435
+
async function sources() {
436
+
const [{ default: SourcesOrchestrator }, i, o] = await Promise.all([
437
+
import("~/components/orchestrator/sources/element.js"),
438
+
input(),
439
+
output(),
440
+
]);
441
+
337
442
const so = new SourcesOrchestrator();
338
443
so.setAttribute("group", GROUP);
339
444
so.setAttribute("input-selector", i.selector);
+19
-19
src/facets/build.vto
+19
-19
src/facets/build.vto
···
61
61
{{- echo -}}
62
62
import foundation from "common/facets/foundation.js"
63
63
{{ /echo }}
64
-
{{ echo -}}foundation.engine.audio(){{- /echo }}
65
-
{{ echo -}}foundation.engine.queue(){{- /echo }}
66
-
{{ echo -}}foundation.engine.repeatShuffle(){{- /echo }}
67
-
{{ echo -}}foundation.engine.scope(){{- /echo }}
64
+
{{ echo -}}await foundation.engine.audio(){{- /echo }}
65
+
{{ echo -}}await foundation.engine.queue(){{- /echo }}
66
+
{{ echo -}}await foundation.engine.repeatShuffle(){{- /echo }}
67
+
{{ echo -}}await foundation.engine.scope(){{- /echo }}
68
68
69
-
{{ echo -}}foundation.orchestrator.autoQueue(){{- /echo }}
70
-
{{ echo -}}foundation.orchestrator.favourites(){{- /echo }}
71
-
{{ echo -}}foundation.orchestrator.input(){{- /echo }}
72
-
{{ echo -}}foundation.orchestrator.output(){{- /echo }}
73
-
{{ echo -}}foundation.orchestrator.queueAudio(){{- /echo }}
74
-
{{ echo -}}foundation.orchestrator.processTracks(){{- /echo }}
75
-
{{ echo -}}foundation.orchestrator.scopedTracks(){{- /echo }}
76
-
{{ echo -}}foundation.orchestrator.sources(){{- /echo }}
69
+
{{ echo -}}await foundation.orchestrator.autoQueue(){{- /echo }}
70
+
{{ echo -}}await foundation.orchestrator.favourites(){{- /echo }}
71
+
{{ echo -}}await foundation.orchestrator.input(){{- /echo }}
72
+
{{ echo -}}await foundation.orchestrator.output(){{- /echo }}
73
+
{{ echo -}}await foundation.orchestrator.queueAudio(){{- /echo }}
74
+
{{ echo -}}await foundation.orchestrator.processTracks(){{- /echo }}
75
+
{{ echo -}}await foundation.orchestrator.scopedTracks(){{- /echo }}
76
+
{{ echo -}}await foundation.orchestrator.sources(){{- /echo }}
77
77
78
-
{{ echo -}}foundation.processor.artwork(){{- /echo }}
79
-
{{ echo -}}foundation.processor.metadata(){{- /echo }}
80
-
{{ echo -}}foundation.processor.search(){{- /echo -}}
78
+
{{ echo -}}await foundation.processor.artwork(){{- /echo }}
79
+
{{ echo -}}await foundation.processor.metadata(){{- /echo }}
80
+
{{ echo -}}await foundation.processor.search(){{- /echo -}}
81
81
</code>
82
82
</div>
83
83
···
88
88
<li>
89
89
<span>Fill the queue automatically <small>(infinite play)</small></span>
90
90
<div class="list-description">
91
-
<code>foundation.features.fillQueueAutomatically()</code>
91
+
<code>await foundation.features.fillQueueAutomatically()</code>
92
92
</div>
93
93
</li>
94
94
<li>
95
95
<span>Play audio from the queue</span>
96
96
<div class="list-description">
97
-
<code>foundation.features.playAudioFromQueue()</code>
97
+
<code>await foundation.features.playAudioFromQueue()</code>
98
98
</div>
99
99
</li>
100
100
<li>
101
101
<span>Process inputs <small>(into tracks, etc)</small></span>
102
102
<div class="list-description">
103
-
<code>foundation.features.processInputs()</code>
103
+
<code>await foundation.features.processInputs()</code>
104
104
</div>
105
105
</li>
106
106
<li>
107
107
<span>Search through your collection</span>
108
108
<div class="list-description" style="margin-bottom: 0;">
109
-
<code>foundation.features.searchThroughCollection()</code>
109
+
<code>await foundation.features.searchThroughCollection()</code>
110
110
</div>
111
111
</li>
112
112
</ul>
+23
-23
src/facets/common/build.js
+23
-23
src/facets/common/build.js
···
21
21
22
22
const $editor = signal(/** @type {EditorView | null} */ (null));
23
23
const $editingFacet = signal(/** @type {Facet | null} */ (null));
24
-
const output = foundation.orchestrator.output();
24
+
const output = await foundation.orchestrator.output();
25
25
26
26
////////////////////////////////////////////
27
27
// EDITOR
···
35
35
const editor = new EditorView({
36
36
parent: editorContainer,
37
37
doc: `
38
-
<main>
39
-
<h1 id="now-playing">
40
-
Waiting on tracks & queue to load ...
41
-
</h1>
42
-
</main>
38
+
<main>
39
+
<h1 id="now-playing">
40
+
Waiting on tracks & queue to load ...
41
+
</h1>
42
+
</main>
43
43
44
-
<style>
45
-
@import "./styles/base.css";
46
-
@import "./styles/diffuse/page.css";
47
-
</style>
44
+
<style>
45
+
@import "./styles/base.css";
46
+
@import "./styles/diffuse/page.css";
47
+
</style>
48
48
49
-
<script type="module">
50
-
import foundation from "~/common/facets/foundation.js";
51
-
import { effect } from "~/common/signal.js";
49
+
<script type="module">
50
+
import foundation from "~/common/facets/foundation.js";
51
+
import { effect } from "~/common/signal.js";
52
52
53
-
const components = foundation.features.fillQueueAutomatically();
54
-
const myHtmlElement = document.querySelector("#now-playing");
53
+
const components = await foundation.features.fillQueueAutomatically();
54
+
const myHtmlElement = document.querySelector("#now-playing");
55
55
56
-
effect(() => {
57
-
const now = components.engine.queue.now();
58
-
const currentlyPlaying = now ? components.orchestrator.output.tracks.collection().find(t => t.id === now.id) : undefined;
59
-
if (currentlyPlaying && myHtmlElement) {
60
-
myHtmlElement.innerText = \`\$\{currentlyPlaying.tags.artist} - \$\{currentlyPlaying.tags.title}\`;
61
-
}
62
-
})
63
-
</script>
56
+
effect(() => {
57
+
const now = components.engine.queue.now();
58
+
const currentlyPlaying = now ? components.orchestrator.output.tracks.collection().find(t => t.id === now.id) : undefined;
59
+
if (currentlyPlaying && myHtmlElement) {
60
+
myHtmlElement.innerText = \`\$\{currentlyPlaying.tags.artist} - \$\{currentlyPlaying.tags.title}\`;
61
+
}
62
+
})
63
+
</script>
64
64
`.trim(),
65
65
extensions: [
66
66
basicSetup,
+2
-2
src/facets/common/crud.js
+2
-2
src/facets/common/crud.js
···
13
13
const c = confirm("Are you sure you want to delete this facet?");
14
14
if (!c) return;
15
15
16
-
const output = foundation.orchestrator.output();
16
+
const output = await foundation.orchestrator.output();
17
17
const col = await Output.data(output.facets);
18
18
19
19
output.facets.save(col.filter((c) => !(c.id === id)));
···
24
24
* @param {Facet} facet
25
25
*/
26
26
export async function saveFacet(facet) {
27
-
const output = foundation.orchestrator.output();
27
+
const output = await foundation.orchestrator.output();
28
28
const col = await Output.data(output.facets);
29
29
const colWithoutId = col.filter((c) => c.id !== facet.id);
30
30
await output.facets.save([...colWithoutId, {
+2
-2
src/facets/common/grid.js
+2
-2
src/facets/common/grid.js
···
28
28
const name = li.getAttribute("data-name");
29
29
if (!uri || !name) return;
30
30
31
-
const out = foundation.orchestrator.output();
31
+
const out = await foundation.orchestrator.output();
32
32
const collection = await Output.data(out.facets);
33
33
const isActive = collection.some((f) => f.uri === uri);
34
34
···
53
53
54
54
export async function monitorToggleButtonStates() {
55
55
if (stopMonitor) stopMonitor();
56
-
const out = foundation.orchestrator.output();
56
+
const out = await foundation.orchestrator.output();
57
57
58
58
stopMonitor = effect(() => {
59
59
const gridItems = /** @type {NodeListOf<HTMLLIElement>} */ (
+1
-2
src/facets/common/you.js
+1
-2
src/facets/common/you.js
···
3
3
import { marked } from "marked";
4
4
import { unsafeHTML } from "lit-html/directives/unsafe-html.js";
5
5
6
-
import * as Output from "~/common/output.js";
7
6
import foundation from "~/common/facets/foundation.js";
8
7
import { effect } from "~/common/signal.js";
9
8
import { facetFromURI } from "~/common/facets/utils.js";
···
166
165
listEl.removeAttribute("data-rendered");
167
166
}
168
167
169
-
const output = foundation.orchestrator.output();
168
+
const output = await foundation.orchestrator.output();
170
169
171
170
stopMonitor = effect(() => {
172
171
_renderList(output, listEl);
+2
-2
src/facets/examples/generate-playlist/index.inline.js
+2
-2
src/facets/examples/generate-playlist/index.inline.js
···
1
1
import foundation from "~/common/facets/foundation.js";
2
2
3
-
const queue = foundation.engine.queue();
4
-
const output = foundation.orchestrator.output();
3
+
const output = await foundation.orchestrator.output();
4
+
const queue = await foundation.engine.queue();
5
5
6
6
/**
7
7
* Playlist generator
+4
-4
src/facets/examples/now-playing/index.inline.js
+4
-4
src/facets/examples/now-playing/index.inline.js
···
1
1
import foundation from "~/common/facets/foundation.js";
2
2
import { effect } from "~/common/signal.js";
3
3
4
-
foundation.features.processInputs();
5
-
foundation.features.fillQueueAutomatically();
4
+
await foundation.features.processInputs();
5
+
await foundation.features.fillQueueAutomatically();
6
6
7
-
const output = foundation.orchestrator.output();
8
-
const queue = foundation.engine.queue();
7
+
const output = await foundation.orchestrator.output();
8
+
const queue = await foundation.engine.queue();
9
9
10
10
effect(() => {
11
11
const now = queue.now();
+3
-4
src/facets/l/index.js
+3
-4
src/facets/l/index.js
···
2
2
import * as CID from "~/common/cid.js";
3
3
import { createLoader, renderError } from "~/common/loader.js";
4
4
5
+
const output = await foundation.orchestrator.output();
6
+
5
7
createLoader({
6
8
$type: "sh.diffuse.output.facet",
7
9
label: "Facet",
8
-
source: () => {
9
-
const output = foundation.orchestrator.output();
10
-
return output.facets;
11
-
},
10
+
source: () => output.facets,
12
11
async render(facet) {
13
12
const container = /** @type {HTMLDivElement} */ (
14
13
document.querySelector("#container")
+7
-5
src/facets/tools/auto-queue/index.inline.js
+7
-5
src/facets/tools/auto-queue/index.inline.js
···
5
5
const ACTIVE_CLASS = "button--active";
6
6
7
7
// Setup
8
-
foundation.features.fillQueueAutomatically();
9
-
foundation.features.processInputs();
8
+
await foundation.features.fillQueueAutomatically();
9
+
await foundation.features.processInputs();
10
10
11
-
const repeatShuffle = foundation.engine.repeatShuffle();
12
-
const scope = foundation.engine.scope();
13
-
const output = foundation.orchestrator.output();
11
+
const [repeatShuffle, scope, output] = await Promise.all([
12
+
foundation.engine.repeatShuffle(),
13
+
foundation.engine.scope(),
14
+
foundation.orchestrator.output(),
15
+
]);
14
16
15
17
// Elements
16
18
const repeatBtn =
+1
-1
src/facets/tools/export-import/index.inline.js
+1
-1
src/facets/tools/export-import/index.inline.js
+1
-1
src/facets/tools/split-view/index.inline.js
+1
-1
src/facets/tools/split-view/index.inline.js
···
424
424
}
425
425
426
426
async function saveSimplifiedCopy() {
427
-
const output = foundation.orchestrator.output();
427
+
const output = await foundation.orchestrator.output();
428
428
const id = crypto.randomUUID();
429
429
const html = generateSimplifiedHTML(id);
430
430
const now = new Date().toISOString();
+3
-3
src/facets/tools/v3-import/index.inline.js
+3
-3
src/facets/tools/v3-import/index.inline.js
···
6
6
*/
7
7
8
8
// Setup
9
-
foundation.features.processInputs();
9
+
await foundation.features.processInputs();
10
10
11
-
const favourites = foundation.orchestrator.favourites();
12
-
const output = foundation.orchestrator.output();
11
+
const favourites = await foundation.orchestrator.favourites();
12
+
const output = await foundation.orchestrator.output();
13
13
14
14
// Elements
15
15
const fileInput =
+10
-8
src/themes/blur/artwork-controller/facet/index.inline.js
+10
-8
src/themes/blur/artwork-controller/facet/index.inline.js
···
2
2
import ArtworkController from "~/themes/blur/artwork-controller/element.js";
3
3
4
4
// Setup the prerequisite elements
5
-
foundation.features.playAudioFromQueue();
6
-
foundation.features.processInputs();
5
+
await foundation.features.playAudioFromQueue();
6
+
await foundation.features.processInputs();
7
7
8
-
const aud = foundation.engine.audio();
9
-
const art = foundation.processor.artwork();
10
-
const fav = foundation.orchestrator.favourites();
11
-
const inp = foundation.orchestrator.input();
12
-
const out = foundation.orchestrator.output();
13
-
const que = foundation.engine.queue();
8
+
const [aud, art, fav, inp, out, que] = await Promise.all([
9
+
foundation.engine.audio(),
10
+
foundation.processor.artwork(),
11
+
foundation.orchestrator.favourites(),
12
+
foundation.orchestrator.input(),
13
+
foundation.orchestrator.output(),
14
+
foundation.engine.queue(),
15
+
]);
14
16
15
17
// Controller
16
18
const dac = new ArtworkController();
+2
-2
src/themes/index.js
+2
-2
src/themes/index.js
···
48
48
}
49
49
case "save": {
50
50
const theme = await themeFromURI({ name, uri }, { fetchHTML: false });
51
-
const out = foundation.orchestrator.output();
51
+
const out = await foundation.orchestrator.output();
52
52
53
53
const col = out.themes.collection();
54
54
out.themes.save([
···
71
71
72
72
listEl.innerHTML = "";
73
73
74
-
const output = foundation.orchestrator.output();
74
+
const output = await foundation.orchestrator.output();
75
75
76
76
effect(() => {
77
77
const themesCol = output.themes.collection();
+3
-4
src/themes/l/index.js
+3
-4
src/themes/l/index.js
···
2
2
import * as CID from "~/common/cid.js";
3
3
import { createLoader, renderError } from "~/common/loader.js";
4
4
5
+
const output = await foundation.orchestrator.output();
6
+
5
7
createLoader({
6
8
$type: "sh.diffuse.output.theme",
7
9
label: "Theme",
8
-
source: () => {
9
-
const output = foundation.orchestrator.output();
10
-
return output.themes;
11
-
},
10
+
source: () => output.themes,
12
11
async render(theme) {
13
12
if (theme.cid) {
14
13
const valid = await CID.verify(
+8
-6
src/themes/webamp/browser/facet/index.inline.js
+8
-6
src/themes/webamp/browser/facet/index.inline.js
···
1
1
import foundation from "~/common/facets/foundation.js";
2
2
import BrowserElement from "~/themes/webamp/browser/element.js";
3
3
4
-
foundation.features.processInputs();
5
-
foundation.features.searchThroughCollection();
4
+
await foundation.features.processInputs();
5
+
await foundation.features.searchThroughCollection();
6
6
7
-
const out = foundation.orchestrator.output();
8
-
const que = foundation.engine.queue();
9
-
const scp = foundation.engine.scope();
10
-
const trc = foundation.orchestrator.scopedTracks();
7
+
const [out, que, scp, trc] = await Promise.all([
8
+
foundation.orchestrator.output(),
9
+
foundation.engine.queue(),
10
+
foundation.engine.scope(),
11
+
foundation.orchestrator.scopedTracks(),
12
+
]);
11
13
12
14
const el = new BrowserElement();
13
15
el.setAttribute("output-selector", out.selector);
+6
-4
src/themes/webamp/configurators/input/facet/index.inline.js
+6
-4
src/themes/webamp/configurators/input/facet/index.inline.js
···
1
1
import foundation from "~/common/facets/foundation.js";
2
2
import InputConfigElement from "~/themes/webamp/configurators/input/element.js";
3
3
4
-
const inp = foundation.orchestrator.input();
5
-
const out = foundation.orchestrator.output();
6
-
const pro = foundation.orchestrator.processTracks({ disableWhenReady: true });
7
-
const sou = foundation.orchestrator.sources();
4
+
const [inp, out, pro, sou] = await Promise.all([
5
+
foundation.orchestrator.input(),
6
+
foundation.orchestrator.output(),
7
+
foundation.orchestrator.processTracks({ disableWhenReady: true }),
8
+
foundation.orchestrator.sources(),
9
+
]);
8
10
9
11
const el = new InputConfigElement();
10
12
el.setAttribute("input-selector", inp.selector);
+1
-1
src/themes/webamp/configurators/output/facet/index.inline.js
+1
-1
src/themes/webamp/configurators/output/facet/index.inline.js
···
1
1
import foundation from "~/common/facets/foundation.js";
2
2
import OutputConfigElement from "~/themes/webamp/configurators/output/element.js";
3
3
4
-
const out = foundation.orchestrator.output();
4
+
const out = await foundation.orchestrator.output();
5
5
6
6
const el = new OutputConfigElement();
7
7
el.setAttribute("output-selector", out.selector);