@maizzle/framework 4.8.8 → 5.0.0-beta.0

package/src/generators/config.js

@@ -1,52 +0,0 @@
-const path = require('node:path')
-const {merge} = require('lodash')
-const {requireUncached} = require('../utils/helpers')
-
-const baseConfigFileNames = [
-  './maizzle.config.js',
-  './maizzle.config.cjs',
-  './maizzle.config.local.js',
-  './maizzle.config.local.cjs',
-  './config.js',
-  './config.cjs',
-  './config.local.js',
-  './config.local.cjs'
-]
-
-module.exports = {
-  getMerged: async (env = 'local') => {
-    if (typeof env !== 'string') {
-      throw new TypeError(`env name must be a string, received ${typeof env}(${env})`)
-    }
-
-    let baseConfig = {env}
-    let envConfig = {env}
-
-    const cwd = ['maizzle-ci', 'test'].includes(env) ? './test/stubs/config' : process.cwd()
-
-    for (const module of baseConfigFileNames) {
-      try {
-        baseConfig = merge(baseConfig, requireUncached(path.resolve(cwd, module)))
-      } catch {}
-    }
-
-    if (env !== 'local') {
-      let loaded = false
-      const modulesToTry = [`./maizzle.config.${env}.js`, `./maizzle.config.${env}.cjs`, `./config.${env}.js`, `./config.${env}.cjs`]
-
-      for (const module of modulesToTry) {
-        try {
-          envConfig = merge(envConfig, requireUncached(path.resolve(cwd, module)))
-          loaded = true
-          break
-        } catch {}
-      }
-
-      if (!loaded) {
-        throw new Error(`Failed to load config file for \`${env}\` environment, do you have one of these files in your project root?\n\n${modulesToTry.join('\n')}`)
-      }
-    }
-
-    return merge(baseConfig, envConfig)
-  }
-}

package/src/generators/output/index.js

@@ -1,4 +0,0 @@
-module.exports = {
-  toDisk: require('./to-disk'),
-  toString: require('./to-string')
-}

package/src/generators/output/to-disk.js

