nibula 1.2.2 → 1.2.4

package/tools/lib/paths.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+const settings = require('../config/settings.json');
+const { paint } = require('./colors');
+const { message } = require('./logger');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const PATH_SEPARATOR = '/';
+const NOT_INSIDE_PROJECT_MESSAGE = paint('red', message('project.notInside'));
+
+let cachedProjectRoot = null;
+
+function findProjectRoot(start) {
+    let directory = path.resolve(start ?? process.cwd());
+    while (true) {
+        if (fs.existsSync(path.join(directory, settings.project.marker))) return directory;
+        const parent = path.dirname(directory);
+        if (parent === directory) return null;
+        directory = parent;
+    }
+}
+
+function projectRoot() {
+    if (cachedProjectRoot) return cachedProjectRoot;
+    const root = findProjectRoot();
+    if (!root) {
+        console.error(NOT_INSIDE_PROJECT_MESSAGE);
+        process.exit(1);
+    }
+    cachedProjectRoot = root;
+    return root;
+}
+
+function resolveFromProject(relativePath) {
+    return path.join(projectRoot(), ...relativePath.split(PATH_SEPARATOR));
+}
+
+function resolveFromPackage(relativePath) {
+    return path.join(PACKAGE_ROOT, ...relativePath.split(PATH_SEPARATOR));
+}
+
+const PATHS = Object.freeze({
+    get root()             { return projectRoot(); },
+    get eleventyConfig()   { return resolveFromProject(settings.paths.eleventyConfig); },
+    get packageJson()      { return resolveFromProject(settings.paths.packageJson); },
+    get typescriptConfig() { return resolveFromProject(settings.paths.typescriptConfig); },
+    get routes()           { return resolveFromProject(settings.paths.routes); },
+    get stylePages()       { return resolveFromProject(settings.paths.stylePages); },
+    get siteData()         { return resolveFromProject(settings.paths.siteData); },
+    get pageComponents()   { return resolveFromProject(settings.paths.pageComponents); },
+    get templates()        { return resolveFromPackage(settings.paths.templates); },
+});
+
+module.exports = {
+    PATHS,
+    PACKAGE_ROOT,
+    NOT_INSIDE_PROJECT_MESSAGE,
+    findProjectRoot,
+    resolveFromProject,
+    resolveFromPackage,
+};

package/tools/lib/project.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const settings = require('../config/settings.json');
+const { PATHS, resolveFromProject } = require('./paths');
+const { readJson, writeJson } = require('./files');
+
+const JAVASCRIPT = 'javascript';
+const TYPESCRIPT = 'typescript';
+const ENTRY_WILDCARD = '*';
+
+function isTypeScriptProject() {
+    return fs.existsSync(PATHS.typescriptConfig);
+}
+
+function currentLanguage() {
+    return isTypeScriptProject() ? TYPESCRIPT : JAVASCRIPT;
+}
+
+function languageSettings(language) {
+    return settings.languages[language ?? currentLanguage()];
+}
+
+function scriptPagesDirectory(language) {
+    return resolveFromProject(languageSettings(language).pages);
+}
+
+function scriptEntries(language) {
+    const { pages, extension } = languageSettings(language);
+    return `${pages}/${ENTRY_WILDCARD}.${extension}`;
+}
+
+function allScriptEntries() {
+    return Object.keys(settings.languages).map((language) => scriptEntries(language));
+}
+
+function readPackageJson() {
+    return readJson(PATHS.packageJson);
+}
+
+function writePackageJson(content) {
+    writeJson(PATHS.packageJson, content);
+}
+
+module.exports = {
+    JAVASCRIPT,
+    TYPESCRIPT,
+    isTypeScriptProject,
+    currentLanguage,
+    languageSettings,
+    scriptPagesDirectory,
+    scriptEntries,
+    allScriptEntries,
+    readPackageJson,
+    writePackageJson,
+};

package/tools/lib/siteData.js

