Skip to content

Commit a57567f

Browse files
ntkmentkme
committed
Implement sass --embedded in pure JS mode
1 parent f6e2e26 commit a57567f

8 files changed

+372
-30
lines changed

‎lib/src/compiler-path.ts

+16-3
Original file line numberDiff line numberDiff line change
@@ -53,8 +53,10 @@ export const compilerCommand = (() => {
5353
`sass-embedded-${platform}-${arch}/dart-sass/src/sass.snapshot`
5454
),
5555
];
56-
} catch (ignored) {
57-
// ignored
56+
} catch (e) {
57+
if (!(isErrnoException(e) && e.code === 'MODULE_NOT_FOUND')) {
58+
throw e;
59+
}
5860
}
5961

6062
try {
@@ -70,10 +72,21 @@ export const compilerCommand = (() => {
7072
}
7173
}
7274

75+
try {
76+
return [
77+
process.execPath,
78+
p.join(p.dirname(require.resolve('sass')), 'sass.js'),
79+
];
80+
} catch (e: unknown) {
81+
if (!(isErrnoException(e) && e.code === 'MODULE_NOT_FOUND')) {
82+
throw e;
83+
}
84+
}
85+
7386
throw new Error(
7487
"Embedded Dart Sass couldn't find the embedded compiler executable. " +
7588
'Please make sure the optional dependency ' +
76-
`sass-embedded-${platform}-${arch} is installed in ` +
89+
`sass-embedded-${platform}-${arch} or sass is installed in ` +
7790
'node_modules.'
7891
);
7992
})();

‎lib/src/embedded/index.mjs

+7
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
// Copyright 2024 Google LLC. Use of this source code is governed by an
2+
// MIT-style license that can be found in the LICENSE file or at
3+
// https://opensource.org/licenses/MIT.
4+
5+
import * as embedded from './index.js';
6+
7+
export const main = embedded.main;

‎lib/src/embedded/index.ts

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
// Copyright 2024 Google LLC. Use of this source code is governed by an
2+
// MIT-style license that can be found in the LICENSE file or at
3+
// https://opensource.org/licenses/MIT.
4+
5+
import {MessagePort, isMainThread, workerData} from 'worker_threads';
6+
import {toJson} from '@bufbuild/protobuf';
7+
8+
import {SyncMessagePort} from '../sync-process/sync-message-port';
9+
import {WorkerDispatcher} from './worker_dispatcher';
10+
import * as proto from '../vendor/embedded_sass_pb';
11+
12+
export function main(
13+
spawnCompilationDispatcher: (
14+
mailbox: SyncMessagePort,
15+
sendPort: MessagePort
16+
) => void
17+
): void {
18+
if (isMainThread) {
19+
if (process.argv.length > 3) {
20+
if (process.argv[3] === '--version') {
21+
console.log(
22+
JSON.stringify(
23+
toJson(
24+
proto.OutboundMessage_VersionResponseSchema,
25+
WorkerDispatcher.versionResponse()
26+
),
27+
null,
28+
2
29+
)
30+
);
31+
} else {
32+
console.error(
33+
'sass --embedded is not intended to be executed with additional arguments.\n' +
34+
'See https://github.com/sass/dart-sass#embedded-dart-sass for details.'
35+
);
36+
process.exitCode = 64;
37+
}
38+
return;
39+
}
40+
41+
new WorkerDispatcher().listen();
42+
} else {
43+
const port = workerData.port as MessagePort;
44+
spawnCompilationDispatcher(new SyncMessagePort(port), {
45+
postMessage(buffer: Uint8Array): void {
46+
port.postMessage(buffer, [buffer.buffer]);
47+
},
48+
} as MessagePort);
49+
}
50+
}

‎lib/src/embedded/reusable_worker.ts