@@ -1,254 +0,0 @@
-const fs = require('fs-extra')
-const path = require('node:path')
-const {glob} = require('fast-glob')
-const {get, merge, isEmpty} = require('lodash')
-
-const Config = require('../config')
-const Plaintext = require('../plaintext')
-const Tailwind = require('../tailwindcss')
-
-const render = require('./to-string')
-
-module.exports = async (env, spinner, config) => {
-  process.env.NODE_ENV = env || 'local'
-
-  if (isEmpty(config)) {
-    config = await Config.getMerged(env).catch(error => {
-      spinner.fail('Build failed')
-      throw error
-    })
-  }
-
-  const buildTemplates = get(config, 'build.templates')
-  const templatesConfig = Array.isArray(buildTemplates) ? buildTemplates : [buildTemplates]
-
-  const parsed = []
-  let files = []
-
-  const css = (typeof get(config, 'build.tailwind.compiled') === 'string')
-    ? config.build.tailwind.compiled
-    : await Tailwind.compile({config})
-
-  // Parse each template config object
-  for await (const templateConfig of templatesConfig) {
-    if (!templateConfig) {
-      const configFileName = env === 'local' ? 'config.js' : `config.${env}.js`
-      throw new Error(`No template sources defined in \`build.templates\`, check your ${configFileName} file`)
-    }
-
-    const outputDir = get(templateConfig, 'destination.path', `build_${env}`)
-
-    await fs.remove(outputDir)
-
-    /**
-     * Get all files in the template config's source directory
-     * Supports `source` defined as:
-     * - string
-     * - array of strings
-     * - function that returns either of the above
-     *
-     *  */
-    const templateSource = []
-    const templateTypeErrorMessage = 'Invalid template source: expected string or array of strings, got '
-
-    if (typeof templateConfig.source === 'function') {
-      const sources = templateConfig.source(config)
-
-      if (Array.isArray(sources)) {
-        templateSource.push(...sources)
-      } else if (typeof sources === 'string') {
-        templateSource.push(sources)
-      } else {
-        throw new TypeError(templateTypeErrorMessage + typeof sources)
-      }
-    } else {
-      if (Array.isArray(templateConfig.source)) {
-        templateSource.push(...templateConfig.source)
-      } else if (typeof templateConfig.source === 'string') {
-        templateSource.push(templateConfig.source)
-      } else {
-        throw new TypeError(templateTypeErrorMessage + typeof templateConfig.source)
-      }
-    }
-
-    // Create a pipe-delimited list of allowed extensions
-    // We only compile these, the rest are copied as-is
-    const fileTypes = get(templateConfig, 'filetypes', 'html')
-    const extensionsList = Array.isArray(fileTypes)
-      ? fileTypes.join(',')
-      : fileTypes.split('|').join(',')
-
-    // List of files that won't be copied to the output directory
-    const omitted = Array.isArray(templateConfig.omit)
-      ? templateConfig.omit
-      : [get(templateConfig, 'omit', '')]
-
-    // Parse each template source
-    for await (const source of templateSource) {
-      /**
-       * Copy single-file sources correctly
-       * If `src` is a file, `dest` cannot be a directory
-       * https://github.com/jprichardson/node-fs-extra/issues/323
-       */
-      const out = fs.lstatSync(source).isFile()
-        ? `${outputDir}/${path.basename(source)}`
-        : outputDir
-
-      await fs
-        .copy(source, out, {filter: file => {
-          // Do not copy omitted files
-          return !omitted
-            .filter(Boolean)
-            .some(omit => path.normalize(file).includes(path.normalize(omit)))
-        }})
-        .then(async () => {
-          const extensions = extensionsList.includes(',')
-            ? `{${extensionsList}}`
-            : extensionsList
-          const allSourceFiles = await glob(`${outputDir}/**/*.${extensions}`)
-
-          const skipped = Array.isArray(templateConfig.skip) ?
-            templateConfig.skip :
-            [get(templateConfig, 'skip', '')]
-
-          const templates = allSourceFiles.filter(template => {
-            return !skipped.includes(template.replace(`${outputDir}/`, ''))
-          })
-
-          if (templates.length === 0) {
-            spinner.warn(`Error: no files with the .${extensions} extension found in ${templateConfig.source}`)
-            return
-          }
-
-          if (config.events && typeof config.events.beforeCreate === 'function') {
-            await config.events.beforeCreate(config)
-          }
-
-          for await (const file of templates) {
-            config.build.current = {
-              path: path.parse(file)
-            }
-
-            const html = await fs.readFile(file, 'utf8')
-
-            try {
-              const compiled = await render(html, {
-                useFileConfig: true,
-                maizzle: {
-                  ...config,
-                  env
-                },
-                tailwind: {
-                  compiled: css
-                },
-                ...config.events
-              })
-
-              const destination = get(compiled, 'config.permalink', file)
-
-              /**
-               * Generate plaintext
-               *
-               * We do this first so that we can remove the <plaintext>
-               * tags from the markup before outputting the file.
-               */
-
-              // Check if plaintext: true globally, fallback to template's front matter
-              const plaintextConfig = get(templateConfig, 'plaintext', get(compiled.config, 'plaintext', false))
-              const plaintextPath = get(plaintextConfig, 'destination.path', destination)
-
-              if (Boolean(plaintextConfig) || !isEmpty(plaintextConfig)) {
-                await Plaintext
-                  .generate(
-                    compiled.html,
-                    plaintextPath,
-                    merge(plaintextConfig, {filepath: file})
-                  )
-                  .then(async ({html, plaintext, destination}) => {
-                    compiled.html = html
-                    await fs.outputFile(destination, plaintext)
-                  })
-              }
-
-              /**
-               * Output file
-               */
-              const parts = path.parse(destination)
-              const extension = get(templateConfig, 'destination.extension', 'html')
-              const finalDestination = `${parts.dir}/${parts.name}.${extension}`
-
-              await fs.outputFile(finalDestination, compiled.html)
-
-              /**
-               * Remove original file if its path is different
-               * from the final destination path.
-               *
-               * This ensures non-HTML files do not pollute
-               * the build destination folder.
-               */
-              if (finalDestination !== file) {
-                await fs.remove(file)
-              }
-
-              // Keep track of handled files
-              files.push(file)
-              parsed.push(file)
-            } catch (error) {
-              switch (config.build.fail) {
-                case 'silent':
-                  spinner.warn(`Failed to compile template: ${path.basename(file)}`)
-                  break
-                case 'verbose':
-                  spinner.warn(`Failed to compile template: ${path.basename(file)}`)
-                  console.error(error)
-                  break
-                default:
-                  spinner.fail(`Failed to compile template: ${path.basename(file)}`)
-                  throw error
-              }
-            }
-          }
-
-          const assets = Array.isArray(get(templateConfig, 'assets'))
-            ? get(templateConfig, 'assets')
-            : [{source: '', destination: 'assets', ...get(templateConfig, 'assets')}]
-
-          for await (const asset of assets) {
-            if (Array.isArray(asset.source)) {
-              for await (const source of asset.source) {
-                if (fs.existsSync(source)) {
-                  await fs
-                    .copy(source, path.join(templateConfig.destination.path, asset.destination))
-                    .catch(error => spinner.warn(error.message))
-                }
-              }
-            } else {
-              if (fs.existsSync(asset.source)) {
-                await fs
-                  .copy(asset.source, path.join(templateConfig.destination.path, asset.destination))
-                  .catch(error => spinner.warn(error.message))
-              }
-            }
-          }
-
-          await glob(path.join(templateConfig.destination.path, '/**').replace(/\\/g, '/'))
-            .then(contents => {
-              files = [...new Set([...files, ...contents])]
-            })
-        })
-        .catch(error => {
-          throw error
-        })
-    }
-  }
-
-  if (config.events && typeof config.events.afterBuild === 'function') {
-    await config.events.afterBuild(files, config)
-  }
-
-  return {
-    files,
-    parsed,
-    css
-  }
-}