@@ -0,0 +1,93 @@
+const path = require('path');
+const settings = require('../config/settings.json');
+const { PATHS } = require('./paths');
+const { exists, readText, writeJson } = require('./files');
+const { log } = require('./logger');
+const { toCamelCase, toTitleCase, formatValue } = require('./text');
+
+const PAGES_KEY = settings.page.dataKeys.pages;
+const SEO_KEY = settings.page.dataKeys.seo;
+const TITLE_KEY = settings.page.dataKeys.title;
+
+function readSiteData() {
+    if (!exists(PATHS.siteData)) {
+        log('siteData.fileMissing', { path: PATHS.siteData });
+        return null;
+    }
+    try {
+        const data = JSON.parse(readText(PATHS.siteData));
+        if (!data[PAGES_KEY] || typeof data[PAGES_KEY] !== 'object') data[PAGES_KEY] = {};
+        return data;
+    } catch (error) {
+        log('siteData.parseFailed', { file: path.basename(PATHS.siteData), error: error.message });
+        return null;
+    }
+}
+
+function writeSiteData(data) {
+    writeJson(PATHS.siteData, data);
+}
+
+function createRecord(pageName) {
+    return formatValue(settings.page.defaultData, { title: toTitleCase(pageName) });
+}
+
+function addSiteData(pageName) {
+    const data = readSiteData();
+    if (!data) return;
+
+    const camelName = toCamelCase(pageName);
+    if (data[PAGES_KEY][camelName]) {
+        log('siteData.recordExists', { name: camelName });
+        return;
+    }
+
+    data[PAGES_KEY][camelName] = createRecord(pageName);
+
+    writeSiteData(data);
+    log('siteData.recordAdded', { name: camelName });
+}
+
+function removeSiteData(pageName) {
+    const data = readSiteData();
+    if (!data) return;
+
+    const camelName = toCamelCase(pageName);
+    if (!data[PAGES_KEY][camelName]) {
+        log('siteData.recordMissing', { name: camelName });
+        return;
+    }
+
+    delete data[PAGES_KEY][camelName];
+    writeSiteData(data);
+    log('siteData.recordRemoved', { name: camelName });
+}
+
+function renameSiteData(oldName, newName) {
+    const data = readSiteData();
+    if (!data) return;
+
+    const oldCamelName = toCamelCase(oldName);
+    const newCamelName = toCamelCase(newName);
+
+    if (!data[PAGES_KEY][oldCamelName]) {
+        log('siteData.recordMissing', { name: oldCamelName });
+        return;
+    }
+    if (data[PAGES_KEY][newCamelName]) {
+        log('siteData.recordExists', { name: newCamelName });
+        return;
+    }
+
+    const record = data[PAGES_KEY][oldCamelName];
+    data[PAGES_KEY][newCamelName] = {
+        ...record,
+        [SEO_KEY]: { ...record[SEO_KEY], [TITLE_KEY]: toTitleCase(newName) },
+    };
+    delete data[PAGES_KEY][oldCamelName];
+
+    writeSiteData(data);
+    log('siteData.recordRenamed', { source: oldCamelName, destination: newCamelName });
+}
+
+module.exports = { addSiteData, removeSiteData, renameSiteData };

package/tools/lib/text.js

@@ -0,0 +1,47 @@
+const PLACEHOLDER_PATTERN = /\{(\w+)\}/g;
+const CAMEL_SEPARATOR_PATTERN = /[-_][a-z0-9]/g;
+const INVALID_KEBAB_PATTERN = /[^a-z0-9\s_-]/g;
+const KEBAB_SEPARATOR_PATTERN = /[\s_]+/g;
+const REPEATED_HYPHEN_PATTERN = /-+/g;
+const EDGE_HYPHEN_PATTERN = /^-+|-+$/g;
+const WORD_SEPARATOR = '-';
+const SPACE = ' ';
+const EMPTY = '';
+
+function formatText(template, values = {}) {
+    return String(template).replace(PLACEHOLDER_PATTERN, (match, key) =>
+        Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : match
+    );
+}
+
+function formatValue(value, values = {}) {
+    if (typeof value === 'string') return formatText(value, values);
+    if (Array.isArray(value)) return value.map((item) => formatValue(item, values));
+    if (value !== null && typeof value === 'object') {
+        return Object.fromEntries(
+            Object.entries(value).map(([key, item]) => [key, formatValue(item, values)])
+        );
+    }
+    return value;
+}
+
+function toCamelCase(value) {
+    return value.toLowerCase().replace(CAMEL_SEPARATOR_PATTERN, (group) => group.slice(1).toUpperCase());
+}
+
+function toKebabCase(value) {
+    return value.trim().toLowerCase()
+        .replace(INVALID_KEBAB_PATTERN, EMPTY)
+        .replace(KEBAB_SEPARATOR_PATTERN, WORD_SEPARATOR)
+        .replace(REPEATED_HYPHEN_PATTERN, WORD_SEPARATOR)
+        .replace(EDGE_HYPHEN_PATTERN, EMPTY);
+}
+
+function toTitleCase(value) {
+    return value.split(WORD_SEPARATOR)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(SPACE);
+}
+
+module.exports = { formatText, formatValue, toCamelCase, toKebabCase, toTitleCase };