+60
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
// Copyright 2024 Google LLC. Use of this source code is governed by an
2+
// MIT-style license that can be found in the LICENSE file or at
3+
// https://opensource.org/licenses/MIT.
4+
5+
import {MessagePort, Worker} from 'worker_threads';
6+
7+
import {SyncMessagePort} from '../sync-process/sync-message-port';
8+
9+
export class ReusableWorker {
10+
private readonly worker: Worker;
11+
12+
private readonly receivePort: MessagePort;
13+
14+
private readonly sendPort: SyncMessagePort;
15+
16+
private onMessage = this.defaultOnMessage;
17+
18+
constructor(path: string) {
19+
const {port1, port2} = SyncMessagePort.createChannel();
20+
this.worker = new Worker(path, {
21+
workerData: {port: port2},
22+
transferList: [port2],
23+
argv: process.argv.slice(2),
24+
});
25+
this.receivePort = port1;
26+
this.sendPort = new SyncMessagePort(port1);
27+
28+
this.receivePort.on('message', value => this.onMessage(value));
29+
}
30+
31+
borrow(listener: (value: Uint8Array) => void): void {
32+
if (this.onMessage !== this.defaultOnMessage) {
33+
throw new Error('ReusableWorker has already been borrowed.');
34+
}
35+
this.onMessage = listener;
36+
}
37+
38+
release(): void {
39+
if (this.onMessage === this.defaultOnMessage) {
40+
throw new Error('ReusableWorker has not been borrowed.');
41+
}
42+
this.onMessage = this.defaultOnMessage;
43+
}
44+
45+
send(value: Uint8Array): void {
46+
this.sendPort.postMessage(value, [value.buffer]);
47+
}
48+
49+
terminate(): void {
50+
this.sendPort.close();
51+
this.worker.terminate();
52+
this.receivePort.close();
53+
}
54+
55+
private defaultOnMessage(value: Uint8Array): void {
56+
throw new Error(
57+
`Shouldn't receive a message before being borrowed: ${value}.`
58+
);
59+
}
60+
}

‎lib/src/embedded/utils.ts

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
// Copyright 2024 Google LLC. Use of this source code is governed by an
2+
// MIT-style license that can be found in the LICENSE file or at
3+
// https://opensource.org/licenses/MIT.
4+
5+
import {create} from '@bufbuild/protobuf';
6+
7+
import * as proto from '../vendor/embedded_sass_pb';
8+
9+
export const errorId = 0xffffffff;
10+
11+
export function paramsError(message: string): proto.ProtocolError {
12+
return create(proto.ProtocolErrorSchema, {
13+
id: errorId,
14+
type: proto.ProtocolErrorType.PARAMS,
15+
message: message,
16+
});
17+
}
18+
19+
export function parseError(message: string): proto.ProtocolError {
20+
return create(proto.ProtocolErrorSchema, {
21+
type: proto.ProtocolErrorType.PARSE,
22+
message: message,
23+
});
24+
}
25+
26+
export function handleError(
27+
error: Error | proto.ProtocolError,
28+
{messageId}: {messageId?: number} = {}
29+
): proto.ProtocolError {
30+
if (error instanceof Error) {
31+
const errorMessage = `${error.message}\n${error.stack}`;
32+
process.stderr.write(`Internal compiler error: ${errorMessage}`);
33+
process.exitCode = 70; // EX_SOFTWARE
34+
return create(proto.ProtocolErrorSchema, {
35+
id: messageId ?? errorId,
36+
type: proto.ProtocolErrorType.INTERNAL,
37+
message: errorMessage,
38+
});
39+
} else {
40+
error.id = messageId ?? errorId;
41+
process.stderr.write(
42+
`Host caused ${proto.ProtocolErrorType[error.type].toLowerCase()} error`
43+
);
44+
if (error.id !== errorId) process.stderr.write(` with request ${error.id}`);
45+
process.stderr.write(`: ${error.message}\n`);
46+
// PROTOCOL error from https://bit.ly/2poTt90
47+
process.exitCode = 76; // EX_PROTOCOL
48+
return error;
49+
}
50+
}

‎lib/src/embedded/worker_dispatcher.ts