package/src/generators/output/to-string.js

@@ -1,73 +0,0 @@
-const fm = require('front-matter')
-const Config = require('../config')
-const {get, merge} = require('lodash')
-const posthtml = require('../posthtml')
-const Tailwind = require('../tailwindcss')
-const Transformers = require('../../transformers')
-
-module.exports = async (html, options) => {
-  process.env.NODE_ENV = get(options, 'maizzle.env', 'local')
-
-  if (typeof html !== 'string') {
-    throw new TypeError(`first argument must be an HTML string, received ${html}`)
-  }
-
-  if (html.length === 0) {
-    throw new RangeError('received empty string')
-  }
-
-  const fileConfig = get(options, 'useFileConfig')
-    ? await Config.getMerged(process.env.NODE_ENV)
-    : {}
-
-  let config = merge(fileConfig, get(options, 'maizzle', {}))
-
-  const {frontmatter} = fm(html)
-
-  html = `---\n${frontmatter}\n---\n\n${fm(html).body}`
-
-  config = merge({applyTransformers: true}, config, fm(html).attributes)
-
-  if (typeof get(options, 'tailwind.compiled') === 'string') {
-    config.css = options.tailwind.compiled
-  } else {
-    config.css = await Tailwind.compile({
-      css: get(options, 'tailwind.css', ''),
-      html,
-      config: merge(config, {
-        build: {
-          tailwind: {
-            config: get(options, 'tailwind.config')
-          }
-        }
-      })
-    })
-  }
-
-  if (options && typeof options.beforeRender === 'function') {
-    html = await options.beforeRender(html, config)
-  }
-
-  html = await posthtml(html, config)
-
-  while (Object.keys(fm(html).attributes).length > 0) {
-    html = fm(html).body
-  }
-
-  if (options && typeof options.afterRender === 'function') {
-    html = await options.afterRender(html, config)
-  }
-
-  if (config.applyTransformers) {
-    html = await Transformers.process(html, config)
-  }
-
-  if (options && typeof options.afterTransformers === 'function') {
-    html = await options.afterTransformers(html, config)
-  }
-
-  return {
-    html,
-    config
-  }
-}

package/src/generators/postcss.js

@@ -1,23 +0,0 @@
-const {get} = require('lodash')
-const postcss = require('postcss')
-const postcssImport = require('postcss-import')
-const postcssNested = require('tailwindcss/nesting')
-const mergeLonghand = require('postcss-merge-longhand')
-
-module.exports = {
-  process: async (css = '', maizzleConfig = {}) => {
-    return postcss([
-      postcssImport(),
-      postcssNested(),
-      get(maizzleConfig, 'shorthandCSS', get(maizzleConfig, 'shorthandInlineCSS')) === true ?
-        mergeLonghand() :
-        () => {},
-      ...get(maizzleConfig, 'build.postcss.plugins', [])
-    ])
-      .process(css, {from: undefined})
-      .then(result => result.css)
-      .catch(error => {
-        throw new SyntaxError(error)
-      })
-  }
-}

package/src/generators/posthtml/index.js

