coralite-scripts 0.36.2 → 0.37.0

package/bin/index.js

@@ -8,7 +8,7 @@ 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 { Coralite } from 'coralite'
+import { createCoralite } from 'coralite'
 import { mkdir, writeFile } from 'node:fs/promises'
 import ora from 'ora'
 
@@ -58,10 +58,8 @@ if (mode === 'dev') {
   // delete old output files
   deleteDirectoryRecursive(config.output)
 
-  const start = process.hrtime()
-
   // start coralite
-  const coralite = new Coralite({
+  const coralite = await createCoralite({
     components: config.components,
     pages: config.pages,
     plugins: config.plugins,
@@ -83,10 +81,10 @@ if (mode === 'dev') {
       }
     }
   })
-  await coralite.initialise()
 
   let spinner
   let pageCount = 0
+  let skippedCount = 0
 
   try {
     let componentCount = 0
@@ -95,8 +93,24 @@ if (mode === 'dev') {
       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)
@@ -108,7 +122,7 @@ if (mode === 'dev') {
         process.stdout.write(toTime() + toMS(result.duration) + dash + result.path.pathname + '\n')
       } else {
         pageCount++
-        spinner.text = `Building pages... (${pageCount} completed)`
+        updateSpinnerText()
       }
     })
 
@@ -130,7 +144,11 @@ if (mode === 'dev') {
     }
 
     if (!options.verbose) {
-      spinner.succeed(`Pages built (${pageCount} completed)`)
+      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()
       }

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,CAmJhC;0CA7JsC,mBAAmB"}
+{"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"}

package/dist/types/index.d.ts

@@ -11,6 +11,9 @@ export type CoraliteScriptBaseConfig = {
     server?: {
         port: number;
     };
+    /**
+     * - The configuration options for style processing.
+     */
     styles?: {
         input?: string[];
         processors?: {
@@ -41,4 +44,5 @@ export type CoraliteScriptOptions = {
     verbose?: boolean;
 };
 import type { Options } from 'sass';
+import type { CoraliteConfig } from 'coralite/types';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../types/index.js"],"names":[],"mappings":";;;;;;YAOc,MAAM;;;;aAEjB;QAA0B,IAAI,EAAnB,MAAM;KACjB;aACA;QAA6B,KAAK,GAAvB,MAAM,EAAE;QACQ,UAAU,GACrC;YAAgD,IAAI,GAAzC,QAAQ,OAAO,CAAC;YACW,OAAO,GAC7C;gBAA0E,OAAO,GAAtE,OAAO,SAAS,EAAE,cAAc,EAAE;aAC7C;SAAA;KAAA;;;;WAAW,YAAY,GAAG,aAAa;;mCAI7B,wBAAwB,iBAAiB;;;;;UAKxC,OAAO;;;;YACP,OAAO;;;;cACP,OAAO;;6BAzBK,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../types/index.js"],"names":[],"mappings":";;;;;;YAOc,MAAM;;;;aAEjB;QAA0B,IAAI,EAAnB,MAAM;KACjB;;;;aACA;QAA6B,KAAK,GAAvB,MAAM,EAAE;QACQ,UAAU,GACrC;YAAgD,IAAI,GAAzC,QAAQ,OAAO,CAAC;YACW,OAAO,GAC7C;gBAA0E,OAAO,GAAtE,OAAO,SAAS,EAAE,cAAc,EAAE;aAC7C;SAAA;KAAA;;;;WAAW,YAAY,GAAG,aAAa;;mCAI7B,wBAAwB,GAAG,cAAc;;;;;UAKxC,OAAO;;;;YACP,OAAO;;;;cACP,OAAO;;6BAzBK,MAAM;oCADC,gBAAgB"}

package/libs/build-styles.js

@@ -12,13 +12,10 @@ import path from 'path'
 
 /**
  * Compiles SCSS and CSS files with optional PostCSS processing
- * @param {Object} options
+ * @param {Object} options - The configuration options for building styles.
  * @param {string[]} options.input - Array of input file paths
  * @param {string} options.output - Output directory for compiled CSS files
  * @param {Object} [options.processors] - Processor configurations
- * @param {import('sass').Options<'async'>} [options.processors.scss] - Sass options
- * @param {Object} [options.processors.postcss] - PostCSS options
- * @param {import('postcss').AcceptedPlugin[]} [options.processors.postcss.plugins] - PostCSS plugins
  * @returns {Promise<BuildStylesResult[]>}
  */
 async function buildStyles ({
@@ -29,6 +26,7 @@ async function buildStyles ({
   const scssOptions = {
     sourceMap: true,
     loadPaths: ['node_modules'],
+    // @ts-ignore
     silenceDeprecations: [
       'color-functions',
       'import',
@@ -50,6 +48,7 @@ async function buildStyles ({
     let map
 
     if (ext === '.scss' || ext === '.sass') {
+      // @ts-ignore
       const result = await sass.compileAsync(filePath, scssOptions)
       css = result.css
       map = result.sourceMap

package/libs/build-utils.js

@@ -2,6 +2,7 @@ import colours from 'kleur'
 import fs from 'node:fs'
 import path from 'node:path'
 import { cp } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
 
 /**
  * Creates current time in format [HH:MM:SS].mmm (milliseconds), colored with ANSI colors, and formatted as bold white string for better readability of logs or console output
@@ -111,6 +112,49 @@ export function displayError (message, error) {
     }
 
     if (isCoraliteError) {
+      const displayFile = targetError.stackFile || targetError.filePath
+      if (displayFile) {
+        let absolutePath = displayFile
+        if (absolutePath.startsWith('file://')) {
+          try {
+            absolutePath = fileURLToPath(absolutePath)
+          } catch {
+          }
+        }
+
+        const relativePath = path.relative(process.cwd(), absolutePath)
+        let location = relativePath
+        if (targetError.line) {
+          location += `:${targetError.line}`
+          if (targetError.column) {
+            location += `:${targetError.column}`
+          }
+        }
+
+        process.stdout.write(colours.bold(`> ${location}: `) + colours.red('error: ') + targetError.message + '\n')
+
+        if (fs.existsSync(absolutePath) && targetError.line) {
+          try {
+            const content = fs.readFileSync(absolutePath, 'utf8')
+            const lines = content.split('\n')
+            const errorLine = lines[targetError.line - 1]
+            if (errorLine !== undefined) {
+              const gutter = ` ${targetError.line} | `
+              process.stdout.write(colours.grey(gutter) + errorLine + '\n')
+              if (targetError.column) {
+                // To handle tabs correctly, we take the prefix of the line up to the error column
+                // and replace all non-whitespace characters with spaces.
+                const prefix = errorLine.substring(0, targetError.column - 1)
+                const padding = ' '.repeat(gutter.length) + prefix.replace(/\S/g, ' ')
+                process.stdout.write(padding + colours.cyan('~') + '\n')
+              }
+            }
+          } catch {
+          }
+        }
+        process.stdout.write('\n')
+      }
+
       process.stdout.write(indent + colours.magenta('Component context:') + '\n')
       if (targetError.componentId) {
         process.stdout.write(indent + '  ' + colours.cyan('ID:        ') + targetError.componentId + '\n')
@@ -129,15 +173,17 @@ export function displayError (message, error) {
 
     let errorDetails = ''
 
-    if (error instanceof Error ||
-      (error !== null
-        && typeof error === 'object'
-        && 'message' in error
-        && 'stack' in error
+    const errorToStack = error.cause && error.cause.stack ? error.cause : error
+
+    if (errorToStack instanceof Error ||
+      (errorToStack !== null
+        && typeof errorToStack === 'object'
+        && 'message' in errorToStack
+        && 'stack' in errorToStack
       )
     ) {
       // @ts-ignore
-      errorDetails = error.stack || error.message
+      errorDetails = errorToStack.stack || errorToStack.message
     } else if (typeof error === 'string') {
       errorDetails = error
     } else if (typeof error === 'object' && error !== null) {

package/libs/config.js

@@ -91,6 +91,7 @@ export function defineConfig (options) {
       }
     }
 
+    // @ts-ignore
     if (options.styles.type) {
       throw new Error('Coralite Config Error: The "styles" configuration has been upgraded. "input" must now be an array, and "type" has been replaced by the "processors" object. Please update your coralite.config.js.')
     }

package/libs/server.js

@@ -6,14 +6,119 @@ import buildStyles from './build-styles.js'
 import { displayError, displayInfo, displayWarning, displaySuccess, toCode, toMS, toTime, deleteDirectoryRecursive } from './build-utils.js'
 import { dirname, extname, join, normalize, relative, sep } from 'path'
 import { access, constants, mkdir, readFile, writeFile } from 'fs/promises'
-import Coralite from 'coralite'
-import { existsSync, mkdirSync } from 'fs'
+import { createCoralite } from 'coralite'
+import { existsSync } from 'fs'
 import portfinder from 'portfinder'
 
 /**
  * @import {CoraliteScriptConfig, CoraliteScriptOptions} from '../types/index.js'
  */
 
+/**
+ * Resolves the requested path to a file or a virtual page.
+ *
+ * @param {string} reqPath - The requested URL path.
+ * @param {string} extension - The extension of the requested path.
+ * @param {CoraliteScriptConfig} config - The Coralite configuration.
+ * @param {any} coralite - The Coralite instance.
+ * @param {Map<string, string>} memoryPageSource - Map of in-memory page sources.
+ * @returns {Promise<{pathname: string, key: string}|null>}
+ */
+export async function resolveSource (reqPath, extension, config, coralite, memoryPageSource) {
+  const candidates = []
+  const pagesRoot = normalize(config.pages)
+  const isPathInsideRoot = (rootPath, candidatePath) => {
+    const rel = relative(rootPath, candidatePath)
+    return rel !== '..' && !rel.startsWith(`..${sep}`) && rel !== '' ? true : candidatePath === rootPath
+  }
+
+  // Ensure relative path doesn't start with / for joining
+  const relPath = reqPath.startsWith('/') ? reqPath.slice(1) : reqPath
+
+  if (reqPath.endsWith('/')) {
+    const key = join(relPath, 'index.html')
+    const candidatePath = normalize(join(config.pages, key))
+
+    if (isPathInsideRoot(pagesRoot, candidatePath)) {
+      candidates.push({
+        path: candidatePath,
+        key
+      })
+    }
+  } else if (extension === '.html') {
+    const key = relPath
+    const candidatePath = normalize(join(config.pages, key))
+
+    if (isPathInsideRoot(pagesRoot, candidatePath)) {
+      candidates.push({
+        path: candidatePath,
+        key
+      })
+    }
+  } else {
+    // No extension, no trailing slash
+    const key1 = relPath + '.html'
+    const candidatePath1 = normalize(join(config.pages, key1))
+
+    if (isPathInsideRoot(pagesRoot, candidatePath1)) {
+      candidates.push({
+        path: candidatePath1,
+        key: key1
+      })
+    }
+
+    const key2 = join(relPath, 'index.html')
+    const candidatePath2 = normalize(join(config.pages, key1))
+
+    if (isPathInsideRoot(pagesRoot, candidatePath2)) {
+      candidates.push({
+        path: candidatePath2,
+        key: key2
+      })
+    }
+  }
+
+  for (const candidate of candidates) {
+    try {
+      await access(candidate.path, constants.R_OK)
+      // Normalize key for consistency (use forward slashes)
+      const normalizedKey = candidate.key.split(sep).join('/')
+      return {
+        pathname: candidate.path,
+        key: normalizedKey
+      }
+    } catch {
+      // continue
+    }
+  }
+
+  // Fallback check coralite pages collection (supports virtual pages)
+  for (const candidate of candidates) {
+    const item = coralite.pages.getItem(candidate.path)
+
+    if (item) {
+      const normalizedKey = candidate.key.split(sep).join('/')
+      return {
+        pathname: candidate.path,
+        key: normalizedKey
+      }
+    }
+  }
+
+  // Fallback check memoryPageSource
+  for (const candidate of candidates) {
+    const normalizedKey = candidate.key.split(sep).join('/')
+    if (memoryPageSource.has(normalizedKey)) {
+      return {
+        pathname: memoryPageSource.get(normalizedKey),
+        key: normalizedKey
+      }
+    }
+  }
+
+  return null
+}
+
 /**
  * Starts a development server with hot-reloading capabilities
  * @param {CoraliteScriptConfig} config - Coralite configuration
@@ -53,7 +158,7 @@ async function server (config, options) {
 
         try {
           await access(configPath, constants.F_OK)
-        } catch (err) {
+        } catch {
           return
         }
 
@@ -73,7 +178,7 @@ async function server (config, options) {
             }
           }
         }
-      } catch (error) {
+      } catch {
         // ignore any other unexpected errors during reading/parsing
       }
     }
@@ -101,7 +206,7 @@ async function server (config, options) {
 
       pageCache.clear()
 
-      coralite = new Coralite({
+      coralite = await createCoralite({
         components: currentConfig.components,
         pages: currentConfig.pages,
         plugins: currentConfig.plugins,
@@ -126,7 +231,6 @@ async function server (config, options) {
         }
       })
 
-      await coralite.initialise()
 
       displaySuccess('Coralite initialized successfully')
 
@@ -141,6 +245,7 @@ async function server (config, options) {
 
         for (const plugin of currentConfig.plugins) {
           if (typeof plugin.server === 'function') {
+            // @ts-ignore
             await plugin.server(app, coralite)
           }
         }
@@ -171,9 +276,8 @@ async function server (config, options) {
 
     // middleware to log request information including response time and status code
     app.use(function (req, res, next) {
-      const start = process.hrtime()
-
       if (options.verbose) {
+        const start = process.hrtime()
         // when the response is finished, calculate duration and log details
         res.on('finish', function () {
           const dash = colours.gray(' ─ ')
@@ -210,14 +314,11 @@ async function server (config, options) {
         cacheControl: false
       }))
 
-      const start = process.hrtime()
-
       // rebuild CSS and send notification
       const results = await buildStyles({
         input: config.styles.input,
         output: join(config.output, 'assets', 'css'),
-        processors: config.styles.processors,
-        start
+        processors: config.styles.processors
       })
 
       const dash = colours.gray(' ─ ')
@@ -261,68 +362,7 @@ async function server (config, options) {
           return res.sendStatus(404)
         }
 
-        const resolveSource = async () => {
-          const candidates = []
-
-          // Ensure relative path doesn't start with / for joining
-          const relPath = reqPath.startsWith('/') ? reqPath.slice(1) : reqPath
-
-          if (reqPath.endsWith('/')) {
-            const key = join(relPath, 'index.html')
-            candidates.push({
-              path: join(config.pages, key),
-              key
-            })
-          } else if (extension === '.html') {
-            const key = relPath
-            candidates.push({
-              path: join(config.pages, key),
-              key
-            })
-          } else {
-            // No extension, no trailing slash
-            const key1 = relPath + '.html'
-            candidates.push({
-              path: join(config.pages, key1),
-              key: key1
-            })
-
-            const key2 = join(relPath, 'index.html')
-            candidates.push({
-              path: join(config.pages, key2),
-              key: key2
-            })
-          }
-
-          for (const candidate of candidates) {
-            try {
-              await access(candidate.path, constants.R_OK)
-              // Normalize key for consistency (use forward slashes)
-              const normalizedKey = candidate.key.split(sep).join('/')
-              return {
-                pathname: candidate.path,
-                key: normalizedKey
-              }
-            } catch {
-              // continue
-            }
-          }
-
-          // Fallback check memoryPageSource
-          for (const candidate of candidates) {
-            const normalizedKey = candidate.key.split(sep).join('/')
-            if (memoryPageSource.has(normalizedKey)) {
-              return {
-                pathname: memoryPageSource.get(normalizedKey),
-                key: normalizedKey
-              }
-            }
-          }
-
-          return null
-        }
-
-        const result = await resolveSource()
+        const result = await resolveSource(reqPath, extension, config, coralite, memoryPageSource)
 
         if (!result) {
           res.sendStatus(404)
@@ -350,7 +390,13 @@ async function server (config, options) {
           rebuildScript += '  </script>\n'
           rebuildScript += '</body>\n'
 
-          await coralite.pages.setItem(pathname)
+          // Only set item if it's not already in the collection (virtual pages are pre-registered)
+          const item = coralite.pages.getItem(pathname)
+
+          if (!item || item.virtual !== true) {
+            await coralite.pages.setItem(pathname)
+          }
+
           // build the HTML for this page using the built-in compiler.
           const documents = await coralite.build(pathname, async (result) => {
             // inject a script to enable live reload via Server-Sent Events
@@ -441,6 +487,7 @@ async function server (config, options) {
     // Helper function to debounce compilations
     const debounceCompile = () => {
       if (compileTimeout) {
+        // @ts-ignore
         clearTimeout(compileTimeout)
       }
       compileTimeout = setTimeout(async () => {
@@ -451,7 +498,6 @@ async function server (config, options) {
         pageCache.clear()
 
         isCompiling = true
-        const start = process.hrtime()
         let dash = colours.gray(' ─ ')
 
         // Process all pending changes
@@ -504,8 +550,7 @@ async function server (config, options) {
             const results = await buildStyles({
               input: currentConfig.styles.input,
               processors: currentConfig.styles.processors,
-              output: join(config.output, 'assets', 'css'),
-              start
+              output: join(config.output, 'assets', 'css')
             })
 
             for (const result of results) {

package/package.json

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

package/types/index.js

@@ -8,11 +8,11 @@
  * @property {string} public - The path to the directory containing static assets.
  * @property {Object} [server] - Server configuration options.
  * @property {number} server.port - The port number on which the development server will run.
- * @property {Object} [styles]
+ * @property {Object} [styles] - The configuration options for style processing.
  * @property {string[]} [styles.input] - Array of inputs, mixing scss and css
- * @property {Object} [styles.processors]
+ * @property {Object} [styles.processors] - The configuration for style processors like Sass or PostCSS.
  * @property {Options<'async'>} [styles.processors.scss] - Native Dart Sass options
- * @property {Object} [styles.processors.postcss]
+ * @property {Object} [styles.processors.postcss] - The configuration for PostCSS.
  * @property {import('postcss').AcceptedPlugin[]} [styles.processors.postcss.plugins] - Native PostCSS plugins
  * @property {'production' | 'development'} [mode='production'] - Set build mode for the coralite instance.
  */