package/tools/lib/validation.js

@@ -0,0 +1,39 @@
+const settings = require('../config/settings.json');
+const { PATHS } = require('./paths');
+const { exists } = require('./files');
+const { message } = require('./logger');
+
+const NAME_PATTERN = /^[a-z0-9-]+$/;
+const LEADING_DIGIT_PATTERN = /^\d/;
+const INVALID_PATH_PATTERN = /[<>|?*"']/;
+
+function requiredFiles() {
+    return [
+        { label: settings.paths.eleventyConfig,  path: PATHS.eleventyConfig },
+        { label: settings.paths.packageJson,     path: PATHS.packageJson },
+        { label: settings.paths.siteData,        path: PATHS.siteData },
+        { label: settings.paths.pageComponents,  path: PATHS.pageComponents },
+        { label: message('validation.templatesLabel'), path: PATHS.templates },
+    ];
+}
+
+function validatePageName(name) {
+    if (!name) return message('validation.invalidName');
+    if (!NAME_PATTERN.test(name)) return message('validation.invalidNameCharacters');
+    if (LEADING_DIGIT_PATTERN.test(name)) return message('validation.nameStartsWithNumber');
+    if (settings.page.protected.includes(name)) return message('validation.protectedName', { name });
+    return null;
+}
+
+function validateOutputPath(input) {
+    const value = (input ?? '').trim();
+    if (!value) return message('validation.invalidPath');
+    if (INVALID_PATH_PATTERN.test(value)) return message('validation.invalidPathCharacters');
+    return null;
+}
+
+function checkRequiredFiles() {
+    return requiredFiles().filter((item) => !exists(item.path));
+}
+
+module.exports = { validatePageName, validateOutputPath, checkRequiredFiles };

package/tools/res/templates/template.js

@@ -2,4 +2,6 @@
 
 document.addEventListener("DOMContentLoaded", () => {
     // initExampleModule();
-});
+});
+
+// Page logic here

package/tools/res/templates/template.ts

@@ -2,4 +2,6 @@
 
 document.addEventListener("DOMContentLoaded", (): void => {
     // initExampleModule();
-});
+});
+
+// Page logic here

package/tools/modules/constants.js

@@ -1,66 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
-const TEMPLATES_DIR = path.join(PACKAGE_ROOT, 'tools', 'res', 'templates');
-
-const PROJECT_MARKER = '.eleventy.js';
-
-const PROTECTED_PAGES = Object.freeze(['homepage', '404']);
-
-const color = Object.freeze({
-    reset:   '\x1b[0m',
-    bold:    '\x1b[1m',
-    dim:     '\x1b[2m',
-    red:     '\x1b[31m',
-    green:   '\x1b[32m',
-    yellow:  '\x1b[33m',
-    blue:    '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan:    '\x1b[36m',
-});
-
-const NOT_INSIDE_PROJECT_MESSAGE = `${color.red}Not inside a Nibula project.${color.reset}`;
-
-function findProjectRoot(start) {
-    let dir = path.resolve(start ?? process.cwd());
-    while (true) {
-        if (fs.existsSync(path.join(dir, PROJECT_MARKER))) return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir) return null;
-        dir = parent;
-    }
-}
-
-let cachedRoot = null;
-
-function projectRoot() {
-    if (cachedRoot) return cachedRoot;
-    const root = findProjectRoot();
-    if (!root) {
-        console.error(NOT_INSIDE_PROJECT_MESSAGE);
-        process.exit(1);
-    }
-    cachedRoot = root;
-    return root;
-}
-
-function frontendDir() {
-    return path.join(projectRoot(), 'src', 'frontend');
-}
-
-const PATHS = Object.freeze({
-    get root()           { return projectRoot(); },
-    get routes()         { return path.join(frontendDir(), 'routes'); },
-    get scssPages()      { return path.join(frontendDir(), 'scss', 'pages'); },
-    get jsPages()        { return path.join(frontendDir(), 'js', 'pages'); },
-    get tsPages()        { return path.join(frontendDir(), 'ts', 'pages'); },
-    get siteData()       { return path.join(frontendDir(), 'data', 'site.json'); },
-    get pageComponents() { return path.join(frontendDir(), 'layouts', 'page-components.njk'); },
-    get eleventyConfig() { return path.join(projectRoot(), '.eleventy.js'); },
-    get packageJson()    { return path.join(projectRoot(), 'package.json'); },
-    get tsconfig()       { return path.join(projectRoot(), 'tsconfig.json'); },
-    templates:           TEMPLATES_DIR,
-});
-
-module.exports = { PATHS, PROJECT_MARKER, PROTECTED_PAGES, color, NOT_INSIDE_PROJECT_MESSAGE, findProjectRoot };