@@ -1,75 +0,0 @@
-const fm = require('front-matter')
-const posthtml = require('posthtml')
-const fetch = require('posthtml-fetch')
-const layouts = require('posthtml-extend')
-const {get, merge, omit} = require('lodash')
-const components = require('posthtml-component')
-const defaultPosthtmlConfig = require('./defaultConfig')
-const defaultComponentsConfig = require('./defaultComponentsConfig')
-
-module.exports = async (html, config) => {
-  const posthtmlOptions = merge(defaultPosthtmlConfig, get(config, 'build.posthtml.options', {}))
-  const posthtmlPlugins = get(config, 'build.posthtml.plugins', [])
-
-  const componentsUserOptions = get(config, 'build.components', {})
-
-  const expressionsOptions = merge(
-    {
-      loopTags: ['each', 'for'],
-      strictMode: false
-    },
-    get(componentsUserOptions, 'expressions', {}),
-    get(config, 'build.posthtml.expressions', {})
-  )
-
-  const locals = merge(
-    get(expressionsOptions, 'locals', {}),
-    get(config, 'locals', {}),
-    {page: config}
-  )
-
-  const fetchPlugin = fetch(
-    merge(
-      {
-        expressions: merge(expressionsOptions, {locals})
-      },
-      get(config, 'build.posthtml.fetch', {})
-    )
-  )
-
-  const componentsOptions = merge(
-    {
-      ...defaultComponentsConfig,
-      folders: [
-        ...get(componentsUserOptions, 'folders', []),
-        ...defaultComponentsConfig.folders
-      ],
-      expressions: merge(expressionsOptions, {locals})
-    },
-    {
-      root: componentsUserOptions.root || './'
-    },
-    /**
-     * We omit `folders`, `root` and `expressions` in order to prevent duplicate
-     * array values, as they are already added above
-     */
-    omit(componentsUserOptions, ['folders', 'root', 'expressions'])
-  )
-
-  return posthtml([
-    fetchPlugin,
-    layouts(
-      merge(
-        {
-          strict: false,
-          expressions: merge(expressionsOptions, {locals})
-        },
-        get(config, 'build.layouts', {})
-      )
-    ),
-    components(componentsOptions),
-    ...posthtmlPlugins
-  ])
-    .process(html, {...posthtmlOptions})
-    .then(result => fm(result.html).body)
-}

package/src/generators/tailwindcss.js

