aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/api/demo/lib/api.ts73
-rw-r--r--src/api/demo/package.json2
-rw-r--r--src/api/demo/pnpm-lock.yaml8
-rw-r--r--src/api/schema.js423
-rw-r--r--src/api/schema.zig1492
-rw-r--r--src/global.zig45
-rw-r--r--src/main.zig10
-rw-r--r--src/main_wasm.zig41
-rw-r--r--src/output_wasm.zig6
9 files changed, 1109 insertions, 991 deletions
diff --git a/src/api/demo/lib/api.ts b/src/api/demo/lib/api.ts
index e09eec51b..1619e2c46 100644
--- a/src/api/demo/lib/api.ts
+++ b/src/api/demo/lib/api.ts
@@ -2,7 +2,7 @@ import * as Schema from "../../schema";
import { ByteBuffer } from "peechy";
export interface WebAssemblyModule {
- init(): number;
+ init(starting_memory: number): number;
transform(a: number): number;
malloc(a: number): number;
calloc(a: number): number;
@@ -10,38 +10,62 @@ export interface WebAssemblyModule {
free(a: number): number;
}
+const wasm_imports_sym: symbol | string =
+ process.env.NODE_ENV === "development"
+ ? "wasm_imports"
+ : Symbol("wasm_imports");
+
export class ESDev {
static has_initialized = false;
static wasm_source: WebAssembly.WebAssemblyInstantiatedSource = null;
- static wasm_exports: WebAssemblyModule;
- static memory: WebAssembly.Memory;
+ static get wasm_exports(): WebAssemblyModule {
+ return ESDev.wasm_source.instance.exports as any;
+ }
+ static get memory() {
+ return ESDev.wasm_exports.memory as WebAssembly.Memory;
+ }
static memory_array: Uint8Array;
- static async init(url) {
- if (typeof SharedArrayBuffer !== "undefined") {
- ESDev.memory = new WebAssembly.Memory({
- initial: 1500,
- maximum: 3000,
- shared: true,
- });
- } else {
- ESDev.memory = new WebAssembly.Memory({
- initial: 1500,
- maximum: 3000,
- });
+
+ static _decoder: TextDecoder;
+
+ static _wasmPtrLenToString(ptr: number, len: number) {
+ if (!ESDev._decoder) {
+ ESDev._decoder = new TextDecoder();
}
- ESDev.memory_array = new Uint8Array(ESDev.memory.buffer);
+ const region = ESDev.memory_array.subarray(ptr, ptr + len + 1);
+ return ESDev._decoder.decode(region);
+ }
+
+ // We don't want people to be calling these manually
+ static [wasm_imports_sym] = {
+ console_log(ptr: number, len: number) {
+ console.log(ESDev._wasmPtrLenToString(ptr, len));
+ },
+ console_error(ptr: number, len: number) {
+ console.error(ESDev._wasmPtrLenToString(ptr, len));
+ },
+ console_warn(ptr: number, len: number) {
+ console.warn(ESDev._wasmPtrLenToString(ptr, len));
+ },
+ console_info(ptr: number, len: number) {
+ console.info(ESDev._wasmPtrLenToString(ptr, len));
+ },
+ };
+
+ static async init(url) {
ESDev.wasm_source = await globalThis.WebAssembly.instantiateStreaming(
fetch(url),
- {
- js: {
- mem: ESDev.memory,
- },
- }
+ { env: ESDev[wasm_imports_sym] }
);
- ESDev.wasm_exports = ESDev.wasm_source.instance.exports as any;
- ESDev.wasm_exports.init();
- console.log("WASM loaded.");
+ const res = ESDev.wasm_exports.init(1500);
+ if (res < 0) {
+ throw `[ESDev] Failed to initialize WASM module: code ${res}`;
+ } else {
+ console.log("WASM loaded.");
+ }
+ ESDev.memory_array = new Uint8Array(ESDev.memory.buffer);
+
ESDev.has_initialized = true;
}
@@ -63,6 +87,7 @@ export class ESDev {
bb
);
const data = bb.toUint8Array();
+
const ptr = ESDev.wasm_exports.malloc(data.byteLength);
ESDev.memory_array.set(data, ptr);
debugger;
diff --git a/src/api/demo/package.json b/src/api/demo/package.json
index 27c8c943e..8576b2bc9 100644
--- a/src/api/demo/package.json
+++ b/src/api/demo/package.json
@@ -9,7 +9,7 @@
},
"dependencies": {
"next": "10.2.0",
- "peechy": "0.3.6",
+ "peechy": "0.4.0",
"react": "17.0.2",
"react-dom": "17.0.2"
}
diff --git a/src/api/demo/pnpm-lock.yaml b/src/api/demo/pnpm-lock.yaml
index cd3dfa28b..3e6b4c6cc 100644
--- a/src/api/demo/pnpm-lock.yaml
+++ b/src/api/demo/pnpm-lock.yaml
@@ -2,13 +2,13 @@ lockfileVersion: 5.3
specifiers:
next: 10.2.0
- peechy: 0.3.6
+ peechy: 0.4.0
react: 17.0.2
react-dom: 17.0.2
dependencies:
next: 10.2.0_react-dom@17.0.2+react@17.0.2
- peechy: 0.3.6
+ peechy: 0.4.0
react: 17.0.2
react-dom: 17.0.2_react@17.0.2
@@ -1327,8 +1327,8 @@ packages:
sha.js: 2.4.11
dev: false
- /peechy/0.3.6:
- resolution: {integrity: sha512-CUtPbzX8W4wlhHwZhPWhD9iK8q9BX09JfmKzXFUsMkbi49MGPH2X/tnRQJQaCwHiPqYUijzLLcRYmZQOLmo7Nw==}
+ /peechy/0.4.0:
+ resolution: {integrity: sha512-dIOZl4mEZGN91WYxrBv1/QOA/R6tNf10FFo4rrCSPfPGPz3gzsvkrXIT8K46XBBlZbSNYS4xUJZ6TZMrptcJIA==}
hasBin: true
dependencies:
change-case: 4.1.2
diff --git a/src/api/schema.js b/src/api/schema.js
index 9f6947b33..55c4bc040 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -1,46 +1,46 @@
const Loader = {
- "1": 1,
- "2": 2,
- "3": 3,
- "4": 4,
- "5": 5,
- "6": 6,
- "7": 7,
- "jsx": 1,
- "js": 2,
- "ts": 3,
- "tsx": 4,
- "css": 5,
- "file": 6,
- "json": 7
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ jsx: 1,
+ js: 2,
+ ts: 3,
+ tsx: 4,
+ css: 5,
+ file: 6,
+ json: 7,
};
const LoaderKeys = {
- "1": "jsx",
- "2": "js",
- "3": "ts",
- "4": "tsx",
- "5": "css",
- "6": "file",
- "7": "json",
- "jsx": "jsx",
- "js": "js",
- "ts": "ts",
- "tsx": "tsx",
- "css": "css",
- "file": "file",
- "json": "json"
+ 1: "jsx",
+ 2: "js",
+ 3: "ts",
+ 4: "tsx",
+ 5: "css",
+ 6: "file",
+ 7: "json",
+ jsx: "jsx",
+ js: "js",
+ ts: "ts",
+ tsx: "tsx",
+ css: "css",
+ file: "file",
+ json: "json",
};
const JSXRuntime = {
- "1": 1,
- "2": 2,
- "automatic": 1,
- "classic": 2
+ 1: 1,
+ 2: 2,
+ automatic: 1,
+ classic: 2,
};
const JSXRuntimeKeys = {
- "1": "automatic",
- "2": "classic",
- "automatic": "automatic",
- "classic": "classic"
+ 1: "automatic",
+ 2: "classic",
+ automatic: "automatic",
+ classic: "classic",
};
function decodeJSX(bb) {
@@ -53,86 +53,92 @@ function decodeJSX(bb) {
result["import_source"] = bb.readString();
result["react_fast_refresh"] = !!bb.readByte();
var length = bb.readVarUint();
- var values = result["loader_keys"] = Array(length);
+ var values = (result["loader_keys"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
var length = bb.readVarUint();
- var values = result["loader_values"] = Array(length);
+ var values = (result["loader_values"] = Array(length));
for (var i = 0; i < length; i++) values[i] = Loader[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\"");
+ throw new Error('Missing required field "factory"');
}
var value = message["runtime"];
if (value != null) {
var encoded = JSXRuntime[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"JSXRuntime\"");
-bb.writeByte(encoded);
+ 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\"");
+ 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\"");
+ throw new Error('Missing required field "fragment"');
}
var value = message["production"];
if (value != null) {
bb.writeByte(value);
} else {
- throw new Error("Missing required field \"production\"");
+ throw new Error('Missing required field "production"');
}
var value = message["import_source"];
if (value != null) {
bb.writeString(value);
} else {
- throw new Error("Missing required field \"import_source\"");
+ 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\"");
+ throw new Error('Missing required field "react_fast_refresh"');
}
var value = message["loader_keys"];
if (value != null) {
- var values = value, n = values.length;
+ 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 \"loader_keys\"");
+ throw new Error('Missing required field "loader_keys"');
}
var value = message["loader_values"];
if (value != null) {
- var values = value, n = values.length;
+ 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);
+ 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_values\"");
+ throw new Error('Missing required field "loader_values"');
}
-
}
function decodeTransformOptions(bb) {
@@ -142,61 +148,61 @@ function decodeTransformOptions(bb) {
result["ts"] = !!bb.readByte();
result["base_path"] = bb.readString();
var length = bb.readVarUint();
- var values = result["define_keys"] = Array(length);
+ var values = (result["define_keys"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
var length = bb.readVarUint();
- var values = result["define_values"] = Array(length);
+ var values = (result["define_values"] = Array(length));
for (var i = 0; i < length; i++) values[i] = bb.readString();
return result;
}
function encodeTransformOptions(message, bb) {
-
var value = message["jsx"];
if (value != null) {
encodeJSX(value, bb);
} else {
- throw new Error("Missing required field \"jsx\"");
+ throw new Error('Missing required field "jsx"');
}
var value = message["ts"];
if (value != null) {
bb.writeByte(value);
} else {
- throw new Error("Missing required field \"ts\"");
+ throw new Error('Missing required field "ts"');
}
var value = message["base_path"];
if (value != null) {
bb.writeString(value);
} else {
- throw new Error("Missing required field \"base_path\"");
+ throw new Error('Missing required field "base_path"');
}
var value = message["define_keys"];
if (value != null) {
- var values = value, n = values.length;
+ 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 \"define_keys\"");
+ throw new Error('Missing required field "define_keys"');
}
var value = message["define_values"];
if (value != null) {
- var values = value, n = values.length;
+ 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 \"define_values\"");
+ throw new Error('Missing required field "define_values"');
}
-
}
function decodeFileHandle(bb) {
@@ -209,111 +215,110 @@ function decodeFileHandle(bb) {
}
function encodeFileHandle(message, bb) {
-
var value = message["path"];
if (value != null) {
bb.writeString(value);
} else {
- throw new Error("Missing required field \"path\"");
+ 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\"");
+ 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\"");
+ throw new Error('Missing required field "fd"');
}
-
}
function decodeTransform(bb) {
var result = {};
while (true) {
- switch (bb.readVarUint()) {
- case 0:
- return result;
+ switch (bb.readByte()) {
+ case 0:
+ return result;
- case 1:
- result["handle"] = decodeFileHandle(bb);
- break;
+ case 1:
+ result["handle"] = decodeFileHandle(bb);
+ break;
- case 2:
- result["path"] = bb.readString();
- break;
+ case 2:
+ result["path"] = bb.readString();
+ break;
- case 3:
- result["contents"] = bb.readString();
- break;
+ case 3:
+ result["contents"] = bb.readString();
+ break;
- case 4:
- result["loader"] = Loader[bb.readByte()];
- break;
+ case 4:
+ result["loader"] = Loader[bb.readByte()];
+ break;
- case 5:
- result["options"] = decodeTransformOptions(bb);
- break;
+ case 5:
+ result["options"] = decodeTransformOptions(bb);
+ break;
- default:
- throw new Error("Attempted to parse invalid message");
+ default:
+ throw new Error("Attempted to parse invalid message");
}
}
}
function encodeTransform(message, bb) {
-
var value = message["handle"];
if (value != null) {
- bb.writeVarUint(1);
+ bb.writeByte(1);
encodeFileHandle(value, bb);
}
var value = message["path"];
if (value != null) {
- bb.writeVarUint(2);
+ bb.writeByte(2);
bb.writeString(value);
}
var value = message["contents"];
if (value != null) {
- bb.writeVarUint(3);
+ bb.writeByte(3);
bb.writeString(value);
}
var value = message["loader"];
if (value != null) {
- bb.writeVarUint(4);
+ bb.writeByte(4);
var encoded = Loader[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
-bb.writeByte(encoded);
+ 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.writeVarUint(5);
+ bb.writeByte(5);
encodeTransformOptions(value, bb);
}
- bb.writeVarUint(0);
-
+ bb.writeByte(0);
}
const TransformResponseStatus = {
- "1": 1,
- "2": 2,
- "success": 1,
- "fail": 2
+ 1: 1,
+ 2: 2,
+ success: 1,
+ fail: 2,
};
const TransformResponseStatusKeys = {
- "1": "success",
- "2": "fail",
- "success": "success",
- "fail": "fail"
+ 1: "success",
+ 2: "fail",
+ success: "success",
+ fail: "fail",
};
function decodeOutputFile(bb) {
@@ -325,21 +330,19 @@ function decodeOutputFile(bb) {
}
function encodeOutputFile(message, bb) {
-
var value = message["data"];
if (value != null) {
- bb.writeByteArray(value);
+ bb.writeByteArray(value);
} else {
- throw new Error("Missing required field \"data\"");
+ 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\"");
+ throw new Error('Missing required field "path"');
}
-
}
function decodeTransformResponse(bb) {
@@ -347,69 +350,74 @@ function decodeTransformResponse(bb) {
result["status"] = TransformResponseStatus[bb.readVarUint()];
var length = bb.readVarUint();
- var values = result["files"] = Array(length);
+ var values = (result["files"] = Array(length));
for (var i = 0; i < length; i++) values[i] = decodeOutputFile(bb);
var length = bb.readVarUint();
- var values = result["errors"] = Array(length);
+ var values = (result["errors"] = Array(length));
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 === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"TransformResponseStatus\"");
-bb.writeVarUint(encoded);
+ 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\"");
+ throw new Error('Missing required field "status"');
}
var value = message["files"];
if (value != null) {
- var values = value, n = values.length;
+ var values = value,
+ n = values.length;
bb.writeVarUint(n);
for (var i = 0; i < n; i++) {
value = values[i];
encodeOutputFile(value, bb);
}
} else {
- throw new Error("Missing required field \"files\"");
+ throw new Error('Missing required field "files"');
}
var value = message["errors"];
if (value != null) {
- var values = value, n = values.length;
+ var values = value,
+ n = values.length;
bb.writeVarUint(n);
for (var i = 0; i < n; i++) {
value = values[i];
encodeMessage(value, bb);
}
} else {
- throw new Error("Missing required field \"errors\"");
+ throw new Error('Missing required field "errors"');
}
-
}
const MessageKind = {
- "1": 1,
- "2": 2,
- "3": 3,
- "4": 4,
- "err": 1,
- "warn": 2,
- "note": 3,
- "debug": 4
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ err: 1,
+ warn: 2,
+ note: 3,
+ debug: 4,
};
const MessageKindKeys = {
- "1": "err",
- "2": "warn",
- "3": "note",
- "4": "debug",
- "err": "err",
- "warn": "warn",
- "note": "note",
- "debug": "debug"
+ 1: "err",
+ 2: "warn",
+ 3: "note",
+ 4: "debug",
+ err: "err",
+ warn: "warn",
+ note: "note",
+ debug: "debug",
};
function decodeLocation(bb) {
@@ -426,95 +434,91 @@ function decodeLocation(bb) {
}
function encodeLocation(message, bb) {
-
var value = message["file"];
if (value != null) {
bb.writeString(value);
} else {
- throw new Error("Missing required field \"file\"");
+ 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\"");
+ 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\"");
+ 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\"");
+ 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\"");
+ 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\"");
+ 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\"");
+ throw new Error('Missing required field "offset"');
}
-
}
function decodeMessageData(bb) {
var result = {};
while (true) {
- switch (bb.readVarUint()) {
- case 0:
- return result;
+ switch (bb.readByte()) {
+ case 0:
+ return result;
- case 1:
- result["text"] = bb.readString();
- break;
+ case 1:
+ result["text"] = bb.readString();
+ break;
- case 2:
- result["location"] = decodeLocation(bb);
- break;
+ case 2:
+ result["location"] = decodeLocation(bb);
+ break;
- default:
- throw new Error("Attempted to parse invalid message");
+ default:
+ throw new Error("Attempted to parse invalid message");
}
}
}
function encodeMessageData(message, bb) {
-
var value = message["text"];
if (value != null) {
- bb.writeVarUint(1);
+ bb.writeByte(1);
bb.writeString(value);
}
var value = message["location"];
if (value != null) {
- bb.writeVarUint(2);
+ bb.writeByte(2);
encodeLocation(value, bb);
}
- bb.writeVarUint(0);
-
+ bb.writeByte(0);
}
function decodeMessage(bb) {
@@ -523,41 +527,43 @@ function decodeMessage(bb) {
result["kind"] = MessageKind[bb.readVarUint()];
result["data"] = decodeMessageData(bb);
var length = bb.readVarUint();
- var values = result["notes"] = Array(length);
+ var values = (result["notes"] = Array(length));
for (var i = 0; i < length; i++) values[i] = decodeMessageData(bb);
return result;
}
function encodeMessage(message, bb) {
-
var value = message["kind"];
if (value != null) {
var encoded = MessageKind[value];
-if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"MessageKind\"");
-bb.writeVarUint(encoded);
+ if (encoded === void 0)
+ throw new Error(
+ "Invalid value " + JSON.stringify(value) + ' for enum "MessageKind"'
+ );
+ bb.writeVarUint(encoded);
} else {
- throw new Error("Missing required field \"kind\"");
+ throw new Error('Missing required field "kind"');
}
var value = message["data"];
if (value != null) {
encodeMessageData(value, bb);
} else {
- throw new Error("Missing required field \"data\"");
+ throw new Error('Missing required field "data"');
}
var value = message["notes"];
if (value != null) {
- var values = value, n = values.length;
+ var values = value,
+ n = values.length;
bb.writeVarUint(n);
for (var i = 0; i < n; i++) {
value = values[i];
encodeMessageData(value, bb);
}
} else {
- throw new Error("Missing required field \"notes\"");
+ throw new Error('Missing required field "notes"');
}
-
}
function decodeLog(bb) {
@@ -566,66 +572,65 @@ function decodeLog(bb) {
result["warnings"] = bb.readUint32();
result["errors"] = bb.readUint32();
var length = bb.readVarUint();
- var values = result["msgs"] = Array(length);
+ var values = (result["msgs"] = Array(length));
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\"");
+ 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\"");
+ throw new Error('Missing required field "errors"');
}
var value = message["msgs"];
if (value != null) {
- var values = value, n = values.length;
+ var values = value,
+ n = values.length;
bb.writeVarUint(n);
for (var i = 0; i < n; i++) {
value = values[i];
encodeMessage(value, bb);
}
} else {
- throw new Error("Missing required field \"msgs\"");
+ throw new Error('Missing required field "msgs"');
}
-
}
-export { Loader }
-export { LoaderKeys }
-export { JSXRuntime }
-export { JSXRuntimeKeys }
-export { decodeJSX }
-export { encodeJSX }
-export { decodeTransformOptions }
-export { encodeTransformOptions }
-export { decodeFileHandle }
-export { encodeFileHandle }
-export { decodeTransform }
-export { encodeTransform }
-export { TransformResponseStatus }
-export { TransformResponseStatusKeys }
-export { decodeOutputFile }
-export { encodeOutputFile }
-export { decodeTransformResponse }
-export { encodeTransformResponse }
-export { MessageKind }
-export { MessageKindKeys }
-export { decodeLocation }
-export { encodeLocation }
-export { decodeMessageData }
-export { encodeMessageData }
-export { decodeMessage }
-export { encodeMessage }
-export { decodeLog }
-export { encodeLog } \ No newline at end of file
+export { Loader };
+export { LoaderKeys };
+export { JSXRuntime };
+export { JSXRuntimeKeys };
+export { decodeJSX };
+export { encodeJSX };
+export { decodeTransformOptions };
+export { encodeTransformOptions };
+export { decodeFileHandle };
+export { encodeFileHandle };
+export { decodeTransform };
+export { encodeTransform };
+export { TransformResponseStatus };
+export { TransformResponseStatusKeys };
+export { decodeOutputFile };
+export { encodeOutputFile };
+export { decodeTransformResponse };
+export { encodeTransformResponse };
+export { MessageKind };
+export { MessageKindKeys };
+export { decodeLocation };
+export { encodeLocation };
+export { decodeMessageData };
+export { encodeMessageData };
+export { decodeMessage };
+export { encodeMessage };
+export { decodeLog };
+export { encodeLog };
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 09da2f058..d34e501a3 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -1,739 +1,781 @@
+
const std = @import("std");
-pub const Api = struct {
- pub const Loader = enum(u8) {
- _none,
- /// jsx
- jsx,
-
- /// js
- js,
-
- /// ts
- ts,
-
- /// tsx
- tsx,
-
- /// css
- css,
-
- /// file
- file,
-
- /// json
- json,
-
- _,
-
- 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: []u8,
-
- /// runtime
- runtime: JsxRuntime,
-
- /// fragment
- fragment: []u8,
-
- /// production
- production: bool = false,
-
- /// import_source
- import_source: []u8,
-
- /// react_fast_refresh
- react_fast_refresh: bool = false,
-
- /// loader_keys
- loader_keys: [][]u8,
-
- /// loader_values
- loader_values: []Loader,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Jsx {
- var obj = std.mem.zeroes(Jsx);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *Jsx, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- length = try reader.readIntNative(u32);
- if (result.factory.len != length) {
- result.factory = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.factory);
- result.runtime = try reader.readEnum(JsxRuntime, .Little);
- length = try reader.readIntNative(u32);
- if (result.fragment.len != length) {
- result.fragment = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.fragment);
- result.production = (try reader.readByte()) == @as(u8, 1);
- length = try reader.readIntNative(u32);
- if (result.import_source.len != length) {
- result.import_source = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.import_source);
- result.react_fast_refresh = (try reader.readByte()) == @as(u8, 1);
- {
- var array_count = try reader.readIntNative(u32);
- if (array_count != result.loader_keys.len) {
- result.loader_keys = try allocator.alloc([]u8, array_count);
- }
- length = try reader.readIntNative(u32);
- for (result.loader_keys) |content, j| {
- if (result.loader_keys[j].len != length) {
- result.loader_keys[j] = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.loader_keys[j]);
- }
- }
- length = try reader.readIntNative(u32);
- result.loader_values = try allocator.alloc(Loader, length);
- {
- var j: usize = 0;
- while (j < length) : (j += 1) {
- result.loader_values[j] = try reader.readEnum(Loader, .Little);
- }
- }
- return;
- }
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- var n: usize = 0;
- try writer.writeIntNative(u32, @intCast(u32, result.factory.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.factory));
+pub const Api = struct {
- try writer.writeIntNative(@TypeOf(@enumToInt(result.runtime)), @enumToInt(result.runtime));
+pub const Loader = enum(u8) {
- try writer.writeIntNative(u32, @intCast(u32, result.fragment.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.fragment));
+_none,
+ /// jsx
+ jsx,
- try writer.writeByte(@boolToInt(result.production));
+ /// js
+ js,
- try writer.writeIntNative(u32, @intCast(u32, result.import_source.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.import_source));
+ /// ts
+ ts,
- try writer.writeByte(@boolToInt(result.react_fast_refresh));
+ /// tsx
+ tsx,
- n = result.loader_keys.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- _ = try writer.writeIntNative(u32, @intCast(u32, result.loader_keys[j].len));
- try writer.writeAll(std.mem.sliceAsBytes(result.loader_keys[j]));
- }
- }
-
- n = result.loader_values.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- try writer.writeByte(@enumToInt(result.loader_values[j]));
- }
- }
- return;
- }
- };
-
- pub const TransformOptions = struct {
- /// jsx
- jsx: Jsx,
-
- /// ts
- ts: bool = false,
-
- /// base_path
- base_path: []u8,
-
- /// define_keys
- define_keys: [][]u8,
-
- /// define_values
- define_values: [][]u8,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformOptions {
- var obj = std.mem.zeroes(TransformOptions);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *TransformOptions, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- result.jsx = try Jsx.decode(allocator, reader);
- result.ts = (try reader.readByte()) == @as(u8, 1);
- length = try reader.readIntNative(u32);
- if (result.base_path.len != length) {
- result.base_path = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.base_path);
- {
- var array_count = try reader.readIntNative(u32);
- if (array_count != result.define_keys.len) {
- result.define_keys = try allocator.alloc([]u8, array_count);
- }
- length = try reader.readIntNative(u32);
- for (result.define_keys) |content, j| {
- if (result.define_keys[j].len != length) {
- result.define_keys[j] = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.define_keys[j]);
- }
- }
- {
- var array_count = try reader.readIntNative(u32);
- if (array_count != result.define_values.len) {
- result.define_values = try allocator.alloc([]u8, array_count);
- }
- length = try reader.readIntNative(u32);
- for (result.define_values) |content, j| {
- if (result.define_values[j].len != length) {
- result.define_values[j] = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.define_values[j]);
- }
- }
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- var n: usize = 0;
- try result.jsx.encode(writer);
-
- try writer.writeByte(@boolToInt(result.ts));
-
- try writer.writeIntNative(u32, @intCast(u32, result.base_path.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.base_path));
-
- n = result.define_keys.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- _ = try writer.writeIntNative(u32, @intCast(u32, result.define_keys[j].len));
- try writer.writeAll(std.mem.sliceAsBytes(result.define_keys[j]));
- }
- }
-
- n = result.define_values.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- _ = try writer.writeIntNative(u32, @intCast(u32, result.define_values[j].len));
- try writer.writeAll(std.mem.sliceAsBytes(result.define_values[j]));
- }
- }
- return;
- }
- };
-
- pub const FileHandle = struct {
- /// path
- path: []u8,
-
- /// size
- size: u32 = 0,
-
- /// fd
- fd: u32 = 0,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!FileHandle {
- var obj = std.mem.zeroes(FileHandle);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *FileHandle, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- length = try reader.readIntNative(u32);
- if (result.path.len != length) {
- result.path = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.path);
- _ = try reader.readAll(std.mem.asBytes(&result.size));
- _ = try reader.readAll(std.mem.asBytes(&result.fd));
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- try writer.writeIntNative(u32, @intCast(u32, result.path.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.path));
-
- try writer.writeIntNative(u32, result.size);
-
- try writer.writeIntNative(u32, result.fd);
- return;
- }
- };
-
- pub const Transform = struct {
- /// handle
- handle: ?FileHandle = null,
-
- /// path
- path: ?[]u8 = null,
-
- /// contents
- contents: ?[]u8 = null,
-
- /// loader
- loader: ?Loader = null,
-
- /// options
- options: ?TransformOptions = null,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Transform {
- var obj = std.mem.zeroes(Transform);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *Transform, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- while (true) {
- const field_type: u8 = try reader.readByte();
- switch (field_type) {
- 0 => {
- return;
- },
-
- 1 => {
- result.handle = try FileHandle.decode(allocator, reader);
- },
- 2 => {
- length = try reader.readIntNative(u32);
- if ((result.path orelse &([_]u8{})).len != length) {
- result.path = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.path.?);
- },
- 3 => {
- length = try reader.readIntNative(u32);
- if ((result.contents orelse &([_]u8{})).len != length) {
- result.contents = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.contents.?);
- },
- 4 => {
- result.loader = try reader.readEnum(Loader, .Little);
- },
- 5 => {
- result.options = try TransformOptions.decode(allocator, reader);
- },
- else => {
- return error.InvalidMessage;
- },
- }
- }
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- if (result.handle) |handle| {
- try writer.writeByte(1);
- try handle.encode(writer);
- }
-
- if (result.path) |path| {
- try writer.writeByte(2);
- try writer.writeIntNative(u32, @intCast(u32, path.len));
- try writer.writeAll(std.mem.sliceAsBytes(path));
- }
-
- if (result.contents) |contents| {
- try writer.writeByte(3);
- try writer.writeIntNative(u32, @intCast(u32, contents.len));
- try writer.writeAll(std.mem.sliceAsBytes(contents));
- }
-
- if (result.loader) |loader| {
- try writer.writeByte(4);
- try writer.writeIntNative(@TypeOf(@enumToInt(result.loader orelse unreachable)), @enumToInt(result.loader orelse unreachable));
- }
-
- if (result.options) |options| {
- try writer.writeByte(5);
- try options.encode(writer);
- }
- try writer.writeByte(0);
- return;
- }
- };
-
- 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: []u8,
-
- /// path
- path: []u8,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!OutputFile {
- var obj = std.mem.zeroes(OutputFile);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *OutputFile, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- _ = try reader.readAll(result.data);
- length = try reader.readIntNative(u32);
- if (result.path.len != length) {
- result.path = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.path);
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- try writer.writeAll(result.data);
-
- try writer.writeIntNative(u32, @intCast(u32, result.path.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.path));
- return;
- }
- };
-
- pub const TransformResponse = struct {
- /// status
- status: TransformResponseStatus,
-
- /// files
- files: []OutputFile,
-
- /// errors
- errors: []Message,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformResponse {
- var obj = std.mem.zeroes(TransformResponse);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *TransformResponse, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- result.status = try reader.readEnum(TransformResponseStatus, .Little);
- length = try reader.readIntNative(u32);
- result.files = try allocator.alloc(OutputFile, length);
- {
- var j: usize = 0;
- while (j < length) : (j += 1) {
- result.files[j] = try OutputFile.decode(allocator, reader);
- }
- }
- length = try reader.readIntNative(u32);
- result.errors = try allocator.alloc(Message, length);
- {
- var j: usize = 0;
- while (j < length) : (j += 1) {
- result.errors[j] = try Message.decode(allocator, reader);
- }
- }
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- var n: usize = 0;
- try writer.writeIntNative(@TypeOf(@enumToInt(result.status)), @enumToInt(result.status));
-
- n = result.files.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- try result.files[j].encode(writer);
- }
- }
-
- n = result.errors.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- try result.errors[j].encode(writer);
- }
- }
- return;
- }
- };
-
- pub const MessageKind = enum(u32) {
- _none,
- /// err
- err,
-
- /// warn
- warn,
-
- /// note
- note,
-
- /// 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: []u8,
-
- /// namespace
- namespace: []u8,
-
- /// line
- line: i32 = 0,
-
- /// column
- column: i32 = 0,
-
- /// line_text
- line_text: []u8,
-
- /// suggestion
- suggestion: []u8,
-
- /// offset
- offset: u32 = 0,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Location {
- var obj = std.mem.zeroes(Location);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *Location, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- length = try reader.readIntNative(u32);
- if (result.file.len != length) {
- result.file = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.file);
- length = try reader.readIntNative(u32);
- if (result.namespace.len != length) {
- result.namespace = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.namespace);
- _ = try reader.readAll(std.mem.asBytes(&result.line));
- _ = try reader.readAll(std.mem.asBytes(&result.column));
- length = try reader.readIntNative(u32);
- if (result.line_text.len != length) {
- result.line_text = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.line_text);
- length = try reader.readIntNative(u32);
- if (result.suggestion.len != length) {
- result.suggestion = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.suggestion);
- _ = try reader.readAll(std.mem.asBytes(&result.offset));
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- try writer.writeIntNative(u32, @intCast(u32, result.file.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.file));
-
- try writer.writeIntNative(u32, @intCast(u32, result.namespace.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.namespace));
-
- try writer.writeIntNative(i32, result.line);
-
- try writer.writeIntNative(i32, result.column);
-
- try writer.writeIntNative(u32, @intCast(u32, result.line_text.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.line_text));
-
- try writer.writeIntNative(u32, @intCast(u32, result.suggestion.len));
- try writer.writeAll(std.mem.sliceAsBytes(result.suggestion));
-
- try writer.writeIntNative(u32, result.offset);
- return;
- }
- };
-
- pub const MessageData = struct {
- /// text
- text: ?[]u8 = null,
-
- /// location
- location: ?Location = null,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!MessageData {
- var obj = std.mem.zeroes(MessageData);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *MessageData, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- while (true) {
- const field_type: u8 = try reader.readByte();
- switch (field_type) {
- 0 => {
- return;
- },
-
- 1 => {
- length = try reader.readIntNative(u32);
- if ((result.text orelse &([_]u8{})).len != length) {
- result.text = try allocator.alloc(u8, length);
- }
- _ = try reader.readAll(result.text.?);
- },
- 2 => {
- result.location = try Location.decode(allocator, reader);
- },
- else => {
- return error.InvalidMessage;
- },
- }
- }
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- if (result.text) |text| {
- try writer.writeByte(1);
- try writer.writeIntNative(u32, @intCast(u32, text.len));
- try writer.writeAll(std.mem.sliceAsBytes(text));
- }
-
- if (result.location) |location| {
- try writer.writeByte(2);
- try location.encode(writer);
- }
- try writer.writeByte(0);
- return;
- }
- };
-
- pub const Message = struct {
- /// kind
- kind: MessageKind,
-
- /// data
- data: MessageData,
-
- /// notes
- notes: []MessageData,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Message {
- var obj = std.mem.zeroes(Message);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *Message, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- result.kind = try reader.readEnum(MessageKind, .Little);
- result.data = try MessageData.decode(allocator, reader);
- length = try reader.readIntNative(u32);
- result.notes = try allocator.alloc(MessageData, length);
- {
- var j: usize = 0;
- while (j < length) : (j += 1) {
- result.notes[j] = try MessageData.decode(allocator, reader);
+ /// css
+ css,
+
+ /// file
+ file,
+
+ /// json
+ json,
+
+_,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
}
- }
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- var n: usize = 0;
- try writer.writeIntNative(@TypeOf(@enumToInt(result.kind)), @enumToInt(result.kind));
-
- try result.data.encode(writer);
-
- n = result.notes.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- try result.notes[j].encode(writer);
+
+
+};
+
+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);
}
- }
- return;
- }
- };
-
- pub const Log = struct {
- /// warnings
- warnings: u32 = 0,
-
- /// errors
- errors: u32 = 0,
-
- /// msgs
- msgs: []Message,
-
- pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Log {
- var obj = std.mem.zeroes(Log);
- try update(&obj, allocator, reader);
- return obj;
- }
- pub fn update(result: *Log, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
- var length: usize = 0;
- _ = try reader.readAll(std.mem.asBytes(&result.warnings));
- _ = try reader.readAll(std.mem.asBytes(&result.errors));
- length = try reader.readIntNative(u32);
- result.msgs = try allocator.alloc(Message, length);
- {
- var j: usize = 0;
- while (j < length) : (j += 1) {
- result.msgs[j] = try Message.decode(allocator, reader);
+
+
+};
+
+pub const Jsx = struct {
+/// factory
+factory: []u8,
+
+/// runtime
+runtime: JsxRuntime,
+
+/// fragment
+fragment: []u8,
+
+/// production
+production: bool = false,
+
+/// import_source
+import_source: []u8,
+
+/// react_fast_refresh
+react_fast_refresh: bool = false,
+
+/// loader_keys
+loader_keys: [][]u8,
+
+/// loader_values
+loader_values: []Loader,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Jsx {
+var obj = std.mem.zeroes(Jsx);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Jsx, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ length = try reader.readIntNative(u32);
+ if (result.factory.len != length) {
+ result.factory = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.factory);
+ result.runtime = try reader.readEnum(JsxRuntime, .Little);
+ length = try reader.readIntNative(u32);
+ if (result.fragment.len != length) {
+ result.fragment = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.fragment);
+ result.production = (try reader.readByte()) == @as(u8, 1);
+ length = try reader.readIntNative(u32);
+ if (result.import_source.len != length) {
+ result.import_source = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.import_source);
+ result.react_fast_refresh = (try reader.readByte()) == @as(u8, 1);
+ {
+ var array_count = try reader.readIntNative(u32);
+ if (array_count != result.loader_keys.len) {
+ result.loader_keys = try allocator.alloc([]u8, array_count);
+ }
+ length = try reader.readIntNative(u32);
+ for (result.loader_keys) |content, j| {
+ if (result.loader_keys[j].len != length) {
+ result.loader_keys[j] = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.loader_keys[j]);
+ }
+ }
+ length = try reader.readIntNative(u32);
+ result.loader_values = try allocator.alloc(Loader, length);
+ {
+ var j: usize = 0;
+ while(j < length) : (j += 1) {
+ result.loader_values[j] = try reader.readEnum(Loader, .Little);
+ }}
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ var n: usize = 0;
+ try writer.writeIntNative(u32, @intCast(u32, result.factory.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.factory));
+
+ try writer.writeIntNative(@TypeOf(@enumToInt(result.runtime)), @enumToInt(result.runtime));
+
+ try writer.writeIntNative(u32, @intCast(u32, result.fragment.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.fragment));
+
+ try writer.writeByte(@boolToInt(result.production));
+
+ try writer.writeIntNative(u32, @intCast(u32, result.import_source.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.import_source));
+
+ try writer.writeByte(@boolToInt(result.react_fast_refresh));
+
+ n = result.loader_keys.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ _ = try writer.writeIntNative(u32, @intCast(u32, result.loader_keys[j].len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.loader_keys[j]));
+ }}
+
+ n = result.loader_values.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ try writer.writeByte(@enumToInt(result.loader_values[j]));
+ }}
+ return;
+}
+
+};
+
+pub const TransformOptions = struct {
+/// jsx
+jsx: Jsx,
+
+/// ts
+ts: bool = false,
+
+/// base_path
+base_path: []u8,
+
+/// define_keys
+define_keys: [][]u8,
+
+/// define_values
+define_values: [][]u8,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformOptions {
+var obj = std.mem.zeroes(TransformOptions);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *TransformOptions, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ result.jsx = try Jsx.decode(allocator, reader);
+ result.ts = (try reader.readByte()) == @as(u8, 1);
+ length = try reader.readIntNative(u32);
+ if (result.base_path.len != length) {
+ result.base_path = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.base_path);
+ {
+ var array_count = try reader.readIntNative(u32);
+ if (array_count != result.define_keys.len) {
+ result.define_keys = try allocator.alloc([]u8, array_count);
+ }
+ length = try reader.readIntNative(u32);
+ for (result.define_keys) |content, j| {
+ if (result.define_keys[j].len != length) {
+ result.define_keys[j] = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.define_keys[j]);
+ }
+ }
+ {
+ var array_count = try reader.readIntNative(u32);
+ if (array_count != result.define_values.len) {
+ result.define_values = try allocator.alloc([]u8, array_count);
+ }
+ length = try reader.readIntNative(u32);
+ for (result.define_values) |content, j| {
+ if (result.define_values[j].len != length) {
+ result.define_values[j] = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.define_values[j]);
+ }
+ }
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ var n: usize = 0;
+ try result.jsx.encode(writer);
+
+ try writer.writeByte(@boolToInt(result.ts));
+
+ try writer.writeIntNative(u32, @intCast(u32, result.base_path.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.base_path));
+
+ n = result.define_keys.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ _ = try writer.writeIntNative(u32, @intCast(u32, result.define_keys[j].len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.define_keys[j]));
+ }}
+
+ n = result.define_values.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ _ = try writer.writeIntNative(u32, @intCast(u32, result.define_values[j].len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.define_values[j]));
+ }}
+ return;
+}
+
+};
+
+pub const FileHandle = struct {
+/// path
+path: []u8,
+
+/// size
+size: u32 = 0,
+
+/// fd
+fd: u32 = 0,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!FileHandle {
+var obj = std.mem.zeroes(FileHandle);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *FileHandle, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ length = try reader.readIntNative(u32);
+ if (result.path.len != length) {
+ result.path = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.path);
+ _ = try reader.readAll(std.mem.asBytes(&result.size));
+ _ = try reader.readAll(std.mem.asBytes(&result.fd));
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ try writer.writeIntNative(u32, @intCast(u32, result.path.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.path));
+
+ try writer.writeIntNative(u32, result.size);
+
+ try writer.writeIntNative(u32, result.fd);
+ return;
+}
+
+};
+
+pub const Transform = struct {
+/// handle
+handle: ?FileHandle = null,
+
+/// path
+path: ?[]u8 = null,
+
+/// contents
+contents: ?[]u8 = null,
+
+/// loader
+loader: ?Loader = null,
+
+/// options
+options: ?TransformOptions = null,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Transform {
+var obj = std.mem.zeroes(Transform);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Transform, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ while(true) {
+ const field_type: u8 = try reader.readByte();
+ switch (field_type) {
+ 0 => { return; },
+
+ 1 => {
+ result.handle = try FileHandle.decode(allocator, reader);
+},
+ 2 => {
+ length = try reader.readIntNative(u32);
+ if ((result.path orelse &([_]u8{})).len != length) {
+ result.path = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.path.?);
+},
+ 3 => {
+ length = try reader.readIntNative(u32);
+ if ((result.contents orelse &([_]u8{})).len != length) {
+ result.contents = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.contents.?);
+},
+ 4 => {
+ result.loader = try reader.readEnum(Loader, .Little);
+},
+ 5 => {
+ result.options = try TransformOptions.decode(allocator, reader);
+},
+ else => {
+ return error.InvalidMessage;
+ }
+ }}
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ if (result.handle) |handle| {
+ try writer.writeByte(1);
+ try handle.encode(writer);
+ }
+
+ if (result.path) |path| {
+ try writer.writeByte(2);
+ try writer.writeIntNative(u32, @intCast(u32, path.len));
+ try writer.writeAll(std.mem.sliceAsBytes(path));
+ }
+
+ if (result.contents) |contents| {
+ try writer.writeByte(3);
+ try writer.writeIntNative(u32, @intCast(u32, contents.len));
+ try writer.writeAll(std.mem.sliceAsBytes(contents));
+ }
+
+ if (result.loader) |loader| {
+ try writer.writeByte(4);
+ try writer.writeIntNative(@TypeOf(@enumToInt(result.loader orelse unreachable)), @enumToInt(result.loader orelse unreachable));
+ }
+
+ if (result.options) |options| {
+ try writer.writeByte(5);
+ try options.encode(writer);
+ }
+ try writer.writeByte(0);
+ return;
+}
+
+};
+
+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);
}
- }
- return;
- }
-
- pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
- var n: usize = 0;
- try writer.writeIntNative(u32, result.warnings);
-
- try writer.writeIntNative(u32, result.errors);
-
- n = result.msgs.len;
- _ = try writer.writeIntNative(u32, @intCast(u32, n));
- {
- var j: usize = 0;
- while (j < n) : (j += 1) {
- try result.msgs[j].encode(writer);
+
+
+};
+
+pub const OutputFile = struct {
+/// data
+data: []u8,
+
+/// path
+path: []u8,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!OutputFile {
+var obj = std.mem.zeroes(OutputFile);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *OutputFile, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ _ = try reader.readAll(result.data);
+ length = try reader.readIntNative(u32);
+ if (result.path.len != length) {
+ result.path = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.path);
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ try writer.writeAll(result.data);
+
+ try writer.writeIntNative(u32, @intCast(u32, result.path.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.path));
+ return;
+}
+
+};
+
+pub const TransformResponse = struct {
+/// status
+status: TransformResponseStatus,
+
+/// files
+files: []OutputFile,
+
+/// errors
+errors: []Message,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformResponse {
+var obj = std.mem.zeroes(TransformResponse);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *TransformResponse, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ result.status = try reader.readEnum(TransformResponseStatus, .Little);
+ length = try reader.readIntNative(u32);
+ result.files = try allocator.alloc(OutputFile, length);
+ {
+ var j: usize = 0;
+ while(j < length) : (j += 1) {
+ result.files[j] = try OutputFile.decode(allocator, reader);
+ }}
+ length = try reader.readIntNative(u32);
+ result.errors = try allocator.alloc(Message, length);
+ {
+ var j: usize = 0;
+ while(j < length) : (j += 1) {
+ result.errors[j] = try Message.decode(allocator, reader);
+ }}
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ var n: usize = 0;
+ try writer.writeIntNative(@TypeOf(@enumToInt(result.status)), @enumToInt(result.status));
+
+ n = result.files.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ try result.files[j].encode(writer);
+
+ }}
+
+ n = result.errors.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ try result.errors[j].encode(writer);
+
+ }}
+ return;
+}
+
+};
+
+pub const MessageKind = enum(u32) {
+
+_none,
+ /// err
+ err,
+
+ /// warn
+ warn,
+
+ /// note
+ note,
+
+ /// debug
+ debug,
+
+_,
+
+ pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+ return try std.json.stringify(@tagName(self), opts, o);
}
- }
- return;
- }
- };
+
+
+};
+
+pub const Location = struct {
+/// file
+file: []u8,
+
+/// namespace
+namespace: []u8,
+
+/// line
+line: i32 = 0,
+
+/// column
+column: i32 = 0,
+
+/// line_text
+line_text: []u8,
+
+/// suggestion
+suggestion: []u8,
+
+/// offset
+offset: u32 = 0,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Location {
+var obj = std.mem.zeroes(Location);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Location, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ length = try reader.readIntNative(u32);
+ if (result.file.len != length) {
+ result.file = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.file);
+ length = try reader.readIntNative(u32);
+ if (result.namespace.len != length) {
+ result.namespace = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.namespace);
+ _ = try reader.readAll(std.mem.asBytes(&result.line));
+ _ = try reader.readAll(std.mem.asBytes(&result.column));
+ length = try reader.readIntNative(u32);
+ if (result.line_text.len != length) {
+ result.line_text = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.line_text);
+ length = try reader.readIntNative(u32);
+ if (result.suggestion.len != length) {
+ result.suggestion = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.suggestion);
+ _ = try reader.readAll(std.mem.asBytes(&result.offset));
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ try writer.writeIntNative(u32, @intCast(u32, result.file.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.file));
+
+ try writer.writeIntNative(u32, @intCast(u32, result.namespace.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.namespace));
+
+ try writer.writeIntNative(i32, result.line);
+
+ try writer.writeIntNative(i32, result.column);
+
+ try writer.writeIntNative(u32, @intCast(u32, result.line_text.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.line_text));
+
+ try writer.writeIntNative(u32, @intCast(u32, result.suggestion.len));
+ try writer.writeAll(std.mem.sliceAsBytes(result.suggestion));
+
+ try writer.writeIntNative(u32, result.offset);
+ return;
+}
+
};
+
+pub const MessageData = struct {
+/// text
+text: ?[]u8 = null,
+
+/// location
+location: ?Location = null,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!MessageData {
+var obj = std.mem.zeroes(MessageData);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *MessageData, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ while(true) {
+ const field_type: u8 = try reader.readByte();
+ switch (field_type) {
+ 0 => { return; },
+
+ 1 => {
+ length = try reader.readIntNative(u32);
+ if ((result.text orelse &([_]u8{})).len != length) {
+ result.text = try allocator.alloc(u8, length);
+ }
+ _ = try reader.readAll(result.text.?);
+},
+ 2 => {
+ result.location = try Location.decode(allocator, reader);
+},
+ else => {
+ return error.InvalidMessage;
+ }
+ }}
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ if (result.text) |text| {
+ try writer.writeByte(1);
+ try writer.writeIntNative(u32, @intCast(u32, text.len));
+ try writer.writeAll(std.mem.sliceAsBytes(text));
+ }
+
+ if (result.location) |location| {
+ try writer.writeByte(2);
+ try location.encode(writer);
+ }
+ try writer.writeByte(0);
+ return;
+}
+
+};
+
+pub const Message = struct {
+/// kind
+kind: MessageKind,
+
+/// data
+data: MessageData,
+
+/// notes
+notes: []MessageData,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Message {
+var obj = std.mem.zeroes(Message);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Message, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ result.kind = try reader.readEnum(MessageKind, .Little);
+ result.data = try MessageData.decode(allocator, reader);
+ length = try reader.readIntNative(u32);
+ result.notes = try allocator.alloc(MessageData, length);
+ {
+ var j: usize = 0;
+ while(j < length) : (j += 1) {
+ result.notes[j] = try MessageData.decode(allocator, reader);
+ }}
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ var n: usize = 0;
+ try writer.writeIntNative(@TypeOf(@enumToInt(result.kind)), @enumToInt(result.kind));
+
+ try result.data.encode(writer);
+
+ n = result.notes.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ try result.notes[j].encode(writer);
+
+ }}
+ return;
+}
+
+};
+
+pub const Log = struct {
+/// warnings
+warnings: u32 = 0,
+
+/// errors
+errors: u32 = 0,
+
+/// msgs
+msgs: []Message,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Log {
+var obj = std.mem.zeroes(Log);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Log, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+ var length: usize = 0;
+ _ = try reader.readAll(std.mem.asBytes(&result.warnings));
+ _ = try reader.readAll(std.mem.asBytes(&result.errors));
+ length = try reader.readIntNative(u32);
+ result.msgs = try allocator.alloc(Message, length);
+ {
+ var j: usize = 0;
+ while(j < length) : (j += 1) {
+ result.msgs[j] = try Message.decode(allocator, reader);
+ }}
+ return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+ var n: usize = 0;
+ try writer.writeIntNative(u32, result.warnings);
+
+ try writer.writeIntNative(u32, result.errors);
+
+ n = result.msgs.len;
+ _ = try writer.writeIntNative(u32, @intCast(u32, n));
+ {
+ var j: usize = 0;
+ while (j < n) : (j += 1) {
+ try result.msgs[j].encode(writer);
+
+ }}
+ return;
+}
+
+};
+
+
+}; \ No newline at end of file
diff --git a/src/global.zig b/src/global.zig
index 4ff43ed8e..eb7fcfec5 100644
--- a/src/global.zig
+++ b/src/global.zig
@@ -2,28 +2,50 @@ const std = @import("std");
pub usingnamespace @import("strings.zig");
pub const Output = struct {
- pub const source = comptime {
- if (std.builtin.os.tag == .wasi) {
- return @import("./output_wasi.zig");
- } else if (std.builtin.target.isWasm()) {
- return @import("./output_wasm.zig");
- } else {
- return @import("./output_native.zig");
+ var source: *Source = undefined;
+ pub const Source = struct {
+ const StreamType = comptime {
+ if (std.builtin.target.isWasm()) {
+ return std.io.FixedBufferStream([]u8);
+ } else {
+ return std.fs.File;
+ }
+ };
+ stream: StreamType,
+ error_stream: StreamType,
+ out_buffer: []u8 = &([_]u8{}),
+ err_buffer: []u8 = &([_]u8{}),
+
+ pub fn init(
+ stream: StreamType,
+ err: StreamType,
+ ) Source {
+ return Source{ .stream = stream, .error_stream = err };
+ }
+
+ pub fn set(_source: *Source) void {
+ source = _source;
}
};
pub fn print(comptime fmt: string, args: anytype) void {
if (comptime std.builtin.target.isWasm()) {
- std.fmt.format(source.writer, fmt, args) catch unreachable;
+ source.stream.pos = 0;
+ std.fmt.format(source.stream.writer(), fmt, args) catch unreachable;
+ const root = @import("root");
+ // root.console_log(@ptrToInt(&source.out_buffer), source.stream.pos);
} else {
- std.fmt.format(source.writer orelse unreachable, fmt, args) catch unreachable;
+ std.fmt.format(source.stream.writer(), fmt, args) catch unreachable;
}
}
pub fn printError(comptime fmt: string, args: anytype) void {
if (comptime std.builtin.target.isWasm()) {
- std.fmt.format(source.writer, fmt, args) catch unreachable;
+ source.error_stream.pos = 0;
+ std.fmt.format(source.error_stream.writer(), fmt, args) catch unreachable;
+ const root = @import("root");
+ // root.console_error(@ptrToInt(&source.err_buffer), source.error_stream.pos);
} else {
- std.fmt.format(source.writer orelse unreachable, fmt, args) catch unreachable;
+ std.fmt.format(source.error_stream.writer(), fmt, args) catch unreachable;
}
}
};
@@ -31,6 +53,7 @@ pub const Output = struct {
pub const Global = struct {
pub fn panic(comptime fmt: string, args: anytype) noreturn {
if (comptime std.builtin.target.isWasm()) {
+ Output.printError(fmt, args);
@panic(fmt);
} else {
std.debug.panic(fmt, args);
diff --git a/src/main.zig b/src/main.zig
index 20a07e33b..1edb78dde 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -30,16 +30,16 @@ pub fn main() anyerror!void {
// var root_alloc = std.heap.ArenaAllocator.init(std.heap.raw_c_allocator);
// var root_alloc_ = &root_alloc.allocator;
try alloc.setup(std.heap.c_allocator);
- Output.source.Stream = std.io.getStdOut();
- Output.source.writer = Output.source.Stream.?.writer();
- Output.source.errorWriter = std.io.getStdErr().writer();
+ var stdout: std.fs.File = std.io.getStdOut();
+ var stderr: std.fs.File = std.io.getStdErr();
+ var output_source = Output.Source.init(stdout, stderr);
+ Output.Source.set(&output_source);
+
var log = logger.Log.init(alloc.dynamic);
var panicker = MainPanicHandler.init(&log);
MainPanicHandler.Singleton = &panicker;
const args = try std.process.argsAlloc(alloc.dynamic);
- const stdout = std.io.getStdOut();
- const stderr = std.io.getStdErr();
if (args.len < 1) {
const len = stderr.write("Pass a file");
diff --git a/src/main_wasm.zig b/src/main_wasm.zig
index a379b4eb0..03360b165 100644
--- a/src/main_wasm.zig
+++ b/src/main_wasm.zig
@@ -16,6 +16,7 @@ const fs = @import("fs.zig");
const Schema = @import("api/schema.zig").Api;
const builtin = std.builtin;
const MainPanicHandler = panicky.NewPanicHandler(panicky.default_panic);
+const zee = @import("zee_alloc.zig");
pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
if (MainPanicHandler.Singleton) |singleton| {
@@ -135,25 +136,45 @@ pub const Api = struct {
}
};
+pub extern fn console_log(ptr: usize, len: usize) void;
+pub extern fn console_error(ptr: usize, len: usize) void;
+pub extern fn console_warn(ptr: usize, len: usize) void;
+pub extern fn console_info(ptr: usize, len: usize) void;
+
+const Gpa = std.heap.GeneralPurposeAllocator(.{});
+var gpa = Gpa{};
pub const Exports = struct {
- fn init() callconv(.C) u8 {
+ fn init(amount_to_grow: usize) callconv(.C) i32 {
+ const res = @wasmMemoryGrow(0, amount_to_grow);
if (alloc.needs_setup) {
- var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
- var allocator = &arena.allocator;
- alloc.setup(allocator) catch return 0;
+ alloc.setup(&gpa.allocator) catch return -1;
+ _ = MainPanicHandler.init(&api.?.log);
+ var out_buffer = alloc.static.alloc(u8, 2048) catch return -1;
+ var err_buffer = alloc.static.alloc(u8, 2048) catch return -1;
+ var output = alloc.static.create(Output.Source) catch return -1;
+ var stream = std.io.fixedBufferStream(out_buffer);
+ var err_stream = std.io.fixedBufferStream(err_buffer);
+ output.* = Output.Source.init(
+ stream,
+ err_stream,
+ );
+ output.out_buffer = out_buffer;
+ output.err_buffer = err_buffer;
+ Output.Source.set(output);
}
- var _api = alloc.static.create(Api) catch return 0;
-
+ var _api = alloc.static.create(Api) catch return -1;
_api.* = Api{ .files = std.ArrayList(string).init(alloc.dynamic), .log = logger.Log.init(alloc.dynamic) };
api = _api;
-
- return 1;
+ // Output.print("Initialized.", .{});
+ return res;
}
fn transform(abi: Uint8Array.Abi) callconv(.C) Uint8Array.Abi {
+ Output.print("Received {d}", .{abi});
const req: Schema.Transform = Uint8Array.decode(abi, Schema.Transform) catch return Uint8Array.empty();
- alloc.dynamic.free(Uint8Array.toSlice(abi));
+ Output.print("Req {s}", .{req});
+ // alloc.dynamic.free(Uint8Array.toSlice(abi));
const resp = api.?.transform(req) catch return Uint8Array.empty();
return Uint8Array.encode(Schema.TransformResponse, resp) catch return Uint8Array.empty();
}
@@ -208,3 +229,5 @@ comptime {
}
var api: ?*Api = null;
+
+pub fn main() anyerror!void {}
diff --git a/src/output_wasm.zig b/src/output_wasm.zig
index 8ad9fdebb..ef08d9a16 100644
--- a/src/output_wasm.zig
+++ b/src/output_wasm.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-pub var out_buffer = [_]u8{0} ** 1024;
-pub var Stream = std.io.fixedBufferStream(&out_buffer);
-pub var writer = Stream.writer();
+pub var out_buffer: []u8 = &([_]u8{});
+pub var Stream: ?std.io.FixedBufferStream([]u8) = null;
+pub var writer = if (Stream) |stream| stream.writer() else null;