coralite-scripts 0.38.6 → 0.40.0

package/bin/index.js

@@ -3,14 +3,11 @@
 import loadConfig from '../libs/load-config.js'
 import { Command, Argument } from 'commander'
 import server from '../libs/server.js'
-import colours from 'kleur'
 import pkg from '../package.json' with { type: 'json' }
-import buildStyles from '../libs/build-styles.js'
-import { join, relative, dirname } from 'node:path'
-import { deleteDirectoryRecursive, copyDirectory, toMS, toTime, displayError, displayWarning, displayInfo } from '../libs/build-utils.js'
-import { createCoralite } from 'coralite'
-import { mkdir, writeFile } from 'node:fs/promises'
-import ora from 'ora'
+import { join } from 'node:path'
+import { mkdir } from 'node:fs/promises'
+import { buildCommand } from '../libs/commands/build.js'
+import { parseAssetMapping, mergeAssets } from '../libs/assets.js'
 
 // remove all Node warnings before doing anything else
 process.removeAllListeners('warning')
@@ -22,7 +19,9 @@ program
   .description(pkg.description)
   .version(pkg.version)
   .addArgument(new Argument('<mode>', 'Run mode: dev (development server) or build (production compilation)').choices(['dev', 'build']).default('dev'))
-  .option('-v --verbose', 'Enable verbose logging output')
+  .option('-v, --verbose', 'Enable verbose logging output')
+  .option('-c, --clean', 'Clear the output directory before building')
+  .option('-a, --assets <mapping...>', 'Static assets to copy during build. Format: pkg:path:dest or src:dest')
 
 program.parse(process.argv)
 program.on('error', (err) => {
@@ -31,171 +30,31 @@ program.on('error', (err) => {
 
 const options = program.opts()
 const mode = program.args[0]
-const config = await loadConfig()
+const config = await loadConfig(process.cwd())
 
 if (!config) {
   process.exit(1)
 }
 
+if (options.assets) {
+  try {
+    const cliAssets = options.assets.map(parseAssetMapping)
+    config.assets = mergeAssets(config.assets, cliAssets)
+  } catch (err) {
+    console.error(`\n  Error: ${err.message}\n`)
+    process.exit(1)
+  }
+}
+
 if (mode === 'dev') {
   config.output = join(process.cwd(), '.coralite')
   await mkdir(config.output, { recursive: true })
 
   await server(config, options)
 } else if (mode === 'build') {
-  const PAD = '  '
-  const border = '─'.repeat(Math.min(process.stdout.columns, 36) / 2)
-  const dash = colours.gray(' ─ ')
-
-  if (options.verbose) {
-    // log the response time and status code
-    process.stdout.write('\n' + PAD + colours.yellow('Compiling Coralite... \n\n'))
-    process.stdout.write(border + colours.inverse(` LOGS `) + border + '\n\n')
-  } else {
-    process.stdout.write('\n' + PAD + colours.yellow('Compiling Coralite... \n\n'))
-  }
-
-  // delete old output files
-  deleteDirectoryRecursive(config.output)
-
-  // start coralite
-  const coralite = await createCoralite({
-    components: config.components,
-    pages: config.pages,
-    plugins: config.plugins,
-    assets: config.assets,
-    externalStyles: config.styles?.input?.map(input => {
-      const ext = input.split('.').pop()
-      return '/assets/css/' + input.split('/').pop().replace(`.${ext}`, '.css')
-    }),
-    baseURL: config.baseURL,
-    output: config.output,
-    mode: 'production',
-    onError: ({ level, message, error }) => {
-      if (level === 'ERR') {
-        displayError(message, error)
-      } else if (level === 'WARN') {
-        displayWarning(message)
-      } else {
-        displayInfo(message)
-      }
-    }
-  })
-
-  let spinner
-  let pageCount = 0
-  let skippedCount = 0
-
   try {
-    let componentCount = 0
-
-    if (!options.verbose) {
-      spinner = ora('Building pages...').start()
-    }
-
-    const updateSpinnerText = () => {
-      if (skippedCount > 0) {
-        spinner.text = `Building pages... (${pageCount} completed, ${skippedCount} skipped)`
-      } else {
-        spinner.text = `Building pages... (${pageCount} completed)`
-      }
-    }
-
-    // compile website
-    await coralite.build(async (result) => {
-      if (result.status === 'skipped') {
-        skippedCount++
-        if (!options.verbose) {
-          updateSpinnerText()
-        }
-        return
-      }
-
-      const relativeDir = relative(config.pages, result.path.dirname)
-      const outDir = join(config.output, relativeDir)
-      const outFile = join(outDir, result.path.filename)
-
-      await mkdir(outDir, { recursive: true })
-      await writeFile(outFile, result.content)
-
-      if (options.verbose) {
-        process.stdout.write(toTime() + toMS(result.duration) + dash + result.path.pathname + '\n')
-      } else {
-        pageCount++
-        updateSpinnerText()
-      }
-    })
-
-    // Write ESM script assets generated during the build phase
-    if (coralite.outputFiles) {
-      const assetsDir = join(config.output, 'assets', 'js')
-
-      const assetWrites = Object.values(coralite.outputFiles).map(async (file) => {
-        const outFile = join(assetsDir, file.hashedPath)
-        await mkdir(dirname(outFile), { recursive: true })
-        await writeFile(outFile, file.text)
-        if (options.verbose) {
-          const dash = colours.gray(' ─ ')
-          process.stdout.write(toTime() + toMS(0) + dash + outFile + '\n')
-        }
-      })
-
-      await Promise.all(assetWrites)
-    }
-
-    if (!options.verbose) {
-      if (skippedCount > 0) {
-        spinner.succeed(`Pages built (${pageCount} completed, ${skippedCount} skipped)`)
-      } else {
-        spinner.succeed(`Pages built (${pageCount} completed)`)
-      }
-      if (componentCount > 0) {
-        ora(`Components built (${componentCount} completed)`).succeed()
-      }
-    }
-
-    const publicDir = config.public
-
-    if (publicDir) {
-      if (!options.verbose) {
-        spinner = ora('Copying public directory...').start()
-      }
-      await copyDirectory(publicDir, config.output)
-      if (!options.verbose) {
-        spinner.succeed('Public directory copied')
-      }
-    }
-
-    if (config.styles && config.styles.input) {
-      if (!options.verbose) {
-        spinner = ora('Building styles...').start()
-      }
-
-      const results = await buildStyles({
-        input: config.styles.input,
-        output: join(config.output, 'assets', 'css'),
-        processors: config.styles.processors,
-        minify: mode === 'build',
-        sourcemap: mode !== 'build'
-      })
-
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i]
-
-        if (options.verbose) {
-          process.stdout.write(toTime() + toMS(result.duration) + dash + result.output + '\n')
-        }
-      }
-
-      if (!options.verbose) {
-        spinner.succeed('Styles built')
-      }
-    }
-  } catch (error) {
-    if (spinner) {
-      spinner.fail('Build failed')
-    }
-    displayError('Build failed', error)
+    await buildCommand(config, options)
+  } catch {
     process.exit(1)
   }
 }

package/dist/libs/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../libs/config.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,sCAzBW,oBAAoB,GAClB,oBAAoB,CAoJhC;0CA9JsC,mBAAmB"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../libs/config.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,sCAzBW,oBAAoB,GAClB,oBAAoB,CA2KhC;0CArLsC,mBAAmB"}

package/libs/assets.js

@@ -0,0 +1,55 @@
+/**
+ * @import { CoraliteStaticAsset } from 'coralite'
+ */
+
+/**
+ * Parses an asset mapping string into an asset object.
+ *
+ * @param {string} mapping - The mapping string (pkg:path:dest or src:dest).
+ * @returns {CoraliteStaticAsset} The parsed asset object.
+ * @throws {Error} If the mapping format is invalid.
+ */
+export function parseAssetMapping (mapping) {
+  const parts = mapping.split(':')
+
+  if (parts.length === 3) {
+    // pkg:path:dest
+    return {
+      pkg: parts[0],
+      path: parts[1],
+      dest: parts[2]
+    }
+  } else if (parts.length === 2) {
+    // src:dest
+    const src = parts[0]
+    if (!src.startsWith('.') && !src.startsWith('/') && !src.startsWith('..')) {
+      throw new Error(`Invalid asset mapping "${mapping}". Local paths must start with ".", "..", or "/". NPM package mappings require 3 parts (pkg:path:dest).`)
+    }
+    return {
+      src,
+      dest: parts[1]
+    }
+  } else {
+    throw new Error(`Invalid asset mapping "${mapping}". Expected format: pkg:path:dest or src:dest`)
+  }
+}
+
+/**
+ * Merges a list of CLI assets into an existing assets array, with CLI assets taking precedence on destination collisions.
+ *
+ * @param {CoraliteStaticAsset[]} baseAssets - The existing assets array.
+ * @param {CoraliteStaticAsset[]} cliAssets - The new assets to merge.
+ * @returns {CoraliteStaticAsset[]} The merged assets array.
+ */
+export function mergeAssets (baseAssets = [], cliAssets = []) {
+  const merged = [...baseAssets]
+  for (const cliAsset of cliAssets) {
+    const index = merged.findIndex(a => a.dest === cliAsset.dest)
+    if (index !== -1) {
+      merged[index] = cliAsset
+    } else {
+      merged.push(cliAsset)
+    }
+  }
+  return merged
+}

package/libs/commands/build.js

@@ -0,0 +1,286 @@
+import colours from 'kleur'
+import buildStyles from '../build-styles.js'
+import { join, relative, dirname } from 'node:path'
+import { existsSync, readdirSync, rmdirSync, statSync, unlinkSync } from 'node:fs'
+import { deleteDirectoryRecursive, copyDirectory, toMS, toTime, displayError, displayWarning, displayInfo } from '../build-utils.js'
+import { createCoralite } from 'coralite'
+import { mkdir, writeFile } from 'node:fs/promises'
+import ora from 'ora'
+
+/**
+ * @param {import('../../types/index.js').CoraliteScriptConfig} config - The configuration object.
+ * @param {any} options - The CLI options.
+ * @param {any} logger - The logger object.
+ */
+export async function buildCommand (config, options, logger = null) {
+  const mode = 'build'
+  const PAD = '  '
+  const border = '─'.repeat(Math.min(process.stdout.columns || 36, 36) / 2)
+  const dash = colours.gray(' ─ ')
+
+  const log = (msg) => {
+    if (logger && logger.write) {
+      logger.write(msg)
+    } else {
+      process.stdout.write(msg)
+    }
+  }
+
+  const createSpinner = (text) => {
+    if (logger && logger.spinner) {
+      return logger.spinner(text)
+    }
+    return ora(text)
+  }
+
+  const internalLogger = {
+    info: (msg) => {
+      return logger && logger.info ? logger.info(msg) : displayInfo(msg)
+    },
+    warn: (msg) => {
+      return logger && logger.warn ? logger.warn(msg) : displayWarning(msg)
+    },
+    error: (msg, err) => {
+      return logger && logger.error ? logger.error(msg, err) : displayError(msg, err)
+    }
+  }
+
+  if (options.verbose) {
+    log('\n' + PAD + colours.yellow('Compiling Coralite... \n\n'))
+    log(border + colours.inverse(` LOGS `) + border + '\n\n')
+  } else {
+    log('\n' + PAD + colours.yellow('Compiling Coralite... \n\n'))
+  }
+
+  if (options.clean) {
+    deleteDirectoryRecursive(config.output)
+  }
+
+  const validFiles = new Set()
+
+  const coralite = await createCoralite({
+    components: config.components,
+    pages: config.pages,
+    plugins: config.plugins,
+    assets: config.assets,
+    externalStyles: config.styles?.input?.map(input => {
+      const ext = input.split('.').pop()
+      return '/assets/css/' + input.split('/').pop().replace(`.${ext}`, '.css')
+    }),
+    baseURL: config.baseURL,
+    output: config.output,
+    mode: 'production',
+    onError: ({ level, message, error }) => {
+      if (level === 'ERR') {
+        internalLogger.error(message, error)
+      } else if (level === 'WARN') {
+        internalLogger.warn(message)
+      } else {
+        internalLogger.info(message)
+      }
+    }
+  })
+
+  let spinner
+  let pageCount = 0
+  let skippedCount = 0
+
+  try {
+    const componentCount = 0
+
+    if (!options.verbose) {
+      spinner = createSpinner('Building pages...').start()
+    }
+
+    const updateSpinnerText = () => {
+      if (skippedCount > 0) {
+        spinner.text = `Building pages... (${pageCount} completed, ${skippedCount} skipped)`
+      } else {
+        spinner.text = `Building pages... (${pageCount} completed)`
+      }
+    }
+
+    await coralite.build(async (result) => {
+      const relativeDir = relative(config.pages, result.path.dirname)
+      const outDir = join(config.output, relativeDir)
+      const outFile = join(outDir, result.path.filename)
+
+      validFiles.add(outFile)
+
+      if (result.status === 'skipped') {
+        skippedCount++
+        if (!options.verbose) {
+          updateSpinnerText()
+        }
+        return
+      }
+
+      await mkdir(outDir, { recursive: true })
+      await writeFile(outFile, result.content)
+
+      if (options.verbose) {
+        log(toTime() + toMS(result.duration) + dash + result.path.pathname + '\n')
+      } else {
+        pageCount++
+        updateSpinnerText()
+      }
+    })
+
+    if (coralite.outputFiles) {
+      const assetsJsDir = join(config.output, 'assets', 'js')
+      const assetsCssDir = join(config.output, 'assets', 'css')
+
+      const assetWrites = Object.values(coralite.outputFiles).map(async (file) => {
+        const isCSS = (file.path || file.hashedPath)?.endsWith('.css')
+        const baseAssetsDir = isCSS ? assetsCssDir : assetsJsDir
+        const outFile = join(baseAssetsDir, file.hashedPath)
+
+        validFiles.add(outFile)
+
+        await mkdir(dirname(outFile), { recursive: true })
+        await writeFile(outFile, file.text)
+        if (options.verbose) {
+          const dash = colours.gray(' ─ ')
+          log(toTime() + toMS(0) + dash + outFile + '\n')
+        }
+      })
+
+      await Promise.all(assetWrites)
+    }
+
+    // Track assets from config to prevent them from being deleted as stale files
+    if (config.assets) {
+      for (const asset of config.assets) {
+        const fullDestPath = join(config.output, asset.dest)
+        if (existsSync(fullDestPath)) {
+          const stat = statSync(fullDestPath)
+          if (stat.isDirectory()) {
+            const trackFiles = (dir) => {
+              const files = readdirSync(dir)
+              for (const file of files) {
+                const fullPath = join(dir, file)
+                if (statSync(fullPath).isDirectory()) {
+                  trackFiles(fullPath)
+                } else {
+                  validFiles.add(fullPath)
+                }
+              }
+            }
+            trackFiles(fullDestPath)
+          } else {
+            validFiles.add(fullDestPath)
+          }
+        }
+      }
+    }
+
+    if (!options.verbose) {
+      if (skippedCount > 0) {
+        spinner.succeed(`Pages built (${pageCount} completed, ${skippedCount} skipped)`)
+      } else {
+        spinner.succeed(`Pages built (${pageCount} completed)`)
+      }
+      if (componentCount > 0) {
+        createSpinner(`Components built (${componentCount} completed)`).succeed()
+      }
+    }
+
+    const publicDir = config.public
+
+    if (publicDir) {
+      if (!options.verbose) {
+        spinner = createSpinner('Copying public directory...').start()
+      }
+      await copyDirectory(publicDir, config.output)
+
+      const trackPublicFiles = (dir, baseDir) => {
+        const files = readdirSync(dir)
+        for (const file of files) {
+          const fullPath = join(dir, file)
+          const stat = statSync(fullPath)
+
+          if (stat.isDirectory()) {
+            trackPublicFiles(fullPath, baseDir)
+          } else {
+            const relativePath = relative(baseDir, fullPath)
+            validFiles.add(join(config.output, relativePath))
+          }
+        }
+      }
+      trackPublicFiles(publicDir, publicDir)
+
+      if (!options.verbose) {
+        spinner.succeed('Public directory copied')
+      }
+    }
+
+    if (config.styles && config.styles.input) {
+      if (!options.verbose) {
+        spinner = createSpinner('Building styles...').start()
+      }
+
+      const results = await buildStyles({
+        input: config.styles.input,
+        output: join(config.output, 'assets', 'css'),
+        processors: config.styles.processors,
+        minify: mode === 'build',
+        sourcemap: mode !== 'build'
+      })
+
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i]
+        validFiles.add(result.output)
+
+        if (options.verbose) {
+          log(toTime() + toMS(result.duration) + dash + result.output + '\n')
+        }
+      }
+
+      if (!options.verbose) {
+        spinner.succeed('Styles built')
+      }
+    }
+
+    if (!options.clean) {
+      if (!options.verbose) {
+        spinner = createSpinner('Cleaning up stale files...').start()
+      }
+
+      const cleanupStaleFiles = (dir) => {
+        if (!existsSync(dir)) {
+          return
+        }
+
+        const files = readdirSync(dir)
+        for (const file of files) {
+          const fullPath = join(dir, file)
+          const stat = statSync(fullPath)
+
+          if (stat.isDirectory()) {
+            cleanupStaleFiles(fullPath)
+            if (readdirSync(fullPath).length === 0) {
+              rmdirSync(fullPath)
+            }
+          } else if (!validFiles.has(fullPath)) {
+            unlinkSync(fullPath)
+
+            if (options.verbose) {
+              log(toTime() + colours.gray('Deleted stale file: ') + fullPath + '\n')
+            }
+          }
+        }
+      }
+      cleanupStaleFiles(config.output)
+
+      if (!options.verbose) {
+        spinner.succeed('Cleanup complete')
+      }
+    }
+  } catch (error) {
+    if (spinner) {
+      spinner.fail('Build failed')
+    }
+    internalLogger.error('Build failed', error)
+    throw error
+  }
+}

