Page MenuHomeSealhub
Files F10352726

build.ts
No OneTemporary
Actions

build.ts
View Options

import { build, BuildContext, context } from "esbuild";
import { promises as fs } from "fs";
import * as chokidar from "chokidar";
import { default as glob } from "tiny-glob";
import { generate_css_includes } from "./find-css-includes.js";
import { sleep } from "./utils/sleep.js";
import { generateCollections } from "./generate-collections.js";
import { generateRoutes } from "./generate-routes.js";
import { generateComponents } from "./generate-components.js";
import { make_notifier } from "./notifier.js";
import getPort from "get-port";
import { removeNamedImports } from "../remove-named-imports.js";
import md5 from "md5";
import _locreq from "locreq";
import path, { basename, extname } from "path";
import { copyFile } from "fs/promises";
import { FONTS_CONFIG_PATH, getFonts } from "./get-fonts.js";
const target_locreq = _locreq(process.cwd());
async function get_notifier_port() {
return getPort({ port: 4000 });
}
async function write_notifier_config(watch: boolean, port?: number) {
const config = { watch } as Record<string, boolean | number>;
if (port) {
config.port = port;
}
await fs.writeFile(
target_locreq.resolve("public/dist/notifier.json"),
JSON.stringify(config)
);
}
function addSuffix(filename: string, suffix: string) {
return filename.replace(/(\.[a-zA-Z0-9]+)?$/, suffix + "$1");
}
async function makeResourceURL(file_path: string) {
const hash_base = file_path + (await fs.stat(file_path)).mtimeMs;
const hash = md5(hash_base);
const public_url =
"dist/" + addSuffix(basename(file_path), "-" + hash.slice(0, 8));
const public_dir = "public";
await copyFile(
file_path,
target_locreq.resolve(path.resolve(public_dir, public_url))
);
return "/" + public_url;
}
async function build_ts() {
await Promise.all([
generateCollections(),
generateRoutes(),
generateComponents(),
]);
const embeddable_file_extensions = ["svg", "png", "jpg", "jpeg", "webp"];
const entryPoints = (
await glob(
`./src/back/**/*.{ts,tsx,${embeddable_file_extensions.join(",")}}`
)
).filter((path) => !path.includes(".#"));
try {
await build({
entryPoints,
sourcemap: true,
bundle: false,
jsxFactory: "TempstreamJSX.createElement",
outdir: "./dist/back",
logLevel: "info",
platform: "node",
target: "es2022",
format: "esm",
loader: Object.fromEntries(
embeddable_file_extensions.map((ext) => ["." + ext, "js"])
),
plugins: [
{
name: "sealgen-rewrite-asset-imports",
setup(build) {
build.onLoad(
{ filter: /\.tsx?$/ },
async (args: any) => {
let contents = await fs.readFile(
args.path,
"utf8"
);
for (const ext of embeddable_file_extensions) {
const regex = new RegExp(
`^import (\\w+|{[^}]+}) from "([^"]+.${ext})";`,
"gm"
);
contents = contents.replaceAll(
regex,
(line) => {
return line.replace(
`.${ext}"`,
'.js"'
);
}
);
}
contents = removeNamedImports(contents);
return {
contents,
loader:
extname(args.path) === ".tsx"
? "tsx"
: "ts",
};
}
);
},
},
{
name: "sealgen-load-assets",
setup(build) {
build.onLoad(
{
filter: new RegExp(
`\\.(${embeddable_file_extensions.join(
"|"
)})$`
),
},
async (args: any) => {
let contents = `export const url = "${await makeResourceURL(
args.path
)}";
import fs from "fs";
let buffer_promise = null;
export const getBuffer = function(){
if(buffer_promise) return buffer_promise;
buffer_promise = fs.promises.readFile("${args.path}");
return buffer_promise;
}
export const getContent = async function(){
const buffer = await getBuffer();
return buffer.toString("utf-8");
}
export const getBase64 = async function(){
const buffer = await getBuffer();
return buffer.toString("base64");
}
export default { getContent, url, getBase64, getBuffer };
`;
return {
contents,
};
}
);
},
},
],
});
} catch (e) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
console.error(e.message);
}
}
async function complex_build(watch: boolean): Promise<void> {
const loader = Object.fromEntries(
(<const>["png", "svg", "jpg", "gif", "jpeg", "otf", "ttf"]).map(
(ext) => <const>["." + ext, "file"]
)
);
let css_build: BuildContext = await context({
entryPoints: ["./src/main.css"],
sourcemap: true,
bundle: true,
outdir: "./public/dist",
logLevel: "info",
// plugins: [sassPlugin()],
loader,
});
let ongoing_fonts = false;
let ongoing_ts = false;
let ongoing_css = false;
let ongoing_ts_promise: Promise<any> | null = null;
if (watch) {
const watcher = chokidar.watch("src", { ignoreInitial: true });
const port = await get_notifier_port();
const notifier = make_notifier(port);
await write_notifier_config(watch, port);
watcher.on("all", async (_, path) => {
if (!css_build) return;
if (path.includes(".#")) return;
if (path == FONTS_CONFIG_PATH) {
if (!ongoing_fonts) {
ongoing_fonts = true;
await getFonts();
ongoing_fonts = false;
}
return;
}
if (path.endsWith(".css") && !path.endsWith("/includes.css")) {
if (ongoing_css) {
return;
}
ongoing_css = true;
// refresh the list of all css files in includes.css
await generate_css_includes();
try {
await css_build?.rebuild?.();
console.log(`Built main.css [on ${path}]`);
} catch (e) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
console.error(e.message);
await sleep(200);
css_build
?.rebuild?.()
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
.catch((e) => console.error(e?.message));
}
if (ongoing_ts_promise) {
await ongoing_ts_promise;
}
notifier("css");
ongoing_css = false;
}
if (
(path.endsWith(".ts") || path.endsWith(".tsx")) &&
!path.endsWith("src/back/collections/collections.ts") &&
!path.endsWith("src/back/routes/routes.ts") &&
!path.endsWith("src/back/routes/urls.ts")
) {
if (ongoing_ts) {
return;
}
ongoing_ts = true;
ongoing_ts_promise = build_ts();
await ongoing_ts_promise;
notifier("ts");
ongoing_ts_promise = null;
console.log(`Finished TS build [on ${path}]`);
ongoing_ts = false;
}
});
} else {
await write_notifier_config(watch);
}
await generate_css_includes();
await Promise.all([css_build.rebuild(), build_ts()]);
if (watch) {
css_build?.rebuild?.();
} else {
css_build.dispose();
}
}
export async function buildProject({
watch,
}: {
watch: boolean;
}): Promise<void> {
try {
await build({
entryPoints: ["./src/front/index.ts"],
sourcemap: true,
outfile: "./public/dist/bundle.js",
logLevel: "info",
bundle: true,
});
await complex_build(watch);
} catch (e) {
console.log("CAUGHT!");
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
console.error(e.message);
if (!watch) {
process.exit(1);
}
}
}

File Metadata

Mime Type
text/x-java
Expires
Sun, Nov 2, 18:26 (1 d, 8 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1005408
Default Alt Text
build.ts (7 KB)

Event Timeline