A music player that connects to your cloud/distributed storage.
chore: create new workers for processing
+53
-15
+12
-8
src/common/element.js
+12
-8
src/common/element.js
···
2
2
import { html, render } from "lit-html";
3
3
4
4
import { effect, signal } from "@common/signal.js";
5
-
import { rpc, workerProxy } from "./worker.js";
5
+
import { rpc, workerLink, workerProxy } from "./worker.js";
6
6
import { BrowserPostMessageIo } from "./worker/rpc.js";
7
7
import { RPCChannel } from "@kunkun/kkrpc";
8
8
···
121
121
return worker;
122
122
}
123
123
124
-
workerLink() {
125
-
this.#worker ??= this.worker();
126
-
const worker = this.#worker;
124
+
/**
125
+
* @param {Worker | SharedWorker} [worker]
126
+
*/
127
+
workerLink(worker) {
128
+
let w;
127
129
128
-
if (worker instanceof SharedWorker) {
129
-
worker.port.start();
130
-
return worker.port;
130
+
if (worker) {
131
+
w = worker;
131
132
} else {
132
-
return worker;
133
+
this.#worker ??= this.worker();
134
+
w = this.#worker;
133
135
}
136
+
137
+
return workerLink(w);
134
138
}
135
139
}
136
140
+12
src/common/worker.js
+12
src/common/worker.js
···
87
87
};
88
88
}
89
89
90
+
/**
91
+
* @param {Worker | SharedWorker} worker
92
+
*/
93
+
export function workerLink(worker) {
94
+
if (worker instanceof SharedWorker) {
95
+
worker.port.start();
96
+
return worker.port;
97
+
} else {
98
+
return worker;
99
+
}
100
+
}
101
+
90
102
////////////////////////////////////////////
91
103
// RAW
92
104
////////////////////////////////////////////
+29
-7
src/components/orchestrator/process-tracks/element.js
+29
-7
src/components/orchestrator/process-tracks/element.js
···
1
1
import { DiffuseElement, query } from "@common/element.js";
2
2
import { signal, untracked } from "@common/signal.js";
3
-
import { portProvider, transfer, workerProxy } from "@common/worker.js";
3
+
import {
4
+
portProvider,
5
+
transfer,
6
+
workerLink,
7
+
workerProxy,
8
+
} from "@common/worker.js";
4
9
5
10
/**
6
11
* @import {Track} from "@definitions/types.d.ts"
···
21
26
* from the assigned output element.
22
27
*/
23
28
class ProcessTracksOrchestrator extends DiffuseElement {
24
-
/** @type {Promise<{ input: ReturnType<portProvider>; metadataProcessor: ReturnType<portProvider> } | undefined> | undefined} */
25
-
#external = undefined;
29
+
/** @type {Promise<{ input: Worker | SharedWorker; metadataProcessor: Worker | SharedWorker } | undefined>} */
30
+
#external = Promise.resolve(undefined);
26
31
#process;
27
32
28
33
static NAME = "diffuse/orchestrator/process-tracks";
···
71
76
if (!this.metadataProcessor) return undefined;
72
77
73
78
return {
74
-
input: portProvider(this.input.workerLink),
75
-
metadataProcessor: portProvider(this.metadataProcessor.workerLink),
79
+
input: this.input.worker(),
80
+
metadataProcessor: this.metadataProcessor.worker(),
76
81
};
77
82
});
78
83
···
90
95
});
91
96
}
92
97
98
+
/**
99
+
* @override
100
+
*/
101
+
async disconnectedCallback() {
102
+
super.disconnectedCallback();
103
+
104
+
const ext = await this.#external;
105
+
if (!ext) return;
106
+
107
+
if (ext.input instanceof Worker) ext.input.terminate();
108
+
if (ext.metadataProcessor instanceof Worker) {
109
+
ext.metadataProcessor.terminate();
110
+
}
111
+
}
112
+
93
113
// ACTIONS
94
114
95
115
async process() {
···
106
126
107
127
// Establish channel between external workers and our processing worker
108
128
const ports = {
109
-
input: ext.input(),
110
-
metadataProcessor: ext.metadataProcessor(),
129
+
input: portProvider(() => workerLink(ext.input))(),
130
+
metadataProcessor: portProvider(() =>
131
+
workerLink(ext.metadataProcessor)
132
+
)(),
111
133
};
112
134
113
135
// Send everything to worker