package/libs/config.js

@@ -154,6 +154,29 @@ export function defineConfig (options) {
     if (!Array.isArray(options.assets)) {
       throw new Error('Configuration "assets" must be an array')
     }
+
+    for (const asset of options.assets) {
+      if (typeof asset !== 'object' || asset === null) {
+        throw new Error('Configuration "assets" items must be objects')
+      }
+
+      if (!asset.dest || typeof asset.dest !== 'string') {
+        throw new Error('Configuration "assets" items must have a string "dest" property')
+      }
+
+      if (asset.src) {
+        if (typeof asset.src !== 'string') {
+          throw new Error('Configuration "assets" items "src" property must be a string')
+        }
+      } else {
+        if (!asset.pkg || typeof asset.pkg !== 'string') {
+          throw new Error('Configuration "assets" items must have a string "pkg" property when "src" is not provided')
+        }
+        if (!asset.path || typeof asset.path !== 'string') {
+          throw new Error('Configuration "assets" items must have a string "path" property when "src" is not provided')
+        }
+      }
+    }
   }
 
   return options

package/libs/load-config.js

@@ -19,9 +19,10 @@ import { defineConfig } from './config.js'
  *
  * const config = await loadConfig()
  * ```
+ * @param {string} [cwd=process.cwd()] - The current working directory.
  */
-async function loadConfig () {
-  const configPath = pathToFileURL(join(process.cwd(), 'coralite.config.js'))
+async function loadConfig (cwd = process.cwd()) {
+  const configPath = pathToFileURL(join(cwd, 'coralite.config.js'))
 
   try {
     await access(configPath)
@@ -42,15 +43,10 @@ async function loadConfig () {
       return null
     }
 
-    try {
-      return defineConfig(config.default)
-    } catch (err) {
-      displayError('Invalid configuration', err.message)
-      return null
-    }
+    return defineConfig(config.default)
   } catch (error) {
-    displayError('Failed to load configuration file', error)
-    return null
+    displayError('Failed to load configuration file', error.message || error)
+    throw error
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coralite-scripts",
-  "version": "0.38.6",
+  "version": "0.40.0",
   "description": "Configuration and scripts for Create Coralite.",
   "type": "module",
   "bin": {
@@ -61,11 +61,11 @@
     "portfinder": "^1.0.38",
     "postcss": "^8.5.15",
     "sass": "^1.101.0",
-    "coralite": "0.38.6"
+    "coralite": "0.40.0"
   },
   "scripts": {
-    "build": "premove dist && pnpm build-types",
-    "build-types": "tsc",
-    "test-unit": "node --test tests/**/*.spec.js"
+    "build": "premove dist && pnpm build:types",
+    "build:types": "tsc",
+    "test:unit": "node --test tests/**/*.spec.js"
   }
 }