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

package/src/transformers/template.js

@@ -1,26 +0,0 @@
-const posthtmlPlugin = () => tree => {
-  const process = node => {
-    // Return the original node if it doesn't have a tag
-    if (!node.tag) {
-      return node
-    }
-
-    if (node.tag === 'template') {
-      // Preserve <template> tags marked as such
-      if ('attrs' in node && 'preserve' in node.attrs) {
-        node.attrs.preserve = false
-
-        return node
-      }
-
-      // Remove the <template> tag
-      node.tag = false
-    }
-
-    return node
-  }
-
-  return tree.walk(process)
-}
-
-export default posthtmlPlugin

package/src/transformers/urlParameters.js

@@ -1,20 +0,0 @@
-import posthtml from 'posthtml'
-import get from 'lodash-es/get.js'
-import urlParameters from 'posthtml-url-parameters'
-
-export default function posthtmlPlugin(options = {}) {
-  const { _options, ...parameters } = options
-  const tags = get(_options, 'tags', ['a'])
-  const strict = get(_options, 'strict', true)
-  const qs = get(_options, 'qs', { encode: false })
-
-  return urlParameters({ parameters, tags, qs, strict })
-}
-
-export async function addURLParams(html = '', options = {}, posthtmlOptions = {}) {
-  return posthtml([
-    posthtmlPlugin(options)
-  ])
-    .process(html, posthtmlOptions)
-    .then(result => result.html)
-}

package/src/transformers/useAttributeSizes.js

@@ -1,63 +0,0 @@
-import postcss from 'postcss'
-import posthtml from 'posthtml'
-import get from 'lodash-es/get.js'
-
-const posthtmlPlugin = (mappings = {}) => tree => {
-  if (!Object.keys(mappings).length) {
-    return tree
-  }
-
-  // Normalize tags in mappings by lowercasing them
-  for (const key in mappings) {
-    if (Array.isArray(mappings[key])) {
-      mappings[key] = mappings[key].map(value => value.toLowerCase())
-    }
-  }
-
-  const process = node => {
-    // Check if the node is defined in mappings
-    if (
-      get(mappings, 'width', []).includes(node.tag)
-      || get(mappings, 'height', []).includes(node.tag)
-    ) {
-      // Check if the node has an inline CSS property equal to one of the keys in mappings
-      if (node.attrs.style) {
-        const { root } = postcss().process(`${node.attrs.style}`, { from: undefined })
-
-        root.walkDecls(decl => {
-          if (mappings.width.includes(node.tag) && decl.prop === 'width') {
-            // Set its value as an attribute on the node; the attribute name is the key in mappings
-            node.attrs.width = decl.value.replace('px', '')
-            // Remove the inline CSS property from the declaration
-            decl.remove()
-          }
-
-          if (mappings.height.includes(node.tag) && decl.prop === 'height') {
-            // Set its value as an attribute on the node; the attribute name is the key in mappings
-            node.attrs.height = decl.value.replace('px', '')
-            // Remove the inline CSS property from the declaration
-            decl.remove()
-          }
-        })
-
-        // Set the remaining inline CSS as the `style` attribute on the node
-        // If there are no remaining declarations, remove the `style` attribute
-        node.attrs.style = root.toString().trim() || false
-      }
-    }
-
-    return node
-  }
-
-  return tree.walk(process)
-}
-
-export default posthtmlPlugin
-
-export async function useAttributeSizes(html = '', mappings = {}, posthtmlOptions = {}) {
-  return posthtml([
-    posthtmlPlugin(mappings)
-  ])
-    .process(html, posthtmlOptions)
-    .then(result => result.html)
-}

package/src/utils/getConfigByFilePath.js

