aboutsummaryrefslogtreecommitdiff
path: root/src/api
diff options
context:
space:
mode:
Diffstat (limited to 'src/api')
-rwxr-xr-xsrc/api/demo/bun.lockbbin0 -> 59433 bytes
-rw-r--r--src/api/demo/lib/api.ts296
-rw-r--r--src/api/demo/lib/run.ts70
-rw-r--r--src/api/demo/lib/scan.ts44
-rw-r--r--src/api/demo/package.json11
-rw-r--r--src/api/demo/pages/index.tsx105
-rw-r--r--src/api/demo/pages/scan.tsx71
-rw-r--r--src/api/demo/schema.d.ts980
-rw-r--r--src/api/demo/schema.js2936
-rw-r--r--src/api/demo/schema.peechy553
-rw-r--r--src/api/demo/schema.zig2878
-rw-r--r--src/api/schema.d.ts56
-rw-r--r--src/api/schema.js165
-rw-r--r--src/api/schema.peechy28
-rw-r--r--src/api/schema.zig128
15 files changed, 8020 insertions, 301 deletions
diff --git a/src/api/demo/bun.lockb b/src/api/demo/bun.lockb
new file mode 100755
index 000000000..703042857
--- /dev/null
+++ b/src/api/demo/bun.lockb
Binary files differ
diff --git a/src/api/demo/lib/api.ts b/src/api/demo/lib/api.ts
index b861bb78b..455c73290 100644
--- a/src/api/demo/lib/api.ts
+++ b/src/api/demo/lib/api.ts
@@ -1,15 +1,15 @@
import * as Schema from "../../schema";
-import { ByteBuffer } from "peechy/bb";
+import { ByteBuffer } from "peechy";
+import path from "path";
+import { Loader } from "../schema";
// import { transform as sucraseTransform } from "sucrase";
export interface WebAssemblyModule {
init(): number;
transform(a: number): number;
- malloc(a: number): number;
- calloc(a: number): number;
- realloc(a: number): number;
- free(a: number): number;
- cycle(): void;
+ bun_malloc(a: number): number;
+ bun_free(a: number): number;
+ scan(a: number): number;
}
const wasm_imports_sym: symbol | string =
@@ -17,168 +17,266 @@ const wasm_imports_sym: symbol | string =
? "wasm_imports"
: Symbol("wasm_imports");
-const ptr_converter = new ArrayBuffer(8);
-const ptr_float = new Float64Array(ptr_converter);
+const ptr_converter = new ArrayBuffer(16);
+const ptr_float = new BigUint64Array(ptr_converter);
const slice = new Uint32Array(ptr_converter);
+const Wasi = {
+ clock_time_get(clk_id, tp) {
+ return Date.now();
+ },
+ environ_sizes_get() {
+ debugger;
+ return 0;
+ },
+ environ_get(__environ, environ_buf) {
+ debugger;
+ return 0;
+ },
+
+ fd_close(fd) {
+ debugger;
+ return 0;
+ },
+ proc_exit() {},
+
+ fd_seek(fd, offset_bigint, whence, newOffset) {
+ debugger;
+ },
+ fd_write(fd, iov, iovcnt, pnum) {
+ debugger;
+ },
+};
+
var scratch: Uint8Array;
+var scratch2: Uint8Array;
-export class ESDev {
+export class Bun {
static has_initialized = false;
static wasm_source: WebAssembly.WebAssemblyInstantiatedSource = null;
static get wasm_exports(): WebAssemblyModule {
- return ESDev.wasm_source.instance.exports as any;
+ return Bun.wasm_source.instance.exports as any;
}
- static get memory() {
- return ESDev[wasm_imports_sym].memory as WebAssembly.Memory;
+ static get memory(): WebAssembly.Memory {
+ return Bun.wasm_source.instance.exports.memory as any;
}
static memory_array: Uint8Array;
static _decoder: TextDecoder;
- static _wasmPtrToSlice(offset: number) {
- if (ESDev.memory_array.buffer !== ESDev.memory.buffer) {
- ESDev.memory_array = new Uint8Array(ESDev.memory.buffer);
- }
- ptr_float[0] = offset;
- return ESDev.memory_array.subarray(slice[0], slice[0] + slice[1]);
+ static _wasmPtrToSlice(offset: number | bigint) {
+ ptr_float[0] = typeof offset === "number" ? BigInt(offset) : offset;
+ return new Uint8Array(Bun.memory.buffer, slice[0], slice[1]);
}
static _wasmPtrLenToString(slice: number) {
- if (!ESDev._decoder) {
- ESDev._decoder = new TextDecoder("utf8");
+ if (!Bun._decoder) {
+ Bun._decoder = new TextDecoder("utf8");
}
const region = this._wasmPtrToSlice(slice);
-
- return ESDev._decoder.decode(region);
+ return Bun._decoder.decode(region);
}
// We don't want people to be calling these manually
static [wasm_imports_sym] = {
console_log(slice: number) {
- console.log(ESDev._wasmPtrLenToString(slice));
+ console.log(Bun._wasmPtrLenToString(slice));
},
console_error(slice: number) {
- console.error(ESDev._wasmPtrLenToString(slice));
+ console.error(Bun._wasmPtrLenToString(slice));
},
console_warn(slice: number) {
- console.warn(ESDev._wasmPtrLenToString(slice));
+ console.warn(Bun._wasmPtrLenToString(slice));
},
console_info(slice: number) {
- console.info(ESDev._wasmPtrLenToString(slice));
+ console.info(Bun._wasmPtrLenToString(slice));
+ },
+
+ __indirect_function_table: new WebAssembly.Table({
+ initial: 0,
+ element: "anyfunc",
+ }),
+ __stack_pointer: new WebAssembly.Global({
+ mutable: true,
+ value: "i32",
+ }),
+ __multi3(one: number, two: number) {
+ return Math.imul(one | 0, two | 0);
+ },
+ fmod(one: number, two: number) {
+ return one % two;
+ },
+ memset(ptr: number, value: number, len: number) {
+ Bun.memory_array.fill(value, ptr, ptr + len);
+ },
+ memcpy(ptr: number, value: number, len: number) {
+ Bun.memory_array.copyWithin(ptr, value, value + len);
+ },
+ // These functions convert a to an unsigned long long, rounding toward zero. Negative values all become zero.
+ __fixunsdfti(a: number) {
+ return Math.floor(a);
},
- memory: null,
- // __indirect_function_table: new WebAssembly.Table({
- // initial: 0,
- // element: "anyfunc",
- // }),
- // __stack_pointer: new WebAssembly.Global({
- // mutable: true,
- // value: "i32",
- // }),
- // __multi3(one: number, two: number) {
- // return Math.imul(one | 0, two | 0);
- // },
- // fmod(one: number, two: number) {
- // return one % two;
- // },
- // memset(ptr: number, value: number, len: number) {
- // ESDev.memory_array.fill(value, ptr, ptr + len);
- // },
- // memcpy(ptr: number, value: number, len: number) {
- // ESDev.memory_array.copyWithin(ptr, value, value + len);
- // },
- // // These functions convert a to an unsigned long long, rounding toward zero. Negative values all become zero.
- // __fixunsdfti(a: number) {
- // return Math.floor(a);
- // },
- // // These functions return the remainder of the unsigned division of a and b.
- // __umodti3(a: number, b: number) {
- // return (a | 0) % (b | 0);
- // },
- // // These functions return the quotient of the unsigned division of a and b.
- // __udivti3(a: number, b: number) {
- // return (a | 0) / (b | 0);
- // },
- // // These functions return the result of shifting a left by b bits.
- // __ashlti3(a: number, b: number) {
- // return (a | 0) >> (b | 0);
- // },
- // /* Returns: convert a to a double, rounding toward even. */
- // __floatuntidf(a: number) {
- // const mod = a % 2;
- // if (mod === 0) {
- // return Math.ceil(a);
- // } else if (mod === 1) {
- // return Math.floor(a);
- // }
- // },
+ // These functions return the remainder of the unsigned division of a and b.
+ __umodti3(a: number, b: number) {
+ return (a | 0) % (b | 0);
+ },
+ // These functions return the quotient of the unsigned division of a and b.
+ __udivti3(a: number, b: number) {
+ return (a | 0) / (b | 0);
+ },
+ // These functions return the result of shifting a left by b bits.
+ __ashlti3(a: number, b: number) {
+ return (a | 0) >> (b | 0);
+ },
+ /* Returns: convert a to a double, rounding toward even. */
+ __floatuntidf(a: number) {
+ const mod = a % 2;
+ if (mod === 0) {
+ return Math.ceil(a);
+ } else if (mod === 1) {
+ return Math.floor(a);
+ }
+ },
+ emscripten_notify_memory_growth() {},
};
static async init(url) {
// globalThis.sucraseTransform = sucraseTransform;
scratch = new Uint8Array(8096);
- if (ESDev.has_initialized) {
+ if (Bun.has_initialized) {
return;
}
- ESDev[wasm_imports_sym].memory = new WebAssembly.Memory({
- initial: 20,
- // shared: typeof SharedArrayBuffer !== "undefined",
- maximum: typeof SharedArrayBuffer !== "undefined" ? 5000 : undefined,
- });
-
- ESDev.wasm_source = await globalThis.WebAssembly.instantiateStreaming(
+ Bun.wasm_source = await globalThis.WebAssembly.instantiateStreaming(
fetch(url),
- { env: ESDev[wasm_imports_sym] }
+ { env: Bun[wasm_imports_sym], wasi_snapshot_preview1: Wasi }
);
- ESDev.memory_array = new Uint8Array(ESDev.memory.buffer);
- const res = ESDev.wasm_exports.init();
+ const res = Bun.wasm_exports.init();
if (res < 0) {
- throw `[ESDev] Failed to initialize WASM module: code ${res}`;
+ throw `[Bun] Failed to initialize WASM module: code ${res}`;
} else {
console.log("WASM loaded.");
}
- ESDev.has_initialized = true;
+ Bun.has_initialized = true;
}
- static transform(content: Uint8Array, file_name: string) {
- if (!ESDev.has_initialized) {
- throw "Please run await ESDev.init(wasm_url) before using this.";
+ static transformSync(content: Uint8Array | string, file_name: string) {
+ if (!Bun.has_initialized) {
+ throw "Please run await Bun.init(wasm_url) before using this.";
}
// if (process.env.NODE_ENV === "development") {
- // console.time("[ESDev] Transform " + file_name);
+ // console.time("[Bun] Transform " + file_name);
// }
const bb = new ByteBuffer(scratch);
bb.length = 0;
+ bb.index = 0;
+ var contents_buffer;
+ if (typeof content === "string") {
+ if (!scratch2) {
+ scratch2 = new Uint8Array(content.length * 2);
+ }
+
+ let i = 0;
+ for (; i < content.length; i++) {
+ if (i > scratch2.length) {
+ var scratch3 = new Uint8Array(scratch2.length * 2);
+ scratch3.set(scratch2);
+ scratch2 = scratch3;
+ }
+ scratch2[i] = content.charCodeAt(i);
+ }
+ contents_buffer = scratch2.subarray(0, i);
+ } else {
+ contents_buffer = content;
+ }
Schema.encodeTransform(
{
- contents: content,
+ contents: contents_buffer,
path: file_name,
+ loader: {
+ ".jsx": Loader.jsx,
+ ".tsx": Loader.tsx,
+ ".ts": Loader.ts,
+ ".js": Loader.js,
+ ".json": Loader.json,
+ }[path.extname(file_name)],
},
bb
);
const data = bb.toUint8Array();
- if (bb._data.buffer !== scratch.buffer) {
- scratch = bb._data;
- }
- ESDev.wasm_exports.cycleStart();
- const ptr = ESDev.wasm_exports.malloc(data.byteLength);
- this._wasmPtrToSlice(ptr).set(data);
- const resp_ptr = ESDev.wasm_exports.transform(ptr);
+
+ const input_ptr = Bun.wasm_exports.bun_malloc(data.length);
+ var buffer = this._wasmPtrToSlice(input_ptr);
+ buffer.set(data);
+
+ const resp_ptr = Bun.wasm_exports.transform(input_ptr);
var _bb = new ByteBuffer(this._wasmPtrToSlice(resp_ptr));
const response = Schema.decodeTransformResponse(_bb);
- ESDev.wasm_exports.cycleEnd();
+ Bun.wasm_exports.bun_free(input_ptr);
+ scratch = bb.data;
+ return response;
+ }
+
+ static scan(content: Uint8Array | string, file_name: string, loader: Loader) {
+ if (!Bun.has_initialized) {
+ throw "Please run await Bun.init(wasm_url) before using this.";
+ }
+
+ // if (process.env.NODE_ENV === "development") {
+ // console.time("[Bun] Transform " + file_name);
+ // }
+ scratch.fill(0);
+ const bb = new ByteBuffer(scratch);
+ bb.length = 0;
+ bb.index = 0;
+ var contents_buffer;
+ if (typeof content === "string") {
+ if (!scratch2) {
+ scratch2 = new Uint8Array(content.length * 2);
+ }
+ const encode_into = new TextEncoder().encodeInto(content, scratch2);
+ contents_buffer = scratch2.subarray(0, encode_into.written);
+ } else {
+ contents_buffer = content;
+ }
+
+ Schema.encodeScan(
+ {
+ contents: contents_buffer,
+ path: file_name,
+ loader:
+ loader ||
+ {
+ ".jsx": Loader.jsx,
+ ".tsx": Loader.tsx,
+ ".ts": Loader.ts,
+ ".js": Loader.js,
+ ".json": Loader.json,
+ }[path.extname(file_name)],
+ },
+ bb
+ );
+ const data = bb.toUint8Array();
+
+ const input_ptr = Bun.wasm_exports.bun_malloc(data.length);
+ var buffer = this._wasmPtrToSlice(input_ptr);
+ buffer.set(data);
+
+ const resp_ptr = Bun.wasm_exports.scan(input_ptr);
+ var _bb = new ByteBuffer(this._wasmPtrToSlice(resp_ptr));
+ const response = Schema.decodeScanResult(_bb);
+ Bun.wasm_exports.bun_free(input_ptr);
+ scratch = bb.data;
return response;
}
}
-globalThis.ESDev = ESDev;
+globalThis.Bun = Bun;
diff --git a/src/api/demo/lib/run.ts b/src/api/demo/lib/run.ts
new file mode 100644
index 000000000..8337eb2c9
--- /dev/null
+++ b/src/api/demo/lib/run.ts
@@ -0,0 +1,70 @@
+import { transform as _transform, initialize } from "esbuild-wasm";
+import initSwc, { transformSync as transformSyncSWC } from "@swc/wasm-web";
+import { Bun } from "./api";
+
+export async function start() {
+ await initialize({
+ worker: false,
+ wasmURL: "/node_modules/esbuild-wasm/esbuild.wasm",
+ });
+ await Bun.init("/bun-wasm.wasm");
+ await initSwc("/node_modules/@swc/wasm-web/wasm_bg.wasm");
+}
+
+const swcOptions = {
+ sourceMaps: false,
+ inlineSourcesContent: false,
+ jsc: {
+ target: "es2022",
+ parser: {
+ jsx: true,
+ syntax: "typescript",
+ tsx: false,
+ decorators: false,
+ dynamicImport: false,
+ },
+ },
+};
+
+export async function transform(contents, file) {
+ var result = {
+ timings: {
+ esbuild: 0,
+ bun: 0,
+ swc: 0,
+ },
+ };
+ result.timings.esbuild = performance.now();
+ result.esbuild = await _transform(contents, {
+ sourcefile: file,
+ loader: file.substring(file.lastIndexOf(".") + 1),
+ });
+ result.timings.esbuild = performance.now() - result.timings.esbuild;
+
+ result.timings.bun = performance.now();
+ result.bun = Bun.transformSync(contents, file);
+ result.timings.bun = performance.now() - result.timings.bun;
+
+ if (file.substring(file.lastIndexOf(".") + 1) === "tsx") {
+ swcOptions.jsc.parser.tsx = true;
+ swcOptions.jsc.parser.syntax = "typescript";
+ } else if (file.substring(file.lastIndexOf(".") + 1) === "jsx") {
+ swcOptions.jsc.parser.tsx = false;
+ swcOptions.jsc.parser.jsx = true;
+ swcOptions.jsc.parser.syntax = "typescript";
+ } else {
+ swcOptions.jsc.parser.tsx = false;
+ swcOptions.jsc.parser.jsx = false;
+ swcOptions.jsc.parser.syntax = "javascript";
+ }
+
+ result.timings.swc = performance.now();
+ result.swc = transformSyncSWC(contents, swcOptions);
+ result.timings.swc = performance.now() - result.timings.swc;
+
+ console.log("esbuild:", result.timings.esbuild, "ms");
+ console.log("Bun:", result.timings.bun, "ms");
+ console.log("SWC:", result.timings.swc, "ms");
+
+ return result;
+}
diff --git a/src/api/demo/lib/scan.ts b/src/api/demo/lib/scan.ts
new file mode 100644
index 000000000..4d16d5b8c
--- /dev/null
+++ b/src/api/demo/lib/scan.ts
@@ -0,0 +1,44 @@
+import { init, parse } from "es-module-lexer";
+
+import { Bun } from "./api";
+
+export async function start() {
+ await init;
+ await Bun.init("/bun-wasm.wasm");
+}
+
+const swcOptions = {
+ sourceMaps: false,
+ inlineSourcesContent: false,
+ jsc: {
+ target: "es2022",
+ parser: {
+ jsx: true,
+ syntax: "typescript",
+ tsx: false,
+ decorators: false,
+ dynamicImport: false,
+ },
+ },
+};
+
+export async function transform(contents, file) {
+ var result = {
+ timings: {
+ lexer: 0,
+ bun: 0,
+ },
+ };
+ result.timings.lexer = performance.now();
+ result.lexer = await parse(contents, file);
+ result.timings.lexer = performance.now() - result.timings.lexer;
+
+ result.timings.bun = performance.now();
+ result.bun = Bun.scan(contents, file);
+ result.timings.bun = performance.now() - result.timings.bun;
+
+ console.log("lexer:", result.timings.lexer, "ms");
+ console.log("Bun:", result.timings.bun, "ms");
+
+ return result;
+}
diff --git a/src/api/demo/package.json b/src/api/demo/package.json
index e10d0e80d..ac452254a 100644
--- a/src/api/demo/package.json
+++ b/src/api/demo/package.json
@@ -8,8 +8,13 @@
"start": "next start"
},
"dependencies": {
- "next": "10.2.0",
- "peechy": "^0.4.5",
+ "@swc/wasm-web": "^1.2.146",
+ "bun-framework-next": "^12.1.0",
+ "es-module-loader": "^2.3.0",
+ "esbuild": "^0.14.23",
+ "esbuild-wasm": "^0.14.23",
+ "next": "12",
+ "peechy": "latest",
"react": "17.0.2",
"react-dom": "17.0.2",
"sucrase": "^3.18.1"
@@ -20,4 +25,4 @@
"webpack": "^5.38.1",
"webpack-cli": "^4.7.0"
}
-}
+} \ No newline at end of file
diff --git a/src/api/demo/pages/index.tsx b/src/api/demo/pages/index.tsx
index 4d60b4084..7274b3d39 100644
--- a/src/api/demo/pages/index.tsx
+++ b/src/api/demo/pages/index.tsx
@@ -1,70 +1,71 @@
import Head from "next/head";
import Image from "next/image";
import styles from "../styles/Home.module.css";
-import "../lib/api.ts";
-export default function Home() {
+import React from "react";
+
+if (typeof window !== "undefined") {
+ globalThis.Run = await import("../lib/run");
+ await import("../lib/api.ts");
+}
+
+export async function getStaticProps(ctx) {
+ return {
+ props: {
+ code: Bun.readFile(
+ "/Users/jarred/Build/es-module-lexer/test/samples/magic-string.js"
+ ),
+ },
+ };
+}
+
+var textDecoder = new TextDecoder();
+export default function Home({ code }) {
+ const fileNameRef = React.useRef();
+ const [esbuildResult, setEsbuildResult] = React.useState("");
+ const [bunResult, setBunResult] = React.useState("");
+ const [swcResult, setSWCResult] = React.useState("");
+ React.useEffect(() => {
+ globalThis.Run.start();
+ }, []);
+
+ const runBuild = React.useCallback(
+ (event) => {
+ globalThis.Run.transform(
+ event.target.value,
+ fileNameRef.current.value
+ ).then((result) => {
+ setEsbuildResult(result.esbuild.code);
+ setBunResult(textDecoder.decode(result.bun.files[0].data));
+ setSWCResult(result.swc.code);
+ }, console.error);
+ },
+ [fileNameRef, setEsbuildResult, setBunResult, setSWCResult]
+ );
return (
<div className={styles.container}>
<Head>
- <title>Create Next App</title>
+ <title>Next.js</title>
<meta name="description" content="Generated by create next app" />
<link rel="icon" href="/favicon.ico" />
</Head>
<main className={styles.main}>
- <h1 className={styles.title}>
- Welcome to <a href="https://nextjs.org">Next.js!</a>
- </h1>
-
- <p className={styles.description}>
- Get started by editing{" "}
- <code className={styles.code}>pages/index.js</code>
- </p>
-
- <div className={styles.grid}>
- <a href="https://nextjs.org/docs" className={styles.card}>
- <h2>Documentation &rarr;</h2>
- <p>Find in-depth information about Next.js features and API.</p>
- </a>
+ <div>
+ <input
+ autoComplete="filename"
+ type="text"
+ placeholder="filename"
+ defaultValue="input.tsx"
+ ref={fileNameRef}
+ />
+ <textarea onChange={runBuild} defaultValue={code}></textarea>
- <a href="https://nextjs.org/learn" className={styles.card}>
- <h2>Learn &rarr;</h2>
- <p>Learn about Next.js in an interactive course with quizzes!</p>
- </a>
-
- <a
- href="https://github.com/vercel/next.js/tree/master/examples"
- className={styles.card}
- >
- <h2>Examples &rarr;</h2>
- <p>Discover and deploy boilerplate example Next.js projects.</p>
- </a>
-
- <a
- href="https://vercel.com/new?utm_source=create-next-app&utm_medium=default-template&utm_campaign=create-next-app"
- className={styles.card}
- >
- <h2>Deploy &rarr;</h2>
- <p>
- Instantly deploy your Next.js site to a public URL with Vercel.
- </p>
- </a>
+ <textarea readOnly value={esbuildResult}></textarea>
+ <textarea readOnly value={bunResult}></textarea>
+ <textarea readOnly value={swcResult}></textarea>
</div>
</main>
-
- <footer className={styles.footer}>
- <a
- href="https://vercel.com?utm_source=create-next-app&utm_medium=default-template&utm_campaign=create-next-app"
- target="_blank"
- rel="noopener noreferrer"
- >
- Powered by{" "}
- <span className={styles.logo}>
- <Image src="/vercel.svg" alt="Vercel Logo" width={72} height={16} />
- </span>
- </a>
- </footer>
</div>
);
}
diff --git a/src/api/demo/pages/scan.tsx b/src/api/demo/pages/scan.tsx
new file mode 100644
index 000000000..819a597b9
--- /dev/null
+++ b/src/api/demo/pages/scan.tsx
@@ -0,0 +1,71 @@
+import Head from "next/head";
+import Image from "next/image";
+import styles from "../styles/Home.module.css";
+
+import React from "react";
+
+if (typeof window !== "undefined") {
+ globalThis.Scan = await import("../lib/scan");
+ await import("../lib/api.ts");
+}
+
+export async function getStaticProps(ctx) {
+ return {
+ props: {
+ code: Bun.readFile(
+ "/Users/jarred/Build/es-module-lexer/test/samples/magic-string.js"
+ ),
+ defaultFile: "magic-string.js",
+ },
+ };
+}
+
+var textDecoder = new TextDecoder();
+export default function Home({ code, defaultFile }) {
+ const fileNameRef = React.useRef();
+ const [lexer, setLexer] = React.useState("");
+ const [bunResult, setBunResult] = React.useState("");
+ const [file, setFile] = React.useState(defaultFile);
+ React.useEffect(() => {
+ globalThis.Scan.start();
+ }, []);
+
+ const runBuild = React.useCallback(
+ (event) => {
+ globalThis.Scan.transform(
+ event.target.value,
+ fileNameRef.current.value
+ ).then((result) => {
+ setLexer(JSON.stringify(result.lexer, null, 2));
+ setBunResult(JSON.stringify(result.bun, null, 2));
+ }, console.error);
+ },
+ [fileNameRef, setBunResult, setLexer]
+ );
+ return (
+ <div className={styles.container}>
+ <Head>
+ <title>Next.js</title>
+ <meta name="description" content="Generated by create next app" />
+ <link rel="icon" href="/favicon.ico" />
+ </Head>
+
+ <main className={styles.main}>
+ <div>
+ <input
+ autoComplete="filename"
+ type="text"
+ placeholder="filename"
+ value={file}
+ onChange={(event) => setFile(event.target.value)}
+ ref={fileNameRef}
+ />
+ <textarea onChange={runBuild} defaultValue={code}></textarea>
+
+ <textarea readOnly value={bunResult}></textarea>
+ <textarea readOnly value={lexer}></textarea>
+ </div>
+ </main>
+ </div>
+ );
+}
diff --git a/src/api/demo/schema.d.ts b/src/api/demo/schema.d.ts
new file mode 100644
index 000000000..0a7ed3b9b
--- /dev/null
+++ b/src/api/demo/schema.d.ts
@@ -0,0 +1,980 @@
+import type { ByteBuffer } from "peechy";
+
+type byte = number;
+type float = number;
+type int = number;
+type alphanumeric = string;
+type uint = number;
+type int8 = number;
+type lowp = number;
+type int16 = number;
+type int32 = number;
+type float32 = number;
+type uint16 = number;
+type uint32 = number;
+export enum Loader {
+ jsx = 1,
+ js = 2,
+ ts = 3,
+ tsx = 4,
+ css = 5,
+ file = 6,
+ json = 7,
+ toml = 8,
+ wasm = 9,
+}
+export const LoaderKeys = {
+ 1: "jsx",
+ jsx: "jsx",
+ 2: "js",
+ js: "js",
+ 3: "ts",
+ ts: "ts",
+ 4: "tsx",
+ tsx: "tsx",
+ 5: "css",
+ css: "css",
+ 6: "file",
+ file: "file",
+ 7: "json",
+ json: "json",
+ 8: "toml",
+ toml: "toml",
+ 9: "wasm",
+ wasm: "wasm",
+};
+export enum FrameworkEntryPointType {
+ client = 1,
+ server = 2,
+ fallback = 3,
+}
+export const FrameworkEntryPointTypeKeys = {
+ 1: "client",
+ client: "client",
+ 2: "server",
+ server: "server",
+ 3: "fallback",
+ fallback: "fallback",
+};
+export enum StackFrameScope {
+ Eval = 1,
+ Module = 2,
+ Function = 3,
+ Global = 4,
+ Wasm = 5,
+ Constructor = 6,
+}
+export const StackFrameScopeKeys = {
+ 1: "Eval",
+ Eval: "Eval",
+ 2: "Module",
+ Module: "Module",
+ 3: "Function",
+ Function: "Function",
+ 4: "Global",
+ Global: "Global",
+ 5: "Wasm",
+ Wasm: "Wasm",
+ 6: "Constructor",
+ Constructor: "Constructor",
+};
+export enum FallbackStep {
+ ssr_disabled = 1,
+ create_vm = 2,
+ configure_router = 3,
+ configure_defines = 4,
+ resolve_entry_point = 5,
+ load_entry_point = 6,
+ eval_entry_point = 7,
+ fetch_event_handler = 8,
+}
+export const FallbackStepKeys = {
+ 1: "ssr_disabled",
+ ssr_disabled: "ssr_disabled",
+ 2: "create_vm",
+ create_vm: "create_vm",
+ 3: "configure_router",
+ configure_router: "configure_router",
+ 4: "configure_defines",
+ configure_defines: "configure_defines",
+ 5: "resolve_entry_point",
+ resolve_entry_point: "resolve_entry_point",
+ 6: "load_entry_point",
+ load_entry_point: "load_entry_point",
+ 7: "eval_entry_point",
+ eval_entry_point: "eval_entry_point",
+ 8: "fetch_event_handler",
+ fetch_event_handler: "fetch_event_handler",
+};
+export enum ResolveMode {
+ disable = 1,
+ lazy = 2,
+ dev = 3,
+ bundle = 4,
+}
+export const ResolveModeKeys = {
+ 1: "disable",
+ disable: "disable",
+ 2: "lazy",
+ lazy: "lazy",
+ 3: "dev",
+ dev: "dev",
+ 4: "bundle",
+ bundle: "bundle",
+};
+export enum Platform {
+ browser = 1,
+ node = 2,
+ bun = 3,
+ bun_macro = 4,
+}
+export const PlatformKeys = {
+ 1: "browser",
+ browser: "browser",
+ 2: "node",
+ node: "node",
+ 3: "bun",
+ bun: "bun",
+ 4: "bun_macro",
+ bun_macro: "bun_macro",
+};
+export enum CSSInJSBehavior {
+ facade = 1,
+ facade_onimportcss = 2,
+ auto_onimportcss = 3,
+}
+export const CSSInJSBehaviorKeys = {
+ 1: "facade",
+ facade: "facade",
+ 2: "facade_onimportcss",
+ facade_onimportcss: "facade_onimportcss",
+ 3: "auto_onimportcss",
+ auto_onimportcss: "auto_onimportcss",
+};
+export enum JSXRuntime {
+ automatic = 1,
+ classic = 2,
+}
+export const JSXRuntimeKeys = {
+ 1: "automatic",
+ automatic: "automatic",
+ 2: "classic",
+ classic: "classic",
+};
+export enum ScanDependencyMode {
+ app = 1,
+ all = 2,
+}
+export const ScanDependencyModeKeys = {
+ 1: "app",
+ app: "app",
+ 2: "all",
+ all: "all",
+};
+export enum ModuleImportType {
+ import = 1,
+ require = 2,
+}
+export const ModuleImportTypeKeys = {
+ 1: "import",
+ import: "import",
+ 2: "require",
+ require: "require",
+};
+export enum DotEnvBehavior {
+ disable = 1,
+ prefix = 2,
+ load_all = 3,
+}
+export const DotEnvBehaviorKeys = {
+ 1: "disable",
+ disable: "disable",
+ 2: "prefix",
+ prefix: "prefix",
+ 3: "load_all",
+ load_all: "load_all",
+};
+export enum ImportKind {
+ entry_point = 1,
+ stmt = 2,
+ require = 3,
+ dynamic = 4,
+ require_resolve = 5,
+ at = 6,
+ url = 7,
+ internal = 8,
+}
+export const ImportKindKeys = {
+ 1: "entry_point",
+ entry_point: "entry_point",
+ 2: "stmt",
+ stmt: "stmt",
+ 3: "require",
+ require: "require",
+ 4: "dynamic",
+ dynamic: "dynamic",
+ 5: "require_resolve",
+ require_resolve: "require_resolve",
+ 6: "at",
+ at: "at",
+ 7: "url",
+ url: "url",
+ 8: "internal",
+ internal: "internal",
+};
+export enum TransformResponseStatus {
+ success = 1,
+ fail = 2,
+}
+export const TransformResponseStatusKeys = {
+ 1: "success",
+ success: "success",
+ 2: "fail",
+ fail: "fail",
+};
+export enum MessageLevel {
+ err = 1,
+ warn = 2,
+ note = 3,
+ info = 4,
+ debug = 5,
+}
+export const MessageLevelKeys = {
+ 1: "err",
+ err: "err",
+ 2: "warn",
+ warn: "warn",
+ 3: "note",
+ note: "note",
+ 4: "info",
+ info: "info",
+ 5: "debug",
+ debug: "debug",
+};
+export enum Reloader {
+ disable = 1,
+ live = 2,
+ fast_refresh = 3,
+}
+export const ReloaderKeys = {
+ 1: "disable",
+ disable: "disable",
+ 2: "live",
+ live: "live",
+ 3: "fast_refresh",
+ fast_refresh: "fast_refresh",
+};
+export enum WebsocketMessageKind {
+ welcome = 1,
+ file_change_notification = 2,
+ build_success = 3,
+ build_fail = 4,
+ manifest_success = 5,
+ manifest_fail = 6,
+ resolve_file = 7,
+ file_change_notification_with_hint = 8,
+}
+export const WebsocketMessageKindKeys = {
+ 1: "welcome",
+ welcome: "welcome",
+ 2: "file_change_notification",
+ file_change_notification: "file_change_notification",
+ 3: "build_success",
+ build_success: "build_success",
+ 4: "build_fail",
+ build_fail: "build_fail",
+ 5: "manifest_success",
+ manifest_success: "manifest_success",
+ 6: "manifest_fail",
+ manifest_fail: "manifest_fail",
+ 7: "resolve_file",
+ resolve_file: "resolve_file",
+ 8: "file_change_notification_with_hint",
+ file_change_notification_with_hint: "file_change_notification_with_hint",
+};
+export enum WebsocketCommandKind {
+ build = 1,
+ manifest = 2,
+ build_with_file_path = 3,
+}
+export const WebsocketCommandKindKeys = {
+ 1: "build",
+ build: "build",
+ 2: "manifest",
+ manifest: "manifest",
+ 3: "build_with_file_path",
+ build_with_file_path: "build_with_file_path",
+};
+export interface StackFrame {
+ function_name: string;
+ file: string;
+ position: StackFramePosition;
+ scope: StackFrameScope;
+}
+
+export interface StackFramePosition {
+ source_offset: int32;
+ line: int32;
+ line_start: int32;
+ line_stop: int32;
+ column_start: int32;
+ column_stop: int32;
+ expression_start: int32;
+ expression_stop: int32;
+}
+
+export interface SourceLine {
+ line: int32;
+ text: string;
+}
+
+export interface StackTrace {
+ source_lines: SourceLine[];
+ frames: StackFrame[];
+}
+
+export interface JSException {
+ name?: string;
+ message?: string;
+ runtime_type?: uint16;
+ code?: uint8;
+ stack?: StackTrace;
+}
+
+export interface Problems {
+ code: uint16;
+ name: string;
+ exceptions: JSException[];
+ build: Log;
+}
+
+export interface Router {
+ routes: StringMap;
+ route: int32;
+ params: StringMap;
+}
+
+export interface FallbackMessageContainer {
+ message?: string;
+ router?: Router;
+ reason?: FallbackStep;
+ problems?: Problems;
+ cwd?: string;
+}
+
+export interface JSX {
+ factory: string;
+ runtime: JSXRuntime;
+ fragment: string;
+ development: boolean;
+ import_source: string;
+ react_fast_refresh: boolean;
+}
+
+export interface StringPointer {
+ offset: uint32;
+ length: uint32;
+}
+
+export interface JavascriptBundledModule {
+ path: StringPointer;
+ code: StringPointer;
+ package_id: uint32;
+ id: uint32;
+ path_extname_length: byte;
+}
+
+export interface JavascriptBundledPackage {
+ name: StringPointer;
+ version: StringPointer;
+ hash: uint32;
+ modules_offset: uint32;
+ modules_length: uint32;
+}
+
+export interface JavascriptBundle {
+ modules: JavascriptBundledModule[];
+ packages: JavascriptBundledPackage[];
+ etag: Uint8Array;
+ generated_at: uint32;
+ app_package_json_dependencies_hash: Uint8Array;
+ import_from_name: Uint8Array;
+ manifest_string: Uint8Array;
+}
+
+export interface JavascriptBundleContainer {
+ bundle_format_version?: uint32;
+ routes?: LoadedRouteConfig;
+ framework?: LoadedFramework;
+ bundle?: JavascriptBundle;
+ code_length?: uint32;
+}
+
+export interface ModuleImportRecord {
+ kind: ModuleImportType;
+ path: string;
+ dynamic: boolean;
+}
+
+export interface Module {
+ path: string;
+ imports: ModuleImportRecord[];
+}
+
+export interface StringMap {
+ keys: string[];
+ values: string[];
+}
+
+export interface LoaderMap {
+ extensions: string[];
+ loaders: Loader[];
+}
+
+export interface EnvConfig {
+ prefix?: string;
+ defaults?: StringMap;
+}
+
+export interface LoadedEnvConfig {
+ dotenv: DotEnvBehavior;
+ defaults: StringMap;
+ prefix: string;
+}
+
+export interface FrameworkConfig {
+ package?: string;
+ client?: FrameworkEntryPointMessage;
+ server?: FrameworkEntryPointMessage;
+ fallback?: FrameworkEntryPointMessage;
+ development?: boolean;
+ client_css_in_js?: CSSInJSBehavior;
+ display_name?: string;
+ overrideModules?: StringMap;
+}
+
+export interface FrameworkEntryPoint {
+ kind: FrameworkEntryPointType;
+ path: string;
+ env: LoadedEnvConfig;
+}
+
+export interface FrameworkEntryPointMap {
+ client?: FrameworkEntryPoint;
+ server?: FrameworkEntryPoint;
+ fallback?: FrameworkEntryPoint;
+}
+
+export interface FrameworkEntryPointMessage {
+ path?: string;
+ env?: EnvConfig;
+}
+
+export interface LoadedFramework {
+ package: string;
+ display_name: string;
+ development: boolean;
+ entry_points: FrameworkEntryPointMap;
+ client_css_in_js: CSSInJSBehavior;
+ overrideModules: StringMap;
+}
+
+export interface LoadedRouteConfig {
+ dir: string;
+ extensions: string[];
+ static_dir: string;
+ asset_prefix: string;
+}
+
+export interface RouteConfig {
+ dir?: string[];
+ extensions?: string[];
+ static_dir?: string;
+ asset_prefix?: string;
+}
+
+export interface TransformOptions {
+ jsx?: JSX;
+ tsconfig_override?: string;
+ resolve?: ResolveMode;
+ origin?: string;
+ absolute_working_dir?: string;
+ define?: StringMap;
+ preserve_symlinks?: boolean;
+ entry_points?: string[];
+ write?: boolean;
+ inject?: string[];
+ output_dir?: string;
+ external?: string[];
+ loaders?: LoaderMap;
+ main_fields?: string[];
+ platform?: Platform;
+ serve?: boolean;
+ extension_order?: string[];
+ generate_node_module_bundle?: boolean;
+ node_modules_bundle_path?: string;
+ node_modules_bundle_path_server?: string;
+ framework?: FrameworkConfig;
+ router?: RouteConfig;
+ no_summary?: boolean;
+ disable_hmr?: boolean;
+ port?: uint16;
+ logLevel?: MessageLevel;
+}
+
+export interface FileHandle {
+ path: string;
+ size: uint;
+ fd: uint;
+}
+
+export interface Transform {
+ handle?: FileHandle;
+ path?: string;
+ contents?: Uint8Array;
+ loader?: Loader;
+ options?: TransformOptions;
+}
+
+export interface Scan {
+ path?: string;
+ contents?: Uint8Array;
+ loader?: Loader;
+}
+
+export interface ScanResult {
+ exports: string[];
+ imports: ScannedImport[];
+}
+
+export interface ScannedImport {
+ path: string;
+ kind: ImportKind;
+}
+
+export interface OutputFile {
+ data: Uint8Array;
+ path: string;
+}
+
+export interface TransformResponse {
+ status: TransformResponseStatus;
+ files: OutputFile[];
+ errors: Message[];
+}
+
+export interface Location {
+ file: string;
+ namespace: string;
+ line: int32;
+ column: int32;
+ line_text: string;
+ suggestion: string;
+ offset: uint;
+}
+
+export interface MessageData {
+ text?: string;
+ location?: Location;
+}
+
+export interface MessageMeta {
+ resolve?: string;
+ build?: boolean;
+}
+
+export interface Message {
+ level: MessageLevel;
+ data: MessageData;
+ notes: MessageData[];
+ on: MessageMeta;
+}
+
+export interface Log {
+ warnings: uint32;
+ errors: uint32;
+ msgs: Message[];
+}
+
+export interface WebsocketMessage {
+ timestamp: uint32;
+ kind: WebsocketMessageKind;
+}
+
+export interface WebsocketMessageWelcome {
+ epoch: uint32;
+ javascriptReloader: Reloader;
+ cwd: string;
+}
+
+export interface WebsocketMessageFileChangeNotification {
+ id: uint32;
+ loader: Loader;
+}
+
+export interface WebsocketCommand {
+ kind: WebsocketCommandKind;
+ timestamp: uint32;
+}
+
+export interface WebsocketCommandBuild {
+ id: uint32;
+}
+
+export interface WebsocketCommandManifest {
+ id: uint32;
+}
+
+export interface WebsocketMessageBuildSuccess {
+ id: uint32;
+ from_timestamp: uint32;
+ loader: Loader;
+ module_path: string;
+ blob_length: uint32;
+}
+
+export interface WebsocketMessageBuildFailure {
+ id: uint32;
+ from_timestamp: uint32;
+ loader: Loader;
+ module_path: string;
+ log: Log;
+}
+
+export interface WebsocketCommandBuildWithFilePath {
+ id: uint32;
+ file_path: string;
+}
+
+export interface WebsocketMessageResolveID {
+ id: uint32;
+}
+
+export interface NPMRegistry {
+ url: string;
+ username: string;
+ password: string;
+ token: string;
+}
+
+export interface NPMRegistryMap {
+ scopes: string[];
+ registries: NPMRegistry[];
+}
+
+export interface BunInstall {
+ default_registry?: NPMRegistry;
+ scoped?: NPMRegistryMap;
+ lockfile_path?: string;
+ save_lockfile_path?: string;
+ cache_directory?: string;
+ dry_run?: boolean;
+ force?: boolean;
+ save_dev?: boolean;
+ save_optional?: boolean;
+ save_peer?: boolean;
+ save_lockfile?: boolean;
+ production?: boolean;
+ save_yarn_lockfile?: boolean;
+ native_bin_links?: string[];
+ disable_cache?: boolean;
+ disable_manifest_cache?: boolean;
+ global_dir?: string;
+ global_bin_dir?: string;
+}
+
+export declare function encodeStackFrame(
+ message: StackFrame,
+ bb: ByteBuffer
+): void;
+export declare function decodeStackFrame(buffer: ByteBuffer): StackFrame;
+export declare function encodeStackFramePosition(
+ message: StackFramePosition,
+ bb: ByteBuffer
+): void;
+export declare function decodeStackFramePosition(
+ buffer: ByteBuffer
+): StackFramePosition;
+export declare function encodeSourceLine(
+ message: SourceLine,
+ bb: ByteBuffer
+): void;
+export declare function decodeSourceLine(buffer: ByteBuffer): SourceLine;
+export declare function encodeStackTrace(
+ message: StackTrace,
+ bb: ByteBuffer
+): void;
+export declare function decodeStackTrace(buffer: ByteBuffer): StackTrace;
+export declare function encodeJSException(
+ message: JSException,
+ bb: ByteBuffer
+): void;
+export declare function decodeJSException(buffer: ByteBuffer): JSException;
+export declare function encodeProblems(message: Problems, bb: ByteBuffer): void;
+export declare function decodeProblems(buffer: ByteBuffer): Problems;
+export declare function encodeRouter(message: Router, bb: ByteBuffer): void;
+export declare function decodeRouter(buffer: ByteBuffer): Router;
+export declare function encodeFallbackMessageContainer(
+ message: FallbackMessageContainer,
+ bb: ByteBuffer
+): void;
+export declare function decodeFallbackMessageContainer(
+ buffer: ByteBuffer
+): FallbackMessageContainer;
+export declare function encodeJSX(message: JSX, bb: ByteBuffer): void;
+export declare function decodeJSX(buffer: ByteBuffer): JSX;
+export declare function encodeStringPointer(
+ message: StringPointer,
+ bb: ByteBuffer
+): void;
+export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer;
+export declare function encodeJavascriptBundledModule(
+ message: JavascriptBundledModule,
+ bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundledModule(
+ buffer: ByteBuffer
+): JavascriptBundledModule;
+export declare function encodeJavascriptBundledPackage(
+ message: JavascriptBundledPackage,
+ bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundledPackage(
+ buffer: ByteBuffer
+): JavascriptBundledPackage;
+export declare function encodeJavascriptBundle(
+ message: JavascriptBundle,
+ bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundle(
+ buffer: ByteBuffer
+): JavascriptBundle;
+export declare function encodeJavascriptBundleContainer(
+ message: JavascriptBundleContainer,
+ bb: ByteBuffer
+): void;
+export declare function decodeJavascriptBundleContainer(
+ buffer: ByteBuffer
+): JavascriptBundleContainer;
+export declare function encodeModuleImportRecord(
+ message: ModuleImportRecord,
+ bb: ByteBuffer
+): void;
+export declare function decodeModuleImportRecord(
+ buffer: ByteBuffer
+): ModuleImportRecord;
+export declare function encodeModule(message: Module, bb: ByteBuffer): void;
+export declare function decodeModule(buffer: ByteBuffer): Module;
+export declare function encodeStringMap(
+ message: StringMap,
+ bb: ByteBuffer
+): void;
+export declare function decodeStringMap(buffer: ByteBuffer): StringMap;
+export declare function encodeLoaderMap(
+ message: LoaderMap,
+ bb: ByteBuffer
+): void;
+export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap;
+export declare function encodeEnvConfig(
+ message: EnvConfig,
+ bb: ByteBuffer
+): void;
+export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig;
+export declare function encodeLoadedEnvConfig(
+ message: LoadedEnvConfig,
+ bb: ByteBuffer
+): void;
+export declare function decodeLoadedEnvConfig(
+ buffer: ByteBuffer
+): LoadedEnvConfig;
+export declare function encodeFrameworkConfig(
+ message: FrameworkConfig,
+ bb: ByteBuffer
+): void;
+export declare function decodeFrameworkConfig(
+ buffer: ByteBuffer
+): FrameworkConfig;
+export declare function encodeFrameworkEntryPoint(
+ message: FrameworkEntryPoint,
+ bb: ByteBuffer
+): void;
+export declare function decodeFrameworkEntryPoint(
+ buffer: ByteBuffer
+): FrameworkEntryPoint;
+export declare function encodeFrameworkEntryPointMap(
+ message: FrameworkEntryPointMap,
+ bb: ByteBuffer
+): void;
+export declare function decodeFrameworkEntryPointMap(
+ buffer: ByteBuffer
+): FrameworkEntryPointMap;
+export declare function encodeFrameworkEntryPointMessage(
+ message: FrameworkEntryPointMessage,
+ bb: ByteBuffer
+): void;
+export declare function decodeFrameworkEntryPointMessage(
+ buffer: ByteBuffer
+): FrameworkEntryPointMessage;
+export declare function encodeLoadedFramework(
+ message: LoadedFramework,
+ bb: ByteBuffer
+): void;
+export declare function decodeLoadedFramework(
+ buffer: ByteBuffer
+): LoadedFramework;
+export declare function encodeLoadedRouteConfig(
+ message: LoadedRouteConfig,
+ bb: ByteBuffer
+): void;
+export declare function decodeLoadedRouteConfig(
+ buffer: ByteBuffer
+): LoadedRouteConfig;
+export declare function encodeRouteConfig(
+ message: RouteConfig,
+ bb: ByteBuffer
+): void;
+export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig;
+export declare function encodeTransformOptions(
+ message: TransformOptions,
+ bb: ByteBuffer
+): void;
+export declare function decodeTransformOptions(
+ buffer: ByteBuffer
+): TransformOptions;
+export declare function encodeFileHandle(
+ message: FileHandle,
+ bb: ByteBuffer
+): void;
+export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle;
+export declare function encodeTransform(
+ message: Transform,
+ bb: ByteBuffer
+): void;
+export declare function decodeTransform(buffer: ByteBuffer): Transform;
+export declare function encodeScan(message: Scan, bb: ByteBuffer): void;
+export declare function decodeScan(buffer: ByteBuffer): Scan;
+export declare function encodeScanResult(
+ message: ScanResult,
+ bb: ByteBuffer
+): void;
+export declare function decodeScanResult(buffer: ByteBuffer): ScanResult;
+export declare function encodeScannedImport(
+ message: ScannedImport,
+ bb: ByteBuffer
+): void;
+export declare function decodeScannedImport(buffer: ByteBuffer): ScannedImport;
+export declare function encodeOutputFile(
+ message: OutputFile,
+ bb: ByteBuffer
+): void;
+export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile;
+export declare function encodeTransformResponse(
+ message: TransformResponse,
+ bb: ByteBuffer
+): void;
+export declare function decodeTransformResponse(
+ buffer: ByteBuffer
+): TransformResponse;
+export declare function encodeLocation(message: Location, bb: ByteBuffer): void;
+export declare function decodeLocation(buffer: ByteBuffer): Location;
+export declare function encodeMessageData(
+ message: MessageData,
+ bb: ByteBuffer
+): void;
+export declare function decodeMessageData(buffer: ByteBuffer): MessageData;
+export declare function encodeMessageMeta(
+ message: MessageMeta,
+ bb: ByteBuffer
+): void;
+export declare function decodeMessageMeta(buffer: ByteBuffer): MessageMeta;
+export declare function encodeMessage(message: Message, bb: ByteBuffer): void;
+export declare function decodeMessage(buffer: ByteBuffer): Message;
+export declare function encodeLog(message: Log, bb: ByteBuffer): void;
+export declare function decodeLog(buffer: ByteBuffer): Log;
+export declare function encodeWebsocketMessage(
+ message: WebsocketMessage,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessage(
+ buffer: ByteBuffer
+): WebsocketMessage;
+export declare function encodeWebsocketMessageWelcome(
+ message: WebsocketMessageWelcome,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageWelcome(
+ buffer: ByteBuffer
+): WebsocketMessageWelcome;
+export declare function encodeWebsocketMessageFileChangeNotification(
+ message: WebsocketMessageFileChangeNotification,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageFileChangeNotification(
+ buffer: ByteBuffer
+): WebsocketMessageFileChangeNotification;
+export declare function encodeWebsocketCommand(
+ message: WebsocketCommand,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommand(
+ buffer: ByteBuffer
+): WebsocketCommand;
+export declare function encodeWebsocketCommandBuild(
+ message: WebsocketCommandBuild,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommandBuild(
+ buffer: ByteBuffer
+): WebsocketCommandBuild;
+export declare function encodeWebsocketCommandManifest(
+ message: WebsocketCommandManifest,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommandManifest(
+ buffer: ByteBuffer
+): WebsocketCommandManifest;
+export declare function encodeWebsocketMessageBuildSuccess(
+ message: WebsocketMessageBuildSuccess,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageBuildSuccess(
+ buffer: ByteBuffer
+): WebsocketMessageBuildSuccess;
+export declare function encodeWebsocketMessageBuildFailure(
+ message: WebsocketMessageBuildFailure,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageBuildFailure(
+ buffer: ByteBuffer
+): WebsocketMessageBuildFailure;
+export declare function encodeWebsocketCommandBuildWithFilePath(
+ message: WebsocketCommandBuildWithFilePath,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketCommandBuildWithFilePath(
+ buffer: ByteBuffer
+): WebsocketCommandBuildWithFilePath;
+export declare function encodeWebsocketMessageResolveID(
+ message: WebsocketMessageResolveID,
+ bb: ByteBuffer
+): void;
+export declare function decodeWebsocketMessageResolveID(
+ buffer: ByteBuffer
+): WebsocketMessageResolveID;
+export declare function encodeNPMRegistry(
+ message: NPMRegistry,
+ bb: ByteBuffer
+): void;
+export declare function decodeNPMRegistry(buffer: ByteBuffer): NPMRegistry;
+export declare function encodeNPMRegistryMap(
+ message: NPMRegistryMap,
+ bb: ByteBuffer
+): void;
+export declare function decodeNPMRegistryMap(
+ buffer: ByteBuffer
+): NPMRegistryMap;
+export declare function encodeBunInstall(
+ message: BunInstall,
+ bb: ByteBuffer
+): void;
+export declare function decodeBunInstall(buffer: ByteBuffer): BunInstall;
diff --git a/src/api/demo/schema.js b/src/api/demo/schema.js
index 01ec08357..b89ed4a08 100644
--- a/src/api/demo/schema.js
+++ b/src/api/demo/schema.js
@@ -6,6 +6,8 @@ const Loader = {
5: 5,
6: 6,
7: 7,
+ 8: 8,
+ 9: 9,
jsx: 1,
js: 2,
ts: 3,
@@ -13,6 +15,8 @@ const Loader = {
css: 5,
file: 6,
json: 7,
+ toml: 8,
+ wasm: 9,
};
const LoaderKeys = {
1: "jsx",
@@ -22,6 +26,8 @@ const LoaderKeys = {
5: "css",
6: "file",
7: "json",
+ 8: "toml",
+ 9: "wasm",
jsx: "jsx",
js: "js",
ts: "ts",
@@ -29,7 +35,489 @@ const LoaderKeys = {
css: "css",
file: "file",
json: "json",
+ toml: "toml",
+ wasm: "wasm",
};
+const FrameworkEntryPointType = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ client: 1,
+ server: 2,
+ fallback: 3,
+};
+const FrameworkEntryPointTypeKeys = {
+ 1: "client",
+ 2: "server",
+ 3: "fallback",
+ client: "client",
+ server: "server",
+ fallback: "fallback",
+};
+const StackFrameScope = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ Eval: 1,
+ Module: 2,
+ Function: 3,
+ Global: 4,
+ Wasm: 5,
+ Constructor: 6,
+};
+const StackFrameScopeKeys = {
+ 1: "Eval",
+ 2: "Module",
+ 3: "Function",
+ 4: "Global",
+ 5: "Wasm",
+ 6: "Constructor",
+ Eval: "Eval",
+ Module: "Module",
+ Function: "Function",
+ Global: "Global",
+ Wasm: "Wasm",
+ Constructor: "Constructor",
+};
+
+function decodeStackFrame(bb) {
+ var result = {};
+
+ result["function_name"] = bb.readString();
+ result["file"] = bb.readString();
+ result["position"] = decodeStackFramePosition(bb);
+ result["scope"] = StackFrameScope[bb.readByte()];
+ return result;
+}
+
+function encodeStackFrame(message, bb) {
+ var value = message["function_name"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "function_name"');
+ }
+
+ var value = message["file"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "file"');
+ }
+
+ var value = message["position"];
+ if (value != null) {
+ encodeStackFramePosition(value, bb);
+ } else {
+ throw new Error('Missing required field "position"');
+ }
+
+ var value = message["scope"];
+ if (value != null) {
+ var encoded = StackFrameScope[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "StackFrameScope"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "scope"');
+ }
+}
+
+function decodeStackFramePosition(bb) {
+ var result = {};
+
+ result["source_offset"] = bb.readInt32();
+ result["line"] = bb.readInt32();
+ result["line_start"] = bb.readInt32();
+ result["line_stop"] = bb.readInt32();
+ result["column_start"] = bb.readInt32();
+ result["column_stop"] = bb.readInt32();
+ result["expression_start"] = bb.readInt32();
+ result["expression_stop"] = bb.readInt32();
+ return result;
+}
+
+function encodeStackFramePosition(message, bb) {
+ var value = message["source_offset"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "source_offset"');
+ }
+
+ var value = message["line"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "line"');
+ }
+
+ var value = message["line_start"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "line_start"');
+ }
+
+ var value = message["line_stop"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "line_stop"');
+ }
+
+ var value = message["column_start"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "column_start"');
+ }
+
+ var value = message["column_stop"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "column_stop"');
+ }
+
+ var value = message["expression_start"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "expression_start"');
+ }
+
+ var value = message["expression_stop"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "expression_stop"');
+ }
+}
+
+function decodeSourceLine(bb) {
+ var result = {};
+
+ result["line"] = bb.readInt32();
+ result["text"] = bb.readString();
+ return result;
+}
+
+function encodeSourceLine(message, bb) {
+ var value = message["line"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "line"');
+ }
+
+ var value = message["text"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "text"');
+ }
+}
+
+function decodeStackTrace(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["source_lines"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeSourceLine(bb);
+ var length = bb.readVarUint();
+ var values = (result["frames"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeStackFrame(bb);
+ return result;
+}
+
+function encodeStackTrace(message, bb) {
+ var value = message["source_lines"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeSourceLine(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "source_lines"');
+ }
+
+ var value = message["frames"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeStackFrame(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "frames"');
+ }
+}
+
+function decodeJSException(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["name"] = bb.readString();
+ break;
+
+ case 2:
+ result["message"] = bb.readString();
+ break;
+
+ case 3:
+ result["runtime_type"] = bb.readUint16();
+ break;
+
+ case 4:
+ result["code"] = bb.readByte();
+ break;
+
+ case 5:
+ result["stack"] = decodeStackTrace(bb);
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeJSException(message, bb) {
+ var value = message["name"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["message"];
+ if (value != null) {
+ bb.writeByte(2);
+ bb.writeString(value);
+ }
+
+ var value = message["runtime_type"];
+ if (value != null) {
+ bb.writeByte(3);
+ bb.writeUint16(value);
+ }
+
+ var value = message["code"];
+ if (value != null) {
+ bb.writeByte(4);
+ bb.writeByte(value);
+ }
+
+ var value = message["stack"];
+ if (value != null) {
+ bb.writeByte(5);
+ encodeStackTrace(value, bb);
+ }
+ bb.writeByte(0);
+}
+const FallbackStep = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ ssr_disabled: 1,
+ create_vm: 2,
+ configure_router: 3,
+ configure_defines: 4,
+ resolve_entry_point: 5,
+ load_entry_point: 6,
+ eval_entry_point: 7,
+ fetch_event_handler: 8,
+};
+const FallbackStepKeys = {
+ 1: "ssr_disabled",
+ 2: "create_vm",
+ 3: "configure_router",
+ 4: "configure_defines",
+ 5: "resolve_entry_point",
+ 6: "load_entry_point",
+ 7: "eval_entry_point",
+ 8: "fetch_event_handler",
+ ssr_disabled: "ssr_disabled",
+ create_vm: "create_vm",
+ configure_router: "configure_router",
+ configure_defines: "configure_defines",
+ resolve_entry_point: "resolve_entry_point",
+ load_entry_point: "load_entry_point",
+ eval_entry_point: "eval_entry_point",
+ fetch_event_handler: "fetch_event_handler",
+};
+
+function decodeProblems(bb) {
+ var result = {};
+
+ result["code"] = bb.readUint16();
+ result["name"] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["exceptions"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeJSException(bb);
+ result["build"] = decodeLog(bb);
+ return result;
+}
+
+function encodeProblems(message, bb) {
+ var value = message["code"];
+ if (value != null) {
+ bb.writeUint16(value);
+ } else {
+ throw new Error('Missing required field "code"');
+ }
+
+ var value = message["name"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "name"');
+ }
+
+ var value = message["exceptions"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeJSException(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "exceptions"');
+ }
+
+ var value = message["build"];
+ if (value != null) {
+ encodeLog(value, bb);
+ } else {
+ throw new Error('Missing required field "build"');
+ }
+}
+
+function decodeRouter(bb) {
+ var result = {};
+
+ result["routes"] = decodeStringMap(bb);
+ result["route"] = bb.readInt32();
+ result["params"] = decodeStringMap(bb);
+ return result;
+}
+
+function encodeRouter(message, bb) {
+ var value = message["routes"];
+ if (value != null) {
+ encodeStringMap(value, bb);
+ } else {
+ throw new Error('Missing required field "routes"');
+ }
+
+ var value = message["route"];
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "route"');
+ }
+
+ var value = message["params"];
+ if (value != null) {
+ encodeStringMap(value, bb);
+ } else {
+ throw new Error('Missing required field "params"');
+ }
+}
+
+function decodeFallbackMessageContainer(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["message"] = bb.readString();
+ break;
+
+ case 2:
+ result["router"] = decodeRouter(bb);
+ break;
+
+ case 3:
+ result["reason"] = FallbackStep[bb.readByte()];
+ break;
+
+ case 4:
+ result["problems"] = decodeProblems(bb);
+ break;
+
+ case 5:
+ result["cwd"] = bb.readString();
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeFallbackMessageContainer(message, bb) {
+ var value = message["message"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["router"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeRouter(value, bb);
+ }
+
+ var value = message["reason"];
+ if (value != null) {
+ bb.writeByte(3);
+ var encoded = FallbackStep[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "FallbackStep"'
+ );
+ bb.writeByte(encoded);
+ }
+
+ var value = message["problems"];
+ if (value != null) {
+ bb.writeByte(4);
+ encodeProblems(value, bb);
+ }
+
+ var value = message["cwd"];
+ if (value != null) {
+ bb.writeByte(5);
+ bb.writeString(value);
+ }
+ bb.writeByte(0);
+}
const ResolveMode = {
1: 1,
2: 2,
@@ -53,14 +541,38 @@ const ResolveModeKeys = {
const Platform = {
1: 1,
2: 2,
+ 3: 3,
+ 4: 4,
browser: 1,
node: 2,
+ bun: 3,
+ bun_macro: 4,
};
const PlatformKeys = {
1: "browser",
2: "node",
+ 3: "bun",
+ 4: "bun_macro",
browser: "browser",
node: "node",
+ bun: "bun",
+ bun_macro: "bun_macro",
+};
+const CSSInJSBehavior = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ facade: 1,
+ facade_onimportcss: 2,
+ auto_onimportcss: 3,
+};
+const CSSInJSBehaviorKeys = {
+ 1: "facade",
+ 2: "facade_onimportcss",
+ 3: "auto_onimportcss",
+ facade: "facade",
+ facade_onimportcss: "facade_onimportcss",
+ auto_onimportcss: "auto_onimportcss",
};
const JSXRuntime = {
1: 1,
@@ -74,8 +586,10 @@ const JSXRuntimeKeys = {
automatic: "automatic",
classic: "classic",
};
+
function decodeJSX(bb) {
var result = {};
+
result["factory"] = bb.readString();
result["runtime"] = JSXRuntime[bb.readByte()];
result["fragment"] = bb.readString();
@@ -84,181 +598,1183 @@ function decodeJSX(bb) {
result["react_fast_refresh"] = !!bb.readByte();
return result;
}
+
function encodeJSX(message, bb) {
var value = message["factory"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "factory"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "factory"');
+ }
+
var value = message["runtime"];
if (value != null) {
var encoded = JSXRuntime[value];
- if (encoded === undefined)
+ if (encoded === void 0)
throw new Error(
"Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"'
);
bb.writeByte(encoded);
- } else throw new Error('Missing required field "runtime"');
+ } else {
+ throw new Error('Missing required field "runtime"');
+ }
+
var value = message["fragment"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "fragment"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "fragment"');
+ }
+
var value = message["development"];
- if (value != null) bb.writeByte(value);
- else throw new Error('Missing required field "development"');
+ if (value != null) {
+ bb.writeByte(value);
+ } else {
+ throw new Error('Missing required field "development"');
+ }
+
var value = message["import_source"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "import_source"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "import_source"');
+ }
+
var value = message["react_fast_refresh"];
- if (value != null) bb.writeByte(value);
- else throw new Error('Missing required field "react_fast_refresh"');
+ if (value != null) {
+ bb.writeByte(value);
+ } else {
+ throw new Error('Missing required field "react_fast_refresh"');
+ }
}
+
+function decodeStringPointer(bb) {
+ var result = {};
+
+ result["offset"] = bb.readUint32();
+ result["length"] = bb.readUint32();
+ return result;
+}
+
+function encodeStringPointer(message, bb) {
+ var value = message["offset"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "offset"');
+ }
+
+ var value = message["length"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "length"');
+ }
+}
+
+function decodeJavascriptBundledModule(bb) {
+ var result = {};
+
+ result["path"] = decodeStringPointer(bb);
+ result["code"] = decodeStringPointer(bb);
+ result["package_id"] = bb.readUint32();
+ result["id"] = bb.readUint32();
+ result["path_extname_length"] = bb.readByte();
+ return result;
+}
+
+function encodeJavascriptBundledModule(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ encodeStringPointer(value, bb);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
+ var value = message["code"];
+ if (value != null) {
+ encodeStringPointer(value, bb);
+ } else {
+ throw new Error('Missing required field "code"');
+ }
+
+ var value = message["package_id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "package_id"');
+ }
+
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+
+ var value = message["path_extname_length"];
+ if (value != null) {
+ bb.writeByte(value);
+ } else {
+ throw new Error('Missing required field "path_extname_length"');
+ }
+}
+
+function decodeJavascriptBundledPackage(bb) {
+ var result = {};
+
+ result["name"] = decodeStringPointer(bb);
+ result["version"] = decodeStringPointer(bb);
+ result["hash"] = bb.readUint32();
+ result["modules_offset"] = bb.readUint32();
+ result["modules_length"] = bb.readUint32();
+ return result;
+}
+
+function encodeJavascriptBundledPackage(message, bb) {
+ var value = message["name"];
+ if (value != null) {
+ encodeStringPointer(value, bb);
+ } else {
+ throw new Error('Missing required field "name"');
+ }
+
+ var value = message["version"];
+ if (value != null) {
+ encodeStringPointer(value, bb);
+ } else {
+ throw new Error('Missing required field "version"');
+ }
+
+ var value = message["hash"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "hash"');
+ }
+
+ var value = message["modules_offset"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "modules_offset"');
+ }
+
+ var value = message["modules_length"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "modules_length"');
+ }
+}
+
+function decodeJavascriptBundle(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["modules"] = Array(length));
+ for (var i = 0; i < length; i++)
+ values[i] = decodeJavascriptBundledModule(bb);
+ var length = bb.readVarUint();
+ var values = (result["packages"] = Array(length));
+ for (var i = 0; i < length; i++)
+ values[i] = decodeJavascriptBundledPackage(bb);
+ result["etag"] = bb.readByteArray();
+ result["generated_at"] = bb.readUint32();
+ result["app_package_json_dependencies_hash"] = bb.readByteArray();
+ result["import_from_name"] = bb.readByteArray();
+ result["manifest_string"] = bb.readByteArray();
+ return result;
+}
+
+function encodeJavascriptBundle(message, bb) {
+ var value = message["modules"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeJavascriptBundledModule(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "modules"');
+ }
+
+ var value = message["packages"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeJavascriptBundledPackage(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "packages"');
+ }
+
+ var value = message["etag"];
+ if (value != null) {
+ bb.writeByteArray(value);
+ } else {
+ throw new Error('Missing required field "etag"');
+ }
+
+ var value = message["generated_at"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "generated_at"');
+ }
+
+ var value = message["app_package_json_dependencies_hash"];
+ if (value != null) {
+ bb.writeByteArray(value);
+ } else {
+ throw new Error(
+ 'Missing required field "app_package_json_dependencies_hash"'
+ );
+ }
+
+ var value = message["import_from_name"];
+ if (value != null) {
+ bb.writeByteArray(value);
+ } else {
+ throw new Error('Missing required field "import_from_name"');
+ }
+
+ var value = message["manifest_string"];
+ if (value != null) {
+ bb.writeByteArray(value);
+ } else {
+ throw new Error('Missing required field "manifest_string"');
+ }
+}
+
+function decodeJavascriptBundleContainer(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["bundle_format_version"] = bb.readUint32();
+ break;
+
+ case 3:
+ result["routes"] = decodeLoadedRouteConfig(bb);
+ break;
+
+ case 2:
+ result["framework"] = decodeLoadedFramework(bb);
+ break;
+
+ case 4:
+ result["bundle"] = decodeJavascriptBundle(bb);
+ break;
+
+ case 5:
+ result["code_length"] = bb.readUint32();
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeJavascriptBundleContainer(message, bb) {
+ var value = message["bundle_format_version"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeUint32(value);
+ }
+
+ var value = message["routes"];
+ if (value != null) {
+ bb.writeByte(3);
+ encodeLoadedRouteConfig(value, bb);
+ }
+
+ var value = message["framework"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeLoadedFramework(value, bb);
+ }
+
+ var value = message["bundle"];
+ if (value != null) {
+ bb.writeByte(4);
+ encodeJavascriptBundle(value, bb);
+ }
+
+ var value = message["code_length"];
+ if (value != null) {
+ bb.writeByte(5);
+ bb.writeUint32(value);
+ }
+ bb.writeByte(0);
+}
+const ScanDependencyMode = {
+ 1: 1,
+ 2: 2,
+ app: 1,
+ all: 2,
+};
+const ScanDependencyModeKeys = {
+ 1: "app",
+ 2: "all",
+ app: "app",
+ all: "all",
+};
+const ModuleImportType = {
+ 1: 1,
+ 2: 2,
+ import: 1,
+ require: 2,
+};
+const ModuleImportTypeKeys = {
+ 1: "import",
+ 2: "require",
+ import: "import",
+ require: "require",
+};
+
+function decodeModuleImportRecord(bb) {
+ var result = {};
+
+ result["kind"] = ModuleImportType[bb.readByte()];
+ result["path"] = bb.readString();
+ result["dynamic"] = !!bb.readByte();
+ return result;
+}
+
+function encodeModuleImportRecord(message, bb) {
+ var value = message["kind"];
+ if (value != null) {
+ var encoded = ModuleImportType[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " +
+ JSON.stringify(value) +
+ ' for enum "ModuleImportType"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "kind"');
+ }
+
+ var value = message["path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
+ var value = message["dynamic"];
+ if (value != null) {
+ bb.writeByte(value);
+ } else {
+ throw new Error('Missing required field "dynamic"');
+ }
+}
+
+function decodeModule(bb) {
+ var result = {};
+
+ result["path"] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["imports"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeModuleImportRecord(bb);
+ return result;
+}
+
+function encodeModule(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
+ var value = message["imports"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeModuleImportRecord(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "imports"');
+ }
+}
+
+function decodeStringMap(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["keys"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["values"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ return result;
+}
+
+function encodeStringMap(message, bb) {
+ var value = message["keys"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "keys"');
+ }
+
+ var value = message["values"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "values"');
+ }
+}
+
+function decodeLoaderMap(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["extensions"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["loaders"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = Loader[bb.readByte()];
+ return result;
+}
+
+function encodeLoaderMap(message, bb) {
+ var value = message["extensions"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "extensions"');
+ }
+
+ var value = message["loaders"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ var encoded = Loader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+ );
+ bb.writeByte(encoded);
+ }
+ } else {
+ throw new Error('Missing required field "loaders"');
+ }
+}
+const DotEnvBehavior = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ disable: 1,
+ prefix: 2,
+ load_all: 3,
+};
+const DotEnvBehaviorKeys = {
+ 1: "disable",
+ 2: "prefix",
+ 3: "load_all",
+ disable: "disable",
+ prefix: "prefix",
+ load_all: "load_all",
+};
+
+function decodeEnvConfig(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["prefix"] = bb.readString();
+ break;
+
+ case 2:
+ result["defaults"] = decodeStringMap(bb);
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeEnvConfig(message, bb) {
+ var value = message["prefix"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["defaults"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeStringMap(value, bb);
+ }
+ bb.writeByte(0);
+}
+
+function decodeLoadedEnvConfig(bb) {
+ var result = {};
+
+ result["dotenv"] = DotEnvBehavior[bb.readVarUint()];
+ result["defaults"] = decodeStringMap(bb);
+ result["prefix"] = bb.readString();
+ return result;
+}
+
+function encodeLoadedEnvConfig(message, bb) {
+ var value = message["dotenv"];
+ if (value != null) {
+ var encoded = DotEnvBehavior[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"'
+ );
+ bb.writeVarUint(encoded);
+ } else {
+ throw new Error('Missing required field "dotenv"');
+ }
+
+ var value = message["defaults"];
+ if (value != null) {
+ encodeStringMap(value, bb);
+ } else {
+ throw new Error('Missing required field "defaults"');
+ }
+
+ var value = message["prefix"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "prefix"');
+ }
+}
+
+function decodeFrameworkConfig(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["package"] = bb.readString();
+ break;
+
+ case 2:
+ result["client"] = decodeFrameworkEntryPointMessage(bb);
+ break;
+
+ case 3:
+ result["server"] = decodeFrameworkEntryPointMessage(bb);
+ break;
+
+ case 4:
+ result["fallback"] = decodeFrameworkEntryPointMessage(bb);
+ break;
+
+ case 5:
+ result["development"] = !!bb.readByte();
+ break;
+
+ case 6:
+ result["client_css_in_js"] = CSSInJSBehavior[bb.readByte()];
+ break;
+
+ case 7:
+ result["display_name"] = bb.readString();
+ break;
+
+ case 8:
+ result["overrideModules"] = decodeStringMap(bb);
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeFrameworkConfig(message, bb) {
+ var value = message["package"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["client"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeFrameworkEntryPointMessage(value, bb);
+ }
+
+ var value = message["server"];
+ if (value != null) {
+ bb.writeByte(3);
+ encodeFrameworkEntryPointMessage(value, bb);
+ }
+
+ var value = message["fallback"];
+ if (value != null) {
+ bb.writeByte(4);
+ encodeFrameworkEntryPointMessage(value, bb);
+ }
+
+ var value = message["development"];
+ if (value != null) {
+ bb.writeByte(5);
+ bb.writeByte(value);
+ }
+
+ var value = message["client_css_in_js"];
+ if (value != null) {
+ bb.writeByte(6);
+ var encoded = CSSInJSBehavior[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "CSSInJSBehavior"'
+ );
+ bb.writeByte(encoded);
+ }
+
+ var value = message["display_name"];
+ if (value != null) {
+ bb.writeByte(7);
+ bb.writeString(value);
+ }
+
+ var value = message["overrideModules"];
+ if (value != null) {
+ bb.writeByte(8);
+ encodeStringMap(value, bb);
+ }
+ bb.writeByte(0);
+}
+
+function decodeFrameworkEntryPoint(bb) {
+ var result = {};
+
+ result["kind"] = FrameworkEntryPointType[bb.readByte()];
+ result["path"] = bb.readString();
+ result["env"] = decodeLoadedEnvConfig(bb);
+ return result;
+}
+
+function encodeFrameworkEntryPoint(message, bb) {
+ var value = message["kind"];
+ if (value != null) {
+ var encoded = FrameworkEntryPointType[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " +
+ JSON.stringify(value) +
+ ' for enum "FrameworkEntryPointType"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "kind"');
+ }
+
+ var value = message["path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
+ var value = message["env"];
+ if (value != null) {
+ encodeLoadedEnvConfig(value, bb);
+ } else {
+ throw new Error('Missing required field "env"');
+ }
+}
+
+function decodeFrameworkEntryPointMap(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["client"] = decodeFrameworkEntryPoint(bb);
+ break;
+
+ case 2:
+ result["server"] = decodeFrameworkEntryPoint(bb);
+ break;
+
+ case 3:
+ result["fallback"] = decodeFrameworkEntryPoint(bb);
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeFrameworkEntryPointMap(message, bb) {
+ var value = message["client"];
+ if (value != null) {
+ bb.writeByte(1);
+ encodeFrameworkEntryPoint(value, bb);
+ }
+
+ var value = message["server"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeFrameworkEntryPoint(value, bb);
+ }
+
+ var value = message["fallback"];
+ if (value != null) {
+ bb.writeByte(3);
+ encodeFrameworkEntryPoint(value, bb);
+ }
+ bb.writeByte(0);
+}
+
+function decodeFrameworkEntryPointMessage(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["path"] = bb.readString();
+ break;
+
+ case 2:
+ result["env"] = decodeEnvConfig(bb);
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeFrameworkEntryPointMessage(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["env"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeEnvConfig(value, bb);
+ }
+ bb.writeByte(0);
+}
+
+function decodeLoadedFramework(bb) {
+ var result = {};
+
+ result["package"] = bb.readString();
+ result["display_name"] = bb.readString();
+ result["development"] = !!bb.readByte();
+ result["entry_points"] = decodeFrameworkEntryPointMap(bb);
+ result["client_css_in_js"] = CSSInJSBehavior[bb.readByte()];
+ result["overrideModules"] = decodeStringMap(bb);
+ return result;
+}
+
+function encodeLoadedFramework(message, bb) {
+ var value = message["package"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "package"');
+ }
+
+ var value = message["display_name"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "display_name"');
+ }
+
+ var value = message["development"];
+ if (value != null) {
+ bb.writeByte(value);
+ } else {
+ throw new Error('Missing required field "development"');
+ }
+
+ var value = message["entry_points"];
+ if (value != null) {
+ encodeFrameworkEntryPointMap(value, bb);
+ } else {
+ throw new Error('Missing required field "entry_points"');
+ }
+
+ var value = message["client_css_in_js"];
+ if (value != null) {
+ var encoded = CSSInJSBehavior[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "CSSInJSBehavior"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "client_css_in_js"');
+ }
+
+ var value = message["overrideModules"];
+ if (value != null) {
+ encodeStringMap(value, bb);
+ } else {
+ throw new Error('Missing required field "overrideModules"');
+ }
+}
+
+function decodeLoadedRouteConfig(bb) {
+ var result = {};
+
+ result["dir"] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["extensions"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ result["static_dir"] = bb.readString();
+ result["asset_prefix"] = bb.readString();
+ return result;
+}
+
+function encodeLoadedRouteConfig(message, bb) {
+ var value = message["dir"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "dir"');
+ }
+
+ var value = message["extensions"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "extensions"');
+ }
+
+ var value = message["static_dir"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "static_dir"');
+ }
+
+ var value = message["asset_prefix"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "asset_prefix"');
+ }
+}
+
+function decodeRouteConfig(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ var length = bb.readVarUint();
+ var values = (result["dir"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ break;
+
+ case 2:
+ var length = bb.readVarUint();
+ var values = (result["extensions"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ break;
+
+ case 3:
+ result["static_dir"] = bb.readString();
+ break;
+
+ case 4:
+ result["asset_prefix"] = bb.readString();
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeRouteConfig(message, bb) {
+ var value = message["dir"];
+ if (value != null) {
+ bb.writeByte(1);
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ }
+
+ var value = message["extensions"];
+ if (value != null) {
+ bb.writeByte(2);
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ }
+
+ var value = message["static_dir"];
+ if (value != null) {
+ bb.writeByte(3);
+ bb.writeString(value);
+ }
+
+ var value = message["asset_prefix"];
+ if (value != null) {
+ bb.writeByte(4);
+ bb.writeString(value);
+ }
+ bb.writeByte(0);
+}
+
function decodeTransformOptions(bb) {
var result = {};
- while (true)
+
+ while (true) {
switch (bb.readByte()) {
case 0:
return result;
+
case 1:
result["jsx"] = decodeJSX(bb);
break;
+
case 2:
result["tsconfig_override"] = bb.readString();
break;
+
case 3:
result["resolve"] = ResolveMode[bb.readByte()];
break;
+
case 4:
result["origin"] = bb.readString();
break;
+
case 5:
result["absolute_working_dir"] = bb.readString();
break;
+
case 6:
- var length = bb.readVarUint();
- var values = (result["define_keys"] = Array(length));
- for (var i = 0; i < length; i++) values[i] = bb.readString();
+ result["define"] = decodeStringMap(bb);
break;
+
case 7:
- var length = bb.readVarUint();
- var values = (result["define_values"] = Array(length));
- for (var i = 0; i < length; i++) values[i] = bb.readString();
- break;
- case 8:
result["preserve_symlinks"] = !!bb.readByte();
break;
- case 9:
+
+ case 8:
var length = bb.readVarUint();
var values = (result["entry_points"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
break;
- case 10:
+
+ case 9:
result["write"] = !!bb.readByte();
break;
- case 11:
+
+ case 10:
var length = bb.readVarUint();
var values = (result["inject"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
break;
- case 12:
+
+ case 11:
result["output_dir"] = bb.readString();
break;
- case 13:
+
+ case 12:
var length = bb.readVarUint();
var values = (result["external"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
break;
+
+ case 13:
+ result["loaders"] = decodeLoaderMap(bb);
+ break;
+
case 14:
var length = bb.readVarUint();
- var values = (result["loader_keys"] = Array(length));
+ var values = (result["main_fields"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
break;
+
case 15:
- var length = bb.readVarUint();
- var values = (result["loader_values"] = Array(length));
- for (var i = 0; i < length; i++) values[i] = Loader[bb.readByte()];
+ result["platform"] = Platform[bb.readByte()];
break;
+
case 16:
- var length = bb.readVarUint();
- var values = (result["main_fields"] = Array(length));
- for (var i = 0; i < length; i++) values[i] = bb.readString();
+ result["serve"] = !!bb.readByte();
break;
+
case 17:
- result["platform"] = Platform[bb.readByte()];
+ var length = bb.readVarUint();
+ var values = (result["extension_order"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
break;
+
case 18:
- result["serve"] = !!bb.readByte();
+ result["generate_node_module_bundle"] = !!bb.readByte();
break;
+
case 19:
- var length = bb.readVarUint();
- var values = (result["extension_order"] = Array(length));
- for (var i = 0; i < length; i++) values[i] = bb.readString();
+ result["node_modules_bundle_path"] = bb.readString();
break;
+
case 20:
- result["public_dir"] = bb.readString();
+ result["node_modules_bundle_path_server"] = bb.readString();
break;
+
+ case 21:
+ result["framework"] = decodeFrameworkConfig(bb);
+ break;
+
+ case 22:
+ result["router"] = decodeRouteConfig(bb);
+ break;
+
+ case 23:
+ result["no_summary"] = !!bb.readByte();
+ break;
+
+ case 24:
+ result["disable_hmr"] = !!bb.readByte();
+ break;
+
+ case 25:
+ result["port"] = bb.readUint16();
+ break;
+
+ case 26:
+ result["logLevel"] = MessageLevel[bb.readVarUint()];
+ break;
+
default:
throw new Error("Attempted to parse invalid message");
}
+ }
}
+
function encodeTransformOptions(message, bb) {
var value = message["jsx"];
if (value != null) {
bb.writeByte(1);
encodeJSX(value, bb);
}
+
var value = message["tsconfig_override"];
if (value != null) {
bb.writeByte(2);
bb.writeString(value);
}
+
var value = message["resolve"];
if (value != null) {
bb.writeByte(3);
var encoded = ResolveMode[value];
- if (encoded === undefined)
+ if (encoded === void 0)
throw new Error(
"Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"'
);
bb.writeByte(encoded);
}
+
var value = message["origin"];
if (value != null) {
bb.writeByte(4);
bb.writeString(value);
}
+
var value = message["absolute_working_dir"];
if (value != null) {
bb.writeByte(5);
bb.writeString(value);
}
- var value = message["define_keys"];
+
+ var value = message["define"];
if (value != null) {
bb.writeByte(6);
- var values = value,
- n = values.length;
- bb.writeVarUint(n);
- for (var i = 0; i < n; i++) {
- value = values[i];
- bb.writeString(value);
- }
- }
- var value = message["define_values"];
- if (value != null) {
- bb.writeByte(7);
- var values = value,
- n = values.length;
- bb.writeVarUint(n);
- for (var i = 0; i < n; i++) {
- value = values[i];
- bb.writeString(value);
- }
+ encodeStringMap(value, bb);
}
+
var value = message["preserve_symlinks"];
if (value != null) {
- bb.writeByte(8);
+ bb.writeByte(7);
bb.writeByte(value);
}
+
var value = message["entry_points"];
if (value != null) {
- bb.writeByte(9);
+ bb.writeByte(8);
var values = value,
n = values.length;
bb.writeVarUint(n);
@@ -267,14 +1783,16 @@ function encodeTransformOptions(message, bb) {
bb.writeString(value);
}
}
+
var value = message["write"];
if (value != null) {
- bb.writeByte(10);
+ bb.writeByte(9);
bb.writeByte(value);
}
+
var value = message["inject"];
if (value != null) {
- bb.writeByte(11);
+ bb.writeByte(10);
var values = value,
n = values.length;
bb.writeVarUint(n);
@@ -283,25 +1801,16 @@ function encodeTransformOptions(message, bb) {
bb.writeString(value);
}
}
+
var value = message["output_dir"];
if (value != null) {
- bb.writeByte(12);
+ bb.writeByte(11);
bb.writeString(value);
}
+
var value = message["external"];
if (value != null) {
- bb.writeByte(13);
- var values = value,
- n = values.length;
- bb.writeVarUint(n);
- for (var i = 0; i < n; i++) {
- value = values[i];
- bb.writeString(value);
- }
- }
- var value = message["loader_keys"];
- if (value != null) {
- bb.writeByte(14);
+ bb.writeByte(12);
var values = value,
n = values.length;
bb.writeVarUint(n);
@@ -310,25 +1819,16 @@ function encodeTransformOptions(message, bb) {
bb.writeString(value);
}
}
- var value = message["loader_values"];
+
+ var value = message["loaders"];
if (value != null) {
- bb.writeByte(15);
- var values = value,
- n = values.length;
- bb.writeVarUint(n);
- for (var i = 0; i < n; i++) {
- value = values[i];
- var encoded = Loader[value];
- if (encoded === undefined)
- throw new Error(
- "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
- );
- bb.writeByte(encoded);
- }
+ bb.writeByte(13);
+ encodeLoaderMap(value, bb);
}
+
var value = message["main_fields"];
if (value != null) {
- bb.writeByte(16);
+ bb.writeByte(14);
var values = value,
n = values.length;
bb.writeVarUint(n);
@@ -337,24 +1837,27 @@ function encodeTransformOptions(message, bb) {
bb.writeString(value);
}
}
+
var value = message["platform"];
if (value != null) {
- bb.writeByte(17);
+ bb.writeByte(15);
var encoded = Platform[value];
- if (encoded === undefined)
+ if (encoded === void 0)
throw new Error(
"Invalid value " + JSON.stringify(value) + ' for enum "Platform"'
);
bb.writeByte(encoded);
}
+
var value = message["serve"];
if (value != null) {
- bb.writeByte(18);
+ bb.writeByte(16);
bb.writeByte(value);
}
+
var value = message["extension_order"];
if (value != null) {
- bb.writeByte(19);
+ bb.writeByte(17);
var values = value,
n = values.length;
bb.writeVarUint(n);
@@ -363,82 +1866,164 @@ function encodeTransformOptions(message, bb) {
bb.writeString(value);
}
}
- var value = message["public_dir"];
+
+ var value = message["generate_node_module_bundle"];
+ if (value != null) {
+ bb.writeByte(18);
+ bb.writeByte(value);
+ }
+
+ var value = message["node_modules_bundle_path"];
+ if (value != null) {
+ bb.writeByte(19);
+ bb.writeString(value);
+ }
+
+ var value = message["node_modules_bundle_path_server"];
if (value != null) {
bb.writeByte(20);
bb.writeString(value);
}
+
+ var value = message["framework"];
+ if (value != null) {
+ bb.writeByte(21);
+ encodeFrameworkConfig(value, bb);
+ }
+
+ var value = message["router"];
+ if (value != null) {
+ bb.writeByte(22);
+ encodeRouteConfig(value, bb);
+ }
+
+ var value = message["no_summary"];
+ if (value != null) {
+ bb.writeByte(23);
+ bb.writeByte(value);
+ }
+
+ var value = message["disable_hmr"];
+ if (value != null) {
+ bb.writeByte(24);
+ bb.writeByte(value);
+ }
+
+ var value = message["port"];
+ if (value != null) {
+ bb.writeByte(25);
+ bb.writeUint16(value);
+ }
+
+ var value = message["logLevel"];
+ if (value != null) {
+ bb.writeByte(26);
+ var encoded = MessageLevel[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"'
+ );
+ bb.writeVarUint(encoded);
+ }
bb.writeByte(0);
}
+
function decodeFileHandle(bb) {
var result = {};
+
result["path"] = bb.readString();
result["size"] = bb.readVarUint();
result["fd"] = bb.readVarUint();
return result;
}
+
function encodeFileHandle(message, bb) {
var value = message["path"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "path"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
var value = message["size"];
- if (value != null) bb.writeVarUint(value);
- else throw new Error('Missing required field "size"');
+ if (value != null) {
+ bb.writeVarUint(value);
+ } else {
+ throw new Error('Missing required field "size"');
+ }
+
var value = message["fd"];
- if (value != null) bb.writeVarUint(value);
- else throw new Error('Missing required field "fd"');
+ if (value != null) {
+ bb.writeVarUint(value);
+ } else {
+ throw new Error('Missing required field "fd"');
+ }
}
+
function decodeTransform(bb) {
var result = {};
- while (true)
+
+ while (true) {
switch (bb.readByte()) {
case 0:
return result;
+
case 1:
result["handle"] = decodeFileHandle(bb);
break;
+
case 2:
result["path"] = bb.readString();
break;
+
case 3:
result["contents"] = bb.readByteArray();
break;
+
case 4:
result["loader"] = Loader[bb.readByte()];
break;
+
case 5:
result["options"] = decodeTransformOptions(bb);
break;
+
default:
throw new Error("Attempted to parse invalid message");
}
+ }
}
+
function encodeTransform(message, bb) {
var value = message["handle"];
if (value != null) {
bb.writeByte(1);
encodeFileHandle(value, bb);
}
+
var value = message["path"];
if (value != null) {
bb.writeByte(2);
bb.writeString(value);
}
+
var value = message["contents"];
if (value != null) {
bb.writeByte(3);
bb.writeByteArray(value);
}
+
var value = message["loader"];
if (value != null) {
bb.writeByte(4);
var encoded = Loader[value];
- if (encoded === undefined)
+ if (encoded === void 0)
throw new Error(
"Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
);
bb.writeByte(encoded);
}
+
var value = message["options"];
if (value != null) {
bb.writeByte(5);
@@ -446,6 +2031,163 @@ function encodeTransform(message, bb) {
}
bb.writeByte(0);
}
+
+function decodeScan(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["path"] = bb.readString();
+ break;
+
+ case 2:
+ result["contents"] = bb.readByteArray();
+ break;
+
+ case 3:
+ result["loader"] = Loader[bb.readByte()];
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeScan(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["contents"];
+ if (value != null) {
+ bb.writeByte(2);
+ bb.writeByteArray(value);
+ }
+
+ var value = message["loader"];
+ if (value != null) {
+ bb.writeByte(3);
+ var encoded = Loader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+ );
+ bb.writeByte(encoded);
+ }
+ bb.writeByte(0);
+}
+
+function decodeScanResult(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["exports"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["imports"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeScannedImport(bb);
+ return result;
+}
+
+function encodeScanResult(message, bb) {
+ var value = message["exports"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "exports"');
+ }
+
+ var value = message["imports"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeScannedImport(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "imports"');
+ }
+}
+
+function decodeScannedImport(bb) {
+ var result = {};
+
+ result["path"] = bb.readString();
+ result["kind"] = ImportKind[bb.readByte()];
+ return result;
+}
+
+function encodeScannedImport(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
+ var value = message["kind"];
+ if (value != null) {
+ var encoded = ImportKind[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "ImportKind"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "kind"');
+ }
+}
+const ImportKind = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ entry_point: 1,
+ stmt: 2,
+ require: 3,
+ dynamic: 4,
+ require_resolve: 5,
+ at: 6,
+ url: 7,
+ internal: 8,
+};
+const ImportKindKeys = {
+ 1: "entry_point",
+ 2: "stmt",
+ 3: "require",
+ 4: "dynamic",
+ 5: "require_resolve",
+ 6: "at",
+ 7: "url",
+ 8: "internal",
+ entry_point: "entry_point",
+ stmt: "stmt",
+ require: "require",
+ dynamic: "dynamic",
+ require_resolve: "require_resolve",
+ at: "at",
+ url: "url",
+ internal: "internal",
+};
const TransformResponseStatus = {
1: 1,
2: 2,
@@ -458,22 +2200,34 @@ const TransformResponseStatusKeys = {
success: "success",
fail: "fail",
};
+
function decodeOutputFile(bb) {
var result = {};
+
result["data"] = bb.readByteArray();
result["path"] = bb.readString();
return result;
}
+
function encodeOutputFile(message, bb) {
var value = message["data"];
- if (value != null) bb.writeByteArray(value);
- else throw new Error('Missing required field "data"');
+ if (value != null) {
+ bb.writeByteArray(value);
+ } else {
+ throw new Error('Missing required field "data"');
+ }
+
var value = message["path"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "path"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
}
+
function decodeTransformResponse(bb) {
var result = {};
+
result["status"] = TransformResponseStatus[bb.readVarUint()];
var length = bb.readVarUint();
var values = (result["files"] = Array(length));
@@ -483,18 +2237,22 @@ function decodeTransformResponse(bb) {
for (var i = 0; i < length; i++) values[i] = decodeMessage(bb);
return result;
}
+
function encodeTransformResponse(message, bb) {
var value = message["status"];
if (value != null) {
var encoded = TransformResponseStatus[value];
- if (encoded === undefined)
+ if (encoded === void 0)
throw new Error(
"Invalid value " +
JSON.stringify(value) +
' for enum "TransformResponseStatus"'
);
bb.writeVarUint(encoded);
- } else throw new Error('Missing required field "status"');
+ } else {
+ throw new Error('Missing required field "status"');
+ }
+
var value = message["files"];
if (value != null) {
var values = value,
@@ -504,7 +2262,10 @@ function encodeTransformResponse(message, bb) {
value = values[i];
encodeOutputFile(value, bb);
}
- } else throw new Error('Missing required field "files"');
+ } else {
+ throw new Error('Missing required field "files"');
+ }
+
var value = message["errors"];
if (value != null) {
var values = value,
@@ -514,30 +2275,38 @@ function encodeTransformResponse(message, bb) {
value = values[i];
encodeMessage(value, bb);
}
- } else throw new Error('Missing required field "errors"');
+ } else {
+ throw new Error('Missing required field "errors"');
+ }
}
-const MessageKind = {
+const MessageLevel = {
1: 1,
2: 2,
3: 3,
4: 4,
+ 5: 5,
err: 1,
warn: 2,
note: 3,
- debug: 4,
+ info: 4,
+ debug: 5,
};
-const MessageKindKeys = {
+const MessageLevelKeys = {
1: "err",
2: "warn",
3: "note",
- 4: "debug",
+ 4: "info",
+ 5: "debug",
err: "err",
warn: "warn",
note: "note",
+ info: "info",
debug: "debug",
};
+
function decodeLocation(bb) {
var result = {};
+
result["file"] = bb.readString();
result["namespace"] = bb.readString();
result["line"] = bb.readInt32();
@@ -547,51 +2316,87 @@ function decodeLocation(bb) {
result["offset"] = bb.readVarUint();
return result;
}
+
function encodeLocation(message, bb) {
var value = message["file"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "file"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "file"');
+ }
+
var value = message["namespace"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "namespace"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "namespace"');
+ }
+
var value = message["line"];
- if (value != null) bb.writeInt32(value);
- else throw new Error('Missing required field "line"');
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "line"');
+ }
+
var value = message["column"];
- if (value != null) bb.writeInt32(value);
- else throw new Error('Missing required field "column"');
+ if (value != null) {
+ bb.writeInt32(value);
+ } else {
+ throw new Error('Missing required field "column"');
+ }
+
var value = message["line_text"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "line_text"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "line_text"');
+ }
+
var value = message["suggestion"];
- if (value != null) bb.writeString(value);
- else throw new Error('Missing required field "suggestion"');
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "suggestion"');
+ }
+
var value = message["offset"];
- if (value != null) bb.writeVarUint(value);
- else throw new Error('Missing required field "offset"');
+ if (value != null) {
+ bb.writeVarUint(value);
+ } else {
+ throw new Error('Missing required field "offset"');
+ }
}
+
function decodeMessageData(bb) {
var result = {};
- while (true)
+
+ while (true) {
switch (bb.readByte()) {
case 0:
return result;
+
case 1:
result["text"] = bb.readString();
break;
+
case 2:
result["location"] = decodeLocation(bb);
break;
+
default:
throw new Error("Attempted to parse invalid message");
}
+ }
}
+
function encodeMessageData(message, bb) {
var value = message["text"];
if (value != null) {
bb.writeByte(1);
bb.writeString(value);
}
+
var value = message["location"];
if (value != null) {
bb.writeByte(2);
@@ -599,28 +2404,76 @@ function encodeMessageData(message, bb) {
}
bb.writeByte(0);
}
+
+function decodeMessageMeta(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["resolve"] = bb.readString();
+ break;
+
+ case 2:
+ result["build"] = !!bb.readByte();
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeMessageMeta(message, bb) {
+ var value = message["resolve"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["build"];
+ if (value != null) {
+ bb.writeByte(2);
+ bb.writeByte(value);
+ }
+ bb.writeByte(0);
+}
+
function decodeMessage(bb) {
var result = {};
- result["kind"] = MessageKind[bb.readVarUint()];
+
+ result["level"] = MessageLevel[bb.readVarUint()];
result["data"] = decodeMessageData(bb);
var length = bb.readVarUint();
var values = (result["notes"] = Array(length));
for (var i = 0; i < length; i++) values[i] = decodeMessageData(bb);
+ result["on"] = decodeMessageMeta(bb);
return result;
}
+
function encodeMessage(message, bb) {
- var value = message["kind"];
+ var value = message["level"];
if (value != null) {
- var encoded = MessageKind[value];
- if (encoded === undefined)
+ var encoded = MessageLevel[value];
+ if (encoded === void 0)
throw new Error(
- "Invalid value " + JSON.stringify(value) + ' for enum "MessageKind"'
+ "Invalid value " + JSON.stringify(value) + ' for enum "MessageLevel"'
);
bb.writeVarUint(encoded);
- } else throw new Error('Missing required field "kind"');
+ } else {
+ throw new Error('Missing required field "level"');
+ }
+
var value = message["data"];
- if (value != null) encodeMessageData(value, bb);
- else throw new Error('Missing required field "data"');
+ if (value != null) {
+ encodeMessageData(value, bb);
+ } else {
+ throw new Error('Missing required field "data"');
+ }
+
var value = message["notes"];
if (value != null) {
var values = value,
@@ -630,10 +2483,21 @@ function encodeMessage(message, bb) {
value = values[i];
encodeMessageData(value, bb);
}
- } else throw new Error('Missing required field "notes"');
+ } else {
+ throw new Error('Missing required field "notes"');
+ }
+
+ var value = message["on"];
+ if (value != null) {
+ encodeMessageMeta(value, bb);
+ } else {
+ throw new Error('Missing required field "on"');
+ }
}
+
function decodeLog(bb) {
var result = {};
+
result["warnings"] = bb.readUint32();
result["errors"] = bb.readUint32();
var length = bb.readVarUint();
@@ -641,13 +2505,22 @@ function decodeLog(bb) {
for (var i = 0; i < length; i++) values[i] = decodeMessage(bb);
return result;
}
+
function encodeLog(message, bb) {
var value = message["warnings"];
- if (value != null) bb.writeUint32(value);
- else throw new Error('Missing required field "warnings"');
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "warnings"');
+ }
+
var value = message["errors"];
- if (value != null) bb.writeUint32(value);
- else throw new Error('Missing required field "errors"');
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "errors"');
+ }
+
var value = message["msgs"];
if (value != null) {
var values = value,
@@ -657,38 +2530,807 @@ function encodeLog(message, bb) {
value = values[i];
encodeMessage(value, bb);
}
- } else throw new Error('Missing required field "msgs"');
+ } else {
+ throw new Error('Missing required field "msgs"');
+ }
+}
+const Reloader = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ disable: 1,
+ live: 2,
+ fast_refresh: 3,
+};
+const ReloaderKeys = {
+ 1: "disable",
+ 2: "live",
+ 3: "fast_refresh",
+ disable: "disable",
+ live: "live",
+ fast_refresh: "fast_refresh",
+};
+const WebsocketMessageKind = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ welcome: 1,
+ file_change_notification: 2,
+ build_success: 3,
+ build_fail: 4,
+ manifest_success: 5,
+ manifest_fail: 6,
+ resolve_file: 7,
+ file_change_notification_with_hint: 8,
+};
+const WebsocketMessageKindKeys = {
+ 1: "welcome",
+ 2: "file_change_notification",
+ 3: "build_success",
+ 4: "build_fail",
+ 5: "manifest_success",
+ 6: "manifest_fail",
+ 7: "resolve_file",
+ 8: "file_change_notification_with_hint",
+ welcome: "welcome",
+ file_change_notification: "file_change_notification",
+ build_success: "build_success",
+ build_fail: "build_fail",
+ manifest_success: "manifest_success",
+ manifest_fail: "manifest_fail",
+ resolve_file: "resolve_file",
+ file_change_notification_with_hint: "file_change_notification_with_hint",
+};
+const WebsocketCommandKind = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ build: 1,
+ manifest: 2,
+ build_with_file_path: 3,
+};
+const WebsocketCommandKindKeys = {
+ 1: "build",
+ 2: "manifest",
+ 3: "build_with_file_path",
+ build: "build",
+ manifest: "manifest",
+ build_with_file_path: "build_with_file_path",
+};
+
+function decodeWebsocketMessage(bb) {
+ var result = {};
+
+ result["timestamp"] = bb.readUint32();
+ result["kind"] = WebsocketMessageKind[bb.readByte()];
+ return result;
+}
+
+function encodeWebsocketMessage(message, bb) {
+ var value = message["timestamp"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "timestamp"');
+ }
+
+ var value = message["kind"];
+ if (value != null) {
+ var encoded = WebsocketMessageKind[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " +
+ JSON.stringify(value) +
+ ' for enum "WebsocketMessageKind"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "kind"');
+ }
+}
+
+function decodeWebsocketMessageWelcome(bb) {
+ var result = {};
+
+ result["epoch"] = bb.readUint32();
+ result["javascriptReloader"] = Reloader[bb.readByte()];
+ result["cwd"] = bb.readString();
+ return result;
+}
+
+function encodeWebsocketMessageWelcome(message, bb) {
+ var value = message["epoch"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "epoch"');
+ }
+
+ var value = message["javascriptReloader"];
+ if (value != null) {
+ var encoded = Reloader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "javascriptReloader"');
+ }
+
+ var value = message["cwd"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "cwd"');
+ }
+}
+
+function decodeWebsocketMessageFileChangeNotification(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ result["loader"] = Loader[bb.readByte()];
+ return result;
+}
+
+function encodeWebsocketMessageFileChangeNotification(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+
+ var value = message["loader"];
+ if (value != null) {
+ var encoded = Loader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "loader"');
+ }
+}
+
+function decodeWebsocketCommand(bb) {
+ var result = {};
+
+ result["kind"] = WebsocketCommandKind[bb.readByte()];
+ result["timestamp"] = bb.readUint32();
+ return result;
+}
+
+function encodeWebsocketCommand(message, bb) {
+ var value = message["kind"];
+ if (value != null) {
+ var encoded = WebsocketCommandKind[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " +
+ JSON.stringify(value) +
+ ' for enum "WebsocketCommandKind"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "kind"');
+ }
+
+ var value = message["timestamp"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "timestamp"');
+ }
+}
+
+function decodeWebsocketCommandBuild(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ return result;
+}
+
+function encodeWebsocketCommandBuild(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+}
+
+function decodeWebsocketCommandManifest(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ return result;
+}
+
+function encodeWebsocketCommandManifest(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+}
+
+function decodeWebsocketMessageBuildSuccess(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ result["from_timestamp"] = bb.readUint32();
+ result["loader"] = Loader[bb.readByte()];
+ result["module_path"] = bb.readString();
+ result["blob_length"] = bb.readUint32();
+ return result;
+}
+
+function encodeWebsocketMessageBuildSuccess(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+
+ var value = message["from_timestamp"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "from_timestamp"');
+ }
+
+ var value = message["loader"];
+ if (value != null) {
+ var encoded = Loader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "loader"');
+ }
+
+ var value = message["module_path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "module_path"');
+ }
+
+ var value = message["blob_length"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "blob_length"');
+ }
+}
+
+function decodeWebsocketMessageBuildFailure(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ result["from_timestamp"] = bb.readUint32();
+ result["loader"] = Loader[bb.readByte()];
+ result["module_path"] = bb.readString();
+ result["log"] = decodeLog(bb);
+ return result;
+}
+
+function encodeWebsocketMessageBuildFailure(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+
+ var value = message["from_timestamp"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "from_timestamp"');
+ }
+
+ var value = message["loader"];
+ if (value != null) {
+ var encoded = Loader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "loader"');
+ }
+
+ var value = message["module_path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "module_path"');
+ }
+
+ var value = message["log"];
+ if (value != null) {
+ encodeLog(value, bb);
+ } else {
+ throw new Error('Missing required field "log"');
+ }
+}
+
+function decodeWebsocketCommandBuildWithFilePath(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ result["file_path"] = bb.readString();
+ return result;
+}
+
+function encodeWebsocketCommandBuildWithFilePath(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+
+ var value = message["file_path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "file_path"');
+ }
+}
+
+function decodeWebsocketMessageResolveID(bb) {
+ var result = {};
+
+ result["id"] = bb.readUint32();
+ return result;
+}
+
+function encodeWebsocketMessageResolveID(message, bb) {
+ var value = message["id"];
+ if (value != null) {
+ bb.writeUint32(value);
+ } else {
+ throw new Error('Missing required field "id"');
+ }
+}
+
+function decodeNPMRegistry(bb) {
+ var result = {};
+
+ result["url"] = bb.readString();
+ result["username"] = bb.readString();
+ result["password"] = bb.readString();
+ result["token"] = bb.readString();
+ return result;
+}
+
+function encodeNPMRegistry(message, bb) {
+ var value = message["url"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "url"');
+ }
+
+ var value = message["username"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "username"');
+ }
+
+ var value = message["password"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "password"');
+ }
+
+ var value = message["token"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "token"');
+ }
+}
+
+function decodeNPMRegistryMap(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["scopes"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["registries"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeNPMRegistry(bb);
+ return result;
+}
+
+function encodeNPMRegistryMap(message, bb) {
+ var value = message["scopes"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "scopes"');
+ }
+
+ var value = message["registries"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeNPMRegistry(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "registries"');
+ }
+}
+
+function decodeBunInstall(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["default_registry"] = decodeNPMRegistry(bb);
+ break;
+
+ case 2:
+ result["scoped"] = decodeNPMRegistryMap(bb);
+ break;
+
+ case 3:
+ result["lockfile_path"] = bb.readString();
+ break;
+
+ case 4:
+ result["save_lockfile_path"] = bb.readString();
+ break;
+
+ case 5:
+ result["cache_directory"] = bb.readString();
+ break;
+
+ case 6:
+ result["dry_run"] = !!bb.readByte();
+ break;
+
+ case 7:
+ result["force"] = !!bb.readByte();
+ break;
+
+ case 8:
+ result["save_dev"] = !!bb.readByte();
+ break;
+
+ case 9:
+ result["save_optional"] = !!bb.readByte();
+ break;
+
+ case 10:
+ result["save_peer"] = !!bb.readByte();
+ break;
+
+ case 11:
+ result["save_lockfile"] = !!bb.readByte();
+ break;
+
+ case 12:
+ result["production"] = !!bb.readByte();
+ break;
+
+ case 13:
+ result["save_yarn_lockfile"] = !!bb.readByte();
+ break;
+
+ case 14:
+ var length = bb.readVarUint();
+ var values = (result["native_bin_links"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ break;
+
+ case 15:
+ result["disable_cache"] = !!bb.readByte();
+ break;
+
+ case 16:
+ result["disable_manifest_cache"] = !!bb.readByte();
+ break;
+
+ case 17:
+ result["global_dir"] = bb.readString();
+ break;
+
+ case 18:
+ result["global_bin_dir"] = bb.readString();
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeBunInstall(message, bb) {
+ var value = message["default_registry"];
+ if (value != null) {
+ bb.writeByte(1);
+ encodeNPMRegistry(value, bb);
+ }
+
+ var value = message["scoped"];
+ if (value != null) {
+ bb.writeByte(2);
+ encodeNPMRegistryMap(value, bb);
+ }
+
+ var value = message["lockfile_path"];
+ if (value != null) {
+ bb.writeByte(3);
+ bb.writeString(value);
+ }
+
+ var value = message["save_lockfile_path"];
+ if (value != null) {
+ bb.writeByte(4);
+ bb.writeString(value);
+ }
+
+ var value = message["cache_directory"];
+ if (value != null) {
+ bb.writeByte(5);
+ bb.writeString(value);
+ }
+
+ var value = message["dry_run"];
+ if (value != null) {
+ bb.writeByte(6);
+ bb.writeByte(value);
+ }
+
+ var value = message["force"];
+ if (value != null) {
+ bb.writeByte(7);
+ bb.writeByte(value);
+ }
+
+ var value = message["save_dev"];
+ if (value != null) {
+ bb.writeByte(8);
+ bb.writeByte(value);
+ }
+
+ var value = message["save_optional"];
+ if (value != null) {
+ bb.writeByte(9);
+ bb.writeByte(value);
+ }
+
+ var value = message["save_peer"];
+ if (value != null) {
+ bb.writeByte(10);
+ bb.writeByte(value);
+ }
+
+ var value = message["save_lockfile"];
+ if (value != null) {
+ bb.writeByte(11);
+ bb.writeByte(value);
+ }
+
+ var value = message["production"];
+ if (value != null) {
+ bb.writeByte(12);
+ bb.writeByte(value);
+ }
+
+ var value = message["save_yarn_lockfile"];
+ if (value != null) {
+ bb.writeByte(13);
+ bb.writeByte(value);
+ }
+
+ var value = message["native_bin_links"];
+ if (value != null) {
+ bb.writeByte(14);
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ }
+
+ var value = message["disable_cache"];
+ if (value != null) {
+ bb.writeByte(15);
+ bb.writeByte(value);
+ }
+
+ var value = message["disable_manifest_cache"];
+ if (value != null) {
+ bb.writeByte(16);
+ bb.writeByte(value);
+ }
+
+ var value = message["global_dir"];
+ if (value != null) {
+ bb.writeByte(17);
+ bb.writeString(value);
+ }
+
+ var value = message["global_bin_dir"];
+ if (value != null) {
+ bb.writeByte(18);
+ bb.writeString(value);
+ }
+ bb.writeByte(0);
}
export { Loader };
export { LoaderKeys };
+export { FrameworkEntryPointType };
+export { FrameworkEntryPointTypeKeys };
+export { StackFrameScope };
+export { StackFrameScopeKeys };
+export { decodeStackFrame };
+export { encodeStackFrame };
+export { decodeStackFramePosition };
+export { encodeStackFramePosition };
+export { decodeSourceLine };
+export { encodeSourceLine };
+export { decodeStackTrace };
+export { encodeStackTrace };
+export { decodeJSException };
+export { encodeJSException };
+export { FallbackStep };
+export { FallbackStepKeys };
+export { decodeProblems };
+export { encodeProblems };
+export { decodeRouter };
+export { encodeRouter };
+export { decodeFallbackMessageContainer };
+export { encodeFallbackMessageContainer };
export { ResolveMode };
export { ResolveModeKeys };
export { Platform };
export { PlatformKeys };
+export { CSSInJSBehavior };
+export { CSSInJSBehaviorKeys };
export { JSXRuntime };
export { JSXRuntimeKeys };
export { decodeJSX };
export { encodeJSX };
+export { decodeStringPointer };
+export { encodeStringPointer };
+export { decodeJavascriptBundledModule };
+export { encodeJavascriptBundledModule };
+export { decodeJavascriptBundledPackage };
+export { encodeJavascriptBundledPackage };
+export { decodeJavascriptBundle };
+export { encodeJavascriptBundle };
+export { decodeJavascriptBundleContainer };
+export { encodeJavascriptBundleContainer };
+export { ScanDependencyMode };
+export { ScanDependencyModeKeys };
+export { ModuleImportType };
+export { ModuleImportTypeKeys };
+export { decodeModuleImportRecord };
+export { encodeModuleImportRecord };
+export { decodeModule };
+export { encodeModule };
+export { decodeStringMap };
+export { encodeStringMap };
+export { decodeLoaderMap };
+export { encodeLoaderMap };
+export { DotEnvBehavior };
+export { DotEnvBehaviorKeys };
+export { decodeEnvConfig };
+export { encodeEnvConfig };
+export { decodeLoadedEnvConfig };
+export { encodeLoadedEnvConfig };
+export { decodeFrameworkConfig };
+export { encodeFrameworkConfig };
+export { decodeFrameworkEntryPoint };
+export { encodeFrameworkEntryPoint };
+export { decodeFrameworkEntryPointMap };
+export { encodeFrameworkEntryPointMap };
+export { decodeFrameworkEntryPointMessage };
+export { encodeFrameworkEntryPointMessage };
+export { decodeLoadedFramework };
+export { encodeLoadedFramework };
+export { decodeLoadedRouteConfig };
+export { encodeLoadedRouteConfig };
+export { decodeRouteConfig };
+export { encodeRouteConfig };
export { decodeTransformOptions };
export { encodeTransformOptions };
export { decodeFileHandle };
export { encodeFileHandle };
export { decodeTransform };
export { encodeTransform };
+export { decodeScan };
+export { encodeScan };
+export { decodeScanResult };
+export { encodeScanResult };
+export { decodeScannedImport };
+export { encodeScannedImport };
+export { ImportKind };
+export { ImportKindKeys };
export { TransformResponseStatus };
export { TransformResponseStatusKeys };
export { decodeOutputFile };
export { encodeOutputFile };
export { decodeTransformResponse };
export { encodeTransformResponse };
-export { MessageKind };
-export { MessageKindKeys };
+export { MessageLevel };
+export { MessageLevelKeys };
export { decodeLocation };
export { encodeLocation };
export { decodeMessageData };
export { encodeMessageData };
+export { decodeMessageMeta };
+export { encodeMessageMeta };
export { decodeMessage };
export { encodeMessage };
export { decodeLog };
export { encodeLog };
+export { Reloader };
+export { ReloaderKeys };
+export { WebsocketMessageKind };
+export { WebsocketMessageKindKeys };
+export { WebsocketCommandKind };
+export { WebsocketCommandKindKeys };
+export { decodeWebsocketMessage };
+export { encodeWebsocketMessage };
+export { decodeWebsocketMessageWelcome };
+export { encodeWebsocketMessageWelcome };
+export { decodeWebsocketMessageFileChangeNotification };
+export { encodeWebsocketMessageFileChangeNotification };
+export { decodeWebsocketCommand };
+export { encodeWebsocketCommand };
+export { decodeWebsocketCommandBuild };
+export { encodeWebsocketCommandBuild };
+export { decodeWebsocketCommandManifest };
+export { encodeWebsocketCommandManifest };
+export { decodeWebsocketMessageBuildSuccess };
+export { encodeWebsocketMessageBuildSuccess };
+export { decodeWebsocketMessageBuildFailure };
+export { encodeWebsocketMessageBuildFailure };
+export { decodeWebsocketCommandBuildWithFilePath };
+export { encodeWebsocketCommandBuildWithFilePath };
+export { decodeWebsocketMessageResolveID };
+export { encodeWebsocketMessageResolveID };
+export { decodeNPMRegistry };
+export { encodeNPMRegistry };
+export { decodeNPMRegistryMap };
+export { encodeNPMRegistryMap };
+export { decodeBunInstall };
+export { encodeBunInstall };
diff --git a/src/api/demo/schema.peechy b/src/api/demo/schema.peechy
new file mode 100644
index 000000000..59cb1edf5
--- /dev/null
+++ b/src/api/demo/schema.peechy
@@ -0,0 +1,553 @@
+package Api;
+
+smol Loader {
+ jsx = 1;
+ js = 2;
+ ts = 3;
+ tsx = 4;
+ css = 5;
+ file = 6;
+ json = 7;
+ toml = 8;
+ wasm = 9;
+}
+
+smol FrameworkEntryPointType {
+ client = 1;
+ server = 2;
+ fallback = 3;
+}
+
+smol StackFrameScope {
+ Eval = 1;
+ Module = 2;
+ Function = 3;
+ Global = 4;
+ Wasm = 5;
+ Constructor = 6;
+}
+
+struct StackFrame {
+ string function_name;
+ string file;
+ StackFramePosition position;
+ StackFrameScope scope;
+}
+
+struct StackFramePosition {
+ int32 source_offset;
+ int32 line;
+ int32 line_start;
+ int32 line_stop;
+ int32 column_start;
+ int32 column_stop;
+ int32 expression_start;
+ int32 expression_stop;
+}
+
+struct SourceLine {
+ int32 line;
+ string text;
+}
+
+struct StackTrace {
+ SourceLine[] source_lines;
+ StackFrame[] frames;
+}
+
+
+message JSException {
+ string name = 1;
+ string message = 2;
+
+ uint16 runtime_type = 3;
+ uint8 code = 4;
+
+ StackTrace stack = 5;
+}
+
+smol FallbackStep {
+ ssr_disabled = 1;
+ create_vm = 2;
+ configure_router = 3;
+ configure_defines = 4;
+ resolve_entry_point = 5;
+ load_entry_point = 6;
+ eval_entry_point = 7;
+ fetch_event_handler = 8;
+}
+
+struct Problems {
+ uint16 code;
+ string name;
+
+ JSException[] exceptions;
+ Log build;
+}
+
+struct Router {
+ StringMap routes;
+ int32 route;
+ StringMap params;
+}
+
+message FallbackMessageContainer {
+ string message = 1;
+ Router router = 2;
+ FallbackStep reason = 3;
+ Problems problems = 4;
+ string cwd = 5;
+}
+
+
+smol ResolveMode {
+ disable = 1;
+ lazy = 2;
+ dev = 3;
+ bundle = 4;
+}
+
+smol Platform {
+ browser = 1;
+ node = 2;
+ bun = 3;
+ bun_macro = 4;
+}
+
+smol CSSInJSBehavior {
+ facade = 1;
+ facade_onimportcss = 2;
+ auto_onimportcss = 3;
+}
+
+smol JSXRuntime {
+ automatic = 1;
+ classic = 2;
+}
+
+struct JSX {
+ string factory;
+ JSXRuntime runtime;
+ string fragment;
+ bool development;
+
+ // Probably react
+ string import_source;
+
+ bool react_fast_refresh;
+}
+
+struct StringPointer {
+ uint32 offset;
+ uint32 length;
+}
+
+struct JavascriptBundledModule {
+ // package-relative path including file extension
+ StringPointer path;
+
+ // Source code
+ StringPointer code;
+
+ // index into JavascriptBundle.packages
+ uint32 package_id;
+
+ // The ESM export is this id ("$" + number.toString(16))
+ uint32 id;
+
+ // This lets us efficiently compare strings ignoring the extension
+ byte path_extname_length;
+}
+
+struct JavascriptBundledPackage {
+ StringPointer name;
+ StringPointer version;
+ uint32 hash;
+
+ uint32 modules_offset;
+ uint32 modules_length;
+}
+
+struct JavascriptBundle {
+ // These are sorted alphabetically so you can do binary search
+ JavascriptBundledModule[] modules;
+ JavascriptBundledPackage[] packages;
+
+ // This is ASCII-encoded so you can send it directly over HTTP
+ byte[] etag;
+
+ uint32 generated_at;
+
+ // generated by hashing all ${name}@${version} in sorted order
+ byte[] app_package_json_dependencies_hash;
+
+ byte[] import_from_name;
+
+ // This is what StringPointer refers to
+ byte[] manifest_string;
+}
+
+message JavascriptBundleContainer {
+ uint32 bundle_format_version = 1;
+
+ // These go first so if we change JavaScriptBundle we can still read these
+ LoadedRouteConfig routes = 3;
+ LoadedFramework framework = 2;
+
+ JavascriptBundle bundle = 4;
+
+ // Don't technically need to store this, but it may be helpful as a sanity check
+ uint32 code_length = 5;
+}
+
+smol ScanDependencyMode {
+ app = 1;
+ all = 2;
+}
+
+smol ModuleImportType {
+ import = 1;
+ require = 2;
+}
+
+struct ModuleImportRecord {
+ ModuleImportType kind;
+ string path;
+
+ bool dynamic;
+}
+
+struct Module {
+ string path;
+ ModuleImportRecord[] imports;
+}
+
+struct StringMap {
+ string[] keys;
+ string[] values;
+}
+
+struct LoaderMap {
+ string[] extensions;
+ Loader[] loaders;
+}
+
+enum DotEnvBehavior {
+ disable = 1;
+ prefix = 2;
+ load_all = 3;
+}
+
+message EnvConfig {
+ string prefix = 1;
+ StringMap defaults = 2;
+}
+
+struct LoadedEnvConfig {
+ DotEnvBehavior dotenv;
+
+ StringMap defaults;
+ string prefix;
+}
+
+message FrameworkConfig {
+ string package = 1;
+ FrameworkEntryPointMessage client = 2;
+ FrameworkEntryPointMessage server = 3;
+ FrameworkEntryPointMessage fallback = 4;
+ bool development = 5;
+
+ CSSInJSBehavior client_css_in_js = 6;
+ string display_name = 7;
+
+ StringMap overrideModules = 8;
+}
+
+struct FrameworkEntryPoint {
+ FrameworkEntryPointType kind;
+ string path;
+ LoadedEnvConfig env;
+}
+
+message FrameworkEntryPointMap {
+ FrameworkEntryPoint client = 1;
+ FrameworkEntryPoint server = 2;
+ FrameworkEntryPoint fallback = 3;
+}
+
+message FrameworkEntryPointMessage {
+ string path = 1;
+ EnvConfig env = 2;
+}
+
+struct LoadedFramework {
+ string package;
+ string display_name;
+ bool development;
+ FrameworkEntryPointMap entry_points;
+ CSSInJSBehavior client_css_in_js;
+ StringMap overrideModules;
+}
+
+struct LoadedRouteConfig {
+ string dir;
+ string[] extensions;
+ string static_dir;
+ string asset_prefix;
+}
+
+message RouteConfig {
+ string[] dir = 1;
+ string[] extensions = 2;
+ string static_dir = 3;
+ string asset_prefix = 4;
+}
+
+message TransformOptions {
+ JSX jsx = 1;
+ string tsconfig_override = 2;
+ ResolveMode resolve = 3;
+
+ string origin = 4;
+ string absolute_working_dir = 5;
+
+ StringMap define = 6;
+
+ bool preserve_symlinks = 7;
+
+ string[] entry_points = 8;
+ bool write = 9;
+
+ string[] inject = 10;
+ string output_dir = 11;
+
+ string[] external = 12;
+
+ LoaderMap loaders = 13;
+
+ string[] main_fields = 14;
+ Platform platform = 15;
+
+ bool serve = 16;
+
+ string[] extension_order = 17;
+
+ bool generate_node_module_bundle = 18;
+
+ string node_modules_bundle_path = 19;
+ string node_modules_bundle_path_server = 20;
+
+ FrameworkConfig framework = 21;
+ RouteConfig router = 22;
+ bool no_summary = 23;
+
+ bool disable_hmr = 24;
+
+ uint16 port = 25;
+ MessageLevel logLevel = 26;
+}
+
+struct FileHandle {
+ string path;
+ uint size;
+ uint fd;
+}
+
+message Transform {
+ FileHandle handle = 1;
+ string path = 2;
+ byte[] contents = 3;
+
+ Loader loader = 4;
+ TransformOptions options = 5;
+}
+
+enum TransformResponseStatus {
+ success = 1;
+ fail = 2;
+}
+
+struct OutputFile {
+ byte[] data;
+ string path;
+}
+
+struct TransformResponse {
+ TransformResponseStatus status;
+ OutputFile[] files;
+ Message[] errors;
+}
+
+enum MessageLevel {
+ err = 1;
+ warn =2;
+ note = 3;
+ info = 4;
+ debug = 5;
+}
+
+struct Location {
+ string file;
+ string namespace;
+ int32 line;
+ int32 column;
+ string line_text;
+ string suggestion;
+ uint offset;
+}
+
+message MessageData {
+ string text = 1;
+ Location location = 2;
+}
+
+
+
+message MessageMeta {
+ string resolve = 1;
+ bool build = 2;
+}
+
+struct Message {
+ MessageLevel level;
+ MessageData data;
+ MessageData[] notes;
+ MessageMeta on;
+}
+
+struct Log {
+ uint32 warnings;
+ uint32 errors;
+ Message[] msgs;
+}
+
+
+smol Reloader {
+ disable = 1;
+ // equivalent of CMD + R
+ live = 2;
+ // React Fast Refresh
+ fast_refresh = 3;
+}
+
+// The WebSocket protocol
+// Server: "hey, this file changed. Does anyone want it?"
+// Browser: *checks array* "uhh yeah, ok. rebuild that for me"
+// Server: "here u go"
+// This makes the client responsible for tracking which files it needs to listen for.
+// From a server perspective, this means the filesystem watching thread can send the same WebSocket message
+// to every client, which is good for performance. It means if you have 5 tabs open it won't really be different than one tab
+// The clients can just ignore files they don't care about
+smol WebsocketMessageKind {
+ welcome = 1;
+ file_change_notification = 2;
+ build_success = 3;
+ build_fail = 4;
+ manifest_success = 5;
+ manifest_fail = 6;
+ resolve_file = 7;
+ file_change_notification_with_hint = 8;
+}
+
+smol WebsocketCommandKind {
+ build = 1;
+ manifest = 2;
+ build_with_file_path = 3;
+}
+
+// Each websocket message has two messages in it!
+// This is the first.
+struct WebsocketMessage {
+ uint32 timestamp;
+ WebsocketMessageKind kind;
+}
+
+// This is the first.
+struct WebsocketMessageWelcome {
+ uint32 epoch;
+ Reloader javascriptReloader;
+ string cwd;
+}
+
+struct WebsocketMessageFileChangeNotification {
+ uint32 id;
+ Loader loader;
+}
+
+struct WebsocketCommand {
+ WebsocketCommandKind kind;
+ uint32 timestamp;
+}
+
+// The timestamp is used for client-side deduping
+struct WebsocketCommandBuild {
+ uint32 id;
+}
+
+struct WebsocketCommandManifest {
+ uint32 id;
+}
+
+// We copy the module_path here incase they don't already have it
+struct WebsocketMessageBuildSuccess {
+ uint32 id;
+ uint32 from_timestamp;
+
+ Loader loader;
+ string module_path;
+
+ // This is the length of the blob that immediately follows this message.
+ uint32 blob_length;
+}
+
+struct WebsocketMessageBuildFailure {
+ uint32 id;
+ uint32 from_timestamp;
+ Loader loader;
+
+ string module_path;
+ Log log;
+}
+
+struct WebsocketCommandBuildWithFilePath {
+ uint32 id;
+ string file_path;
+}
+
+struct WebsocketMessageResolveID {
+ uint32 id;
+}
+
+struct NPMRegistry {
+ string url;
+ string username;
+ string password;
+ string token;
+}
+
+struct NPMRegistryMap {
+ string[] scopes;
+ NPMRegistry[] registries;
+}
+
+message BunInstall {
+ NPMRegistry default_registry = 1;
+ NPMRegistryMap scoped = 2;
+ string lockfile_path = 3;
+ string save_lockfile_path = 4;
+ string cache_directory = 5;
+ bool dry_run = 6;
+ bool force = 7;
+ bool save_dev = 8;
+ bool save_optional = 9;
+ bool save_peer = 10;
+ bool save_lockfile = 11;
+ bool production = 12;
+ bool save_yarn_lockfile = 13;
+ string[] native_bin_links = 14;
+
+ bool disable_cache = 15;
+ bool disable_manifest_cache = 16;
+ string global_dir = 17;
+ string global_bin_dir = 18;
+} \ No newline at end of file
diff --git a/src/api/demo/schema.zig b/src/api/demo/schema.zig
new file mode 100644
index 000000000..61d6b82d1
--- /dev/null
+++ b/src/api/demo/schema.zig
@@ -0,0 +1,2878 @@
+const std = @import("std");
+
+pub const Reader = struct {
+ const Self = @This();
+ pub const ReadError = error{EOF};
+
+ buf: []u8,
+ remain: []u8,
+ allocator: std.mem.Allocator,
+
+ pub fn init(buf: []u8, allocator: std.mem.Allocator) Reader {
+ return Reader{
+ .buf = buf,
+ .remain = buf,
+ .allocator = allocator,
+ };
+ }
+
+ pub fn read(this: *Self, count: usize) ![]u8 {
+ const read_count = @minimum(count, this.remain.len);
+ if (read_count < count) {
+ return error.EOF;
+ }
+
+ var slice = this.remain[0..read_count];
+
+ this.remain = this.remain[read_count..];
+
+ return slice;
+ }
+
+ pub inline fn readAs(this: *Self, comptime T: type) !T {
+ if (!std.meta.trait.hasUniqueRepresentation(T)) {
+ @compileError(@typeName(T) ++ " must have unique representation.");
+ }
+
+ return std.mem.bytesAsValue(T, try this.read(@sizeOf(T)));
+ }
+
+ pub inline fn readByte(this: *Self) !u8 {
+ return (try this.read(1))[0];
+ }
+
+ pub fn readEnum(this: *Self, comptime Enum: type) !Enum {
+ const E = error{
+ /// An integer was read, but it did not match any of the tags in the supplied enum.
+ InvalidValue,
+ };
+ const type_info = @typeInfo(Enum).Enum;
+ const tag = try this.readInt(type_info.tag_type);
+
+ inline for (std.meta.fields(Enum)) |field| {
+ if (tag == field.value) {
+ return @field(Enum, field.name);
+ }
+ }
+
+ return E.InvalidValue;
+ }
+
+ pub inline fn readArray(this: *Self, comptime T: type) ![]const T {
+ const length = try this.readInt(u32);
+ if (length == 0) {
+ return &([_]T{});
+ }
+
+ switch (comptime T) {
+ u8 => {
+ return try this.read(length);
+ },
+ u16, u32, i8, i16, i32 => {
+ return std.mem.readIntSliceNative(T, this.read(length * @sizeOf(T)));
+ },
+ [:0]const u8, []const u8 => {
+ var i: u32 = 0;
+ var array = try this.allocator.alloc(T, length);
+ while (i < length) : (i += 1) {
+ array[i] = try this.readArray(u8);
+ }
+ return array;
+ },
+ else => {
+ switch (comptime @typeInfo(T)) {
+ .Struct => |Struct| {
+ switch (Struct.layout) {
+ .Packed => {
+ const sizeof = @sizeOf(T);
+ var slice = try this.read(sizeof * length);
+ return std.mem.bytesAsSlice(T, slice);
+ },
+ else => {},
+ }
+ },
+ .Enum => |type_info| {
+ const enum_values = try this.read(length * @sizeOf(type_info.tag_type));
+ return @ptrCast([*]T, enum_values.ptr)[0..length];
+ },
+ else => {},
+ }
+
+ var i: u32 = 0;
+ var array = try this.allocator.alloc(T, length);
+ while (i < length) : (i += 1) {
+ array[i] = try this.readValue(T);
+ }
+
+ return array;
+ },
+ }
+ }
+
+ pub inline fn readByteArray(this: *Self) ![]u8 {
+ const length = try this.readInt(u32);
+ if (length == 0) {
+ return &([_]u8{});
+ }
+
+ return try this.read(@as(usize, length));
+ }
+
+ pub inline fn readInt(this: *Self, comptime T: type) !T {
+ var slice = try this.read(@sizeOf(T));
+
+ return std.mem.readIntSliceNative(T, slice);
+ }
+
+ pub inline fn readBool(this: *Self) !bool {
+ return (try this.readByte()) > 0;
+ }
+
+ pub inline fn readValue(this: *Self, comptime T: type) !T {
+ switch (comptime T) {
+ bool => {
+ return try this.readBool();
+ },
+ u8 => {
+ return try this.readByte();
+ },
+ [*:0]const u8, [:0]const u8, []const u8 => {
+ return try this.readArray(u8);
+ },
+
+ []const [:0]const u8, []const [*:0]const u8, []const []const u8 => {
+ return try this.readArray([]const u8);
+ },
+ []u8, [:0]u8, [*:0]u8 => {
+ return try this.readArray([]u8);
+ },
+ u16, u32, i8, i16, i32 => {
+ return std.mem.readIntSliceNative(T, try this.read(@sizeOf(T)));
+ },
+ else => {
+ switch (comptime @typeInfo(T)) {
+ .Struct => |Struct| {
+ switch (Struct.layout) {
+ .Packed => {
+ const sizeof = @sizeOf(T);
+ var slice = try this.read(sizeof);
+ return @ptrCast(*T, slice[0..sizeof]).*;
+ },
+ else => {},
+ }
+ },
+ .Enum => {
+ return try this.readEnum(T);
+ },
+ else => {},
+ }
+
+ return try T.decode(this);
+ },
+ }
+
+ @compileError("Invalid type passed to readValue");
+ }
+};
+
+pub fn Writer(comptime WritableStream: type) type {
+ return struct {
+ const Self = @This();
+ writable: WritableStream,
+
+ pub fn init(writable: WritableStream) Self {
+ return Self{ .writable = writable };
+ }
+
+ pub inline fn write(this: *Self, bytes: anytype) !void {
+ _ = try this.writable.write(bytes);
+ }
+
+ pub inline fn writeByte(this: *Self, byte: u8) !void {
+ _ = try this.writable.write(&[1]u8{byte});
+ }
+
+ pub inline fn writeInt(this: *Self, int: anytype) !void {
+ try this.write(std.mem.asBytes(&int));
+ }
+
+ pub inline fn writeFieldID(this: *Self, comptime id: comptime_int) !void {
+ try this.writeByte(id);
+ }
+
+ pub inline fn writeEnum(this: *Self, val: anytype) !void {
+ try this.writeInt(@enumToInt(val));
+ }
+
+ pub fn writeValue(this: *Self, comptime SliceType: type, slice: SliceType) !void {
+ switch (SliceType) {
+ []u16,
+ []u32,
+ []i16,
+ []i32,
+ []i8,
+ []const u16,
+ []const u32,
+ []const i16,
+ []const i32,
+ []const i8,
+ [:0]u16,
+ [:0]u32,
+ [:0]i16,
+ [:0]i32,
+ [:0]i8,
+ [:0]const u16,
+ [:0]const u32,
+ [:0]const i16,
+ [:0]const i32,
+ [:0]const i8,
+ [*:0]u16,
+ [*:0]u32,
+ [*:0]i16,
+ [*:0]i32,
+ [*:0]i8,
+ [*:0]const u16,
+ [*:0]const u32,
+ [*:0]const i16,
+ [*:0]const i32,
+ [*:0]const i8,
+ => {
+ try this.writeArray(SliceType, slice);
+ },
+
+ []u8,
+ []const u8,
+ [:0]u8,
+ [:0]const u8,
+ [*:0]u8,
+ [*:0]const u8,
+ => {
+ try this.writeArray(u8, slice);
+ },
+
+ u8 => {
+ try this.write(slice);
+ },
+ u16, u32, i16, i32, i8 => {
+ try this.write(std.mem.asBytes(slice));
+ },
+
+ else => {
+ try slice.encode(this);
+ },
+ }
+ }
+
+ pub inline fn writeArray(this: *Self, comptime T: type, slice: anytype) !void {
+ try this.writeInt(@truncate(u32, slice.len));
+
+ switch (T) {
+ u8 => {
+ try this.write(slice);
+ },
+ u16, u32, i16, i32, i8 => {
+ try this.write(std.mem.asBytes(slice));
+ },
+ [:0]u8,
+ []u8,
+ []u16,
+ []u32,
+ []i16,
+ []i32,
+ []i8,
+ []const u8,
+ [:0]const u8,
+ []const u16,
+ []const u32,
+ []const i16,
+ []const i32,
+ []const i8,
+ [:0]u16,
+ [:0]u32,
+ [:0]i16,
+ [:0]i32,
+ [:0]i8,
+ [:0]const u16,
+ [:0]const u32,
+ [:0]const i16,
+ [:0]const i32,
+ [:0]const i8,
+ [*:0]u16,
+ [*:0]u32,
+ [*:0]i16,
+ [*:0]i32,
+ [*:0]i8,
+ [*:0]const u16,
+ [*:0]const u32,
+ [*:0]const i16,
+ [*:0]const i32,
+ [*:0]const i8,
+ => {
+ for (slice) |num_slice| {
+ try this.writeArray(std.meta.Child(@TypeOf(num_slice)), num_slice);
+ }
+ },
+ else => {
+ for (slice) |val| {
+ try val.encode(this);
+ }
+ },
+ }
+ }
+
+ pub inline fn endMessage(this: *Self) !void {
+ try this.writeByte(0);
+ }
+ };
+}
+
+pub const ByteWriter = Writer(*std.io.FixedBufferStream([]u8));
+pub const FileWriter = Writer(std.fs.File);
+
+pub const Api = struct {
+ pub const Loader = enum(u8) {
+ _none,
+ /// jsx
+ jsx,
+
+ /// js
+ js,
+
+ /// ts
+ ts,
+
+ /// tsx
+ tsx,
+
+ /// css
+ css,
+
+ /// file
+ file,
+
+ /// json
+ json,
+
+ /// toml
+ toml,
+
+ /// wasm
+ wasm,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const FrameworkEntryPointType = enum(u8) {
+ _none,
+ /// client
+ client,
+
+ /// server
+ server,
+
+ /// fallback
+ fallback,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const StackFrameScope = enum(u8) {
+ _none,
+ /// Eval
+ eval,
+
+ /// Module
+ module,
+
+ /// Function
+ function,
+
+ /// Global
+ global,
+
+ /// Wasm
+ wasm,
+
+ /// Constructor
+ constructor,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const StackFrame = struct {
+ /// function_name
+ function_name: []const u8,
+
+ /// file
+ file: []const u8,
+
+ /// position
+ position: StackFramePosition,
+
+ /// scope
+ scope: StackFrameScope,
+
+ pub fn decode(reader: anytype) anyerror!StackFrame {
+ var this = std.mem.zeroes(StackFrame);
+
+ this.function_name = try reader.readValue([]const u8);
+ this.file = try reader.readValue([]const u8);
+ this.position = try reader.readValue(StackFramePosition);
+ this.scope = try reader.readValue(StackFrameScope);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.function_name), this.function_name);
+ try writer.writeValue(@TypeOf(this.file), this.file);
+ try writer.writeValue(@TypeOf(this.position), this.position);
+ try writer.writeEnum(this.scope);
+ }
+ };
+
+ pub const StackFramePosition = packed struct {
+ /// source_offset
+ source_offset: i32 = 0,
+
+ /// line
+ line: i32 = 0,
+
+ /// line_start
+ line_start: i32 = 0,
+
+ /// line_stop
+ line_stop: i32 = 0,
+
+ /// column_start
+ column_start: i32 = 0,
+
+ /// column_stop
+ column_stop: i32 = 0,
+
+ /// expression_start
+ expression_start: i32 = 0,
+
+ /// expression_stop
+ expression_stop: i32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!StackFramePosition {
+ var this = std.mem.zeroes(StackFramePosition);
+
+ this.source_offset = try reader.readValue(i32);
+ this.line = try reader.readValue(i32);
+ this.line_start = try reader.readValue(i32);
+ this.line_stop = try reader.readValue(i32);
+ this.column_start = try reader.readValue(i32);
+ this.column_stop = try reader.readValue(i32);
+ this.expression_start = try reader.readValue(i32);
+ this.expression_stop = try reader.readValue(i32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.source_offset);
+ try writer.writeInt(this.line);
+ try writer.writeInt(this.line_start);
+ try writer.writeInt(this.line_stop);
+ try writer.writeInt(this.column_start);
+ try writer.writeInt(this.column_stop);
+ try writer.writeInt(this.expression_start);
+ try writer.writeInt(this.expression_stop);
+ }
+ };
+
+ pub const SourceLine = struct {
+ /// line
+ line: i32 = 0,
+
+ /// text
+ text: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!SourceLine {
+ var this = std.mem.zeroes(SourceLine);
+
+ this.line = try reader.readValue(i32);
+ this.text = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.line);
+ try writer.writeValue(@TypeOf(this.text), this.text);
+ }
+ };
+
+ pub const StackTrace = struct {
+ /// source_lines
+ source_lines: []const SourceLine,
+
+ /// frames
+ frames: []const StackFrame,
+
+ pub fn decode(reader: anytype) anyerror!StackTrace {
+ var this = std.mem.zeroes(StackTrace);
+
+ this.source_lines = try reader.readArray(SourceLine);
+ this.frames = try reader.readArray(StackFrame);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray(SourceLine, this.source_lines);
+ try writer.writeArray(StackFrame, this.frames);
+ }
+ };
+
+ pub const JsException = struct {
+ /// name
+ name: ?[]const u8 = null,
+
+ /// message
+ message: ?[]const u8 = null,
+
+ /// runtime_type
+ runtime_type: ?u16 = null,
+
+ /// code
+ code: ?u8 = null,
+
+ /// stack
+ stack: ?StackTrace = null,
+
+ pub fn decode(reader: anytype) anyerror!JsException {
+ var this = std.mem.zeroes(JsException);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.name = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.message = try reader.readValue([]const u8);
+ },
+ 3 => {
+ this.runtime_type = try reader.readValue(u16);
+ },
+ 4 => {
+ this.code = try reader.readValue(u8);
+ },
+ 5 => {
+ this.stack = try reader.readValue(StackTrace);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.name) |name| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(name), name);
+ }
+ if (this.message) |message| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(message), message);
+ }
+ if (this.runtime_type) |runtime_type| {
+ try writer.writeFieldID(3);
+ try writer.writeInt(runtime_type);
+ }
+ if (this.code) |code| {
+ try writer.writeFieldID(4);
+ try writer.writeInt(code);
+ }
+ if (this.stack) |stack| {
+ try writer.writeFieldID(5);
+ try writer.writeValue(@TypeOf(stack), stack);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const FallbackStep = enum(u8) {
+ _none,
+ /// ssr_disabled
+ ssr_disabled,
+
+ /// create_vm
+ create_vm,
+
+ /// configure_router
+ configure_router,
+
+ /// configure_defines
+ configure_defines,
+
+ /// resolve_entry_point
+ resolve_entry_point,
+
+ /// load_entry_point
+ load_entry_point,
+
+ /// eval_entry_point
+ eval_entry_point,
+
+ /// fetch_event_handler
+ fetch_event_handler,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const Problems = struct {
+ /// code
+ code: u16 = 0,
+
+ /// name
+ name: []const u8,
+
+ /// exceptions
+ exceptions: []const JsException,
+
+ /// build
+ build: Log,
+
+ pub fn decode(reader: anytype) anyerror!Problems {
+ var this = std.mem.zeroes(Problems);
+
+ this.code = try reader.readValue(u16);
+ this.name = try reader.readValue([]const u8);
+ this.exceptions = try reader.readArray(JsException);
+ this.build = try reader.readValue(Log);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.code);
+ try writer.writeValue(@TypeOf(this.name), this.name);
+ try writer.writeArray(JsException, this.exceptions);
+ try writer.writeValue(@TypeOf(this.build), this.build);
+ }
+ };
+
+ pub const Router = struct {
+ /// routes
+ routes: StringMap,
+
+ /// route
+ route: i32 = 0,
+
+ /// params
+ params: StringMap,
+
+ pub fn decode(reader: anytype) anyerror!Router {
+ var this = std.mem.zeroes(Router);
+
+ this.routes = try reader.readValue(StringMap);
+ this.route = try reader.readValue(i32);
+ this.params = try reader.readValue(StringMap);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.routes), this.routes);
+ try writer.writeInt(this.route);
+ try writer.writeValue(@TypeOf(this.params), this.params);
+ }
+ };
+
+ pub const FallbackMessageContainer = struct {
+ /// message
+ message: ?[]const u8 = null,
+
+ /// router
+ router: ?Router = null,
+
+ /// reason
+ reason: ?FallbackStep = null,
+
+ /// problems
+ problems: ?Problems = null,
+
+ /// cwd
+ cwd: ?[]const u8 = null,
+
+ pub fn decode(reader: anytype) anyerror!FallbackMessageContainer {
+ var this = std.mem.zeroes(FallbackMessageContainer);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.message = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.router = try reader.readValue(Router);
+ },
+ 3 => {
+ this.reason = try reader.readValue(FallbackStep);
+ },
+ 4 => {
+ this.problems = try reader.readValue(Problems);
+ },
+ 5 => {
+ this.cwd = try reader.readValue([]const u8);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.message) |message| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(message), message);
+ }
+ if (this.router) |router| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(router), router);
+ }
+ if (this.reason) |reason| {
+ try writer.writeFieldID(3);
+ try writer.writeEnum(reason);
+ }
+ if (this.problems) |problems| {
+ try writer.writeFieldID(4);
+ try writer.writeValue(@TypeOf(problems), problems);
+ }
+ if (this.cwd) |cwd| {
+ try writer.writeFieldID(5);
+ try writer.writeValue(@TypeOf(cwd), cwd);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const ResolveMode = enum(u8) {
+ _none,
+ /// disable
+ disable,
+
+ /// lazy
+ lazy,
+
+ /// dev
+ dev,
+
+ /// bundle
+ bundle,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const Platform = enum(u8) {
+ _none,
+ /// browser
+ browser,
+
+ /// node
+ node,
+
+ /// bun
+ bun,
+
+ /// bun_macro
+ bun_macro,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const CssInJsBehavior = enum(u8) {
+ _none,
+ /// facade
+ facade,
+
+ /// facade_onimportcss
+ facade_onimportcss,
+
+ /// auto_onimportcss
+ auto_onimportcss,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const JsxRuntime = enum(u8) {
+ _none,
+ /// automatic
+ automatic,
+
+ /// classic
+ classic,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const Jsx = struct {
+ /// factory
+ factory: []const u8,
+
+ /// runtime
+ runtime: JsxRuntime,
+
+ /// fragment
+ fragment: []const u8,
+
+ /// development
+ development: bool = false,
+
+ /// import_source
+ import_source: []const u8,
+
+ /// react_fast_refresh
+ react_fast_refresh: bool = false,
+
+ pub fn decode(reader: anytype) anyerror!Jsx {
+ var this = std.mem.zeroes(Jsx);
+
+ this.factory = try reader.readValue([]const u8);
+ this.runtime = try reader.readValue(JsxRuntime);
+ this.fragment = try reader.readValue([]const u8);
+ this.development = try reader.readValue(bool);
+ this.import_source = try reader.readValue([]const u8);
+ this.react_fast_refresh = try reader.readValue(bool);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.factory), this.factory);
+ try writer.writeEnum(this.runtime);
+ try writer.writeValue(@TypeOf(this.fragment), this.fragment);
+ try writer.writeInt(@as(u8, @boolToInt(this.development)));
+ try writer.writeValue(@TypeOf(this.import_source), this.import_source);
+ try writer.writeInt(@as(u8, @boolToInt(this.react_fast_refresh)));
+ }
+ };
+
+ pub const StringPointer = packed struct {
+ /// offset
+ offset: u32 = 0,
+
+ /// length
+ length: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!StringPointer {
+ var this = std.mem.zeroes(StringPointer);
+
+ this.offset = try reader.readValue(u32);
+ this.length = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.offset);
+ try writer.writeInt(this.length);
+ }
+ };
+
+ pub const JavascriptBundledModule = struct {
+ /// path
+ path: StringPointer,
+
+ /// code
+ code: StringPointer,
+
+ /// package_id
+ package_id: u32 = 0,
+
+ /// id
+ id: u32 = 0,
+
+ /// path_extname_length
+ path_extname_length: u8 = 0,
+
+ pub fn decode(reader: anytype) anyerror!JavascriptBundledModule {
+ var this = std.mem.zeroes(JavascriptBundledModule);
+
+ this.path = try reader.readValue(StringPointer);
+ this.code = try reader.readValue(StringPointer);
+ this.package_id = try reader.readValue(u32);
+ this.id = try reader.readValue(u32);
+ this.path_extname_length = try reader.readValue(u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ try writer.writeValue(@TypeOf(this.code), this.code);
+ try writer.writeInt(this.package_id);
+ try writer.writeInt(this.id);
+ try writer.writeInt(this.path_extname_length);
+ }
+ };
+
+ pub const JavascriptBundledPackage = struct {
+ /// name
+ name: StringPointer,
+
+ /// version
+ version: StringPointer,
+
+ /// hash
+ hash: u32 = 0,
+
+ /// modules_offset
+ modules_offset: u32 = 0,
+
+ /// modules_length
+ modules_length: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!JavascriptBundledPackage {
+ var this = std.mem.zeroes(JavascriptBundledPackage);
+
+ this.name = try reader.readValue(StringPointer);
+ this.version = try reader.readValue(StringPointer);
+ this.hash = try reader.readValue(u32);
+ this.modules_offset = try reader.readValue(u32);
+ this.modules_length = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.name), this.name);
+ try writer.writeValue(@TypeOf(this.version), this.version);
+ try writer.writeInt(this.hash);
+ try writer.writeInt(this.modules_offset);
+ try writer.writeInt(this.modules_length);
+ }
+ };
+
+ pub const JavascriptBundle = struct {
+ /// modules
+ modules: []const JavascriptBundledModule,
+
+ /// packages
+ packages: []const JavascriptBundledPackage,
+
+ /// etag
+ etag: []const u8,
+
+ /// generated_at
+ generated_at: u32 = 0,
+
+ /// app_package_json_dependencies_hash
+ app_package_json_dependencies_hash: []const u8,
+
+ /// import_from_name
+ import_from_name: []const u8,
+
+ /// manifest_string
+ manifest_string: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!JavascriptBundle {
+ var this = std.mem.zeroes(JavascriptBundle);
+
+ this.modules = try reader.readArray(JavascriptBundledModule);
+ this.packages = try reader.readArray(JavascriptBundledPackage);
+ this.etag = try reader.readArray(u8);
+ this.generated_at = try reader.readValue(u32);
+ this.app_package_json_dependencies_hash = try reader.readArray(u8);
+ this.import_from_name = try reader.readArray(u8);
+ this.manifest_string = try reader.readArray(u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray(JavascriptBundledModule, this.modules);
+ try writer.writeArray(JavascriptBundledPackage, this.packages);
+ try writer.writeArray(u8, this.etag);
+ try writer.writeInt(this.generated_at);
+ try writer.writeArray(u8, this.app_package_json_dependencies_hash);
+ try writer.writeArray(u8, this.import_from_name);
+ try writer.writeArray(u8, this.manifest_string);
+ }
+ };
+
+ pub const JavascriptBundleContainer = struct {
+ /// bundle_format_version
+ bundle_format_version: ?u32 = null,
+
+ /// routes
+ routes: ?LoadedRouteConfig = null,
+
+ /// framework
+ framework: ?LoadedFramework = null,
+
+ /// bundle
+ bundle: ?JavascriptBundle = null,
+
+ /// code_length
+ code_length: ?u32 = null,
+
+ pub fn decode(reader: anytype) anyerror!JavascriptBundleContainer {
+ var this = std.mem.zeroes(JavascriptBundleContainer);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.bundle_format_version = try reader.readValue(u32);
+ },
+ 2 => {
+ this.routes = try reader.readValue(LoadedRouteConfig);
+ },
+ 3 => {
+ this.framework = try reader.readValue(LoadedFramework);
+ },
+ 4 => {
+ this.bundle = try reader.readValue(JavascriptBundle);
+ },
+ 5 => {
+ this.code_length = try reader.readValue(u32);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.bundle_format_version) |bundle_format_version| {
+ try writer.writeFieldID(1);
+ try writer.writeInt(bundle_format_version);
+ }
+ if (this.routes) |routes| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(routes), routes);
+ }
+ if (this.framework) |framework| {
+ try writer.writeFieldID(3);
+ try writer.writeValue(@TypeOf(framework), framework);
+ }
+ if (this.bundle) |bundle| {
+ try writer.writeFieldID(4);
+ try writer.writeValue(@TypeOf(bundle), bundle);
+ }
+ if (this.code_length) |code_length| {
+ try writer.writeFieldID(5);
+ try writer.writeInt(code_length);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const ScanDependencyMode = enum(u8) {
+ _none,
+ /// app
+ app,
+
+ /// all
+ all,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const ModuleImportType = enum(u8) {
+ _none,
+ /// import
+ import,
+
+ /// require
+ require,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const ModuleImportRecord = struct {
+ /// kind
+ kind: ModuleImportType,
+
+ /// path
+ path: []const u8,
+
+ /// dynamic
+ dynamic: bool = false,
+
+ pub fn decode(reader: anytype) anyerror!ModuleImportRecord {
+ var this = std.mem.zeroes(ModuleImportRecord);
+
+ this.kind = try reader.readValue(ModuleImportType);
+ this.path = try reader.readValue([]const u8);
+ this.dynamic = try reader.readValue(bool);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeEnum(this.kind);
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ try writer.writeInt(@as(u8, @boolToInt(this.dynamic)));
+ }
+ };
+
+ pub const Module = struct {
+ /// path
+ path: []const u8,
+
+ /// imports
+ imports: []const ModuleImportRecord,
+
+ pub fn decode(reader: anytype) anyerror!Module {
+ var this = std.mem.zeroes(Module);
+
+ this.path = try reader.readValue([]const u8);
+ this.imports = try reader.readArray(ModuleImportRecord);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ try writer.writeArray(ModuleImportRecord, this.imports);
+ }
+ };
+
+ pub const StringMap = struct {
+ /// keys
+ keys: []const []const u8,
+
+ /// values
+ values: []const []const u8,
+
+ pub fn decode(reader: anytype) anyerror!StringMap {
+ var this = std.mem.zeroes(StringMap);
+
+ this.keys = try reader.readArray([]const u8);
+ this.values = try reader.readArray([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray([]const u8, this.keys);
+ try writer.writeArray([]const u8, this.values);
+ }
+ };
+
+ pub const LoaderMap = struct {
+ /// extensions
+ extensions: []const []const u8,
+
+ /// loaders
+ loaders: []const Loader,
+
+ pub fn decode(reader: anytype) anyerror!LoaderMap {
+ var this = std.mem.zeroes(LoaderMap);
+
+ this.extensions = try reader.readArray([]const u8);
+ this.loaders = try reader.readArray(Loader);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray([]const u8, this.extensions);
+ try writer.writeArray(Loader, this.loaders);
+ }
+ };
+
+ pub const DotEnvBehavior = enum(u32) {
+ _none,
+ /// disable
+ disable,
+
+ /// prefix
+ prefix,
+
+ /// load_all
+ load_all,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const EnvConfig = struct {
+ /// prefix
+ prefix: ?[]const u8 = null,
+
+ /// defaults
+ defaults: ?StringMap = null,
+
+ pub fn decode(reader: anytype) anyerror!EnvConfig {
+ var this = std.mem.zeroes(EnvConfig);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.prefix = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.defaults = try reader.readValue(StringMap);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.prefix) |prefix| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(prefix), prefix);
+ }
+ if (this.defaults) |defaults| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(defaults), defaults);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const LoadedEnvConfig = struct {
+ /// dotenv
+ dotenv: DotEnvBehavior,
+
+ /// defaults
+ defaults: StringMap,
+
+ /// prefix
+ prefix: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!LoadedEnvConfig {
+ var this = std.mem.zeroes(LoadedEnvConfig);
+
+ this.dotenv = try reader.readValue(DotEnvBehavior);
+ this.defaults = try reader.readValue(StringMap);
+ this.prefix = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeEnum(this.dotenv);
+ try writer.writeValue(@TypeOf(this.defaults), this.defaults);
+ try writer.writeValue(@TypeOf(this.prefix), this.prefix);
+ }
+ };
+
+ pub const FrameworkConfig = struct {
+ /// package
+ package: ?[]const u8 = null,
+
+ /// client
+ client: ?FrameworkEntryPointMessage = null,
+
+ /// server
+ server: ?FrameworkEntryPointMessage = null,
+
+ /// fallback
+ fallback: ?FrameworkEntryPointMessage = null,
+
+ /// development
+ development: ?bool = null,
+
+ /// client_css_in_js
+ client_css_in_js: ?CssInJsBehavior = null,
+
+ /// display_name
+ display_name: ?[]const u8 = null,
+
+ /// overrideModules
+ override_modules: ?StringMap = null,
+
+ pub fn decode(reader: anytype) anyerror!FrameworkConfig {
+ var this = std.mem.zeroes(FrameworkConfig);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.package = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.client = try reader.readValue(FrameworkEntryPointMessage);
+ },
+ 3 => {
+ this.server = try reader.readValue(FrameworkEntryPointMessage);
+ },
+ 4 => {
+ this.fallback = try reader.readValue(FrameworkEntryPointMessage);
+ },
+ 5 => {
+ this.development = try reader.readValue(bool);
+ },
+ 6 => {
+ this.client_css_in_js = try reader.readValue(CssInJsBehavior);
+ },
+ 7 => {
+ this.display_name = try reader.readValue([]const u8);
+ },
+ 8 => {
+ this.override_modules = try reader.readValue(StringMap);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.package) |package| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(package), package);
+ }
+ if (this.client) |client| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(client), client);
+ }
+ if (this.server) |server| {
+ try writer.writeFieldID(3);
+ try writer.writeValue(@TypeOf(server), server);
+ }
+ if (this.fallback) |fallback| {
+ try writer.writeFieldID(4);
+ try writer.writeValue(@TypeOf(fallback), fallback);
+ }
+ if (this.development) |development| {
+ try writer.writeFieldID(5);
+ try writer.writeInt(@as(u8, @boolToInt(development)));
+ }
+ if (this.client_css_in_js) |client_css_in_js| {
+ try writer.writeFieldID(6);
+ try writer.writeEnum(client_css_in_js);
+ }
+ if (this.display_name) |display_name| {
+ try writer.writeFieldID(7);
+ try writer.writeValue(@TypeOf(display_name), display_name);
+ }
+ if (this.override_modules) |override_modules| {
+ try writer.writeFieldID(8);
+ try writer.writeValue(@TypeOf(override_modules), override_modules);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const FrameworkEntryPoint = struct {
+ /// kind
+ kind: FrameworkEntryPointType,
+
+ /// path
+ path: []const u8,
+
+ /// env
+ env: LoadedEnvConfig,
+
+ pub fn decode(reader: anytype) anyerror!FrameworkEntryPoint {
+ var this = std.mem.zeroes(FrameworkEntryPoint);
+
+ this.kind = try reader.readValue(FrameworkEntryPointType);
+ this.path = try reader.readValue([]const u8);
+ this.env = try reader.readValue(LoadedEnvConfig);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeEnum(this.kind);
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ try writer.writeValue(@TypeOf(this.env), this.env);
+ }
+ };
+
+ pub const FrameworkEntryPointMap = struct {
+ /// client
+ client: ?FrameworkEntryPoint = null,
+
+ /// server
+ server: ?FrameworkEntryPoint = null,
+
+ /// fallback
+ fallback: ?FrameworkEntryPoint = null,
+
+ pub fn decode(reader: anytype) anyerror!FrameworkEntryPointMap {
+ var this = std.mem.zeroes(FrameworkEntryPointMap);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.client = try reader.readValue(FrameworkEntryPoint);
+ },
+ 2 => {
+ this.server = try reader.readValue(FrameworkEntryPoint);
+ },
+ 3 => {
+ this.fallback = try reader.readValue(FrameworkEntryPoint);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.client) |client| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(client), client);
+ }
+ if (this.server) |server| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(server), server);
+ }
+ if (this.fallback) |fallback| {
+ try writer.writeFieldID(3);
+ try writer.writeValue(@TypeOf(fallback), fallback);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const FrameworkEntryPointMessage = struct {
+ /// path
+ path: ?[]const u8 = null,
+
+ /// env
+ env: ?EnvConfig = null,
+
+ pub fn decode(reader: anytype) anyerror!FrameworkEntryPointMessage {
+ var this = std.mem.zeroes(FrameworkEntryPointMessage);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.path = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.env = try reader.readValue(EnvConfig);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.path) |path| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(path), path);
+ }
+ if (this.env) |env| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(env), env);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const LoadedFramework = struct {
+ /// package
+ package: []const u8,
+
+ /// display_name
+ display_name: []const u8,
+
+ /// development
+ development: bool = false,
+
+ /// entry_points
+ entry_points: FrameworkEntryPointMap,
+
+ /// client_css_in_js
+ client_css_in_js: CssInJsBehavior,
+
+ /// overrideModules
+ override_modules: StringMap,
+
+ pub fn decode(reader: anytype) anyerror!LoadedFramework {
+ var this = std.mem.zeroes(LoadedFramework);
+
+ this.package = try reader.readValue([]const u8);
+ this.display_name = try reader.readValue([]const u8);
+ this.development = try reader.readValue(bool);
+ this.entry_points = try reader.readValue(FrameworkEntryPointMap);
+ this.client_css_in_js = try reader.readValue(CssInJsBehavior);
+ this.override_modules = try reader.readValue(StringMap);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.package), this.package);
+ try writer.writeValue(@TypeOf(this.display_name), this.display_name);
+ try writer.writeInt(@as(u8, @boolToInt(this.development)));
+ try writer.writeValue(@TypeOf(this.entry_points), this.entry_points);
+ try writer.writeEnum(this.client_css_in_js);
+ try writer.writeValue(@TypeOf(this.override_modules), this.override_modules);
+ }
+ };
+
+ pub const LoadedRouteConfig = struct {
+ /// dir
+ dir: []const u8,
+
+ /// extensions
+ extensions: []const []const u8,
+
+ /// static_dir
+ static_dir: []const u8,
+
+ /// asset_prefix
+ asset_prefix: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!LoadedRouteConfig {
+ var this = std.mem.zeroes(LoadedRouteConfig);
+
+ this.dir = try reader.readValue([]const u8);
+ this.extensions = try reader.readArray([]const u8);
+ this.static_dir = try reader.readValue([]const u8);
+ this.asset_prefix = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.dir), this.dir);
+ try writer.writeArray([]const u8, this.extensions);
+ try writer.writeValue(@TypeOf(this.static_dir), this.static_dir);
+ try writer.writeValue(@TypeOf(this.asset_prefix), this.asset_prefix);
+ }
+ };
+
+ pub const RouteConfig = struct {
+ /// dir
+ dir: []const []const u8,
+
+ /// extensions
+ extensions: []const []const u8,
+
+ /// static_dir
+ static_dir: ?[]const u8 = null,
+
+ /// asset_prefix
+ asset_prefix: ?[]const u8 = null,
+
+ pub fn decode(reader: anytype) anyerror!RouteConfig {
+ var this = std.mem.zeroes(RouteConfig);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.dir = try reader.readArray([]const u8);
+ },
+ 2 => {
+ this.extensions = try reader.readArray([]const u8);
+ },
+ 3 => {
+ this.static_dir = try reader.readValue([]const u8);
+ },
+ 4 => {
+ this.asset_prefix = try reader.readValue([]const u8);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.dir) |dir| {
+ try writer.writeFieldID(1);
+ try writer.writeArray([]const u8, dir);
+ }
+ if (this.extensions) |extensions| {
+ try writer.writeFieldID(2);
+ try writer.writeArray([]const u8, extensions);
+ }
+ if (this.static_dir) |static_dir| {
+ try writer.writeFieldID(3);
+ try writer.writeValue(@TypeOf(static_dir), static_dir);
+ }
+ if (this.asset_prefix) |asset_prefix| {
+ try writer.writeFieldID(4);
+ try writer.writeValue(@TypeOf(asset_prefix), asset_prefix);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const TransformOptions = struct {
+ /// jsx
+ jsx: ?Jsx = null,
+
+ /// tsconfig_override
+ tsconfig_override: ?[]const u8 = null,
+
+ /// resolve
+ resolve: ?ResolveMode = null,
+
+ /// origin
+ origin: ?[]const u8 = null,
+
+ /// absolute_working_dir
+ absolute_working_dir: ?[]const u8 = null,
+
+ /// define
+ define: ?StringMap = null,
+
+ /// preserve_symlinks
+ preserve_symlinks: ?bool = null,
+
+ /// entry_points
+ entry_points: []const []const u8,
+
+ /// write
+ write: ?bool = null,
+
+ /// inject
+ inject: []const []const u8,
+
+ /// output_dir
+ output_dir: ?[]const u8 = null,
+
+ /// external
+ external: []const []const u8,
+
+ /// loaders
+ loaders: ?LoaderMap = null,
+
+ /// main_fields
+ main_fields: []const []const u8,
+
+ /// platform
+ platform: ?Platform = null,
+
+ /// serve
+ serve: ?bool = null,
+
+ /// extension_order
+ extension_order: []const []const u8,
+
+ /// generate_node_module_bundle
+ generate_node_module_bundle: ?bool = null,
+
+ /// node_modules_bundle_path
+ node_modules_bundle_path: ?[]const u8 = null,
+
+ /// node_modules_bundle_path_server
+ node_modules_bundle_path_server: ?[]const u8 = null,
+
+ /// framework
+ framework: ?FrameworkConfig = null,
+
+ /// router
+ router: ?RouteConfig = null,
+
+ /// no_summary
+ no_summary: ?bool = null,
+
+ /// disable_hmr
+ disable_hmr: ?bool = null,
+
+ /// port
+ port: ?u16 = null,
+
+ /// logLevel
+ log_level: ?MessageLevel = null,
+
+ pub fn decode(reader: anytype) anyerror!TransformOptions {
+ var this = std.mem.zeroes(TransformOptions);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.jsx = try reader.readValue(Jsx);
+ },
+ 2 => {
+ this.tsconfig_override = try reader.readValue([]const u8);
+ },
+ 3 => {
+ this.resolve = try reader.readValue(ResolveMode);
+ },
+ 4 => {
+ this.origin = try reader.readValue([]const u8);
+ },
+ 5 => {
+ this.absolute_working_dir = try reader.readValue([]const u8);
+ },
+ 6 => {
+ this.define = try reader.readValue(StringMap);
+ },
+ 7 => {
+ this.preserve_symlinks = try reader.readValue(bool);
+ },
+ 8 => {
+ this.entry_points = try reader.readArray([]const u8);
+ },
+ 9 => {
+ this.write = try reader.readValue(bool);
+ },
+ 10 => {
+ this.inject = try reader.readArray([]const u8);
+ },
+ 11 => {
+ this.output_dir = try reader.readValue([]const u8);
+ },
+ 12 => {
+ this.external = try reader.readArray([]const u8);
+ },
+ 13 => {
+ this.loaders = try reader.readValue(LoaderMap);
+ },
+ 14 => {
+ this.main_fields = try reader.readArray([]const u8);
+ },
+ 15 => {
+ this.platform = try reader.readValue(Platform);
+ },
+ 16 => {
+ this.serve = try reader.readValue(bool);
+ },
+ 17 => {
+ this.extension_order = try reader.readArray([]const u8);
+ },
+ 18 => {
+ this.generate_node_module_bundle = try reader.readValue(bool);
+ },
+ 19 => {
+ this.node_modules_bundle_path = try reader.readValue([]const u8);
+ },
+ 20 => {
+ this.node_modules_bundle_path_server = try reader.readValue([]const u8);
+ },
+ 21 => {
+ this.framework = try reader.readValue(FrameworkConfig);
+ },
+ 22 => {
+ this.router = try reader.readValue(RouteConfig);
+ },
+ 23 => {
+ this.no_summary = try reader.readValue(bool);
+ },
+ 24 => {
+ this.disable_hmr = try reader.readValue(bool);
+ },
+ 25 => {
+ this.port = try reader.readValue(u16);
+ },
+ 26 => {
+ this.log_level = try reader.readValue(MessageLevel);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.jsx) |jsx| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(jsx), jsx);
+ }
+ if (this.tsconfig_override) |tsconfig_override| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(tsconfig_override), tsconfig_override);
+ }
+ if (this.resolve) |resolve| {
+ try writer.writeFieldID(3);
+ try writer.writeEnum(resolve);
+ }
+ if (this.origin) |origin| {
+ try writer.writeFieldID(4);
+ try writer.writeValue(@TypeOf(origin), origin);
+ }
+ if (this.absolute_working_dir) |absolute_working_dir| {
+ try writer.writeFieldID(5);
+ try writer.writeValue(@TypeOf(absolute_working_dir), absolute_working_dir);
+ }
+ if (this.define) |define| {
+ try writer.writeFieldID(6);
+ try writer.writeValue(@TypeOf(define), define);
+ }
+ if (this.preserve_symlinks) |preserve_symlinks| {
+ try writer.writeFieldID(7);
+ try writer.writeInt(@as(u8, @boolToInt(preserve_symlinks)));
+ }
+ if (this.entry_points) |entry_points| {
+ try writer.writeFieldID(8);
+ try writer.writeArray([]const u8, entry_points);
+ }
+ if (this.write) |write| {
+ try writer.writeFieldID(9);
+ try writer.writeInt(@as(u8, @boolToInt(write)));
+ }
+ if (this.inject) |inject| {
+ try writer.writeFieldID(10);
+ try writer.writeArray([]const u8, inject);
+ }
+ if (this.output_dir) |output_dir| {
+ try writer.writeFieldID(11);
+ try writer.writeValue(@TypeOf(output_dir), output_dir);
+ }
+ if (this.external) |external| {
+ try writer.writeFieldID(12);
+ try writer.writeArray([]const u8, external);
+ }
+ if (this.loaders) |loaders| {
+ try writer.writeFieldID(13);
+ try writer.writeValue(@TypeOf(loaders), loaders);
+ }
+ if (this.main_fields) |main_fields| {
+ try writer.writeFieldID(14);
+ try writer.writeArray([]const u8, main_fields);
+ }
+ if (this.platform) |platform| {
+ try writer.writeFieldID(15);
+ try writer.writeEnum(platform);
+ }
+ if (this.serve) |serve| {
+ try writer.writeFieldID(16);
+ try writer.writeInt(@as(u8, @boolToInt(serve)));
+ }
+ if (this.extension_order) |extension_order| {
+ try writer.writeFieldID(17);
+ try writer.writeArray([]const u8, extension_order);
+ }
+ if (this.generate_node_module_bundle) |generate_node_module_bundle| {
+ try writer.writeFieldID(18);
+ try writer.writeInt(@as(u8, @boolToInt(generate_node_module_bundle)));
+ }
+ if (this.node_modules_bundle_path) |node_modules_bundle_path| {
+ try writer.writeFieldID(19);
+ try writer.writeValue(@TypeOf(node_modules_bundle_path), node_modules_bundle_path);
+ }
+ if (this.node_modules_bundle_path_server) |node_modules_bundle_path_server| {
+ try writer.writeFieldID(20);
+ try writer.writeValue(@TypeOf(node_modules_bundle_path_server), node_modules_bundle_path_server);
+ }
+ if (this.framework) |framework| {
+ try writer.writeFieldID(21);
+ try writer.writeValue(@TypeOf(framework), framework);
+ }
+ if (this.router) |router| {
+ try writer.writeFieldID(22);
+ try writer.writeValue(@TypeOf(router), router);
+ }
+ if (this.no_summary) |no_summary| {
+ try writer.writeFieldID(23);
+ try writer.writeInt(@as(u8, @boolToInt(no_summary)));
+ }
+ if (this.disable_hmr) |disable_hmr| {
+ try writer.writeFieldID(24);
+ try writer.writeInt(@as(u8, @boolToInt(disable_hmr)));
+ }
+ if (this.port) |port| {
+ try writer.writeFieldID(25);
+ try writer.writeInt(port);
+ }
+ if (this.log_level) |log_level| {
+ try writer.writeFieldID(26);
+ try writer.writeEnum(log_level);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const FileHandle = struct {
+ /// path
+ path: []const u8,
+
+ /// size
+ size: u32 = 0,
+
+ /// fd
+ fd: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!FileHandle {
+ var this = std.mem.zeroes(FileHandle);
+
+ this.path = try reader.readValue([]const u8);
+ this.size = try reader.readValue(u32);
+ this.fd = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ try writer.writeInt(this.size);
+ try writer.writeInt(this.fd);
+ }
+ };
+
+ pub const Transform = struct {
+ /// handle
+ handle: ?FileHandle = null,
+
+ /// path
+ path: ?[]const u8 = null,
+
+ /// contents
+ contents: []const u8,
+
+ /// loader
+ loader: ?Loader = null,
+
+ /// options
+ options: ?TransformOptions = null,
+
+ pub fn decode(reader: anytype) anyerror!Transform {
+ var this = std.mem.zeroes(Transform);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.handle = try reader.readValue(FileHandle);
+ },
+ 2 => {
+ this.path = try reader.readValue([]const u8);
+ },
+ 3 => {
+ this.contents = try reader.readArray(u8);
+ },
+ 4 => {
+ this.loader = try reader.readValue(Loader);
+ },
+ 5 => {
+ this.options = try reader.readValue(TransformOptions);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.handle) |handle| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(handle), handle);
+ }
+ if (this.path) |path| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(path), path);
+ }
+ if (this.contents) |contents| {
+ try writer.writeFieldID(3);
+ try writer.writeArray(u8, contents);
+ }
+ if (this.loader) |loader| {
+ try writer.writeFieldID(4);
+ try writer.writeEnum(loader);
+ }
+ if (this.options) |options| {
+ try writer.writeFieldID(5);
+ try writer.writeValue(@TypeOf(options), options);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const TransformResponseStatus = enum(u32) {
+ _none,
+ /// success
+ success,
+
+ /// fail
+ fail,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const OutputFile = struct {
+ /// data
+ data: []const u8,
+
+ /// path
+ path: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!OutputFile {
+ var this = std.mem.zeroes(OutputFile);
+
+ this.data = try reader.readArray(u8);
+ this.path = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray(u8, this.data);
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ }
+ };
+
+ pub const TransformResponse = struct {
+ /// status
+ status: TransformResponseStatus,
+
+ /// files
+ files: []const OutputFile,
+
+ /// errors
+ errors: []const Message,
+
+ pub fn decode(reader: anytype) anyerror!TransformResponse {
+ var this = std.mem.zeroes(TransformResponse);
+
+ this.status = try reader.readValue(TransformResponseStatus);
+ this.files = try reader.readArray(OutputFile);
+ this.errors = try reader.readArray(Message);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeEnum(this.status);
+ try writer.writeArray(OutputFile, this.files);
+ try writer.writeArray(Message, this.errors);
+ }
+ };
+
+ pub const MessageLevel = enum(u32) {
+ _none,
+ /// err
+ err,
+
+ /// warn
+ warn,
+
+ /// note
+ note,
+
+ /// info
+ info,
+
+ /// debug
+ debug,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const Location = struct {
+ /// file
+ file: []const u8,
+
+ /// namespace
+ namespace: []const u8,
+
+ /// line
+ line: i32 = 0,
+
+ /// column
+ column: i32 = 0,
+
+ /// line_text
+ line_text: []const u8,
+
+ /// suggestion
+ suggestion: []const u8,
+
+ /// offset
+ offset: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!Location {
+ var this = std.mem.zeroes(Location);
+
+ this.file = try reader.readValue([]const u8);
+ this.namespace = try reader.readValue([]const u8);
+ this.line = try reader.readValue(i32);
+ this.column = try reader.readValue(i32);
+ this.line_text = try reader.readValue([]const u8);
+ this.suggestion = try reader.readValue([]const u8);
+ this.offset = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.file), this.file);
+ try writer.writeValue(@TypeOf(this.namespace), this.namespace);
+ try writer.writeInt(this.line);
+ try writer.writeInt(this.column);
+ try writer.writeValue(@TypeOf(this.line_text), this.line_text);
+ try writer.writeValue(@TypeOf(this.suggestion), this.suggestion);
+ try writer.writeInt(this.offset);
+ }
+ };
+
+ pub const MessageData = struct {
+ /// text
+ text: ?[]const u8 = null,
+
+ /// location
+ location: ?Location = null,
+
+ pub fn decode(reader: anytype) anyerror!MessageData {
+ var this = std.mem.zeroes(MessageData);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.text = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.location = try reader.readValue(Location);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.text) |text| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(text), text);
+ }
+ if (this.location) |location| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(location), location);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const MessageMeta = struct {
+ /// resolve
+ resolve: ?[]const u8 = null,
+
+ /// build
+ build: ?bool = null,
+
+ pub fn decode(reader: anytype) anyerror!MessageMeta {
+ var this = std.mem.zeroes(MessageMeta);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.resolve = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.build = try reader.readValue(bool);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.resolve) |resolve| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(resolve), resolve);
+ }
+ if (this.build) |build| {
+ try writer.writeFieldID(2);
+ try writer.writeInt(@as(u8, @boolToInt(build)));
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const Message = struct {
+ /// level
+ level: MessageLevel,
+
+ /// data
+ data: MessageData,
+
+ /// notes
+ notes: []const MessageData,
+
+ /// on
+ on: MessageMeta,
+
+ pub fn decode(reader: anytype) anyerror!Message {
+ var this = std.mem.zeroes(Message);
+
+ this.level = try reader.readValue(MessageLevel);
+ this.data = try reader.readValue(MessageData);
+ this.notes = try reader.readArray(MessageData);
+ this.on = try reader.readValue(MessageMeta);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeEnum(this.level);
+ try writer.writeValue(@TypeOf(this.data), this.data);
+ try writer.writeArray(MessageData, this.notes);
+ try writer.writeValue(@TypeOf(this.on), this.on);
+ }
+ };
+
+ pub const Log = struct {
+ /// warnings
+ warnings: u32 = 0,
+
+ /// errors
+ errors: u32 = 0,
+
+ /// msgs
+ msgs: []const Message,
+
+ pub fn decode(reader: anytype) anyerror!Log {
+ var this = std.mem.zeroes(Log);
+
+ this.warnings = try reader.readValue(u32);
+ this.errors = try reader.readValue(u32);
+ this.msgs = try reader.readArray(Message);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.warnings);
+ try writer.writeInt(this.errors);
+ try writer.writeArray(Message, this.msgs);
+ }
+ };
+
+ pub const Reloader = enum(u8) {
+ _none,
+ /// disable
+ disable,
+
+ /// live
+ live,
+
+ /// fast_refresh
+ fast_refresh,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const WebsocketMessageKind = enum(u8) {
+ _none,
+ /// welcome
+ welcome,
+
+ /// file_change_notification
+ file_change_notification,
+
+ /// build_success
+ build_success,
+
+ /// build_fail
+ build_fail,
+
+ /// manifest_success
+ manifest_success,
+
+ /// manifest_fail
+ manifest_fail,
+
+ /// resolve_file
+ resolve_file,
+
+ /// file_change_notification_with_hint
+ file_change_notification_with_hint,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const WebsocketCommandKind = enum(u8) {
+ _none,
+ /// build
+ build,
+
+ /// manifest
+ manifest,
+
+ /// build_with_file_path
+ build_with_file_path,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
+ pub const WebsocketMessage = struct {
+ /// timestamp
+ timestamp: u32 = 0,
+
+ /// kind
+ kind: WebsocketMessageKind,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketMessage {
+ var this = std.mem.zeroes(WebsocketMessage);
+
+ this.timestamp = try reader.readValue(u32);
+ this.kind = try reader.readValue(WebsocketMessageKind);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.timestamp);
+ try writer.writeEnum(this.kind);
+ }
+ };
+
+ pub const WebsocketMessageWelcome = struct {
+ /// epoch
+ epoch: u32 = 0,
+
+ /// javascriptReloader
+ javascript_reloader: Reloader,
+
+ /// cwd
+ cwd: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketMessageWelcome {
+ var this = std.mem.zeroes(WebsocketMessageWelcome);
+
+ this.epoch = try reader.readValue(u32);
+ this.javascript_reloader = try reader.readValue(Reloader);
+ this.cwd = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.epoch);
+ try writer.writeEnum(this.javascript_reloader);
+ try writer.writeValue(@TypeOf(this.cwd), this.cwd);
+ }
+ };
+
+ pub const WebsocketMessageFileChangeNotification = struct {
+ /// id
+ id: u32 = 0,
+
+ /// loader
+ loader: Loader,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketMessageFileChangeNotification {
+ var this = std.mem.zeroes(WebsocketMessageFileChangeNotification);
+
+ this.id = try reader.readValue(u32);
+ this.loader = try reader.readValue(Loader);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ try writer.writeEnum(this.loader);
+ }
+ };
+
+ pub const WebsocketCommand = struct {
+ /// kind
+ kind: WebsocketCommandKind,
+
+ /// timestamp
+ timestamp: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketCommand {
+ var this = std.mem.zeroes(WebsocketCommand);
+
+ this.kind = try reader.readValue(WebsocketCommandKind);
+ this.timestamp = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeEnum(this.kind);
+ try writer.writeInt(this.timestamp);
+ }
+ };
+
+ pub const WebsocketCommandBuild = packed struct {
+ /// id
+ id: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketCommandBuild {
+ var this = std.mem.zeroes(WebsocketCommandBuild);
+
+ this.id = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ }
+ };
+
+ pub const WebsocketCommandManifest = packed struct {
+ /// id
+ id: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketCommandManifest {
+ var this = std.mem.zeroes(WebsocketCommandManifest);
+
+ this.id = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ }
+ };
+
+ pub const WebsocketMessageBuildSuccess = struct {
+ /// id
+ id: u32 = 0,
+
+ /// from_timestamp
+ from_timestamp: u32 = 0,
+
+ /// loader
+ loader: Loader,
+
+ /// module_path
+ module_path: []const u8,
+
+ /// blob_length
+ blob_length: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketMessageBuildSuccess {
+ var this = std.mem.zeroes(WebsocketMessageBuildSuccess);
+
+ this.id = try reader.readValue(u32);
+ this.from_timestamp = try reader.readValue(u32);
+ this.loader = try reader.readValue(Loader);
+ this.module_path = try reader.readValue([]const u8);
+ this.blob_length = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ try writer.writeInt(this.from_timestamp);
+ try writer.writeEnum(this.loader);
+ try writer.writeValue(@TypeOf(this.module_path), this.module_path);
+ try writer.writeInt(this.blob_length);
+ }
+ };
+
+ pub const WebsocketMessageBuildFailure = struct {
+ /// id
+ id: u32 = 0,
+
+ /// from_timestamp
+ from_timestamp: u32 = 0,
+
+ /// loader
+ loader: Loader,
+
+ /// module_path
+ module_path: []const u8,
+
+ /// log
+ log: Log,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketMessageBuildFailure {
+ var this = std.mem.zeroes(WebsocketMessageBuildFailure);
+
+ this.id = try reader.readValue(u32);
+ this.from_timestamp = try reader.readValue(u32);
+ this.loader = try reader.readValue(Loader);
+ this.module_path = try reader.readValue([]const u8);
+ this.log = try reader.readValue(Log);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ try writer.writeInt(this.from_timestamp);
+ try writer.writeEnum(this.loader);
+ try writer.writeValue(@TypeOf(this.module_path), this.module_path);
+ try writer.writeValue(@TypeOf(this.log), this.log);
+ }
+ };
+
+ pub const WebsocketCommandBuildWithFilePath = struct {
+ /// id
+ id: u32 = 0,
+
+ /// file_path
+ file_path: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketCommandBuildWithFilePath {
+ var this = std.mem.zeroes(WebsocketCommandBuildWithFilePath);
+
+ this.id = try reader.readValue(u32);
+ this.file_path = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ try writer.writeValue(@TypeOf(this.file_path), this.file_path);
+ }
+ };
+
+ pub const WebsocketMessageResolveId = packed struct {
+ /// id
+ id: u32 = 0,
+
+ pub fn decode(reader: anytype) anyerror!WebsocketMessageResolveId {
+ var this = std.mem.zeroes(WebsocketMessageResolveId);
+
+ this.id = try reader.readValue(u32);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeInt(this.id);
+ }
+ };
+
+ pub const NpmRegistry = struct {
+ /// url
+ url: []const u8,
+
+ /// username
+ username: []const u8,
+
+ /// password
+ password: []const u8,
+
+ /// token
+ token: []const u8,
+
+ pub fn decode(reader: anytype) anyerror!NpmRegistry {
+ var this = std.mem.zeroes(NpmRegistry);
+
+ this.url = try reader.readValue([]const u8);
+ this.username = try reader.readValue([]const u8);
+ this.password = try reader.readValue([]const u8);
+ this.token = try reader.readValue([]const u8);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.url), this.url);
+ try writer.writeValue(@TypeOf(this.username), this.username);
+ try writer.writeValue(@TypeOf(this.password), this.password);
+ try writer.writeValue(@TypeOf(this.token), this.token);
+ }
+ };
+
+ pub const NpmRegistryMap = struct {
+ /// scopes
+ scopes: []const []const u8,
+
+ /// registries
+ registries: []const NpmRegistry,
+
+ pub fn decode(reader: anytype) anyerror!NpmRegistryMap {
+ var this = std.mem.zeroes(NpmRegistryMap);
+
+ this.scopes = try reader.readArray([]const u8);
+ this.registries = try reader.readArray(NpmRegistry);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray([]const u8, this.scopes);
+ try writer.writeArray(NpmRegistry, this.registries);
+ }
+ };
+
+ pub const BunInstall = struct {
+ /// default_registry
+ default_registry: ?NpmRegistry = null,
+
+ /// scoped
+ scoped: ?NpmRegistryMap = null,
+
+ /// lockfile_path
+ lockfile_path: ?[]const u8 = null,
+
+ /// save_lockfile_path
+ save_lockfile_path: ?[]const u8 = null,
+
+ /// cache_directory
+ cache_directory: ?[]const u8 = null,
+
+ /// dry_run
+ dry_run: ?bool = null,
+
+ /// force
+ force: ?bool = null,
+
+ /// save_dev
+ save_dev: ?bool = null,
+
+ /// save_optional
+ save_optional: ?bool = null,
+
+ /// save_peer
+ save_peer: ?bool = null,
+
+ /// save_lockfile
+ save_lockfile: ?bool = null,
+
+ /// production
+ production: ?bool = null,
+
+ /// save_yarn_lockfile
+ save_yarn_lockfile: ?bool = null,
+
+ /// native_bin_links
+ native_bin_links: []const []const u8,
+
+ /// disable_cache
+ disable_cache: ?bool = null,
+
+ /// disable_manifest_cache
+ disable_manifest_cache: ?bool = null,
+
+ /// global_dir
+ global_dir: ?[]const u8 = null,
+
+ /// global_bin_dir
+ global_bin_dir: ?[]const u8 = null,
+
+ pub fn decode(reader: anytype) anyerror!BunInstall {
+ var this = std.mem.zeroes(BunInstall);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.default_registry = try reader.readValue(NpmRegistry);
+ },
+ 2 => {
+ this.scoped = try reader.readValue(NpmRegistryMap);
+ },
+ 3 => {
+ this.lockfile_path = try reader.readValue([]const u8);
+ },
+ 4 => {
+ this.save_lockfile_path = try reader.readValue([]const u8);
+ },
+ 5 => {
+ this.cache_directory = try reader.readValue([]const u8);
+ },
+ 6 => {
+ this.dry_run = try reader.readValue(bool);
+ },
+ 7 => {
+ this.force = try reader.readValue(bool);
+ },
+ 8 => {
+ this.save_dev = try reader.readValue(bool);
+ },
+ 9 => {
+ this.save_optional = try reader.readValue(bool);
+ },
+ 10 => {
+ this.save_peer = try reader.readValue(bool);
+ },
+ 11 => {
+ this.save_lockfile = try reader.readValue(bool);
+ },
+ 12 => {
+ this.production = try reader.readValue(bool);
+ },
+ 13 => {
+ this.save_yarn_lockfile = try reader.readValue(bool);
+ },
+ 14 => {
+ this.native_bin_links = try reader.readArray([]const u8);
+ },
+ 15 => {
+ this.disable_cache = try reader.readValue(bool);
+ },
+ 16 => {
+ this.disable_manifest_cache = try reader.readValue(bool);
+ },
+ 17 => {
+ this.global_dir = try reader.readValue([]const u8);
+ },
+ 18 => {
+ this.global_bin_dir = try reader.readValue([]const u8);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.default_registry) |default_registry| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(default_registry), default_registry);
+ }
+ if (this.scoped) |scoped| {
+ try writer.writeFieldID(2);
+ try writer.writeValue(@TypeOf(scoped), scoped);
+ }
+ if (this.lockfile_path) |lockfile_path| {
+ try writer.writeFieldID(3);
+ try writer.writeValue(@TypeOf(lockfile_path), lockfile_path);
+ }
+ if (this.save_lockfile_path) |save_lockfile_path| {
+ try writer.writeFieldID(4);
+ try writer.writeValue(@TypeOf(save_lockfile_path), save_lockfile_path);
+ }
+ if (this.cache_directory) |cache_directory| {
+ try writer.writeFieldID(5);
+ try writer.writeValue(@TypeOf(cache_directory), cache_directory);
+ }
+ if (this.dry_run) |dry_run| {
+ try writer.writeFieldID(6);
+ try writer.writeInt(@as(u8, @boolToInt(dry_run)));
+ }
+ if (this.force) |force| {
+ try writer.writeFieldID(7);
+ try writer.writeInt(@as(u8, @boolToInt(force)));
+ }
+ if (this.save_dev) |save_dev| {
+ try writer.writeFieldID(8);
+ try writer.writeInt(@as(u8, @boolToInt(save_dev)));
+ }
+ if (this.save_optional) |save_optional| {
+ try writer.writeFieldID(9);
+ try writer.writeInt(@as(u8, @boolToInt(save_optional)));
+ }
+ if (this.save_peer) |save_peer| {
+ try writer.writeFieldID(10);
+ try writer.writeInt(@as(u8, @boolToInt(save_peer)));
+ }
+ if (this.save_lockfile) |save_lockfile| {
+ try writer.writeFieldID(11);
+ try writer.writeInt(@as(u8, @boolToInt(save_lockfile)));
+ }
+ if (this.production) |production| {
+ try writer.writeFieldID(12);
+ try writer.writeInt(@as(u8, @boolToInt(production)));
+ }
+ if (this.save_yarn_lockfile) |save_yarn_lockfile| {
+ try writer.writeFieldID(13);
+ try writer.writeInt(@as(u8, @boolToInt(save_yarn_lockfile)));
+ }
+ if (this.native_bin_links) |native_bin_links| {
+ try writer.writeFieldID(14);
+ try writer.writeArray([]const u8, native_bin_links);
+ }
+ if (this.disable_cache) |disable_cache| {
+ try writer.writeFieldID(15);
+ try writer.writeInt(@as(u8, @boolToInt(disable_cache)));
+ }
+ if (this.disable_manifest_cache) |disable_manifest_cache| {
+ try writer.writeFieldID(16);
+ try writer.writeInt(@as(u8, @boolToInt(disable_manifest_cache)));
+ }
+ if (this.global_dir) |global_dir| {
+ try writer.writeFieldID(17);
+ try writer.writeValue(@TypeOf(global_dir), global_dir);
+ }
+ if (this.global_bin_dir) |global_bin_dir| {
+ try writer.writeFieldID(18);
+ try writer.writeValue(@TypeOf(global_bin_dir), global_bin_dir);
+ }
+ try writer.endMessage();
+ }
+ };
+};
diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts
index d8129fd27..0a7ed3b9b 100644
--- a/src/api/schema.d.ts
+++ b/src/api/schema.d.ts
@@ -194,6 +194,34 @@ export const DotEnvBehaviorKeys = {
3: "load_all",
load_all: "load_all",
};
+export enum ImportKind {
+ entry_point = 1,
+ stmt = 2,
+ require = 3,
+ dynamic = 4,
+ require_resolve = 5,
+ at = 6,
+ url = 7,
+ internal = 8,
+}
+export const ImportKindKeys = {
+ 1: "entry_point",
+ entry_point: "entry_point",
+ 2: "stmt",
+ stmt: "stmt",
+ 3: "require",
+ require: "require",
+ 4: "dynamic",
+ dynamic: "dynamic",
+ 5: "require_resolve",
+ require_resolve: "require_resolve",
+ 6: "at",
+ at: "at",
+ 7: "url",
+ url: "url",
+ 8: "internal",
+ internal: "internal",
+};
export enum TransformResponseStatus {
success = 1,
fail = 2,
@@ -508,6 +536,22 @@ export interface Transform {
options?: TransformOptions;
}
+export interface Scan {
+ path?: string;
+ contents?: Uint8Array;
+ loader?: Loader;
+}
+
+export interface ScanResult {
+ exports: string[];
+ imports: ScannedImport[];
+}
+
+export interface ScannedImport {
+ path: string;
+ kind: ImportKind;
+}
+
export interface OutputFile {
data: Uint8Array;
path: string;
@@ -807,6 +851,18 @@ export declare function encodeTransform(
bb: ByteBuffer
): void;
export declare function decodeTransform(buffer: ByteBuffer): Transform;
+export declare function encodeScan(message: Scan, bb: ByteBuffer): void;
+export declare function decodeScan(buffer: ByteBuffer): Scan;
+export declare function encodeScanResult(
+ message: ScanResult,
+ bb: ByteBuffer
+): void;
+export declare function decodeScanResult(buffer: ByteBuffer): ScanResult;
+export declare function encodeScannedImport(
+ message: ScannedImport,
+ bb: ByteBuffer
+): void;
+export declare function decodeScannedImport(buffer: ByteBuffer): ScannedImport;
export declare function encodeOutputFile(
message: OutputFile,
bb: ByteBuffer
diff --git a/src/api/schema.js b/src/api/schema.js
index f2e9b24a5..b89ed4a08 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -2031,6 +2031,163 @@ function encodeTransform(message, bb) {
}
bb.writeByte(0);
}
+
+function decodeScan(bb) {
+ var result = {};
+
+ while (true) {
+ switch (bb.readByte()) {
+ case 0:
+ return result;
+
+ case 1:
+ result["path"] = bb.readString();
+ break;
+
+ case 2:
+ result["contents"] = bb.readByteArray();
+ break;
+
+ case 3:
+ result["loader"] = Loader[bb.readByte()];
+ break;
+
+ default:
+ throw new Error("Attempted to parse invalid message");
+ }
+ }
+}
+
+function encodeScan(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ bb.writeByte(1);
+ bb.writeString(value);
+ }
+
+ var value = message["contents"];
+ if (value != null) {
+ bb.writeByte(2);
+ bb.writeByteArray(value);
+ }
+
+ var value = message["loader"];
+ if (value != null) {
+ bb.writeByte(3);
+ var encoded = Loader[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
+ );
+ bb.writeByte(encoded);
+ }
+ bb.writeByte(0);
+}
+
+function decodeScanResult(bb) {
+ var result = {};
+
+ var length = bb.readVarUint();
+ var values = (result["exports"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = bb.readString();
+ var length = bb.readVarUint();
+ var values = (result["imports"] = Array(length));
+ for (var i = 0; i < length; i++) values[i] = decodeScannedImport(bb);
+ return result;
+}
+
+function encodeScanResult(message, bb) {
+ var value = message["exports"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ bb.writeString(value);
+ }
+ } else {
+ throw new Error('Missing required field "exports"');
+ }
+
+ var value = message["imports"];
+ if (value != null) {
+ var values = value,
+ n = values.length;
+ bb.writeVarUint(n);
+ for (var i = 0; i < n; i++) {
+ value = values[i];
+ encodeScannedImport(value, bb);
+ }
+ } else {
+ throw new Error('Missing required field "imports"');
+ }
+}
+
+function decodeScannedImport(bb) {
+ var result = {};
+
+ result["path"] = bb.readString();
+ result["kind"] = ImportKind[bb.readByte()];
+ return result;
+}
+
+function encodeScannedImport(message, bb) {
+ var value = message["path"];
+ if (value != null) {
+ bb.writeString(value);
+ } else {
+ throw new Error('Missing required field "path"');
+ }
+
+ var value = message["kind"];
+ if (value != null) {
+ var encoded = ImportKind[value];
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "ImportKind"'
+ );
+ bb.writeByte(encoded);
+ } else {
+ throw new Error('Missing required field "kind"');
+ }
+}
+const ImportKind = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ entry_point: 1,
+ stmt: 2,
+ require: 3,
+ dynamic: 4,
+ require_resolve: 5,
+ at: 6,
+ url: 7,
+ internal: 8,
+};
+const ImportKindKeys = {
+ 1: "entry_point",
+ 2: "stmt",
+ 3: "require",
+ 4: "dynamic",
+ 5: "require_resolve",
+ 6: "at",
+ 7: "url",
+ 8: "internal",
+ entry_point: "entry_point",
+ stmt: "stmt",
+ require: "require",
+ dynamic: "dynamic",
+ require_resolve: "require_resolve",
+ at: "at",
+ url: "url",
+ internal: "internal",
+};
const TransformResponseStatus = {
1: 1,
2: 2,
@@ -3119,6 +3276,14 @@ export { decodeFileHandle };
export { encodeFileHandle };
export { decodeTransform };
export { encodeTransform };
+export { decodeScan };
+export { encodeScan };
+export { decodeScanResult };
+export { encodeScanResult };
+export { decodeScannedImport };
+export { encodeScannedImport };
+export { ImportKind };
+export { ImportKindKeys };
export { TransformResponseStatus };
export { TransformResponseStatusKeys };
export { decodeOutputFile };
diff --git a/src/api/schema.peechy b/src/api/schema.peechy
index 59cb1edf5..cf954cc4c 100644
--- a/src/api/schema.peechy
+++ b/src/api/schema.peechy
@@ -362,6 +362,34 @@ message Transform {
TransformOptions options = 5;
}
+message Scan {
+ string path = 1;
+ byte[] contents = 2;
+ Loader loader = 3;
+}
+
+struct ScanResult {
+ string[] exports;
+ ScannedImport[] imports;
+}
+
+struct ScannedImport {
+ string path;
+ ImportKind kind;
+}
+
+smol ImportKind {
+ entry_point = 1;
+ stmt = 2;
+ require = 3;
+ dynamic = 4;
+ require_resolve = 5;
+ at = 6;
+ url = 7;
+ internal = 8;
+}
+
+
enum TransformResponseStatus {
success = 1;
fail = 2;
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 61d6b82d1..5f4532522 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -2047,6 +2047,134 @@ pub const Api = struct {
}
};
+ pub const Scan = struct {
+ /// path
+ path: ?[]const u8 = null,
+
+ /// contents
+ contents: []const u8,
+
+ /// loader
+ loader: ?Loader = null,
+
+ pub fn decode(reader: anytype) anyerror!Scan {
+ var this = std.mem.zeroes(Scan);
+
+ while (true) {
+ switch (try reader.readByte()) {
+ 0 => {
+ return this;
+ },
+
+ 1 => {
+ this.path = try reader.readValue([]const u8);
+ },
+ 2 => {
+ this.contents = try reader.readArray(u8);
+ },
+ 3 => {
+ this.loader = try reader.readValue(Loader);
+ },
+ else => {
+ return error.InvalidMessage;
+ },
+ }
+ }
+ unreachable;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ if (this.path) |path| {
+ try writer.writeFieldID(1);
+ try writer.writeValue(@TypeOf(path), path);
+ }
+ if (this.contents) |contents| {
+ try writer.writeFieldID(2);
+ try writer.writeArray(u8, contents);
+ }
+ if (this.loader) |loader| {
+ try writer.writeFieldID(3);
+ try writer.writeEnum(loader);
+ }
+ try writer.endMessage();
+ }
+ };
+
+ pub const ScanResult = struct {
+ /// exports
+ exports: []const []const u8,
+
+ /// imports
+ imports: []const ScannedImport,
+
+ pub fn decode(reader: anytype) anyerror!ScanResult {
+ var this = std.mem.zeroes(ScanResult);
+
+ this.exports = try reader.readArray([]const u8);
+ this.imports = try reader.readArray(ScannedImport);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeArray([]const u8, this.exports);
+ try writer.writeArray(ScannedImport, this.imports);
+ }
+ };
+
+ pub const ScannedImport = struct {
+ /// path
+ path: []const u8,
+
+ /// kind
+ kind: ImportKind,
+
+ pub fn decode(reader: anytype) anyerror!ScannedImport {
+ var this = std.mem.zeroes(ScannedImport);
+
+ this.path = try reader.readValue([]const u8);
+ this.kind = try reader.readValue(ImportKind);
+ return this;
+ }
+
+ pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+ try writer.writeValue(@TypeOf(this.path), this.path);
+ try writer.writeEnum(this.kind);
+ }
+ };
+
+ pub const ImportKind = enum(u8) {
+ _none,
+ /// entry_point
+ entry_point,
+
+ /// stmt
+ stmt,
+
+ /// require
+ require,
+
+ /// dynamic
+ dynamic,
+
+ /// require_resolve
+ require_resolve,
+
+ /// at
+ at,
+
+ /// url
+ url,
+
+ /// internal
+ internal,
+
+ _,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
+ }
+ };
+
pub const TransformResponseStatus = enum(u32) {
_none,
/// success
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-02 14:14:06 +0000