language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-08-04 02:48:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

refactor: Use ES modules for internal runtime code (#17648)

Browse source 
This PR refactors all internal js files (except core) to be written as
ES modules.
`__bootstrap`has been mostly replaced with static imports in form in
`internal:[path to file from repo root]`.
To specify if files are ESM, an `esm` method has been added to
`Extension`, similar to the `js` method.
A new ModuleLoader called `InternalModuleLoader` has been added to
enable the loading of internal specifiers, which is used in all
situations except when a snapshot is only loaded, and not a new one is
created from it.

---------

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>
This commit is contained in:
Leo Kettmeir 2023-02-07 20:22:46 +01:00 • committed by GitHub
parent 65500f36e8
commit b4aa153097
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
123 changed files with 41574 additions and 41713 deletions
Download patch file Download diff file Expand all files Collapse all files

215
ext/web/14_compression.js
View file

@ -5,127 +5,120 @@
/// <reference path="./internal.d.ts" />
/// <reference path="./lib.deno_web.d.ts" />
"use strict";
const core = globalThis.Deno.core;
const ops = core.ops;
import * as webidl from "internal:ext/webidl/00_webidl.js";
import { TransformStream } from "internal:ext/web/06_streams.js";
((window) => {
const core = window.Deno.core;
const ops = core.ops;
const webidl = window.__bootstrap.webidl;
const { TransformStream } = window.__bootstrap.streams;
webidl.converters.CompressionFormat = webidl.createEnumConverter(
"CompressionFormat",
[
"deflate",
"deflate-raw",
"gzip",
],
);
webidl.converters.CompressionFormat = webidl.createEnumConverter(
"CompressionFormat",
[
"deflate",
"deflate-raw",
"gzip",
],
);
class CompressionStream {
#transform;
class CompressionStream {
#transform;
constructor(format) {
const prefix = "Failed to construct 'CompressionStream'";
webidl.requiredArguments(arguments.length, 1, { prefix });
format = webidl.converters.CompressionFormat(format, {
prefix,
context: "Argument 1",
});
constructor(format) {
const prefix = "Failed to construct 'CompressionStream'";
webidl.requiredArguments(arguments.length, 1, { prefix });
format = webidl.converters.CompressionFormat(format, {
prefix,
context: "Argument 1",
});
const rid = ops.op_compression_new(format, false);
const rid = ops.op_compression_new(format, false);
this.#transform = new TransformStream({
transform(chunk, controller) {
chunk = webidl.converters.BufferSource(chunk, {
prefix,
context: "chunk",
});
const output = ops.op_compression_write(
rid,
chunk,
);
maybeEnqueue(controller, output);
},
flush(controller) {
const output = ops.op_compression_finish(rid);
maybeEnqueue(controller, output);
},
});
this.#transform = new TransformStream({
transform(chunk, controller) {
chunk = webidl.converters.BufferSource(chunk, {
prefix,
context: "chunk",
});
const output = ops.op_compression_write(
rid,
chunk,
);
maybeEnqueue(controller, output);
},
flush(controller) {
const output = ops.op_compression_finish(rid);
maybeEnqueue(controller, output);
},
});
this[webidl.brand] = webidl.brand;
}
get readable() {
webidl.assertBranded(this, CompressionStreamPrototype);
return this.#transform.readable;
}
get writable() {
webidl.assertBranded(this, CompressionStreamPrototype);
return this.#transform.writable;
}
this[webidl.brand] = webidl.brand;
}
webidl.configurePrototype(CompressionStream);
const CompressionStreamPrototype = CompressionStream.prototype;
class DecompressionStream {
#transform;
constructor(format) {
const prefix = "Failed to construct 'DecompressionStream'";
webidl.requiredArguments(arguments.length, 1, { prefix });
format = webidl.converters.CompressionFormat(format, {
prefix,
context: "Argument 1",
});
const rid = ops.op_compression_new(format, true);
this.#transform = new TransformStream({
transform(chunk, controller) {
chunk = webidl.converters.BufferSource(chunk, {
prefix,
context: "chunk",
});
const output = ops.op_compression_write(
rid,
chunk,
);
maybeEnqueue(controller, output);
},
flush(controller) {
const output = ops.op_compression_finish(rid);
maybeEnqueue(controller, output);
},
});
this[webidl.brand] = webidl.brand;
}
get readable() {
webidl.assertBranded(this, DecompressionStreamPrototype);
return this.#transform.readable;
}
get writable() {
webidl.assertBranded(this, DecompressionStreamPrototype);
return this.#transform.writable;
}
get readable() {
webidl.assertBranded(this, CompressionStreamPrototype);
return this.#transform.readable;
}
function maybeEnqueue(controller, output) {
if (output && output.byteLength > 0) {
controller.enqueue(output);
}
get writable() {
webidl.assertBranded(this, CompressionStreamPrototype);
return this.#transform.writable;
}
}
webidl.configurePrototype(CompressionStream);
const CompressionStreamPrototype = CompressionStream.prototype;
class DecompressionStream {
#transform;
constructor(format) {
const prefix = "Failed to construct 'DecompressionStream'";
webidl.requiredArguments(arguments.length, 1, { prefix });
format = webidl.converters.CompressionFormat(format, {
prefix,
context: "Argument 1",
});
const rid = ops.op_compression_new(format, true);
this.#transform = new TransformStream({
transform(chunk, controller) {
chunk = webidl.converters.BufferSource(chunk, {
prefix,
context: "chunk",
});
const output = ops.op_compression_write(
rid,
chunk,
);
maybeEnqueue(controller, output);
},
flush(controller) {
const output = ops.op_compression_finish(rid);
maybeEnqueue(controller, output);
},
});
this[webidl.brand] = webidl.brand;
}
webidl.configurePrototype(DecompressionStream);
const DecompressionStreamPrototype = DecompressionStream.prototype;
get readable() {
webidl.assertBranded(this, DecompressionStreamPrototype);
return this.#transform.readable;
}
window.__bootstrap.compression = {
CompressionStream,
DecompressionStream,
};
})(globalThis);
get writable() {
webidl.assertBranded(this, DecompressionStreamPrototype);
return this.#transform.writable;
}
}
function maybeEnqueue(controller, output) {
if (output && output.byteLength > 0) {
controller.enqueue(output);
}
}
webidl.configurePrototype(DecompressionStream);
const DecompressionStreamPrototype = DecompressionStream.prototype;
export { CompressionStream, DecompressionStream };