@@ -1,143 +0,0 @@
-import { resolve } from 'pathe'
-import get from 'lodash/get.js'
-import { defu as merge } from 'defu'
-import { lstat } from 'node:fs/promises'
-import isEmpty from 'lodash-es/isEmpty.js'
-
-/**
- * Compute the Maizzle config object.
- *
- * If a config file path is provided, that file will be read
- * instead of trying to merge the base and environment configs.
- *
- * If an environment is provided, the config object will be
- * computed based on a base config and the resolved
- * environment config.
- *
- * @param {string} env - The environment name to use.
- * @param {string} path - The path to the config file to use.
- * @returns {Promise<object>} The computed config object.
- */
-export async function readFileConfig(config) {
-  try {
-    /**
-     * If `config` is string, try to read and return
-     * the config object from it.
-     */
-    if (typeof config === 'string' && config) {
-      const { default: resolvedConfig } = await import(`file://${resolve(config)}?d=${Date.now()}`)
-        .catch(() => { throw new Error('Could not read config file') })
-
-      return merge(resolvedConfig, { env: config })
-    }
-
-    /**
-     * Otherwise, default to the Environment config approach,
-     * where we check for config files that follow a
-     * specific naming convention.
-     *
-     * First, we check for a base config file, in this order:
-     */
-    const baseConfigFileNames = [
-      './maizzle.config.js',
-      './maizzle.config.local.js',
-      './config.js',
-      './config.local.js',
-      './maizzle.config.cjs',
-      './maizzle.config.local.cjs',
-      './config.cjs',
-      './config.local.cjs',
-    ]
-
-    const env = get(config, 'env', 'local')
-    let baseConfig = merge({ env }, config)
-    let envConfig = merge({ env }, config)
-
-    const cwd = env === 'maizzle-ci' ? './test/stubs/config' : process.cwd()
-
-    // We load the first base config found
-    for (const module of baseConfigFileNames) {
-      // Check if the file exists, go to next one if not
-      const configFileExists = await lstat(resolve(cwd, module)).catch(() => false)
-
-      if (!configFileExists) {
-        continue
-      }
-
-      // Load the config file
-      try {
-        const { default: baseConfigFile } = await import(`file://${resolve(cwd, module)}?d=${Date.now()}`)
-
-        // Use the first base config found
-        if (!isEmpty(baseConfigFile)) {
-          baseConfig = merge(baseConfigFile, baseConfig)
-          break
-        }
-      } catch (_error) {
-        break
-      }
-
-    }
-
-    // Then, we load and compute the first Environment config found
-    if (env !== 'local') {
-      let loaded = false
-      const modulesToTry = [
-        `./maizzle.config.${env}.js`,
-        `./config.${env}.js`,
-        `./maizzle.config.${env}.cjs`,
-        `./config.${env}.cjs`,
-      ]
-
-      for (const module of modulesToTry) {
-        // Check if the file exists, go to next one if not
-        const configFileExists = await lstat(resolve(cwd, module)).catch(() => false)
-
-        if (!configFileExists) {
-          continue
-        }
-
-        // Load the config file
-        try {
-          const { default: envConfigFile } = await import(`file://${resolve(cwd, module)}?d=${Date.now()}`)
-
-          // If it's not an empty object, merge it with the base config
-          if (!isEmpty(envConfigFile)) {
-            envConfig = merge(envConfigFile, envConfig)
-            loaded = true
-            break
-          }
-        } catch (_error) {
-          break
-        }
-      }
-
-      if (!loaded) {
-        throw new Error(`Failed to load the \`${env}\` environment config, do you have one of these files in your project root?\n\n${modulesToTry.join('\n')}`)
-      }
-    }
-
-    /**
-     * Override the `build.content` key in `baseConfig` with the one in `envConfig`
-     * if present. We do this so that each build uses its own `content` paths,
-     * in order to avoid compiling unnecessary files.
-     */
-    if (envConfig.build && Array.isArray(envConfig.build.content)) {
-      baseConfig.build = baseConfig.build || {}
-      baseConfig.build.content = envConfig.build.content
-      // Remove build.content from envConfig to prevent merging duplicates
-      envConfig = { ...envConfig, build: { ...envConfig.build, content: undefined } }
-    }
-
-    // Merge envConfig and baseConfig, but ensure build.content is not duplicated
-    const merged = merge(envConfig, baseConfig)
-
-    if (baseConfig.build && Array.isArray(baseConfig.build.content)) {
-      merged.build.content = baseConfig.build.content
-    }
-
-    return merged
-  } catch (_error) {
-    throw new Error('Could not compute config')
-  }
-}

package/src/utils/node.js

@@ -1,68 +0,0 @@
-import os from 'node:os'
-import gm from 'gray-matter'
-import pico from 'picocolors'
-import { humanFileSize } from './string.js'
-
-// Return a local IP address
-export function getLocalIP() {
-  const interfaces = os.networkInterfaces()
-
-  for (const iface in interfaces) {
-    const ifaceInfo = interfaces[iface]
-
-    for (const alias of ifaceInfo) {
-      if (alias.family === 'IPv4' && !alias.internal) {
-        return alias.address
-      }
-    }
-  }
-
-  return '127.0.0.1' // Default to localhost if no suitable IP is found
-}
-
-/**
- * Return the file size of a string
- *
- * @param {string} string The HTML string to calculate the file size of
- * @returns {number} The file size in bytes, a floating-point number
- * */
-export function getFileSize(string) {
-  const blob = new Blob([string], { type: 'text/html' })
-
-  return blob.size.toFixed(2)
-}
-
-/**
- * Color-code a formatted file size string depending on the size
- *
- * 0-49 KB: green
- * 50-102 KB: yellow
- * >102 KB: red
- *
- * @param {string} string The HTML string to calculate the file size of
- * @returns {string} The formatted, color-coded file size
- * */
-export function getColorizedFileSize(string) {
-  const size = getFileSize(string)
-  const formattedSize = humanFileSize(size)
-
-  if (size / 1024 < 50) {
-    return formattedSize
-  }
-
-  if (size / 1024 < 102) {
-    return pico.yellow(formattedSize)
-  }
-
-  return pico.red(formattedSize)
-}
-
-export function parseFrontMatter(html) {
-  /**
-   * Need to pass empty options object to gray-matter
-   * in order to disable caching.
-   * https://github.com/jonschlinkert/gray-matter/issues/43
-   */
-  const { content, data, matter, stringify } = gm(html, {})
-  return { content, data, matter, stringify }
-}

