Carbon/build.js

283 lines
8.4 KiB
JavaScript
Raw Normal View History

const pug = require("pug")
const sass = require("sass")
2020-10-23 14:15:14 +00:00
const fs = require("fs")
const os = require("os")
const crypto = require("crypto")
const path = require("path")
const pj = path.join
const babel = require("@babel/core")
const fetch = require("node-fetch")
const chalk = require("chalk")
const hint = require("jshint").JSHINT
2020-10-23 14:15:14 +00:00
const browserify = require('browserify')
process.chdir(pj(__dirname, "src"))
const buildDir = "../build"
const validationQueue = []
const validationHost = os.hostname() === "future" ? "http://localhost:8888/" : "http://validator.w3.org/nu/"
2020-10-23 14:15:14 +00:00
const static_files = new Map()
const links = new Map()
const sources = new Map()
2020-10-23 14:15:14 +00:00
const pugLocals = {static: static_files, links}
const spec = require("./spec.js")
2020-10-11 13:26:24 +00:00
function hash(buffer) {
return crypto.createHash("sha256").update(buffer).digest("hex").slice(0, 10)
2020-10-11 13:26:24 +00:00
}
function getRelative(targetPath, staticTarget) {
const pathLayer = (path.dirname(targetPath).replace(/\/$/, "").match(/\//g) || []).length
const prefix = Array(pathLayer).fill("../").join("")
const result = prefix + staticTarget.replace(/^\//, "")
if (result) return result
else return "./"
}
2020-10-11 13:26:24 +00:00
function validate(filename, body, type) {
const promise = fetch(validationHost+"?out=json", {
method: "POST",
body,
headers: {
"content-type": `text/${type}; charset=UTF-8`
}
}).then(res => res.json()).then(root => {
return function cont() {
let concerningMessages = 0
for (const message of root.messages) {
if (message.hiliteStart) {
let type = message.type
if (message.type === "error") {
type = chalk.red("error")
} else if (message.type === "warning") {
type = chalk.yellow("warning")
} else {
continue // don't care about info
}
let match
if (match = message.message.match(/Property “([\w-]+)” doesn't exist.$/)) {
// allow these properties specifically
if (["scrollbar-width", "scrollbar-color", "overflow-anchor"].includes(match[1])) {
continue
}
}
concerningMessages++
console.log(`validation: ${type} in ${filename}`)
console.log(` ${message.message}`)
const text = message.extract.replace(/\n/g, "⏎").replace(/\t/g, " ")
console.log(chalk.grey(
" "
+ text.slice(0, message.hiliteStart)
+ chalk.inverse(text.substr(message.hiliteStart, message.hiliteLength))
+ text.slice(message.hiliteStart+message.hiliteLength)
))
} else {
console.log(message)
}
}
if (!concerningMessages) {
console.log(`validation: ${chalk.green("ok")} for ${filename}`)
}
}
})
validationQueue.push(promise)
return promise
2020-10-11 13:26:24 +00:00
}
function runHint(filename, source) {
hint(source, {
esversion: 9,
undef: true,
// unused: true,
loopfunc: true,
globals: ["console", "URLSearchParams", "staticFiles"],
browser: true,
asi: true,
})
const result = hint.data()
let problems = 0
if (result.errors) {
for (const error of result.errors) {
if (error.evidence) {
const text = error.evidence.replace(/\t/g, " ")
if ([
"W014"
].includes(error.code)) continue
let type = error.code.startsWith("W") ? chalk.yellow("warning") : chalk.red("error")
console.log(`hint: ${type} in ${filename}`)
console.log(` ${error.line}:${error.character}: ${error.reason} (${error.code})`)
console.log(chalk.gray(
" "
+ text.slice(0, error.character)
+ chalk.inverse(text.substr(error.character, 1))
+ text.slice(error.character+1)
))
problems++
}
}
}
if (problems) {
console.log(`hint: ${chalk.cyan(problems+" problems")} in ${filename}`)
} else {
console.log(`hint: ${chalk.green("ok")} for ${filename}`)
}
2020-10-11 13:26:24 +00:00
}
async function addFile(sourcePath, targetPath) {
2020-10-23 14:15:14 +00:00
const contents = await fs.promises.readFile(pj(".", sourcePath), {encoding: null});
static_files.set(sourcePath, `${targetPath}?static=${hash(contents)}`)
await fs.promises.writeFile(pj(buildDir, targetPath), contents)
2020-10-11 13:26:24 +00:00
}
async function loadJS(sourcePath, targetPath) {
2020-10-23 14:15:14 +00:00
let content = await fs.promises.readFile(pj(".", sourcePath), {encoding: "utf8"})
sources.set(sourcePath, content);
static_files.set(sourcePath, `${targetPath}?static=${hash(content)}`)
}
2020-10-11 13:26:24 +00:00
async function addJS(sourcePath, targetPath) {
let content = sources.get(sourcePath)
// resolve imports to hashed paths
content = content.replace(/\$to_relative "([^"]+)"/g, function(_, file) {
2020-10-23 14:15:14 +00:00
if (!static_files.get(file)) throw new Error(`Tried to relative import ${file} from ${sourcePath}, but import not found`)
return '"' + getRelative(targetPath, static_files.get(file)) + '"'
})
runHint(sourcePath, content)
2020-10-23 14:15:14 +00:00
await fs.promises.writeFile(pj(buildDir, targetPath), content)
}
async function addBundle(sourcePath, targetPath) {
await browserify()
.add(pj(".", sourcePath))
.bundle()
.pipe(fs.createWriteStream(pj(buildDir, targetPath)));
static_files.set(sourcePath, targetPath)
2020-10-11 13:26:24 +00:00
}
async function addSass(sourcePath, targetPath) {
const renderedCSS = sass.renderSync({
file: pj(".", sourcePath),
outputStyle: "expanded",
indentType: "tab",
indentWidth: 1,
functions: {
2020-10-20 11:26:46 +00:00
"relative($name)": function(name) {
if (!(name instanceof sass.types.String)) {
throw "$name: expected a string"
}
2020-10-23 14:15:14 +00:00
const result = getRelative(targetPath, static_files.get(name.getValue()))
if (typeof result === "string") {
return new sass.types.String(result)
} else {
throw new Error("static file '"+name.getValue()+"' does not exist")
}
}
}
2020-10-23 14:15:14 +00:00
}).css;
static_files.set(sourcePath, `${targetPath}?static=${hash(renderedCSS)}`)
await validate(sourcePath, renderedCSS, "css")
await fs.promises.writeFile(pj(buildDir, targetPath), renderedCSS)
2020-10-11 13:26:24 +00:00
}
async function addPug(sourcePath, targetPath) {
function getRelativeHere(staticTarget) {
return getRelative(targetPath, staticTarget)
}
function getStatic(target) {
2020-10-23 14:15:14 +00:00
return getRelativeHere(static_files.get(target))
}
function getStaticName(target) {
2020-10-23 14:15:14 +00:00
return getRelativeHere(static_files.get(target)).replace(/\?.*$/, "")
}
function getLink(target) {
return getRelativeHere(links.get(target))
}
const renderedHTML = pug.compileFile(pj(".", sourcePath), {pretty: true})({getStatic, getStaticName, getLink, ...pugLocals})
let renderedWithoutPHP = renderedHTML.replace(/<\?(?:php|=).*?\?>/gsm, "")
2020-10-23 14:15:14 +00:00
await validate(sourcePath, renderedWithoutPHP, "html")
await fs.promises.writeFile(pj(buildDir, targetPath), renderedHTML)
2020-10-11 13:26:24 +00:00
}
async function addBabel(sourcePath, targetPath) {
2020-10-23 14:15:14 +00:00
const originalCode = await fs.promises.readFile(pj(".", sourcePath), "utf8")
const compiled = babel.transformSync(originalCode, {
sourceMaps: false,
sourceType: "script",
presets: [
[
"@babel/env", {
targets: {
"ie": 11
}
}
]
],
generatorOpts: {
comments: false,
minified: false,
sourceMaps: false,
}
})
2020-10-23 14:15:14 +00:00
const filenameWithQuery = `${targetPath}?static=${hash(compiled.code)}`;
2020-10-23 14:15:14 +00:00
static_files.set(sourcePath, filenameWithQuery)
await Promise.all([
2020-10-23 14:15:14 +00:00
fs.promises.writeFile(pj(buildDir, targetPath), originalCode),
fs.promises.writeFile(pj(buildDir, minFilename), compiled.code),
fs.promises.writeFile(pj(buildDir, mapFilename), JSON.stringify(compiled.map))
])
2020-10-11 13:26:24 +00:00
}
;(async () => {
// Stage 1: Register
for (const item of spec) {
if (item.type === "pug") {
links.set(item.source, item.target.replace(/index.html$/, ""))
}
}
// Stage 2: Load JS
await Promise.all(spec.filter(item => {
return item.type === "js"
}).map(item => {
return loadJS(item.source, item.target)
}))
// Stage 3: Create dirs
const dirs = [...new Set(spec.map(item => path.dirname(item.target))).values()]
2020-10-23 14:15:14 +00:00
await Promise.all(dirs.map(d => fs.promises.mkdir(pj(buildDir, d), {recursive: true})))
// Stage 4: Build
for (const item of spec) {
if (item.type === "file") {
await addFile(item.source, item.target)
} else if (item.type === "js") {
await addJS(item.source, item.target)
} else if (item.type === "sass") {
await addSass(item.source, item.target)
} else if (item.type === "babel") {
await addBabel(item.source, item.target)
} else if (item.type === "pug") {
await addPug(item.source, item.target)
2020-10-23 14:15:14 +00:00
} else if (item.type === "bundle") {
await addBundle(item.source, item.target)
} else {
throw new Error("Unknown item type: "+item.type)
}
}
console.log(chalk.green("All files emitted."))
await Promise.all(validationQueue).then(v => {
console.log(`validation: using host ${chalk.cyan(validationHost)}`)
v.forEach(cont => cont())
})
console.log(chalk.green("Build complete.") + "\n\n------------\n")
})()