package/tools/modules/pageComponents.js

@@ -1,77 +0,0 @@
-const fs = require('fs');
-const { PATHS } = require('./constants');
-const { toCamelCase } = require('./utils');
-
-function readPageComponents() {
-    if (!fs.existsSync(PATHS.pageComponents)) {
-        console.log(`[skip] not found: ${PATHS.pageComponents}`);
-        return null;
-    }
-    return fs.readFileSync(PATHS.pageComponents, 'utf8');
-}
-
-function writePageComponents(content) {
-    fs.writeFileSync(PATHS.pageComponents, content);
-}
-
-function elifBlockRegex(camelName) {
-    return new RegExp(
-        `[ \\t]*\\{%\\s*elif\\s+title\\s*==\\s*"${camelName}"\\s*%\\}[\\s\\S]*?(?=[ \\t]*\\{%\\s*(?:elif|else|endif))`,
-    );
-}
-
-function addPageBlock(pageName) {
-    const content = readPageComponents();
-    if (!content) return;
-
-    const camelName = toCamelCase(pageName);
-    if (content.includes(`{% elif title == "${camelName}" %}`)) return;
-
-    if (!content.includes('{% else %}')) {
-        console.log('[skip] no {% else %} anchor in page-components.njk');
-        return;
-    }
-
-    const block =
-        `{% elif title == "${camelName}" %}\n` +
-        `{% include "component.njk" ignore missing %}\n\n`;
-
-    writePageComponents(content.replace('{% else %}', `${block}{% else %}`));
-    console.log(`[updated] page block added for "${camelName}"`);
-}
-
-function removePageBlock(pageName) {
-    const content = readPageComponents();
-    if (!content) return;
-
-    const camelName = toCamelCase(pageName);
-    if (!elifBlockRegex(camelName).test(content)) {
-        console.log(`[skip] page block for "${camelName}" not found`);
-        return;
-    }
-
-    const updated = content
-        .replace(elifBlockRegex(camelName), '')
-        .replace(/\n\s*\n\s*\n/g, '\n\n');
-
-    writePageComponents(updated);
-    console.log(`[cleaned] page block removed for "${camelName}"`);
-}
-
-function renamePageBlock(oldName, newName) {
-    const content = readPageComponents();
-    if (!content) return;
-
-    const oldLine = `{% elif title == "${toCamelCase(oldName)}" %}`;
-    const newLine = `{% elif title == "${toCamelCase(newName)}" %}`;
-
-    if (!content.includes(oldLine)) {
-        console.log(`[skip] page block for "${toCamelCase(oldName)}" not found`);
-        return;
-    }
-
-    writePageComponents(content.replace(oldLine, newLine));
-    console.log(`[renamed] page block "${toCamelCase(oldName)}" → "${toCamelCase(newName)}"`);
-}
-
-module.exports = { addPageBlock, removePageBlock, renamePageBlock };

package/tools/modules/updateData.js

