create-berna-stencil 2.6.0 → 2.6.1

package/_tools/modules/updateOutputPath.js

@@ -1,113 +1,109 @@
-const fs   = require('fs');
+const fs = require('fs');
 const path = require('path');
+const { PATHS } = require('./constants');
 const { isTypeScriptProject } = require('./utils');
 
-const ELEVENTY_CONFIG = path.resolve(__dirname, '../../.eleventy.js');
-const PACKAGE_JSON    = path.resolve(__dirname, '../../package.json');
-const TSCONFIG        = path.resolve(__dirname, '../../tsconfig.json');
-
 const OUTPUT_DIR_REGEX = /const OUTPUT_DIR\s*=\s*['"`]([^'"`]*)['"`]/;
-
-// --- Helpers ---
+const TSCONFIG_OUTDIR_REGEX = /"outDir"\s*:\s*"[^"]*"/;
 
 function parseOutputDir(content) {
     const match = content.match(OUTPUT_DIR_REGEX);
     return match ? match[1] : null;
 }
 
-// --- Updaters ---
-
 function updateEleventyConfig(newPath) {
-    const content = fs.readFileSync(ELEVENTY_CONFIG, 'utf-8');
-
-    const updated = content.replace(
-        OUTPUT_DIR_REGEX,
-        `const OUTPUT_DIR = "${newPath}"`
-    );
+    const content = fs.readFileSync(PATHS.eleventyConfig, 'utf8');
+    const updated = content.replace(OUTPUT_DIR_REGEX, `const OUTPUT_DIR = "${newPath}"`);
 
     if (content === updated) {
-        console.log('(!) OUTPUT_DIR not found in .eleventy.js');
-        return false;
+        console.log('[skip] OUTPUT_DIR not found in .eleventy.js');
+        return;
     }
-
-    fs.writeFileSync(ELEVENTY_CONFIG, updated, 'utf-8');
-    console.log(`(✓) .eleventy.js updated → ${newPath}`);
-    return true;
+    fs.writeFileSync(PATHS.eleventyConfig, updated);
+    console.log(`[updated] .eleventy.js → ${newPath}`);
 }
 
 function updatePackageJson(newPath) {
-    const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, 'utf-8'));
+    const pkg = JSON.parse(fs.readFileSync(PATHS.packageJson, 'utf8'));
+    const scriptGlob = isTypeScriptProject()
+        ? 'src/frontend/ts/pages/*.ts'
+        : 'src/frontend/js/pages/*.js';
 
     pkg.outputDir = newPath;
-
-    const usesTs = isTypeScriptProject();
-
+    pkg.scripts = pkg.scripts || {};
     pkg.scripts['build:css'] = `sass src/frontend/scss:${newPath}/css --no-source-map --style=compressed --quiet`;
     pkg.scripts['serve:css'] = `sass --watch src/frontend/scss:${newPath}/css --no-source-map --quiet`;
+    pkg.scripts['build:js']  = `esbuild "${scriptGlob}" --bundle --outdir=${newPath}/js/pages --minify`;
+    pkg.scripts['serve:js']  = `esbuild "${scriptGlob}" --bundle --outdir=${newPath}/js/pages --watch`;
 
-    if (usesTs) {
-        pkg.scripts['build:js']  = `esbuild "src/frontend/ts/pages/*.ts" --bundle --outdir=${newPath}/js/pages --minify`;
-        pkg.scripts['serve:js']  = `esbuild "src/frontend/ts/pages/*.ts" --bundle --outdir=${newPath}/js/pages --watch`;
-    } else {
-        pkg.scripts['build:js']  = `esbuild "src/frontend/js/pages/*.js" --bundle --outdir=${newPath}/js/pages --minify`;
-        pkg.scripts['serve:js']  = `esbuild "src/frontend/js/pages/*.js" --bundle --outdir=${newPath}/js/pages --watch`;
-    }
-
-    fs.writeFileSync(PACKAGE_JSON, JSON.stringify(pkg, null, 2), 'utf-8');
-    console.log(`(✓) package.json updated → ${newPath}`);
-    return true;
+    fs.writeFileSync(PATHS.packageJson, `${JSON.stringify(pkg, null, 2)}\n`);
+    console.log(`[updated] package.json → ${newPath}`);
 }
 
-const TSCONFIG_OUTDIR_REGEX = /"outDir"\s*:\s*"[^"]*"/;
-
 function updateTsConfig(newPath) {
     if (!isTypeScriptProject()) return;
 
-    const content = fs.readFileSync(TSCONFIG, 'utf-8');
+    const content = fs.readFileSync(PATHS.tsconfig, 'utf8');
     const updated = content.replace(TSCONFIG_OUTDIR_REGEX, `"outDir": "./${newPath}/ts"`);
 
     if (content === updated) {
-        console.log('(!) outDir not found in tsconfig.json');
+        console.log('[skip] outDir not found in tsconfig.json');
         return;
     }
-
-    fs.writeFileSync(TSCONFIG, updated, 'utf-8');
-    console.log(`(✓) tsconfig.json updated → ${newPath}/ts`);
+    fs.writeFileSync(PATHS.tsconfig, updated);
+    console.log(`[updated] tsconfig.json → ${newPath}/ts`);
 }
 
-// --- Public API ---
+function deleteOldOutput(oldPath) {
+    if (!oldPath) return;
 
-function updateOutputPath(newPath) {
-    const trimmed = newPath.trim().replace(/\\/g, '/');
+    const oldAbsPath = path.resolve(PATHS.root, oldPath);
+    const insideProject = oldAbsPath.startsWith(PATHS.root + path.sep);
+
+    if (!insideProject || oldAbsPath === PATHS.root) {
+        console.log(`[skip] refusing to delete "${oldAbsPath}" (outside project)`);
+        return;
+    }
+    if (fs.existsSync(oldAbsPath)) {
+        fs.rmSync(oldAbsPath, { recursive: true, force: true });
+        console.log(`[deleted] ${oldAbsPath}`);
+    }
+}
+
+function updateOutputPath(rawPath) {
+    const trimmed = (rawPath ?? '').trim().replace(/\\/g, '/');
+    if (!trimmed) {
+        console.log('[skip] empty output path');
+        return;
+    }
 
     const normalizedPath = trimmed === '.'
         ? 'out'
         : `${trimmed.replace(/\/$/, '')}/${path.basename(process.cwd())}-out`;
 
-    const eleventyContent = fs.readFileSync(ELEVENTY_CONFIG, 'utf-8');
-    const oldPath = parseOutputDir(eleventyContent);
-
-    if (oldPath) {
-        const oldAbsPath = path.resolve(__dirname, '../../', oldPath);
-        if (fs.existsSync(oldAbsPath)) {
-            fs.rmSync(oldAbsPath, { recursive: true, force: true });
-            console.log(`(✓) folder deleted → ${oldAbsPath}`);
-        } else {
-            console.log(`(i) folder not found, nothing to delete → ${oldAbsPath}`);
-        }
+    let oldPath = null;
+    try {
+        oldPath = parseOutputDir(fs.readFileSync(PATHS.eleventyConfig, 'utf8'));
+    } catch (err) {
+        console.log(`[error] cannot read .eleventy.js: ${err.message}`);
+        return;
     }
 
-    console.log(`\nupdating output path → "${normalizedPath}"...`);
+    deleteOldOutput(oldPath);
 
-    updatePackageJson(normalizedPath);
-    updateEleventyConfig(normalizedPath);
-    updateTsConfig(normalizedPath);
+    console.log(`\nupdating output path → "${normalizedPath}"`);
+    try {
+        updatePackageJson(normalizedPath);
+        updateEleventyConfig(normalizedPath);
+        updateTsConfig(normalizedPath);
+    } catch (err) {
+        console.log(`[error] could not update output path: ${err.message}`);
+    }
 }
 
 function getCurrentOutputPath() {
     try {
-        const content = fs.readFileSync(ELEVENTY_CONFIG, 'utf-8');
-        return parseOutputDir(content);
+        return parseOutputDir(fs.readFileSync(PATHS.eleventyConfig, 'utf8'));
     } catch {
         return null;
     }

package/_tools/modules/updatePage.js

@@ -1,135 +1,162 @@
-const fileSystem = require('fs');
+const fs = require('fs');
 const path = require('path');
 
+const { PATHS } = require('./constants');
+const { toCamelCase, isTypeScriptProject } = require('./utils');
 const { addSiteData, removeSiteData, renameSiteData } = require('./updateData');
-const { addLayout, removeLayout, renameLayout } = require('./updateIncludes');
+const { addPageBlock, removePageBlock, renamePageBlock } = require('./pageComponents');
 const { getCurrentOutputPath } = require('./updateOutputPath');
-const { toCamelCase, isTypeScriptProject } = require('./utils');
-
-const TEMPLATES_DIR = path.join(__dirname, '..', 'res', 'templates');
-
-function getPageTargets(pageName) {
-    const camelName = toCamelCase(pageName);
-    const usesTs    = isTypeScriptProject();
 
-    return [
-        {
-            folder:       'src/frontend/scss/pages',
-            templateFile: 'template.scss',
-            fileName:     `${camelName}.scss`,
-        },
-        {
-            folder:       usesTs ? 'src/frontend/ts/pages' : 'src/frontend/js/pages',
-            templateFile: usesTs ? 'template.ts'           : 'template.js',
-            fileName:     usesTs ? `${camelName}.ts`       : `${camelName}.js`,
+function getPageArtifacts(pageName) {
+    const camelName  = toCamelCase(pageName);
+    const usesTs     = isTypeScriptProject();
+    const scriptDir  = usesTs ? PATHS.tsPages : PATHS.jsPages;
+    const scriptExt  = usesTs ? 'ts' : 'js';
+    const outputRoot = path.join(PATHS.root, getCurrentOutputPath() || 'out');
+
+    return {
+        camelName,
+        source: {
+            scss:   path.join(PATHS.scssPages, `${camelName}.scss`),
+            script: path.join(scriptDir, `${camelName}.${scriptExt}`),
+            route:  path.join(PATHS.routes, `${pageName}.njk`),
         },
-        {
-            folder:       'src/frontend/_routes',
-            templateFile: 'template.njk',
-            fileName:     `${pageName}.njk`,
+        output: {
+            files: [
+                path.join(outputRoot, 'js', 'pages',  `${camelName}.js`),
+                path.join(outputRoot, 'css', 'pages', `${camelName}.css`),
+                path.join(outputRoot, `${pageName}.html`),
+                path.join(outputRoot, 'pages', `${pageName}.html`),
+            ],
+            folders: [
+                path.join(outputRoot, pageName),
+                path.join(outputRoot, 'pages', pageName),
+            ],
         },
-    ];
+    };
 }
 
-function addPage(pageName) {
-    const camelName = toCamelCase(pageName);
-
-    getPageTargets(pageName).forEach(({ folder, templateFile, fileName }) => {
-        const destPath = path.join(folder, fileName);
-        fileSystem.mkdirSync(folder, { recursive: true });
-
-        if (fileSystem.existsSync(destPath)) return;
-
-        const srcPath = path.join(TEMPLATES_DIR, templateFile);
+function pageExists(pageName) {
+    return fs.existsSync(path.join(PATHS.routes, `${pageName}.njk`));
+}
 
-        if (templateFile === 'template.njk') {
-            const content = fileSystem.readFileSync(srcPath, 'utf8')
-                .replace(/^title:.*$/m,     `title: "${camelName}"`)
-                .replace(/^permalink:.*$/m, `permalink: "/${pageName}/"`);
-            fileSystem.writeFileSync(destPath, content);
-        } else {
-            fileSystem.copyFileSync(srcPath, destPath);
-        }
+function applyRouteFrontMatter(filePath, camelName, pageName) {
+    const content = fs.readFileSync(filePath, 'utf8')
+        .replace(/^title:.*$/m,     `title: "${camelName}"`)
+        .replace(/^permalink:.*$/m, `permalink: "/${pageName}/"`);
+    fs.writeFileSync(filePath, content);
+}
 
-        console.log(`[created file] ${destPath}`);
-    });
+function addPage(pageName) {
+    if (pageExists(pageName)) {
+        console.log(`[skip] page "${pageName}" already exists`);
+        return;
+    }
+
+    const { camelName, source } = getPageArtifacts(pageName);
+    const usesTs = isTypeScriptProject();
+
+    const creations = [
+        { dest: source.scss,   template: 'template.scss',                       isRoute: false },
+        { dest: source.script, template: usesTs ? 'template.ts' : 'template.js', isRoute: false },
+        { dest: source.route,  template: 'template.njk',                        isRoute: true  },
+    ];
 
-    addLayout(pageName);
+    try {
+        creations.forEach(({ dest, template, isRoute }) => {
+            const templatePath = path.join(PATHS.templates, template);
+            if (!fs.existsSync(templatePath)) {
+                console.log(`[skip] template not found: ${templatePath}`);
+                return;
+            }
+
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.copyFileSync(templatePath, dest);
+            if (isRoute) applyRouteFrontMatter(dest, camelName, pageName);
+
+            console.log(`[created] ${dest}`);
+        });
+    } catch (err) {
+        console.log(`[error] could not create page files: ${err.message}`);
+        return;
+    }
+
+    addPageBlock(pageName);
     addSiteData(pageName);
 }
 
 function renamePage(oldName, newName) {
-    const oldCamel = toCamelCase(oldName);
-    const newCamel = toCamelCase(newName);
-    const usesTs   = isTypeScriptProject();
-    const ext      = usesTs ? 'ts' : 'js';
-    const jsFolder = usesTs ? 'src/frontend/ts/pages' : 'src/frontend/js/pages';
-
-    const filesToRename = [
-        { src: `src/frontend/scss/pages/${oldCamel}.scss`, dest: `src/frontend/scss/pages/${newCamel}.scss` },
-        { src: `${jsFolder}/${oldCamel}.${ext}`,           dest: `${jsFolder}/${newCamel}.${ext}`           },
-        { src: `src/frontend/_routes/${oldName}.njk`,      dest: `src/frontend/_routes/${newName}.njk`      },
+    if (!pageExists(oldName)) {
+        console.log(`[skip] page "${oldName}" does not exist`);
+        return;
+    }
+    if (pageExists(newName)) {
+        console.log(`[skip] target page "${newName}" already exists`);
+        return;
+    }
+
+    const oldArtifacts = getPageArtifacts(oldName);
+    const newArtifacts = getPageArtifacts(newName);
+
+    const moves = [
+        { src: oldArtifacts.source.scss,   dest: newArtifacts.source.scss   },
+        { src: oldArtifacts.source.script, dest: newArtifacts.source.script },
+        { src: oldArtifacts.source.route,  dest: newArtifacts.source.route  },
     ];
 
-    filesToRename.forEach(({ src, dest }) => {
-        if (!fileSystem.existsSync(src)) {
-            console.log(`[skip] not found: ${src}`);
-            return;
-        }
-        
-        fileSystem.renameSync(src, dest);
-        console.log(`[renamed] ${src} → ${dest}`);
-
-        if (dest.endsWith('.njk')) {
-            const content = fileSystem.readFileSync(dest, 'utf8')
-                .replace(/^title:.*$/m,     `title: "${newCamel}"`)
-                .replace(/^permalink:.*$/m, `permalink: "/${newName}/"`);
-            fileSystem.writeFileSync(dest, content);
-        }
-    });
-
-    renameLayout(oldName, newName);
+    try {
+        moves.forEach(({ src, dest }) => {
+            if (!fs.existsSync(src)) {
+                console.log(`[skip] not found: ${src}`);
+                return;
+            }
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.renameSync(src, dest);
+            console.log(`[renamed] ${src} → ${dest}`);
+
+            if (dest.endsWith('.njk')) applyRouteFrontMatter(dest, newArtifacts.camelName, newName);
+        });
+    } catch (err) {
+        console.log(`[error] could not rename page files: ${err.message}`);
+        return;
+    }
+
+    renamePageBlock(oldName, newName);
     renameSiteData(oldName, newName);
 }
 
 function removePage(pageName) {
-    const camelName  = toCamelCase(pageName);
-    const usesTs     = isTypeScriptProject();
-    const ext        = usesTs ? 'ts' : 'js';
-    const jsFolder   = usesTs ? 'src/frontend/ts/pages' : 'src/frontend/js/pages';
-    const OUTPUT_DIR = getCurrentOutputPath() || 'out';
-
-    const filesToDelete = [
-        `src/frontend/scss/pages/${camelName}.scss`,
-        `${jsFolder}/${camelName}.${ext}`,
-        `src/frontend/_routes/${pageName}.njk`,
-        path.join(OUTPUT_DIR, 'js/pages',  `${camelName}.js`),
-        path.join(OUTPUT_DIR, 'css/pages', `${camelName}.css`),
-        path.join(OUTPUT_DIR, `${pageName}.html`),
-        path.join(OUTPUT_DIR, 'pages', `${pageName}.html`),
-    ];
-
-    const foldersToDelete = [
-        path.join(OUTPUT_DIR, pageName),
-        path.join(OUTPUT_DIR, 'pages', pageName),
-    ];
-
-    filesToDelete.forEach(f => {
-        if (fileSystem.existsSync(f)) {
-            fileSystem.unlinkSync(f);
-            console.log(`[deleted file] ${f}`);
+    if (!pageExists(pageName)) {
+        console.log(`[skip] page "${pageName}" does not exist`);
+    }
+
+    const { source, output } = getPageArtifacts(pageName);
+    const filesToDelete = [source.scss, source.script, source.route, ...output.files];
+
+    filesToDelete.forEach((file) => {
+        try {
+            if (fs.existsSync(file)) {
+                fs.unlinkSync(file);
+                console.log(`[deleted] ${file}`);
+            }
+        } catch (err) {
+            console.log(`[error] ${file}: ${err.message}`);
         }
     });
 
-    foldersToDelete.forEach(folder => {
-        if (fileSystem.existsSync(folder)) {
-            fileSystem.rmSync(folder, { recursive: true, force: true });
-            console.log(`[deleted folder] ${folder}`);
+    output.folders.forEach((folder) => {
+        try {
+            if (fs.existsSync(folder)) {
+                fs.rmSync(folder, { recursive: true, force: true });
+                console.log(`[deleted] ${folder}`);
+            }
+        } catch (err) {
+            console.log(`[error] ${folder}: ${err.message}`);
         }
     });
 
-    removeLayout(pageName);
+    removePageBlock(pageName);
     removeSiteData(pageName);
 }
 
-module.exports = { addPage, removePage, renamePage };
+module.exports = { addPage, removePage, renamePage, pageExists };

package/_tools/modules/utils.js

@@ -1,30 +1,27 @@
-const fs   = require('fs');
-const path = require('path');
+const fs = require('fs');
+const { PATHS } = require('./constants');
 
-const TSCONFIG = path.resolve(__dirname, '../../tsconfig.json');
-
-// Shared utility functions used across modules
+function toCamelCase(value) {
+    return value.toLowerCase().replace(/[-_][a-z0-9]/g, (group) => group.slice(1).toUpperCase());
+}
 
-// Converts a kebab-case or snake_case string to camelCase.
-// Uses slice(1) to remove the delimiter, avoiding the double-replace bug
-// that occurs when using .replace('-', '') without the /g flag.
-function toCamelCase(str) {
-    return str.toLowerCase().replace(/[-_][a-z0-9]/g, (group) =>
-        group.slice(1).toUpperCase()
-    );
+function toKebabCase(value) {
+    return value.trim().toLowerCase()
+        .replace(/[^a-z0-9\s_-]/g, '')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
 }
 
-// Converts a kebab-case page name to a human-readable title
-// e.g. "about-us" → "About Us"
 function toNiceTitle(pageName) {
-    return pageName
-        .split('-')
-        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+    return pageName.split('-')
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join(' ');
 }
 
 function isTypeScriptProject() {
-    return fs.existsSync(TSCONFIG);
+    return fs.existsSync(PATHS.tsconfig);
 }
 
-module.exports = { toCamelCase, toNiceTitle, isTypeScriptProject };
+module.exports = { toCamelCase, toKebabCase, toNiceTitle, isTypeScriptProject };

package/_tools/modules/validation.js

@@ -0,0 +1,20 @@
+const { MAX_PAGE_NAME_LENGTH, PROTECTED_PAGES } = require('./constants');
+
+function validatePageName(name) {
+    if (!name)                              return 'Invalid name.';
+    if (name.length > MAX_PAGE_NAME_LENGTH) return `Name must be ${MAX_PAGE_NAME_LENGTH} characters or fewer.`;
+    if (!/^[a-z0-9-]+$/.test(name))         return 'Page name can only contain lowercase letters, numbers, and hyphens.';
+    if (/^\d/.test(name))                   return 'Page name cannot start with a number.';
+    if (PROTECTED_PAGES.includes(name))     return `"${name}" is a protected page name.`;
+    return null;
+}
+
+function validateOutputPath(input) {
+    const value = (input ?? '').trim();
+    if (!value)                    return 'Invalid path.';
+    if (value.includes('..'))      return 'Path cannot contain "..".';
+    if (/[<>|?*"']/.test(value))   return 'Path contains invalid characters.';
+    return null;
+}
+
+module.exports = { validatePageName, validateOutputPath };