Very Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515import { basename, dirname, extname, join, normalize } from "./deps/path.js";import { copy, emptyDir, ensureDir, exists } from "./deps/fs.js";import { gray } from "./deps/colors.js";import { createHash } from "./deps/hash.js";import Source from "./source.js";import Scripts from "./scripts.js";import { concurrent } from "./utils.js";
const defaults = { cwd: Deno.cwd(), src: "./", dest: "./_site", dev: false, prettyUrls: true, flags: [], server: { port: 3000, page404: "/404.html", },};
export default class Site { engines = new Map(); filters = new Map(); extraData = {}; listeners = new Map(); processors = new Map(); pages = [];
constructor(options = {}) { this.options = { ...defaults, ...options };
this.options.location = (options.location instanceof URL) ? this.options.location : new URL(this.options.location || "http://localhost");
this.source = new Source(this); this.scripts = new Scripts(this); }
/** * Returns the src path */ src(...path) { return join(this.options.cwd, this.options.src, ...path); }
/** * Returns the dest path */ dest(...path) { return join(this.options.cwd, this.options.dest, ...path); }
/** * Adds an event */ addEventListener(type, listener) { const listeners = this.listeners.get(type) || new Set(); listeners.add(listener); this.listeners.set(type, listeners); return this; }
/** * Dispatch an event */ async dispatchEvent(event) { const type = event.type; const listeners = this.listeners.get(type);
if (!listeners) { return; }
for (let listener of listeners) { if (typeof listener === "string") { listener = [listener]; }
if (Array.isArray(listener)) { const status = await this.run(...listener);
if (status) { return false; }
continue; }
if (await listener(event) === false) { return false; } } }
/** * Use a plugin */ use(plugin) { plugin(this); return this; }
/** * Register a script */ script(name, ...scripts) { this.scripts.set(name, ...scripts); return this; }
/** * Register a data loader for some extensions */ loadData(extensions, loader) { extensions.forEach((extension) => this.source.data.set(extension, loader)); return this; }
/** * Register a page loader for some extensions */ loadPages(extensions, loader) { extensions.forEach((extension) => this.source.pages.set(extension, loader)); return this; }
/** * Register an assets loader for some extensions */ loadAssets(extensions, loader) { extensions.forEach((extension) => this.source.pages.set(extension, loader)); extensions.forEach((extension) => this.source.assets.add(extension)); return this; }
/** * Register a processor for some extensions */ process(extensions, processor) { extensions.forEach((extension) => { const processors = this.processors.get(extension) || []; processors.push(processor); this.processors.set(extension, processors); }); return this; }
/** * Register template engine used for some extensions */ engine(extensions, engine) { extensions.forEach((extension) => this.engines.set(extension, engine)); this.loadPages(extensions, engine.load.bind(engine));
for (const [name, filter] of this.filters) { engine.addFilter(name, filter); }
return this; }
/** * Register a template filter */ filter(name, filter) { this.filters.set(name, filter);
for (const engine of this.engines.values()) { engine.addFilter(name, filter); }
return this; }
/** * Register extra data accesible by layouts */ data(name, data) { this.extraData[name] = data; return this; }
/** * Copy static files/folders without processing */ copy(from, to = from) { this.source.staticFiles.set(join("/", from), join("/", to)); return this; }
/** * Ignore one or several files or folders */ ignore(...paths) { paths.forEach((path) => this.source.ignored.add(join("/", path))); return this; }
/** * Clear the dest folder */ async clear() { await emptyDir(this.dest()); }
/** * Build the entire site */ async build() { await this.dispatchEvent({ type: "beforeBuild" });
await this.clear();
for (const [from, to] of this.source.staticFiles) { await this.#copyStatic(from, to); }
await this.source.loadDirectory(); await this.#buildPages();
await this.dispatchEvent({ type: "afterBuild" }); }
/** * Reload some files that might be changed */ async update(files) { await this.dispatchEvent({ type: "beforeUpdate" });
//Update engines cache new Set(this.engines.values()).forEach((engine) => engine.update(Array.from(files).map((file) => this.src(file))) );
for (const file of files) { // file inside a _data file or folder if (file.includes("/_data/") || file.match(/\/_data.\w+$/)) { await this.source.loadFile(file); continue; }
// file path contains /_ or /. if (file.includes("/_") || file.includes("/.")) { continue; }
//Static file const entry = this.source.isStatic(file);
if (entry) { const [from, to] = entry;
await this.#copyStatic(file, join(to, file.slice(from.length))); continue; }
//Default await this.source.loadFile(file); }
await this.#buildPages(); await this.dispatchEvent({ type: "afterUpdate" }); }
/** * Run a script */ async run(name, options = {}) { return await this.scripts.run(options, name); }
/** * Return the site flags */ get flags() { return this.options.flags || []; }
/** * Returns the url of a page */ url(path, absolute) { if ( path.startsWith("./") || path.startsWith("../") || path.startsWith("#") || path.startsWith("?") ) { return path; }
try { return new URL(path).toString(); } catch (err) { if (!this.options.location) { return normalize(join("/", path)); }
path = normalize(join(this.options.location.pathname, path));
return absolute ? this.options.location.origin + path : path; } }
/** * Copy a static file */ async #copyStatic(from, to) { const pathFrom = this.src(from); const pathTo = this.dest(to);
if (await exists(pathFrom)) { await ensureDir(dirname(pathTo)); console.log(`🔥 ${from}`); return copy(pathFrom, pathTo, { overwrite: true }); } }
/** * Build the pages */ async #buildPages() { this.pages = [];
for (const page of this.source.root.getPages()) { if (page.data.draft && !this.options.dev) { continue; }
page.content = page.data.content;
if (await this.#expandPage(page)) { continue; }
this.#urlPage(page);
this.pages.push(page); }
return concurrent( this.pages, async (page) => { await this.#renderPage(page);
if (!page.content) { return; }
const processors = this.processors.get(page.dest.ext);
if (processors) { for (const process of processors) { await process(page); } }
await this.#savePage(page); }, ); }
/** * Generate the url and dest info of a page */ #urlPage(page) { const { dest } = page;
if (page.data.permalink) { const ext = extname(page.data.permalink); dest.ext = ext || ".html"; dest.path = ext ? page.data.permalink.slice(0, -ext.length) : page.data.permalink;
if (!ext && this.options.prettyUrls) { dest.path = join(dest.path, "index"); } } else if ( this.options.prettyUrls && dest.ext === ".html" && basename(dest.path) !== "index" ) { dest.path = join(dest.path, "index"); }
if (!dest.path.startsWith("/")) { dest.path = `/${dest.path}`; }
page.data.url = (dest.ext === ".html" && basename(dest.path) === "index") ? dest.path.slice(0, -5) : dest.path + dest.ext; }
/** * Generate subpages (for pagination) */ async #expandPage(page) { const content = page.content;
if (typeof content === "function") { const data = { ...page.fullData, ...this.extraData }; const result = content(data, Object.fromEntries(this.filters));
switch (String(result)) { case "[object Generator]": case "[object AsyncGenerator]": let num = 1;
for await (const pageData of result) { const key = `${page.src.path}-${num}${page.src.ext}`; const value = page.duplicate(pageData);
if (value.data.content === content) { value.data.content = null; }
page.parent.setPage(key, value);
num++; }
return true; }
page.content = result; } }
/** * Render a page */ async #renderPage(page) { let content = page.content; let pageData = { ...page.fullData, ...this.extraData }; let layout = pageData.layout; let path = this.src(page.src.path + page.src.ext); const engine = this.#getEngine(page.src.ext, pageData.templateEngine);
if (Array.isArray(engine)) { for (const eng of engine) { content = await eng.render(content, pageData, path); } } else if (engine) { content = await engine.render(content, pageData, path); }
while (layout) { const engine = this.#getEngine(layout); const path = this.src(engine.includes, layout); const layoutData = await engine.load(path); pageData = { ...layoutData, ...pageData, content, ...this.extraData, };
content = await engine.render(layoutData.content, pageData, path);
layout = layoutData.layout; }
page.content = content; }
/** * Save a page */ async #savePage(page) { const sha1 = createHash("sha1"); sha1.update(page.content); const hash = sha1.toString();
//The page content didn't change if (page.dest.hash === hash) { return; } page.dest.hash = hash; const dest = page.dest.path + page.dest.ext; const src = page.src.path + page.src.ext;
console.log(`🔥 ${dest} ${gray(src)}`);
const filename = this.dest(dest); await ensureDir(dirname(filename)); return Deno.writeTextFile(filename, page.content); }
/** * Get the engine used by a path or extension */ #getEngine(path, custom) { if (custom) { custom = Array.isArray(custom) ? custom : custom.split(",");
return custom.map((name) => { const engine = this.engines.get(`.${name.trim()}`);
if (engine) { return engine; }
throw new Error(`Invalid template engine: "${name}"`); }); }
for (const [ext, engine] of this.engines) { if (path.endsWith(ext)) { return engine; } } }}