127 lines
3.8 KiB
TypeScript
127 lines
3.8 KiB
TypeScript
import toast from "react-hot-toast";
|
|
import Router from 'next/router';
|
|
|
|
import state from "../index";
|
|
import { saveFile } from "./saveFile";
|
|
import { decodeBinary } from "../../utils/decodeBinary";
|
|
import { ref } from "valtio";
|
|
|
|
/* compileCode sends the code of the active file to compile endpoint
|
|
* If all goes well you will get base64 encoded wasm file back with
|
|
* some extra logging information if we can provide it. This function
|
|
* also decodes the returned wasm and creates human readable WAT file
|
|
* out of it and store both in global state.
|
|
*/
|
|
export const compileCode = async (activeId: number) => {
|
|
// Save the file to global state
|
|
saveFile(false, activeId);
|
|
if (!process.env.NEXT_PUBLIC_COMPILE_API_ENDPOINT) {
|
|
throw Error("Missing env!");
|
|
}
|
|
// Bail out if we're already compiling
|
|
if (state.compiling) {
|
|
// if compiling is ongoing return // TODO Inform user about it.
|
|
return;
|
|
}
|
|
// Set loading state to true
|
|
state.compiling = true;
|
|
state.logs = []
|
|
const file = state.files[activeId]
|
|
try {
|
|
file.containsErrors = false
|
|
let res: Response
|
|
try {
|
|
res = await fetch(process.env.NEXT_PUBLIC_COMPILE_API_ENDPOINT, {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify({
|
|
output: "wasm",
|
|
compress: true,
|
|
strip: state.compileOptions.strip,
|
|
files: [
|
|
{
|
|
type: "c",
|
|
options: state.compileOptions.optimizationLevel || '-O2',
|
|
name: file.name,
|
|
src: file.content,
|
|
},
|
|
],
|
|
}),
|
|
});
|
|
} catch (error) {
|
|
throw Error("Something went wrong, check your network connection and try again!")
|
|
}
|
|
const json = await res.json();
|
|
state.compiling = false;
|
|
if (!json.success) {
|
|
const errors = [json.message]
|
|
if (json.tasks && json.tasks.length > 0) {
|
|
json.tasks.forEach((task: any) => {
|
|
if (!task.success) {
|
|
errors.push(task?.console)
|
|
}
|
|
});
|
|
}
|
|
throw errors
|
|
}
|
|
try {
|
|
// Decode base64 encoded wasm that is coming back from the endpoint
|
|
const bufferData = await decodeBinary(json.output);
|
|
|
|
// Import wabt from and create human readable version of wasm file and
|
|
// put it into state
|
|
const ww = (await import('wabt')).default()
|
|
const myModule = ww.readWasm(new Uint8Array(bufferData), {
|
|
readDebugNames: true,
|
|
});
|
|
myModule.applyNames();
|
|
|
|
const wast = myModule.toText({ foldExprs: false, inlineExport: false });
|
|
|
|
file.compiledContent = ref(bufferData);
|
|
file.lastCompiled = new Date();
|
|
file.compiledValueSnapshot = file.content
|
|
file.compiledWatContent = wast;
|
|
} catch (error) {
|
|
throw Error("Invalid compilation result produced, check your code for errors and try again!")
|
|
}
|
|
|
|
toast.success("Compiled successfully!", { position: "bottom-center" });
|
|
state.logs.push({
|
|
type: "success",
|
|
message: `File ${state.files?.[activeId]?.name} compiled successfully. Ready to deploy.`,
|
|
link: Router.asPath.replace("develop", "deploy"),
|
|
linkText: "Go to deploy",
|
|
});
|
|
} catch (err) {
|
|
console.log(err);
|
|
|
|
if (err instanceof Array && typeof err[0] === 'string') {
|
|
err.forEach(message => {
|
|
state.logs.push({
|
|
type: "error",
|
|
message,
|
|
});
|
|
})
|
|
}
|
|
else if (err instanceof Error) {
|
|
state.logs.push({
|
|
type: "error",
|
|
message: err.message,
|
|
});
|
|
}
|
|
else {
|
|
state.logs.push({
|
|
type: "error",
|
|
message: "Something went wrong, come back later!",
|
|
});
|
|
}
|
|
|
|
state.compiling = false;
|
|
toast.error(`Error occurred while compiling!`, { position: "bottom-center" });
|
|
file.containsErrors = true
|
|
}
|
|
};
|