package/src/utils/string.js

@@ -1,186 +0,0 @@
-/**
- * Inject a script into HTML by "prepending" it to the first available closing
- * tag from a list of candidates.
- *
- * @param {string} html The HTML content
- * @param {string} script The script to inject
- * @returns {string} The modified HTML
- */
-export function injectScript(html = '', script = '') {
-  if (html.includes('</head>')) {
-    return html.replace('</head>', `${script}</head>`)
-  }
-
-  if (html.includes('</title>')) {
-    return html.replace('</title>', `</title>${script}`)
-  }
-
-  if (html.includes('</body>')) {
-    return html.replace('</body>', `${script}</body>`)
-  }
-
-  if (html.includes('</html>')) {
-    return html.replace('</html>', `${script}</html>`)
-  }
-
-  if (html.includes('<!doctype html>')) {
-    return html.replace('<!doctype html>', `<!doctype html>${script}`)
-  }
-
-  return script + html
-}
-
-/**
- * Find the common prefix among an array of strings.
- *
- * @param {string[]} strings Array of strings
- * @returns {string} Common prefix
- * @throws {TypeError} If the input is not an array
- */
-export function findCommonPrefix(strings) {
-  // Must be an array
-  if (!Array.isArray(strings)) {
-    throw new TypeError('findCommonPrefix expects an array')
-  }
-
-  const sortedStrings = strings.slice().sort()
-  const first = sortedStrings[0]
-  const last = sortedStrings[sortedStrings.length - 1]
-  let i = 0
-
-  while (i < first.length && first.charAt(i) === last.charAt(i)) {
-    i++
-  }
-
-  return first.substring(0, i)
-}
-
-export function formatMs(milliseconds) {
-  const date = new Date(milliseconds);
-
-  const hours = date.getUTCHours();
-  const minutes = date.getUTCMinutes();
-  const seconds = date.getUTCSeconds();
-  const formattedTime = `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
-
-  return formattedTime;
-}
-
-/**
- * Format milliseconds as human-readable text.
- *
- * @param {number} ms Number of milliseconds.
- * @returns {string} Formatted string.
- */
-export function formatTime(ms) {
-  if (ms < 1000) {
-    return `${ms} ms`
-  }
-
-  if (ms < 60000) { // Less than 1 minute
-    const seconds = ms / 1000
-    return `${seconds.toFixed(2)} s`
-  }
-
-  const minutes = ms / 60000
-  return `${minutes.toFixed(2)} min`
-}
-
-/**
- * Format bytes as human-readable text.
- *
- * @param {number} bytes Number of bytes.
- * @param {boolean} si True to use metric (SI) units, aka powers of 1000. False to use
- *           binary (IEC), aka powers of 1024.
- * @param {number} dp Number of decimal places to display.
- *
- * @return {string} Formatted string.
- */
-export function humanFileSize(bytes, si=false, dp=2) {
-  const threshold = si ? 1000 : 1024
-
-  if (Math.abs(bytes) < threshold) {
-    return bytes + ' B'
-  }
-
-  const units = ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-  let u = -1
-  const r = 10**dp
-
-  do {
-    bytes /= threshold
-    ++u
-  } while (Math.round(Math.abs(bytes) * r) / r >= threshold && u < units.length - 1)
-
-
-  return bytes.toFixed(dp) + ' ' + units[u]
-}
-
-/**
- * Get the root directories from a list of glob patterns.
- *
- * @param {array} patterns List of glob patterns.
- * @returns {array} List of root directories.
- */
-export function getRootDirectories(patterns = []) {
-  if (!Array.isArray(patterns)) {
-    return []
-  }
-
-  if (patterns.length === 0) {
-    return []
-  }
-
-  return [...new Set(
-    patterns
-      .filter(pattern => !pattern.startsWith('!'))
-      .map(pattern => {
-        // If the pattern doesn't include wildcards, use it as is
-        if (!pattern.includes('*')) {
-          return pattern.replace(/\/$/, '') // Remove trailing slash if present
-        }
-        // For patterns with wildcards, get the part before the first wildcard
-        const parts = pattern.split(/[*{]/)[0].split('/')
-        return parts.slice(0, -1).join('/')
-      })
-      .filter(Boolean)
-  )]
-}
-
-/**
- * Get the file extensions from a glob pattern.
- * @param {*} pattern
- * @returns
- */
-export function getFileExtensionsFromPattern(pattern) {
-  // biome-ignore lint: needs to be escaped
-  const starExtPattern = /\.([^\*\{\}]+)$/ // Matches .ext but not .* or .{ext}
-  const bracePattern = /\.{([^}]+)}$/ // Matches .{ext} or .{ext,ext}
-  const wildcardPattern = /\.\*$/ // Matches .*
-
-  if (wildcardPattern.test(pattern)) {
-    return ['html'] // We default to 'html' if the pattern is a wildcard
-  }
-
-  const braceMatch = pattern.match(bracePattern);
-  if (braceMatch) {
-    return braceMatch[1].split(',') // Split and return extensions inside braces
-  }
-
-  const starExtMatch = pattern.match(starExtPattern)
-  if (starExtMatch) {
-    return [starExtMatch[1]] // Return single extension
-  }
-
-  return ['html'] // No recognizable extension pattern, default to 'html'
-}
-
-/**
- * Normalize a string by removing extra whitespace.
- *
- * @param {String} str The string to clean
- * @returns {String} The cleaned string
- */
-export function cleanString(str) {
-  return str.replace(/\s+/g, ' ').trim()
-}

package/types/build.d.ts

@@ -1,166 +0,0 @@
-import type { SpinnerName } from 'cli-spinners';
-
-export default interface BuildConfig {
-  /**
-   * Paths where Maizzle should look for Templates to compile.
-   *
-   * @default ['src/templates/**\/*.html']
-   *
-   * @example
-   * ```
-   * export default {
-   *   build: {
-   *     content: ['src/templates/**\/*.html']
-   *   }
-   * }
-   * ```
-   */
-  content?: string[];
-
-  /**
-   * Define the output path for compiled Templates, and what file extension they should use.
-   *
-   * @example
-   * ```
-   * export default {
-   *   build: {
-   *     output: {
-   *       path: 'build_production',
-   *       extension: 'html'
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  output?: {
-    /**
-     * Directory where Maizzle should output compiled Templates.
-     *
-     * @default 'build_{env}'
-     */
-    path?: string;
-    /**
-     * File extension to be used for compiled Templates.
-     *
-     * @default 'html'
-     */
-    extension: string;
-    /**
-     * Path or array of paths that will be unwrapped.
-     * Everything inside them will be copied to
-     * the root of the output directory.
-     *
-     * @example
-     *
-     * ```
-     * export default {
-     *  build: {
-     *   content: ['test/fixtures/**\/*.html'],
-     *   output: {
-     *    from: ['test/fixtures'],
-     *  }
-     * }
-     * ```
-     *
-     * This will copy everything inside `test/fixtures` to the root
-     * of the output directory, not creating the `test/fixtures`
-     * directory.
-     *
-     */
-    from: string;
-  };
-
-  /**
-   * Source and destination directories for static files.
-   *
-   * @example
-   * ```
-   * export default {
-   *   build: {
-   *     static: {
-   *       source: ['src/images/**\/*.*'],
-   *       destination: 'images'
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  static?: {
-    /**
-     * Array of paths where Maizzle should look for static files.
-     *
-     * @default undefined
-     */
-    source?: string[];
-    /**
-     * Directory where static files should be copied to,
-     * relative to the `build.output` path.
-     *
-     * @default undefined
-     */
-    destination?: string;
-  } | Array<{
-    source?: string[];
-    destination?: string;
-  }>
-
-  /**
-   * Type of spinner to show in the console.
-   *
-   * @default 'dots'
-   *
-   * @example
-   * ```
-   * export default {
-   *   build: {
-   *     spinner: 'bounce'
-   *   }
-   * }
-   * ```
-   */
-  spinner?: SpinnerName;
-
-  /**
-   * Show a summary of files that were compiled, along with their
-   * size and the time it took to compile them.
-   *
-   * @default false
-   *
-   * @example
-   * ```
-   * export default {
-   *   build: {
-   *     summary: true
-   *   }
-   * }
-   * ```
-   */
-  summary?: boolean;
-
-  /**
-   * Information about the Template currently being compiled.
-   *
-   * @example
-   *
-   * ```
-   * {
-      path: {
-        root: '',
-        dir: 'build_production',
-        base: 'transactional.html',
-        ext: '.html',
-        name: 'transactional'
-      }
-    }
-    * ```
-   */
-  readonly current?: {
-    path?: {
-      root: string;
-      dir: string;
-      base: string;
-      ext: string;
-      name: string;
-    };
-  };
-}