🐢 @benev/turtle
📦 turtle is an npm package: @benev/turtle
🪄 turtle is a one-line static-site-generator
📜️ turtle scripts standardize our ts app builds
⚙️ turtle patterns optimize our websites' prod/dev modes
🧐 turtle is typescript-first, but you can use plain javascript
❤️ turtle is free and open source
🪄 turtle static-site-generator
- turtle's original and primary purpose is to be a static site generator
-
turtlea one-line command that sniffs out your.html.jsfiles and renders them into html files - turtle provides your templates a
pathutility that has hash versioning capabilities, to fix browser-caching issues with your css on deployments - turtle also copies over css files and such
- turtle also executes
.turtle.jsscripts
generate a website with turtle's cli
npx @benev/turtle --in="s:x" --out="x" --exclude="**/*.partial.html.js" --verbose="true"
note: turtle can accept multiple input directories.
that's because you'll likely keep your .css files alongside your typescript sources, whereas your .html.js javascript will be built into your typescript's output directory.
ask turtle for help
npx @benev/turtle --help
write your first webpage template
turtle will sniff out your .html.js files as inputs, then output matching .html files.
index.html.js
import {template, html} from "@benev/turtle"
export default template(async({path}) => html`
<!doctype html>
<html>
<head>
<title>@benev/turtle</title>
<link
rel="stylesheet"
href="${path(import.meta.url).version.root('style.css')}"
/>
</head>
<body>
<h1>@benev/turtle</h1>
</body>
</html>
`)you can write template partials
notice the x parameter, which is the example "context" for this template. it doesn't need to be a number, it could be anything.
page.partial.ts
import {template, html} from "@benev/turtle"
export default template(async({path}, x: number) => html`
<!doctype html>
<html>
<head>
<meta charset="utf-8"/>
<title>@benev/turtle - stamp test</title>
<link
rel="stylesheet"
href="${path(import.meta.url).version.root('style.css')}"
/>
</head>
<body>
<h1>@benev/turtle - stamp test</h1>
<p>${x}</p>
</body>
</html>
`)write your first turtle script
turtle also sniffs out .turtle.js scripts and executes them.
in these, you can do anything you want. your turtle script function is provided some handy stuff like the write_webpage function.
stamp.turtle.ts
import {turtle_script} from "@benev/turtle"
// import the partial from the previous example
import page from "./page.partial.js"
// we'll stamp out a webpage for each of these values
const values = [1, 2]
// your default export must be a turtle_script
export default turtle_script(async({write_webpage}) => {
// loop over each value
await Promise.all(values.map(async(x) => {
// write a webpage
await write_webpage({
// provide the page template
template: page,
// provide the x value in the context
context: x,
// specify the destination relative
// to this build script
destination: `${x}.html`,
})
}))
})you've gotta get into file path hash versioning!
- some of the above examples are using this
pathfunction - if you use
.versionthen it will attach the file's hash as a suffix - so
/style.cssbecomes/style.css?v=c252882f - now when you deploy your site, your users won't see old cached css files that break your website -- now the browser cache becomes version aware! 🤯
use path in your templates
turtle gives you a path utility that allows you to link to file from different reference points. it can also do file path hash versioning for you.
to understand it, consider a hypothetical file structure like this:
s/ <-- (source directory)
favicon.png
cool/
awesome.html.ts <-- (your turtle template)
style.css
also, we'll assume you've set const {url} = import.meta
-
path(url).root("favicon.png")
use root to reference files relative to the website root.
result:../favicon.png -
path(url).local("style.css")
use local to reference files relative to the current template module.
result:style.css -
path(url).dest("rofl.jpg")use dest for special cases, to reference files relative to the destination html file that it output.
this is for custom turtle script builds, where the destination html file output will be written into a different directory structure than the location of the current template module.
okay, this might make more sense when you consider file path versioning.
simply add .version to the above commands, and turtle will attach a hash query param suffix, which will magically fix all your browser caching problems:
-
path(url).version.root("favicon.png")
result:../favicon.png?v=f6dd3bc1 -
path(url).version.local("style.css")
result:style.css?v=ce5f3acd -
path(url).version.dest("rofl.jpg")
remember, the templates are just async js functions
- so you can import other modules, read and write files, whatever you want
- thanks to top-level await, you could have a module read yaml files or whatever, and then templates can import that data
be sure to escape globs
- if you provide a glob to a flag like
--exclude="partials/**/*"-- be sure to use double quotes so that your shell doesn't expand the glob -- the double quotes tells your shell to pass the literal glob to turtle, which will then process the glob properly (if you let the shell expand the glob, it won't work)
📜️ turtle scripts
we use turtle scripts to standardize the whole build routine for our typescript apps across our many projects, to reduce repetitive boilerplate and centralize its maintenance.
with turtle installed, you can run these scripts with like npx turtle-standard at the command line, or in an npm package.json script, just turtle-standard will work as a one-line command.
primary scripts:
-
turtle-install
run this once to install the dependencies for these scripts into your current project. -
turtle-standard
run a standard typescript build, rollup bundle, and run the turtle static site generator. -
turtle-standard-watch
run the http-server, and watch routine for the standard build.
there are more scripts/ but i don't feel like documenting them all.
⚙️ turtle patterns
these are just functions for your turtle html templates that make life easier.
-
easypagetakes care of the boilerplate of an ordinary html page, it takes care of the meta charset and the meta viewport stuff. -
startup_scripts_with_dev_modewill load your app via the rollup bundle in production, but in dev mode, it will load your app as individual es modules.- you can add
?dev=trueto your website's url to enable dev mode - if you are browsing your website from a
localhostaddress, dev mode will be enabled by default - you can force disable dev mode with
?dev=false - the document title will be prefixed with
[dev]when dev mode is enabled, to make it obvious
- you can add