+175
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,175 @@
1+
// Copyright 2024 Google LLC. Use of this source code is governed by an
2+
// MIT-style license that can be found in the LICENSE file or at
3+
// https://opensource.org/licenses/MIT.
4+
5+
import {Observable} from 'rxjs';
6+
import {takeUntil} from 'rxjs/operators';
7+
import {create, fromBinary, toBinary} from '@bufbuild/protobuf';
8+
import * as varint from 'varint';
9+
10+
import * as pkg from '../../../package.json';
11+
import {PacketTransformer} from '../packet-transformer';
12+
import {ReusableWorker} from './reusable_worker';
13+
import {errorId, handleError, paramsError, parseError} from './utils';
14+
import * as proto from '../vendor/embedded_sass_pb';
15+
16+
export class WorkerDispatcher {
17+
private readonly allWorkers: ReusableWorker[] = [];
18+
19+
private readonly inactiveWorkers: ReusableWorker[] = [];
20+
21+
private readonly activeWorkers = new Map<number, ReusableWorker>();
22+
23+
private readonly stdin$ = new Observable<Buffer>(observer => {
24+
process.stdin.on('data', buffer => observer.next(buffer));
25+
}).pipe(
26+
takeUntil(
27+
new Promise(resolve => {
28+
process.stdin.on('close', () => resolve(undefined));
29+
})
30+
)
31+
);
32+
33+
private readonly packetTransformer = new PacketTransformer(
34+
this.stdin$,
35+
buffer => process.stdout.write(buffer)
36+
);
37+
38+
listen(): void {
39+
this.packetTransformer.protobufs$.subscribe({
40+
next: (buffer: Uint8Array) => {
41+
let compilationId: number;
42+
try {
43+
compilationId = varint.decode(buffer);
44+
} catch (error) {
45+
throw parseError(`Invalid compilation ID varint: ${error}`);
46+
}
47+
48+
try {
49+
if (compilationId !== 0) {
50+
if (this.activeWorkers.has(compilationId)) {
51+
const worker = this.activeWorkers.get(compilationId)!;
52+
worker.send(buffer);
53+
} else {
54+
const worker = this.getWorker(compilationId);
55+
this.activeWorkers.set(compilationId, worker);
56+
worker.send(buffer);
57+
}
58+
return;
59+
}
60+
61+
let message;
62+
try {
63+
message = fromBinary(
64+
proto.InboundMessageSchema,
65+
new Uint8Array(buffer.buffer, varint.decode.bytes)
66+
);
67+
} catch (error) {
68+
throw parseError(`Invalid protobuf: ${error}`);
69+
}
70+
71+
if (message.message.case !== 'versionRequest') {
72+
throw paramsError(
73+
`Only VersionRequest may have wire ID 0, was ${message.message.case}.`
74+
);
75+
}
76+
const request = message.message.value;
77+
const response = WorkerDispatcher.versionResponse();
78+
response.id = request.id;
79+
this.send(
80+
0,
81+
create(proto.OutboundMessageSchema, {
82+
message: {
83+
case: 'versionResponse',
84+
value: response,
85+
},
86+
})
87+
);
88+
} catch (error) {
89+
this.handleError(error);
90+
}
91+
},
92+
complete: () => {
93+
this.allWorkers.forEach(worker => worker.terminate());
94+
},
95+
error: error => {
96+
this.handleError(parseError(error.message));
97+
},
98+
});
99+
}
100+
101+
private getWorker(compilationId: number): ReusableWorker {
102+
let worker: ReusableWorker;
103+
if (this.inactiveWorkers.length > 0) {
104+
worker = this.inactiveWorkers.pop()!;
105+
} else {
106+
worker = new ReusableWorker(process.argv[1]);
107+
this.allWorkers.push(worker);
108+
}
109+
110+
worker.borrow(buffer => {
111+
const category = buffer.at(0);
112+
const packet = Buffer.from(buffer.buffer, 1);
113+
114+
switch (category) {
115+
case 0:
116+
this.packetTransformer.writeProtobuf(packet);
117+
break;
118+
case 1:
119+
this.activeWorkers.delete(compilationId);
120+
worker.release();
121+
this.inactiveWorkers.push(worker);
122+
this.packetTransformer.writeProtobuf(packet);
123+
break;
124+
case 2: {
125+
this.packetTransformer.writeProtobuf(packet);
126+
/* eslint-disable-next-line n/no-process-exit */
127+
process.exit();
128+
}
129+
}
130+
});
131+
132+
return worker;
133+
}
134+
135+
private handleError(
136+
error: Error | proto.ProtocolError,
137+
{
138+
compilationId,
139+
messageId,
140+
}: {compilationId?: number; messageId?: number} = {}
141+
): void {
142+
this.sendError(compilationId ?? errorId, handleError(error, {messageId}));
143+
process.stdin.destroy();
144+
}
145+
146+
private send(compilationId: number, message: proto.OutboundMessage): void {
147+
const compilationIdLength = varint.encodingLength(compilationId);
148+
const encodedMessage = toBinary(proto.OutboundMessageSchema, message);
149+
const buffer = new Uint8Array(compilationIdLength + encodedMessage.length);
150+
varint.encode(compilationId, buffer);
151+
buffer.set(encodedMessage, compilationIdLength);
152+
this.packetTransformer.writeProtobuf(buffer);
153+
}
154+
155+
private sendError(compilationId: number, error: proto.ProtocolError): void {
156+
this.send(
157+
compilationId,
158+
create(proto.OutboundMessageSchema, {
159+
message: {
160+
case: 'error',
161+
value: error,
162+
},
163+
})
164+
);
165+
}
166+
167+
static versionResponse(): proto.OutboundMessage_VersionResponse {
168+
return create(proto.OutboundMessage_VersionResponseSchema, {
169+
protocolVersion: pkg['protocol-version'],
170+
compilerVersion: pkg['compiler-version'],
171+
implementationVersion: pkg['version'],
172+
implementationName: 'dart-sass',
173+
});
174+
}
175+
}

0 commit comments

Comments
 (0)