// Copyright 2016 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. import type * as PlatformApi from '../../core/platform/api/api.js'; import * as Platform from '../../core/platform/platform.js'; import * as FormatterActions from '../../entrypoints/formatter_worker/FormatterActions.js'; // eslint-disable-line @devtools/es-modules-import export {DefinitionKind, ScopeKind, type ScopeTreeNode} from '../../entrypoints/formatter_worker/FormatterActions.js'; let formatterWorkerPoolInstance: FormatterWorkerPool|undefined; export class FormatterWorkerPool { private taskQueue: Task[]; private workerTasks: Map; private entrypointURL: string; constructor(entrypointURL?: string) { this.taskQueue = []; this.workerTasks = new Map(); this.entrypointURL = entrypointURL ?? import.meta.resolve('../../entrypoints/formatter_worker/formatter_worker-entrypoint.js'); } static instance(opts?: {forceNew: true, entrypointURL: string}): FormatterWorkerPool { if (!formatterWorkerPoolInstance || opts?.forceNew) { formatterWorkerPoolInstance = new FormatterWorkerPool(opts?.entrypointURL); } return formatterWorkerPoolInstance; } dispose(): void { for (const task of this.taskQueue) { console.error('rejecting task'); task.errorCallback(new Event('Worker terminated')); } for (const [worker, task] of this.workerTasks.entries()) { task?.errorCallback(new Event('Worker terminated')); worker.terminate(/* immediately=*/ true); } } static removeInstance(): void { formatterWorkerPoolInstance?.dispose(); formatterWorkerPoolInstance = undefined; } private createWorker(): PlatformApi.HostRuntime.Worker { const worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(this.entrypointURL); worker.onmessage = this.onWorkerMessage.bind(this, worker); worker.onerror = this.onWorkerError.bind(this, worker); return worker; } private processNextTask(): void { const maxWorkers = Math.max(2, navigator.hardwareConcurrency - 1); if (!this.taskQueue.length) { return; } let freeWorker = [...this.workerTasks.keys()].find(worker => !this.workerTasks.get(worker)); if (!freeWorker && this.workerTasks.size < maxWorkers) { freeWorker = this.createWorker(); } if (!freeWorker) { return; } const task = this.taskQueue.shift(); if (task) { this.workerTasks.set(freeWorker, task); freeWorker.postMessage({method: task.method, params: task.params}); } } private onWorkerMessage(worker: PlatformApi.HostRuntime.Worker, event: PlatformApi.HostRuntime.WorkerMessageEvent): void { const task = this.workerTasks.get(worker); if (!task) { return; } if (task.isChunked && event.data && !event.data['isLastChunk']) { task.callback(event.data); return; } this.workerTasks.set(worker, null); this.processNextTask(); task.callback(event.data ? event.data : null); } private onWorkerError(worker: PlatformApi.HostRuntime.Worker, event: Event): void { console.error(event); const task = this.workerTasks.get(worker); worker.terminate(); this.workerTasks.delete(worker); const newWorker = this.createWorker(); this.workerTasks.set(newWorker, null); this.processNextTask(); if (task) { task.errorCallback(event); } } private runChunkedTask( methodName: string, params: Record, callback: (arg0: boolean, arg1: unknown) => void): void { const task = new Task(methodName, params, onData, () => onData(null), true); this.taskQueue.push(task); this.processNextTask(); function onData(data: Object|null): void { if (!data) { callback(true, null); return; } const isLastChunk = 'isLastChunk' in data && Boolean(data['isLastChunk']); const chunk = 'chunk' in data && data['chunk']; callback(isLastChunk, chunk); } } // eslint-disable-next-line @typescript-eslint/no-explicit-any private runTask(methodName: FormatterActions.FormatterActions, params: Record): Promise { return new Promise((resolve, reject) => { const task = new Task(methodName, params, resolve, reject, false); this.taskQueue.push(task); this.processNextTask(); }); } format(mimeType: string, content: string, indentString: string): Promise { const parameters = {mimeType, content, indentString}; return this.runTask(FormatterActions.FormatterActions.FORMAT, parameters) as Promise; } javaScriptSubstitute(expression: string, mapping: Map): Promise { if (mapping.size === 0) { return Promise.resolve(expression); } return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SUBSTITUTE, {content: expression, mapping}) .then(result => result || ''); } javaScriptScopeTree(expression: string, sourceType: 'module'|'script' = 'script'): Promise { return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SCOPE_TREE, {content: expression, sourceType}) .then(result => result || null); } parseCSS(content: string, callback: (arg0: boolean, arg1: CSSRule[]) => void): void { this.runChunkedTask(FormatterActions.FormatterActions.PARSE_CSS, {content}, onDataChunk); // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration // eslint-disable-next-line @typescript-eslint/no-explicit-any function onDataChunk(isLastChunk: boolean, data: any): void { const rules = (data || [] as CSSRule[]); callback(isLastChunk, rules); } } } class Task { method: string; params: unknown; callback: (arg0: MessageEvent|null) => void; errorCallback: (arg0: Event) => void; isChunked: boolean|undefined; constructor( method: string, params: unknown, callback: (arg0: MessageEvent|null) => void, errorCallback: (arg0: Event) => void, isChunked?: boolean) { this.method = method; this.params = params; this.callback = callback; this.errorCallback = errorCallback; this.isChunked = isChunked; } } interface CSSProperty { name: string; nameRange: TextRange; value: string; valueRange: TextRange; range: TextRange; disabled?: boolean; } export function formatterWorkerPool(): FormatterWorkerPool { return FormatterWorkerPool.instance(); } export interface OutlineItem { line: number; column: number; title: string; subtitle?: string; } export interface CSSStyleRule { selectorText: string; styleRange: TextRange; lineNumber: number; columnNumber: number; properties: CSSProperty[]; } export interface CSSAtRule { atRule: string; lineNumber: number; columnNumber: number; } export type CSSRule = CSSStyleRule|CSSAtRule; export interface TextRange { startLine: number; startColumn: number; endLine: number; endColumn: number; }