1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | "use strict";
|
7 |
|
8 | const { pathToFileURL } = require("url");
|
9 | const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
|
10 | const CommentCompilationWarning = require("../CommentCompilationWarning");
|
11 | const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
|
12 | const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
|
13 | const { equals } = require("../util/ArrayHelpers");
|
14 | const createHash = require("../util/createHash");
|
15 | const { contextify } = require("../util/identifier");
|
16 | const EnableWasmLoadingPlugin = require("../wasm/EnableWasmLoadingPlugin");
|
17 | const ConstDependency = require("./ConstDependency");
|
18 | const CreateScriptUrlDependency = require("./CreateScriptUrlDependency");
|
19 | const {
|
20 | harmonySpecifierTag
|
21 | } = require("./HarmonyImportDependencyParserPlugin");
|
22 | const WorkerDependency = require("./WorkerDependency");
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 | const getUrl = module => {
|
37 | return pathToFileURL(module.resource).toString();
|
38 | };
|
39 |
|
40 | const DEFAULT_SYNTAX = [
|
41 | "Worker",
|
42 | "SharedWorker",
|
43 | "navigator.serviceWorker.register()",
|
44 | "Worker from worker_threads"
|
45 | ];
|
46 |
|
47 |
|
48 | const workerIndexMap = new WeakMap();
|
49 |
|
50 | class WorkerPlugin {
|
51 | constructor(chunkLoading, wasmLoading, module) {
|
52 | this._chunkLoading = chunkLoading;
|
53 | this._wasmLoading = wasmLoading;
|
54 | this._module = module;
|
55 | }
|
56 | |
57 |
|
58 |
|
59 |
|
60 |
|
61 | apply(compiler) {
|
62 | if (this._chunkLoading) {
|
63 | new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
|
64 | }
|
65 | if (this._wasmLoading) {
|
66 | new EnableWasmLoadingPlugin(this._wasmLoading).apply(compiler);
|
67 | }
|
68 | const cachedContextify = contextify.bindContextCache(
|
69 | compiler.context,
|
70 | compiler.root
|
71 | );
|
72 | compiler.hooks.thisCompilation.tap(
|
73 | "WorkerPlugin",
|
74 | (compilation, { normalModuleFactory }) => {
|
75 | compilation.dependencyFactories.set(
|
76 | WorkerDependency,
|
77 | normalModuleFactory
|
78 | );
|
79 | compilation.dependencyTemplates.set(
|
80 | WorkerDependency,
|
81 | new WorkerDependency.Template()
|
82 | );
|
83 | compilation.dependencyTemplates.set(
|
84 | CreateScriptUrlDependency,
|
85 | new CreateScriptUrlDependency.Template()
|
86 | );
|
87 |
|
88 | |
89 |
|
90 |
|
91 |
|
92 |
|
93 | const parseModuleUrl = (parser, expr) => {
|
94 | if (
|
95 | expr.type !== "NewExpression" ||
|
96 | expr.callee.type === "Super" ||
|
97 | expr.arguments.length !== 2
|
98 | )
|
99 | return;
|
100 | const [arg1, arg2] = expr.arguments;
|
101 | if (arg1.type === "SpreadElement") return;
|
102 | if (arg2.type === "SpreadElement") return;
|
103 | const callee = parser.evaluateExpression(expr.callee);
|
104 | if (!callee.isIdentifier() || callee.identifier !== "URL") return;
|
105 | const arg2Value = parser.evaluateExpression(arg2);
|
106 | if (
|
107 | !arg2Value.isString() ||
|
108 | !arg2Value.string.startsWith("file://") ||
|
109 | arg2Value.string !== getUrl(parser.state.module)
|
110 | ) {
|
111 | return;
|
112 | }
|
113 | const arg1Value = parser.evaluateExpression(arg1);
|
114 | return [arg1Value, [arg1.range[0], arg2.range[1]]];
|
115 | };
|
116 |
|
117 | |
118 |
|
119 |
|
120 |
|
121 |
|
122 | const parseObjectExpression = (parser, expr) => {
|
123 |
|
124 | const values = {};
|
125 |
|
126 | const expressions = {};
|
127 |
|
128 | const otherElements = [];
|
129 | let spread = false;
|
130 | for (const prop of expr.properties) {
|
131 | if (prop.type === "SpreadElement") {
|
132 | spread = true;
|
133 | } else if (
|
134 | prop.type === "Property" &&
|
135 | !prop.method &&
|
136 | !prop.computed &&
|
137 | prop.key.type === "Identifier"
|
138 | ) {
|
139 | expressions[prop.key.name] = prop.value;
|
140 | if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
|
141 | const value = parser.evaluateExpression(
|
142 | (prop.value)
|
143 | );
|
144 | if (value.isCompileTimeValue())
|
145 | values[prop.key.name] = value.asCompileTimeValue();
|
146 | }
|
147 | } else {
|
148 | otherElements.push(prop);
|
149 | }
|
150 | }
|
151 | const insertType = expr.properties.length > 0 ? "comma" : "single";
|
152 | const insertLocation =
|
153 | expr.properties[expr.properties.length - 1].range[1];
|
154 | return {
|
155 | expressions,
|
156 | otherElements,
|
157 | values,
|
158 | spread,
|
159 | insertType,
|
160 | insertLocation
|
161 | };
|
162 | };
|
163 |
|
164 | |
165 |
|
166 |
|
167 |
|
168 | const parserPlugin = (parser, parserOptions) => {
|
169 | if (parserOptions.worker === false) return;
|
170 | const options = !Array.isArray(parserOptions.worker)
|
171 | ? ["..."]
|
172 | : parserOptions.worker;
|
173 | const handleNewWorker = expr => {
|
174 | if (expr.arguments.length === 0 || expr.arguments.length > 2)
|
175 | return;
|
176 | const [arg1, arg2] = expr.arguments;
|
177 | if (arg1.type === "SpreadElement") return;
|
178 | if (arg2 && arg2.type === "SpreadElement") return;
|
179 | const parsedUrl = parseModuleUrl(parser, arg1);
|
180 | if (!parsedUrl) return;
|
181 | const [url, range] = parsedUrl;
|
182 | if (!url.isString()) return;
|
183 | const {
|
184 | expressions,
|
185 | otherElements,
|
186 | values: options,
|
187 | spread: hasSpreadInOptions,
|
188 | insertType,
|
189 | insertLocation
|
190 | } = arg2 && arg2.type === "ObjectExpression"
|
191 | ? parseObjectExpression(parser, arg2)
|
192 | : {
|
193 | expressions: {},
|
194 | otherElements: [],
|
195 | values: {},
|
196 | spread: false,
|
197 | insertType: arg2 ? "spread" : "argument",
|
198 | insertLocation: arg2 ? arg2.range : arg1.range[1]
|
199 | };
|
200 | const { options: importOptions, errors: commentErrors } =
|
201 | parser.parseCommentOptions(expr.range);
|
202 |
|
203 | if (commentErrors) {
|
204 | for (const e of commentErrors) {
|
205 | const { comment } = e;
|
206 | parser.state.module.addWarning(
|
207 | new CommentCompilationWarning(
|
208 | `Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
|
209 | comment.loc
|
210 | )
|
211 | );
|
212 | }
|
213 | }
|
214 |
|
215 |
|
216 | let entryOptions = {};
|
217 |
|
218 | if (importOptions) {
|
219 | if (importOptions.webpackIgnore !== undefined) {
|
220 | if (typeof importOptions.webpackIgnore !== "boolean") {
|
221 | parser.state.module.addWarning(
|
222 | new UnsupportedFeatureWarning(
|
223 | `\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
|
224 | expr.loc
|
225 | )
|
226 | );
|
227 | } else {
|
228 | if (importOptions.webpackIgnore) {
|
229 | return false;
|
230 | }
|
231 | }
|
232 | }
|
233 | if (importOptions.webpackEntryOptions !== undefined) {
|
234 | if (
|
235 | typeof importOptions.webpackEntryOptions !== "object" ||
|
236 | importOptions.webpackEntryOptions === null
|
237 | ) {
|
238 | parser.state.module.addWarning(
|
239 | new UnsupportedFeatureWarning(
|
240 | `\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
|
241 | expr.loc
|
242 | )
|
243 | );
|
244 | } else {
|
245 | Object.assign(
|
246 | entryOptions,
|
247 | importOptions.webpackEntryOptions
|
248 | );
|
249 | }
|
250 | }
|
251 | if (importOptions.webpackChunkName !== undefined) {
|
252 | if (typeof importOptions.webpackChunkName !== "string") {
|
253 | parser.state.module.addWarning(
|
254 | new UnsupportedFeatureWarning(
|
255 | `\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
|
256 | expr.loc
|
257 | )
|
258 | );
|
259 | } else {
|
260 | entryOptions.name = importOptions.webpackChunkName;
|
261 | }
|
262 | }
|
263 | }
|
264 |
|
265 | if (
|
266 | !Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
|
267 | options &&
|
268 | typeof options.name === "string"
|
269 | ) {
|
270 | entryOptions.name = options.name;
|
271 | }
|
272 |
|
273 | if (entryOptions.runtime === undefined) {
|
274 | let i = workerIndexMap.get(parser.state) || 0;
|
275 | workerIndexMap.set(parser.state, i + 1);
|
276 | let name = `${cachedContextify(
|
277 | parser.state.module.identifier()
|
278 | )}|${i}`;
|
279 | const hash = createHash(compilation.outputOptions.hashFunction);
|
280 | hash.update(name);
|
281 | const digest = (
|
282 | hash.digest(compilation.outputOptions.hashDigest)
|
283 | );
|
284 | entryOptions.runtime = digest.slice(
|
285 | 0,
|
286 | compilation.outputOptions.hashDigestLength
|
287 | );
|
288 | }
|
289 |
|
290 | const block = new AsyncDependenciesBlock({
|
291 | name: entryOptions.name,
|
292 | entryOptions: {
|
293 | chunkLoading: this._chunkLoading,
|
294 | wasmLoading: this._wasmLoading,
|
295 | ...entryOptions
|
296 | }
|
297 | });
|
298 | block.loc = expr.loc;
|
299 | const dep = new WorkerDependency(url.string, range);
|
300 | dep.loc = expr.loc;
|
301 | block.addDependency(dep);
|
302 | parser.state.module.addBlock(block);
|
303 |
|
304 | if (compilation.outputOptions.trustedTypes) {
|
305 | const dep = new CreateScriptUrlDependency(
|
306 | expr.arguments[0].range
|
307 | );
|
308 | dep.loc = expr.loc;
|
309 | parser.state.module.addDependency(dep);
|
310 | }
|
311 |
|
312 | if (expressions.type) {
|
313 | const expr = expressions.type;
|
314 | if (options.type !== false) {
|
315 | const dep = new ConstDependency(
|
316 | this._module ? '"module"' : "undefined",
|
317 | expr.range
|
318 | );
|
319 | dep.loc = expr.loc;
|
320 | parser.state.module.addPresentationalDependency(dep);
|
321 | expressions.type = undefined;
|
322 | }
|
323 | } else if (insertType === "comma") {
|
324 | if (this._module || hasSpreadInOptions) {
|
325 | const dep = new ConstDependency(
|
326 | `, type: ${this._module ? '"module"' : "undefined"}`,
|
327 | insertLocation
|
328 | );
|
329 | dep.loc = expr.loc;
|
330 | parser.state.module.addPresentationalDependency(dep);
|
331 | }
|
332 | } else if (insertType === "spread") {
|
333 | const dep1 = new ConstDependency(
|
334 | "Object.assign({}, ",
|
335 | insertLocation[0]
|
336 | );
|
337 | const dep2 = new ConstDependency(
|
338 | `, { type: ${this._module ? '"module"' : "undefined"} })`,
|
339 | insertLocation[1]
|
340 | );
|
341 | dep1.loc = expr.loc;
|
342 | dep2.loc = expr.loc;
|
343 | parser.state.module.addPresentationalDependency(dep1);
|
344 | parser.state.module.addPresentationalDependency(dep2);
|
345 | } else if (insertType === "argument") {
|
346 | if (this._module) {
|
347 | const dep = new ConstDependency(
|
348 | ', { type: "module" }',
|
349 | insertLocation
|
350 | );
|
351 | dep.loc = expr.loc;
|
352 | parser.state.module.addPresentationalDependency(dep);
|
353 | }
|
354 | }
|
355 |
|
356 | parser.walkExpression(expr.callee);
|
357 | for (const key of Object.keys(expressions)) {
|
358 | if (expressions[key]) parser.walkExpression(expressions[key]);
|
359 | }
|
360 | for (const prop of otherElements) {
|
361 | parser.walkProperty(prop);
|
362 | }
|
363 | if (insertType === "spread") {
|
364 | parser.walkExpression(arg2);
|
365 | }
|
366 |
|
367 | return true;
|
368 | };
|
369 | const processItem = item => {
|
370 | if (item.endsWith("()")) {
|
371 | parser.hooks.call
|
372 | .for(item.slice(0, -2))
|
373 | .tap("WorkerPlugin", handleNewWorker);
|
374 | } else {
|
375 | const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
|
376 | if (match) {
|
377 | const ids = match[1].split(".");
|
378 | const call = match[2];
|
379 | const source = match[3];
|
380 | (call ? parser.hooks.call : parser.hooks.new)
|
381 | .for(harmonySpecifierTag)
|
382 | .tap("WorkerPlugin", expr => {
|
383 | const settings = (
|
384 | parser.currentTagData
|
385 | );
|
386 | if (
|
387 | !settings ||
|
388 | settings.source !== source ||
|
389 | !equals(settings.ids, ids)
|
390 | ) {
|
391 | return;
|
392 | }
|
393 | return handleNewWorker(expr);
|
394 | });
|
395 | } else {
|
396 | parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
|
397 | }
|
398 | }
|
399 | };
|
400 | for (const item of options) {
|
401 | if (item === "...") {
|
402 | DEFAULT_SYNTAX.forEach(processItem);
|
403 | } else processItem(item);
|
404 | }
|
405 | };
|
406 | normalModuleFactory.hooks.parser
|
407 | .for("javascript/auto")
|
408 | .tap("WorkerPlugin", parserPlugin);
|
409 | normalModuleFactory.hooks.parser
|
410 | .for("javascript/esm")
|
411 | .tap("WorkerPlugin", parserPlugin);
|
412 | }
|
413 | );
|
414 | }
|
415 | }
|
416 | module.exports = WorkerPlugin;
|