@@ -1,157 +0,0 @@
-const fs = require('fs-extra')
-const path = require('node:path')
-const postcss = require('postcss')
-const tailwindcss = require('tailwindcss')
-const postcssImport = require('postcss-import')
-const {get, merge, isObject, isEmpty} = require('lodash')
-const postcssNested = require('tailwindcss/nesting')
-const {requireUncached} = require('../utils/helpers')
-const mergeLonghand = require('postcss-merge-longhand')
-const defaultComponentsConfig = require('./posthtml/defaultComponentsConfig')
-
-const addImportantPlugin = () => {
-  return {
-    postcssPlugin: 'add-important',
-    Rule(rule) {
-      const shouldAddImportant = get(rule, 'raws.tailwind.layer') === 'variants'
-      || get(rule, 'parent.type') === 'atrule'
-
-      if (shouldAddImportant) {
-        rule.walkDecls(decl => {
-          decl.important = true
-        })
-      }
-    }
-  }
-}
-
-module.exports = {
-  compile: async ({css = '', html = '', config = {}}) => {
-    // Compute the Tailwind config to use
-    const userConfig = config => {
-      const tailwindUserConfig = get(config, 'build.tailwind.config', 'tailwind.config.js')
-
-      // If a custom config object was passed, use that
-      if (isObject(tailwindUserConfig) && !isEmpty(tailwindUserConfig)) {
-        return tailwindUserConfig
-      }
-
-      /**
-       * Try loading a fresh tailwind.config.js, with fallback to an empty object.
-       * This will use the default Tailwind config (with rem units etc)
-       */
-      try {
-        return requireUncached(path.resolve(process.cwd(), tailwindUserConfig))
-      } catch {
-        return {}
-      }
-    }
-
-    // Merge user's Tailwind config on top of a 'base' config
-    const layoutsRoot = get(config, 'build.layouts.root')
-    const componentsRoot = get(config, 'build.components.root', defaultComponentsConfig.root)
-
-    const layoutsPath = typeof layoutsRoot === 'string' && layoutsRoot ?
-      `${layoutsRoot}/**/*.*`.replace(/\/\//g, '/') :
-      'src/layouts/**/*.*'
-
-    const componentsPath = defaultComponentsConfig.folders.map(folder => {
-      return path
-        .join(componentsRoot, folder, `**/*.${defaultComponentsConfig.fileExtension}`)
-        .replace(/\\/g, '/')
-        .replace(/\/\//g, '/')
-    })
-
-    const tailwindConfig = merge({
-      content: {
-        files: [
-          ...componentsPath,
-          layoutsPath
-        ]
-      }
-    }, userConfig(config))
-
-    // If `content` is an array, add it to `content.files`
-    if (Array.isArray(tailwindConfig.content)) {
-      tailwindConfig.content = {
-        files: [
-          ...componentsPath,
-          layoutsPath,
-          ...tailwindConfig.content
-        ]
-      }
-    }
-
-    // Add raw HTML if using API
-    if (html) {
-      tailwindConfig.content.files.push({raw: html, extension: 'html'})
-    }
-
-    // Include all `build.templates.source` paths when scanning for selectors to preserve
-    const buildTemplates = get(config, 'build.templates')
-
-    if (buildTemplates) {
-      const templateObjects = Array.isArray(buildTemplates) ? buildTemplates : [buildTemplates]
-      const configFileTypes = get(buildTemplates, 'filetypes', ['html'])
-      const fileTypes = Array.isArray(configFileTypes) ? configFileTypes : configFileTypes.split('|')
-      const fileTypesPattern = fileTypes.length > 1 ? `{${fileTypes.join(',')}}` : fileTypes[0]
-
-      for (const template of templateObjects) {
-        const source = get(template, 'source')
-
-        if (typeof source === 'function') {
-          const sources = source(config)
-
-          if (Array.isArray(sources)) {
-            sources.map(s => tailwindConfig.content.files.push(`${s}/**/*.${fileTypesPattern}`))
-          } else if (typeof sources === 'string') {
-            tailwindConfig.content.files.push(sources)
-          }
-        }
-
-        // Support single-file sources i.e. src/templates/index.html
-        else if (typeof source === 'string' && Boolean(path.extname(source))) {
-          tailwindConfig.content.files.push(source)
-        }
-
-        // Default behavior - directory sources as a string
-        else {
-          tailwindConfig.content.files.push(`${source}/**/*.${fileTypesPattern}`)
-        }
-      }
-    }
-
-    // Filter out any duplicate content paths
-    tailwindConfig.content.files = [...new Set(tailwindConfig.content.files)]
-
-    const userFilePath = get(config, 'build.tailwind.css', path.join(process.cwd(), 'src/css/tailwind.css'))
-    const userFileExists = await fs.pathExists(userFilePath)
-
-    const toProcess = [
-      postcssNested(),
-      tailwindcss(tailwindConfig),
-      get(tailwindConfig, 'important') === false ? () => {} : addImportantPlugin(),
-      get(config, 'shorthandCSS', get(config, 'shorthandInlineCSS')) === true ?
-        mergeLonghand() :
-        () => {},
-      ...get(config, 'build.postcss.plugins', [])
-    ]
-
-    if (userFileExists) {
-      css = await fs.readFile(path.resolve(userFilePath), 'utf8') + css
-
-      toProcess.unshift(
-        postcssImport({path: path.dirname(userFilePath)})
-      )
-    } else {
-      css = `@tailwind components; @tailwind utilities; ${css}`
-    }
-
-    return postcss([...toProcess])
-      .process(css, {from: userFileExists ? userFilePath : undefined})
-      .then(result => result.css)
-      .catch(error => {
-        throw new SyntaxError(error)
-      })
-  }
-}

package/src/transformers/extraAttributes.js

@@ -1,33 +0,0 @@
-const posthtml = require('posthtml')
-const {get, merge, isObject} = require('lodash')
-const addAttributes = require('posthtml-extra-attributes')
-const defaultConfig = require('../generators/posthtml/defaultConfig')
-
-module.exports = async (html, config = {}, direct = false) => {
-  if (get(config, 'extraAttributes') === false) {
-    return html
-  }
-
-  const posthtmlOptions = merge(defaultConfig, get(config, 'build.posthtml.options', {}))
-
-  let attributes = {
-    table: {
-      cellpadding: 0,
-      cellspacing: 0,
-      role: 'none'
-    },
-    img: {
-      alt: ''
-    }
-  }
-
-  attributes = direct
-    ? {...attributes, ...config}
-    : (
-      isObject(config.extraAttributes)
-        ? {...attributes, ...config.extraAttributes}
-        : attributes
-    )
-
-  return posthtml([addAttributes({attributes})]).process(html, posthtmlOptions).then(result => result.html)
-}