@@ -1,90 +0,0 @@
-const fs = require('fs');
-const { PATHS } = require('./constants');
-const { toCamelCase, toNiceTitle } = require('./utils');
-
-function readSiteData() {
-    if (!fs.existsSync(PATHS.siteData)) {
-        console.log(`[skip] not found: ${PATHS.siteData}`);
-        return null;
-    }
-    try {
-        const data = JSON.parse(fs.readFileSync(PATHS.siteData, 'utf8'));
-        if (!data.pages || typeof data.pages !== 'object') data.pages = {};
-        return data;
-    } catch (err) {
-        console.log(`[error] cannot parse site.json: ${err.message}`);
-        return null;
-    }
-}
-
-function writeSiteData(data) {
-    fs.writeFileSync(PATHS.siteData, `${JSON.stringify(data, null, 2)}\n`);
-}
-
-function addSiteData(pageName) {
-    const data = readSiteData();
-    if (!data) return;
-
-    const camelName = toCamelCase(pageName);
-    if (data.pages[camelName]) {
-        console.log(`[skip] record "${camelName}" already exists`);
-        return;
-    }
-
-    data.pages[camelName] = {
-        seo: {
-            title: toNiceTitle(pageName),
-            description: 'description',
-            keywords: '',
-            noindex: false,
-            canonical: '',
-        },
-        cdn: { css: [], js: [] },
-    };
-
-    writeSiteData(data);
-    console.log(`[updated] record "${camelName}" added`);
-}
-
-function removeSiteData(pageName) {
-    const data = readSiteData();
-    if (!data) return;
-
-    const camelName = toCamelCase(pageName);
-    if (!data.pages[camelName]) {
-        console.log(`[skip] record "${camelName}" not found`);
-        return;
-    }
-
-    delete data.pages[camelName];
-    writeSiteData(data);
-    console.log(`[cleaned] record "${camelName}" removed`);
-}
-
-function renameSiteData(oldName, newName) {
-    const data = readSiteData();
-    if (!data) return;
-
-    const oldCamel = toCamelCase(oldName);
-    const newCamel = toCamelCase(newName);
-
-    if (!data.pages[oldCamel]) {
-        console.log(`[skip] record "${oldCamel}" not found`);
-        return;
-    }
-    if (data.pages[newCamel]) {
-        console.log(`[skip] record "${newCamel}" already exists`);
-        return;
-    }
-
-    data.pages[newCamel] = {
-        ...data.pages[oldCamel],
-        seo: { ...data.pages[oldCamel].seo, title: toNiceTitle(newName) },
-    };
-    delete data.pages[oldCamel];
-
-    writeSiteData(data);
-    console.log(`[updated] record "${oldCamel}" renamed to "${newCamel}"`);
-}
-
-module.exports = { addSiteData, removeSiteData, renameSiteData };

package/tools/modules/updateOutputPath.js

@@ -1,112 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { PATHS } = require('./constants');
-const { isTypeScriptProject } = require('./utils');
-
-const OUTPUT_DIR_REGEX = /const OUTPUT_DIR\s*=\s*['"`]([^'"`]*)['"`]/;
-const TSCONFIG_OUTDIR_REGEX = /"outDir"\s*:\s*"[^"]*"/;
-
-function parseOutputDir(content) {
-    const match = content.match(OUTPUT_DIR_REGEX);
-    return match ? match[1] : null;
-}
-
-function updateEleventyConfig(newPath) {
-    const content = fs.readFileSync(PATHS.eleventyConfig, 'utf8');
-    const updated = content.replace(OUTPUT_DIR_REGEX, `const OUTPUT_DIR = "${newPath}"`);
-
-    if (content === updated) {
-        console.log('[skip] OUTPUT_DIR not found in .eleventy.js');
-        return;
-    }
-    fs.writeFileSync(PATHS.eleventyConfig, updated);
-    console.log(`[updated] .eleventy.js → ${newPath}`);
-}
-
-function updatePackageJson(newPath) {
-    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;
-    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`;
-
-    fs.writeFileSync(PATHS.packageJson, `${JSON.stringify(pkg, null, 2)}\n`);
-    console.log(`[updated] package.json → ${newPath}`);
-}
-
-function updateTsConfig(newPath) {
-    if (!isTypeScriptProject()) return;
-
-    const content = fs.readFileSync(PATHS.tsconfig, 'utf8');
-    const updated = content.replace(TSCONFIG_OUTDIR_REGEX, `"outDir": "./${newPath}/ts"`);
-
-    if (content === updated) {
-        console.log('[skip] outDir not found in tsconfig.json');
-        return;
-    }
-    fs.writeFileSync(PATHS.tsconfig, updated);
-    console.log(`[updated] tsconfig.json → ${newPath}/ts`);
-}
-
-function deleteOldOutput(oldPath) {
-    if (!oldPath) return;
-
-    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(PATHS.root)}-out`;
-
-    let oldPath = null;
-    try {
-        oldPath = parseOutputDir(fs.readFileSync(PATHS.eleventyConfig, 'utf8'));
-    } catch (err) {
-        console.log(`[error] cannot read .eleventy.js: ${err.message}`);
-        return;
-    }
-
-    deleteOldOutput(oldPath);
-
-    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 {
-        return parseOutputDir(fs.readFileSync(PATHS.eleventyConfig, 'utf8'));
-    } catch {
-        return null;
-    }
-}
-
-module.exports = { updateOutputPath, getCurrentOutputPath };