stakit

estakit

Un conjunto de herramientas modular para crear sitios web estáticos

Stakit es un marco que le ayuda a componer potentes canales de compilación para sitios web estáticos sin sudar. Es mínimo y modular, utiliza transmisiones y el kit de herramientas Stakit tiene un montón de complementos y transformaciones que puedes usar.

Stakit aún se encuentra en una etapa temprana de desarrollo, pero puedes tomarlo y usarlo para ver si te debe importar o no.

Características

• Agnóstico del marco : funciona con cualquier marco que pueda generar una cadena.

• modular : nunca tienes lo que no necesitas, pero puedes npm install

• API pequeña : solo tiene 7 métodos principales, solo debes usar 3 de ellos

• sin restricciones : nunca estará limitado por las funciones y plantillas de un generador de sitios estáticos

• rápido, memoria eficiente : uso intensivo de transmisiones

Instalación

npm i stakit

Ejemplo

 var stakit = require('stakit')var { renderizar, hidratar } = require('stakit-choo')var app = require('.')var kit = stakit()
  .routes(función (estado) {retorno [ '/' ]
  })
  .render(renderizar(aplicación))
  .transform(hidrato)kit.output(stakit.writeFiles('./public'))

¿Por qué?

Generalmente, haces 2 cosas al generar un sitio estático:

• llena tu aplicación con algún contenido

• copiar archivos estáticos

Hay muchas herramientas modulares (y encantadoras) para agrupar Javascript o transformar CSS, Stakit es algo similar, pero para el sitio completo, y se centra especialmente en archivos HTML.

Tendrás que encargarte de agrupar tu aplicación e incluir el paquete si eso es lo que necesitas. Siguiendo la filosofía de Choo, es pequeño, comprensible y fácil de usar. Fue diseñado para funcionar principalmente con Choo, pero debería funcionar también con otros marcos isomórficos.

Uso

Stakit se llama mediante programación, no desde la línea de comandos, por lo tanto, necesitará un archivo Javascript (como build.js ), donde lo necesite. Luego puedes inicializar el kit con stakit() y luego encadenar un par de métodos.

Deben aparecer dos métodos en proceso:

• routes(fn)

• render(fn)

Todos los demás métodos son opcionales y se llaman en el siguiente orden:

1. todos los middlewares aplicados por kit.use()

2. la función routesReducer aplicada

3. para cada ruta:

1. una sola llamada al renderer aplicado

2. todas las llamadas transform

Finalice la canalización con kit.output() .

API

Esta sección proporciona documentación sobre cómo funciona cada función en Stakit. Está destinado a ser una referencia técnica.

kit = stakit()

Inicialice una nueva instancia kit .

kit.html(template, selector)

Establece la plantilla HTML inicial y el selector.

kit.use(fn(context))

Empuja un middleware/complemento a la lista de middlewares, las funciones de propósito general se ejecutaron antes de la generación de la ruta. Puede modificar el contexto como desee, desde alterar el state hasta instalar transform s.

 kit.use(función (ctx) {
  ctx._transforms.push(transformar)})

Consulte Middlewares para obtener más información.

kit.routes(routeReducer(state))

routeReducer es una función que obtiene context.state como parámetro y devuelve una Array de cadenas/rutas. Estas son las rutas en las que Stakit llamará render .

 kit.routes(función (estado) {
  devolver Objeto.claves(estado.contenido)
  // o estáticamente
  return [ '/', '/acerca de', '/blog' ]})

kit.render(renderer(route, state))

Establece el renderizador de la compilación. Aquí es donde ocurre la magia. Se llamará al renderer para cada ruta devuelta por routes .

Tiene que devolver un objeto con los siguientes valores:

 {
  html: cadena, // el resultado del renderizado
  estado: objeto // el estado después del renderizado (opcional)}

Las transformaciones recibirán el estado actualizado que se devuelve aquí.

kit.transform(transformFn, opts)

Empuja una transformación a la lista de transformaciones. Stakit utiliza documentify y streams para construir el HTML.

Se les llama después de que el contenido renderizado haya sido reemplazado en el HTML.

Consulte Transformaciones para obtener más información.

kit.output(writerObject)

Inicia la canalización de compilación y la finaliza pasando todas las rutas a writerObject.write({ destination, stream }) . Devuelve una Promise que espera hasta que todos los archivos (rutas y estáticos) se hayan escrito por completo.

De forma predeterminada, utiliza un escritor que envía el sitio al directorio ./public .

Consulte Escritores para obtener más información.

Middlewares

Middlewares integrados:

stakit.state(extendState)

Utilidad para ayudarle a agregar valores a context.state

 kit.use(stakit.state({ mensaje: '¡buenos días!' }))

stakit.copy(files)

Middleware para copiar archivos al directorio de salida.

 // Copiar archivos en la misma ubicaciónkit.use(stakit.copy([ 'robots.txt' ]))// Copiar archivos en una ubicación diferente dentro de la ruta de salidakit.use(stakit.copy({
  'robots.txt': 'robots.txt',
  'sitemap.xml': 'sitemaps/sitemap.xml'}))

Transforma

Documentify es muy poderoso y se puede modular fácilmente. El formato general de una transformación Stakit es:

 // envuelto en una funciónfunción lang (contexto) {
  // devuelve la transformación documentificada
  función de retorno (lang) {// devolver una secuencia de transformaciónreturn hstream({ html: { lang: lang } })
  }}

Nota: hstream es un muy buen amigo!

La transformación documentify está envuelta en una función, por lo que podemos obtener el context cuando lo necesitamos, sin alterar la API de documentify . Si desea evitar esto, simplemente puede devolver la transformación documentify desde una función.

Vea qué transformaciones vienen con Stakit en transforms/readme.md .

Escritores

Los escritores generan los archivos estáticos transformados generados. Esto puede variar desde enviarlos al sistema de archivos hasta colocarlos en un archivo Dat.

Un escritor debe implementar un método: write . Para cada archivo, incluidas las páginas generadas + los archivos agregados a context._files , se llamará writer.write con un objeto de archivo. Debería devolver una Promise que regresa después de que se vació la tubería (el archivo se escribió por completo).

Un objeto de archivo se ve así:

{
  source: null | string,
  destination: string,
  stream: Stream
}

Se recomienda limpiar el directorio de salida antes de cada compilación.

Eche un vistazo al método integrado stakit.writeFiles como ejemplo.

Eso es todo acerca de los escritores.

Ver también

• choo - robusto marco de interfaz de 4kb

• documentify - Paquete HTML modular

• jalla: compilador y servidor web ultrarrápidos en uno (¡también gracias por tantos fragmentos de código!)