@maizzle/framework 6.0.0-9 → 6.0.0-rc.0

package/bin/maizzle

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import bootstrap from '@maizzle/cli'
-
-await bootstrap()

package/src/commands/build.js

@@ -1,348 +0,0 @@
-import {
-  readFile,
-  writeFile,
-  copyFile,
-  lstat,
-  mkdir,
-  rm,
-  cp,
-} from 'node:fs/promises'
-import path from 'pathe'
-import fg from 'fast-glob'
-import { defu as merge } from 'defu'
-
-import get from 'lodash/get.js'
-import isEmpty from 'lodash-es/isEmpty.js'
-
-import ora from 'ora'
-import pico from 'picocolors'
-import cliTable from 'cli-table3'
-
-import { render } from '../generators/render.js'
-
-import {
-  formatTime,
-  getRootDirectories,
-  getFileExtensionsFromPattern,
-} from '../utils/string.js'
-
-import { getColorizedFileSize } from '../utils/node.js'
-
-import {
-  generatePlaintext,
-  handlePlaintextTags,
-  writePlaintextFile
-} from '../generators/plaintext.js'
-
-import { readFileConfig } from '../utils/getConfigByFilePath.js'
-
-/**
- * Ensures that a directory exists, creating it if needed.
- *
- * @param {string} filePath - The path to the file to check.
- */
-async function ensureDirectoryExistence(filePath) {
-  const dirname = path.dirname(filePath)
-  await mkdir(dirname, { recursive: true })
-}
-
-/**
- * Copy a file from source to target.
- *
- * @param {string} source - The source file path.
- * @param {string} target - The target file path.
- */
-async function copyFileAsync(source, target) {
-  await ensureDirectoryExistence(target)
-  await copyFile(source, target)
-}
-
-/**
- * Compile templates and output to the build directory.
- * Returns a promise containing an object with files output and the config object.
- *
- * @param {object|string} config - The Maizzle config object, or path to a config file.
- * @returns {Promise<object>} The build output, containing the  files and config.
- */
-export default async (config = {}) => {
-  const spinner = ora()
-
-  try {
-    const startTime = Date.now()
-
-    /**
-     * Read the config file for this environment,
-     * merging it with the default config.
-     */
-    config = await readFileConfig(config).catch(() => { throw new Error('Could not compute config') })
-
-    /**
-     * Support customizing the spinner
-     */
-    const spinnerConfig = get(config, 'build.spinner')
-
-    if (spinnerConfig === false) {
-      // Show only 'Building...' text
-      spinner.isEnabled = false
-    } else {
-      spinner.spinner = get(config, 'build.spinner', 'circleHalves')
-    }
-
-    spinner.start('Building...')
-
-    // Run beforeCreate event
-    if (typeof config.beforeCreate === 'function') {
-      await config.beforeCreate({ config })
-    }
-
-    const buildOutputPath = get(config, 'build.output.path', 'build_local')
-
-    // Remove output directory
-    await rm(buildOutputPath, { recursive: true, force: true })
-
-    const table = new cliTable({
-      head: ['File name', 'File size', 'Build time'].map(item => pico.bold(item)),
-    })
-
-    /**
-     * Check that templates to be built, actually exist
-     */
-    const contentPaths = get(config, 'build.content', ['emails/**/*.html'])
-
-    const templateFolders = Array.isArray(contentPaths) ? contentPaths : [contentPaths]
-    const templatePaths = await fg.glob([...new Set(templateFolders)])
-
-    // If there are no templates to build, throw error
-    if (templatePaths.length === 0) {
-      throw new Error(`No templates found in ${pico.inverse(templateFolders)}`)
-    }
-
-    /**
-     * Copy source directories to destination
-     *
-     * Copies each `build.content` path to the `build.output.path` directory.
-     */
-    let from = get(config, 'build.output.from', ['emails'])
-
-    const globPathsToCopy = contentPaths.map(glob => {
-      // Keep negated paths as they are
-      if (glob.startsWith('!')) {
-        return glob
-      }
-
-      // Keep single-file sources as they are
-      if (!/\*/.test(glob)) {
-        return glob
-      }
-
-      // Update non-negated paths to target all files, avoiding duplication
-      return glob.replace(/\/\*\*\/\*\.\{.*?\}$|\/\*\*\/\*\.[^/]*$|\/*\.[^/]*$/, '/**/*')
-    })
-
-    try {
-      from = Array.isArray(from) ? from : [from]
-
-      /**
-       * Copy files from source to destination
-       *
-       * The array/set conversion is to remove duplicates
-       */
-      for (const file of await fg(Array.from(new Set(globPathsToCopy)))) {
-        let relativePath
-        for (const dir of from) {
-          if (file.startsWith(dir)) {
-            relativePath = path.relative(dir, file)
-            break
-          }
-        }
-        if (!relativePath) {
-          relativePath = path.relative('.', file)
-        }
-
-        const targetPath = path.join(buildOutputPath, relativePath)
-        await copyFileAsync(file, targetPath)
-      }
-    } catch (error) {
-      console.error('Error while processing pattern:', error)
-    }
-
-    /**
-     * Get a list of files to render, from the output directory
-     *
-     * Uses all file extensions from non-negated glob paths in `build.content`
-     * to determine which files to render from the output directory.
-     */
-    const outputExtensions = new Set()
-
-    for (const pattern of contentPaths) {
-      getFileExtensionsFromPattern(pattern).map(ext => outputExtensions.add(ext))
-    }
-
-    /**
-     * Create a list of templates to compile
-     */
-    const extensions = outputExtensions.size > 1
-      ? `{${[...outputExtensions].join(',')}}`
-      : [...outputExtensions][0] || 'html'
-
-    const templatesToCompile = await fg.glob(
-      path.join(
-        buildOutputPath,
-        `**/*.${extensions}`
-      )
-    )
-
-    /**
-     * Render templates
-     */
-    for await (const templatePath of templatesToCompile) {
-      const templateBuildStartTime = Date.now()
-
-      /**
-       * Add the current template path to the config
-       *
-       * Can be used in events like `beforeRender` to determine
-       * which template file is being rendered.
-       */
-      config.build.current = {
-        path: path.parse(templatePath),
-      }
-
-      const html = await readFile(templatePath, 'utf8')
-
-      /**
-       * Render the markup.
-       *
-       * Merging a custom `components` object to make sure that file extensions from both
-       * `build.content` * and * `components.fileExtension` are used when scanning for
-       * component files.
-       */
-      const userComponentFileExtensions = get(config, 'components.fileExtension', ['html'])
-
-      const rendered = await render(html, merge(
-        {
-          components: {
-            fileExtension: [
-              ...outputExtensions,
-              ...(new Set([].concat(userComponentFileExtensions))),
-            ],
-          }
-        },
-        config
-      ))
-
-      /**
-       * Generate plaintext
-       *
-       * We do this first so that we can remove the <plaintext>
-       * tags from the markup before outputting the file.
-       */
-      const plaintextConfig = get(rendered.config, 'plaintext')
-
-      if (Boolean(plaintextConfig) || !isEmpty(plaintextConfig)) {
-        const posthtmlOptions = get(rendered.config, 'posthtml.options', {})
-
-        await writePlaintextFile(
-          await generatePlaintext(rendered.html, merge(plaintextConfig, posthtmlOptions)),
-          rendered.config
-        ).catch(error => {
-          throw new Error(`Error writing plaintext file: ${error}`)
-        })
-
-        rendered.html = await handlePlaintextTags(rendered.html, posthtmlOptions)
-      }
-
-      /**
-       * Determine output path, creating directories if needed
-       *
-       * Prioritize `permalink` path from Front Matter,
-       * fallback to the current template path.
-       *
-       * We do this before generating plaintext, so that
-       * any paths will already have been created.
-       */
-      const outputPathFromConfig = get(rendered.config, 'permalink', templatePath)
-      const parsedOutputPath = path.parse(outputPathFromConfig)
-      // This keeps original file extension if no output extension is set
-      const extension = get(rendered.config, 'build.output.extension', parsedOutputPath.ext.slice(1))
-      const outputPath = `${parsedOutputPath.dir}/${parsedOutputPath.name}.${extension}`
-
-      const pathExists = await lstat(path.dirname(outputPath)).catch(() => false)
-
-      if (!pathExists) {
-        await mkdir(path.dirname(outputPath), { recursive: true })
-      }
-
-      /**
-       * Write the rendered HTML to disk, creating directories if needed
-       */
-      await writeFile(outputPath, rendered.html)
-
-      /**
-       * Remove original file if its path is different
-       * from the final destination path.
-       */
-      if (outputPath !== templatePath) {
-        await rm(templatePath)
-      }
-
-      /**
-       * Add file to CLI table for build summary logging
-       */
-      table.push([
-        path.relative(get(rendered.config, 'build.output.path'), outputPath),
-        getColorizedFileSize(rendered.html),
-        formatTime(Date.now() - templateBuildStartTime)
-      ])
-    }
-
-    /**
-     * Copy static files
-     */
-    let staticFiles = get(config, 'build.static', [])
-
-    if (!Array.isArray(staticFiles)) {
-        staticFiles = [staticFiles]
-    }
-
-    for (const definition of staticFiles) {
-      const staticSourcePaths = getRootDirectories([...new Set(definition.source)])
-
-      for await (const rootDir of staticSourcePaths) {
-        await cp(rootDir, path.join(buildOutputPath, definition.destination), { recursive: true })
-      }
-    }
-
-    const allOutputFiles = await fg.glob(path.join(buildOutputPath, '**/*'))
-
-    /**
-     * Run `afterBuild` event
-     */
-    if (typeof config.afterBuild === 'function') {
-      await config.afterBuild({
-        config,
-        files: allOutputFiles,
-      })
-    }
-
-    /**
-     * Log a build summary if enabled in the config
-     */
-
-    spinner.clear()
-
-    if (config.build.summary) {
-      console.log(table.toString() + '\n')
-    }
-
-    spinner.succeed(`Built ${table.length} template${table.length > 1 ? 's' : ''} in ${formatTime(Date.now() - startTime)}`)
-
-    return {
-      files: allOutputFiles,
-      config
-    }
-  } catch (error) {
-    spinner.fail('Build failed')
-    throw error
-  }
-}

package/src/commands/serve.js

@@ -1,3 +0,0 @@
-import server from '../server/index.js'
-
-export default server

package/src/generators/plaintext.js

@@ -1,222 +0,0 @@
-import path from 'pathe'
-import posthtml from 'posthtml'
-import get from 'lodash-es/get.js'
-import { defu as merge } from 'defu'
-import { stripHtml } from 'string-strip-html'
-import { writeFile, lstat, mkdir } from 'node:fs/promises'
-import { getPosthtmlOptions } from '../posthtml/defaultConfig.js'
-
-/**
- * Removes HTML tags from a given HTML string based on
- * a specified tag name or an array of tag names.
- *
- * @param {Object} options - The options object.
- * @param {string|string[]} [options.tag='not-plaintext'] - The tag name or an array of tag names to remove from the HTML.
- * @param {string} [options.html=''] - The HTML string from which to remove the tags.
- * @param {Object} [options.config={}] - PostHTML options.
- * @returns {string} - The HTML string with the specified tags removed.
- */
-const removeTags = ({ tag = 'not-plaintext', html = '', config = {} }) => {
-  /**
-   * If the HTML string is empty, return it as is
-   */
-  if (!html) {
-    return html
-  }
-
-  const posthtmlPlugin = () => tree => {
-    const process = node => {
-      if (!node.tag) {
-        return node
-      }
-
-      /**
-       * If the tag is a string and it matches the node tag, remove it
-       */
-      if (node.tag === tag) {
-        return {
-          tag: false,
-          content: ['']
-        }
-      }
-
-      return node
-    }
-
-    return tree.walk(process)
-  }
-
-  const posthtmlOptions = merge(config, getPosthtmlOptions())
-
-  return posthtml([posthtmlPlugin()]).process(html, { ...posthtmlOptions }).then(res => res.html)
-}
-
-/**
- * Handles custom <plaintext> tags and replaces their content based on the tag name.
- *
- * @param {Object} options - The options object.
- * @param {string} [options.html=''] - The HTML string containing custom tags to be processed.
- * @param {Object} [options.config={}] - PostHTML options.
- * @returns {string} - The modified HTML string after processing custom tags.
- */
-export async function handlePlaintextTags(html = '', config = {}) {
-  /**
-   * If the HTML string is empty, return early
-   */
-  if (!html) {
-    return html
-  }
-
-  const posthtmlPlugin = () => tree => {
-    const process = node => {
-      /**
-       * Remove <plaintext> tags and their content from the HTML
-       */
-      if (node.tag === 'plaintext') {
-        return {
-          tag: false,
-          content: ['']
-        }
-      }
-
-      /**
-       * Replace <not-plaintext> tags with their content
-       */
-      if (node.tag === 'not-plaintext') {
-        return {
-          tag: false,
-          content: tree.render(node.content)
-        }
-      }
-
-      return node
-    }
-
-    return tree.walk(process)
-  }
-
-  const posthtmlOptions = merge(config, getPosthtmlOptions())
-
-  return posthtml([posthtmlPlugin()]).process(html, { ...posthtmlOptions }).then(res => res.html)
-}
-
-/**
- * Generate a plaintext representation from the provided HTML.
- *
- * @param {Object} options - The options object.
- * @param {string} [options.html=''] - The HTML string to convert to plaintext.
- * @param {Object} [options.config={}] - Configuration object.
- * @returns {Promise<string>|void} - The generated plaintext as a string.
- */
-export async function generatePlaintext(html = '', config = {}) {
-  const { posthtml: posthtmlOptions, ...stripOptions } = config
-
-  /**
-   * Remove <not-plaintext> tags and their content from the HTML.
-   * `config` is an object containing PostHTML options.
-   */
-  html = await removeTags({ tag: 'not-plaintext', html, config: posthtmlOptions })
-
-  /**
-   * Return the plaintext representation from the stripped HTML.
-   * The `dumpLinkHrefsNearby` option is enabled by default.
-   */
-  return stripHtml(
-    html,
-    merge(
-      stripOptions,
-      {
-        dumpLinkHrefsNearby: {
-          enabled: true,
-        },
-      },
-    )
-  ).result
-}
-
-export async function writePlaintextFile(plaintext = '', config = {}) {
-  if (!plaintext) {
-    throw new Error('Missing plaintext content.')
-  }
-
-  if (typeof plaintext !== 'string') {
-    throw new Error('Plaintext content must be a string.')
-  }
-
-  /**
-   * Get plaintext output path config, i.e `config.plaintext.destination.path`
-   *
-   * Fall back to template's build output path and extension, for example:
-   * `config.build.output.path`
-   */
-  const plaintextConfig = get(config, 'plaintext')
-  let plaintextOutputPath = get(plaintextConfig, 'output.path', '')
-  const plaintextExtension = get(plaintextConfig, 'output.extension', 'txt')
-
-  /**
-   * If `plaintext: true` (either from Front Matter or from config),
-   * output plaintext file in the same location as the HTML file.
-   */
-  if (plaintextConfig === true) {
-    plaintextOutputPath = ''
-  }
-
-  /**
-   * If `plaintext: path/to/file.ext` in the FM
-   * Can't work if set in config.js as file path, because it would be the same for all templates
-   * We check later if it's a dir path, won't work if it's a file path
-   */
-  if (typeof plaintextConfig === 'string') {
-    plaintextOutputPath = plaintextConfig
-  }
-
-  // No need to handle if it's an object, since we already set it to that initially
-
-  /**
-   * If the template has a `permalink` key set in the FM, always output plaintext file there
-   */
-  if (typeof config.permalink === 'string') {
-    plaintextOutputPath = config.permalink
-  }
-
-  /**
-   * If `plaintextOutputPath` is a file path, output file there.
-   *
-   * The file will be output relative to the project root, and the extension
-   * doesn't matter, it will be replaced with `plaintextExtension`.
-   */
-  if (path.extname(plaintextOutputPath)) {
-    // Ensure the target directory exists
-    await lstat(plaintextOutputPath).catch(async () => {
-      await mkdir(path.dirname(plaintextOutputPath), { recursive: true })
-    })
-
-    // Ensure correct extension is used
-    plaintextOutputPath = path.join(
-      path.dirname(plaintextOutputPath),
-      path.basename(plaintextOutputPath, path.extname(plaintextOutputPath)) + '.' + plaintextExtension
-    )
-
-    return writeFile(plaintextOutputPath, plaintext)
-  }
-
-  /**
-   * If `plaintextOutputPath` is a directory path, output file there using the Template's name.
-   *
-   * The file will be output relative to the `build.output.path` directory.
-   */
-  const templateFileName = get(config, 'build.current.path.name')
-
-  plaintextOutputPath = path.join(
-    get(config, 'build.current.path.dir'),
-    plaintextOutputPath,
-    templateFileName + '.' + plaintextExtension
-  )
-
-  // Ensure the target directory exists
-  await lstat(path.dirname(plaintextOutputPath)).catch(async () => {
-    await mkdir(path.dirname(plaintextOutputPath), { recursive: true })
-  })
-
-  return writeFile(plaintextOutputPath, plaintext)
-}

package/src/generators/render.js

@@ -1,129 +0,0 @@
-import { parse } from 'pathe'
-import posthtml from 'posthtml'
-import { cwd } from 'node:process'
-import { defu as merge } from 'defu'
-import expressions from 'posthtml-expressions'
-import { parseFrontMatter } from '../utils/node.js'
-import { getPosthtmlOptions } from '../posthtml/defaultConfig.js'
-import { process as compilePostHTML } from '../posthtml/index.js'
-import { run as useTransformers } from '../transformers/index.js'
-
-export async function render(html = '', config = {}) {
-  if (typeof html !== 'string') {
-    throw new TypeError(`first argument must be a string, received ${html}`)
-  }
-
-  if (html.length === 0) {
-    throw new RangeError('received empty string')
-  }
-
-  /**
-   * Parse front matter
-   *
-   * Parse expressions in front matter and add to config
-   * This could be handled by components() but plugins aren't working with it currently
-   */
-  let { content, matter } = parseFrontMatter(html)
-
-  /**
-    * Compute template config
-    *
-    * Merge it with front matter data and set the `cwd` for Tailwind.
-    */
-  const { data: matterData } = await posthtml(
-    [
-      expressions({
-        strictMode: false,
-        missingLocal: '{local}',
-        locals: {
-          page: config
-        }
-      })
-    ]
-  )
-    .process(matter, getPosthtmlOptions())
-    .then(({ html }) => parseFrontMatter(`---${html}\n---`))
-
-  const templateConfig = merge(matterData, config)
-
-  /**
-   * Used for PostCSS `from` to make `@config` work in Tailwind
-   *
-   * @todo use only when in Node environment
-   */
-  templateConfig.cwd = parse(cwd()).base
-
-  /**
-   * Run `beforeRender` event
-   *
-   * @param {Object} options
-   * @param {string} options.html - The HTML to be transformed
-   * @param {Object} options.matter - The front matter data
-   * @param {Object} options.config - The current template config
-   * @returns {string} - The transformed HTML, or the original one if nothing was returned
-   */
-  if (typeof templateConfig.beforeRender === 'function') {
-    content = await templateConfig.beforeRender(({
-      html: content,
-      matter: matterData,
-      config: templateConfig,
-    })) ?? content
-  }
-
-  /**
-   * Compile PostHTML
-   */
-  const compiled = await compilePostHTML(content, templateConfig)
-
-  /**
-   * Run `afterRender` event
-   *
-   * @param {Object} options
-   * @param {string} options.html - The HTML to be transformed
-   * @param {Object} options.matter - The front matter data
-   * @param {Object} options.config - The current template config
-   * @returns {string} - The transformed HTML, or the original one if nothing was returned
-   */
-  if (typeof templateConfig.afterRender === 'function') {
-    compiled.html = await templateConfig.afterRender(({
-      html: compiled.html,
-      matter: matterData,
-      config: compiled.config,
-    })) ?? compiled.html
-  }
-
-  /**
-   * Run Transformers
-   *
-   * Runs only if `useTransformers` is not explicitly disabled in the config.
-   *
-   * @param {string} html - The HTML to be transformed
-   * @param {Object} config - The current template config
-   * @returns {string} - The transformed HTML
-   */
-  if (templateConfig.useTransformers !== false) {
-    compiled.html = await useTransformers(compiled.html, compiled.config).then(({ html }) => html)
-  }
-
-  /**
-   * Run `afterTransformers` event
-   *
-   * @param {Object} options
-   * @param {string} options.html - The HTML to be transformed
-   * @param {Object} options.matter - The front matter data
-   * @param {Object} options.config - The current template config
-   * @returns {string} - The transformed HTML, or the original one if nothing was returned
-   */
-  if (typeof templateConfig.afterTransformers === 'function') {
-    compiled.html = await templateConfig.afterTransformers(({
-      html: compiled.html,
-      matter: matterData,
-      config: compiled.config,
-    })) ?? compiled.html
-  }
-
-  return {
-    config: compiled.config,
-    html: compiled.html,
-  }
-}