125 lines
3.7 KiB
TypeScript
125 lines
3.7 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
|
|
}
|
|
}
|