nibula 1.2.2 → 1.2.4

package/tools/config/settings.json

@@ -0,0 +1,135 @@
+{
+  "project": {
+    "marker": ".eleventy.js",
+    "defaultOutputDirectory": "out",
+    "currentDirectory": ".",
+    "outputSuffix": "-out"
+  },
+  "paths": {
+    "eleventyConfig": ".eleventy.js",
+    "packageJson": "package.json",
+    "typescriptConfig": "tsconfig.json",
+    "routes": "src/frontend/routes",
+    "stylePages": "src/frontend/scss/pages",
+    "siteData": "src/frontend/data/site.json",
+    "pageComponents": "src/frontend/layouts/page-components.njk",
+    "templates": "tools/res/templates"
+  },
+  "languages": {
+    "javascript": {
+      "pages": "src/frontend/js/pages",
+      "extension": "js",
+      "template": "template.js"
+    },
+    "typescript": {
+      "pages": "src/frontend/ts/pages",
+      "extension": "ts",
+      "template": "template.ts"
+    }
+  },
+  "packageJson": {
+    "outputKey": "outputDir",
+    "scriptsKey": "scripts"
+  },
+  "eleventy": {
+    "outputVariable": "OUTPUT_DIR"
+  },
+  "typescript": {
+    "outputKey": "outDir",
+    "outputSubdirectory": "ts"
+  },
+  "build": {
+    "scriptOutput": "js/pages"
+  },
+  "outputScripts": [
+    {
+      "name": "build:css",
+      "marker": "/css",
+      "template": "sass src/frontend/scss:{output}/css --no-source-map --style=compressed --quiet --load-path=node_modules"
+    },
+    {
+      "name": "serve:css",
+      "marker": "/css",
+      "template": "sass --watch src/frontend/scss:{output}/css --no-source-map --quiet --load-path=node_modules"
+    },
+    {
+      "name": "build:js",
+      "marker": "/js/pages",
+      "template": "esbuild \"{entries}\" --bundle --outdir={output}/js/pages --minify"
+    },
+    {
+      "name": "serve:js",
+      "marker": "/js/pages",
+      "template": "esbuild \"{entries}\" --bundle --outdir={output}/js/pages --watch"
+    }
+  ],
+  "page": {
+    "protected": ["homepage", "404"],
+    "styleExtension": "scss",
+    "routeExtension": "njk",
+    "styleTemplate": "template.scss",
+    "routeTemplate": "template.njk",
+    "outputFiles": [
+      "js/pages/{camelName}.js",
+      "css/pages/{camelName}.css",
+      "{pageName}.html",
+      "pages/{pageName}.html"
+    ],
+    "outputDirectories": [
+      "{pageName}",
+      "pages/{pageName}"
+    ],
+    "dataKeys": {
+      "pages": "pages",
+      "seo": "seo",
+      "title": "title"
+    },
+    "defaultData": {
+      "seo": {
+        "title": "{title}",
+        "description": "description",
+        "keywords": "",
+        "noindex": false,
+        "canonical": ""
+      },
+      "cdn": {
+        "css": [],
+        "js": []
+      }
+    }
+  },
+  "pageComponents": {
+    "anchor": "{% else %}",
+    "condition": "{% elif title == \"{camelName}\" %}",
+    "include": "{% include \"component.njk\" ignore missing %}"
+  },
+  "frontMatter": {
+    "title": "title: \"{camelName}\"",
+    "permalink": "permalink: \"/{pageName}/\""
+  },
+  "cli": {
+    "title": "Nibula CLI",
+    "boxWidth": 17,
+    "confirmHint": "[y/N]",
+    "symbols": {
+      "prompt": "\u276f",
+      "error": "\u2716",
+      "warning": "\u26a0",
+      "bullet": "-"
+    },
+    "colors": {
+      "box": "cyan",
+      "menuKey": "dim",
+      "prompt": "cyan",
+      "error": "red",
+      "warning": "yellow",
+      "notice": "dim"
+    },
+    "menu": [
+      { "key": "1", "action": "createPage", "label": "Create page" },
+      { "key": "2", "action": "removePage", "label": "Remove page" },
+      { "key": "3", "action": "renamePage", "label": "Rename page" },
+      { "key": "4", "action": "outputPath", "label": "Configure output path" }
+    ]
+  }
+} 

package/tools/lib/colors.js

@@ -0,0 +1,17 @@
+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',
+});
+
+function paint(name, text) {
+    return `${color[name] ?? ''}${text}${color.reset}`;
+}
+
+module.exports = { color, paint };

package/tools/lib/files.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const path = require('path');
+
+const ENCODING = 'utf8';
+const INDENTATION = 2;
+const NEW_LINE = '\n';
+
+function exists(target) {
+    return fs.existsSync(target);
+}
+
+function ensureDirectory(target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+}
+
+function readText(target) {
+    return fs.readFileSync(target, ENCODING);
+}
+
+function writeText(target, content) {
+    ensureDirectory(target);
+    fs.writeFileSync(target, content);
+}
+
+function readJson(target) {
+    return JSON.parse(readText(target));
+}
+
+function writeJson(target, data) {
+    writeText(target, `${JSON.stringify(data, null, INDENTATION)}${NEW_LINE}`);
+}
+
+function copyFile(source, destination) {
+    ensureDirectory(destination);
+    fs.copyFileSync(source, destination);
+}
+
+function moveFile(source, destination) {
+    ensureDirectory(destination);
+    fs.renameSync(source, destination);
+}
+
+function removeFile(target) {
+    if (!exists(target)) return false;
+    fs.unlinkSync(target);
+    return true;
+}
+
+function removeDirectory(target) {
+    if (!exists(target)) return false;
+    fs.rmSync(target, { recursive: true, force: true });
+    return true;
+}
+
+module.exports = {
+    exists,
+    readText,
+    writeText,
+    readJson,
+    writeJson,
+    copyFile,
+    moveFile,
+    removeFile,
+    removeDirectory,
+};

package/tools/lib/logger.js

@@ -0,0 +1,22 @@
+const messages = require('../config/messages.json');
+const { formatText } = require('./text');
+
+const KEY_SEPARATOR = '.';
+
+function resolveTemplate(key) {
+    return key.split(KEY_SEPARATOR).reduce(
+        (current, part) => (current !== null && typeof current === 'object' ? current[part] : undefined),
+        messages
+    );
+}
+
+function message(key, values) {
+    const template = resolveTemplate(key);
+    return typeof template === 'string' ? formatText(template, values) : key;
+}
+
+function log(key, values) {
+    console.log(message(key, values));
+}
+
+module.exports = { message, log };

package/tools/lib/outputPath.js

@@ -0,0 +1,141 @@
+const path = require('path');
+const settings = require('../config/settings.json');
+const { PATHS } = require('./paths');
+const { readText, writeText, readJson, writeJson, removeDirectory } = require('./files');
+const { log } = require('./logger');
+const { formatText } = require('./text');
+const { isTypeScriptProject, scriptEntries } = require('./project');
+
+const OUTPUT_VARIABLE = settings.eleventy.outputVariable;
+const TYPESCRIPT_OUTPUT_KEY = settings.typescript.outputKey;
+const OUTPUT_VARIABLE_PATTERN = new RegExp(`const ${OUTPUT_VARIABLE}\\s*=\\s*['"\`]([^'"\`]*)['"\`]`);
+const TYPESCRIPT_OUTPUT_PATTERN = new RegExp(`"${TYPESCRIPT_OUTPUT_KEY}"\\s*:\\s*"[^"]*"`);
+const WINDOWS_DRIVE_PATTERN = /^[a-zA-Z]:/;
+const BACKSLASH_PATTERN = /\\/g;
+const TRAILING_SLASH_PATTERN = /\/$/;
+const FORWARD_SLASH = '/';
+const RELATIVE_PREFIX = './';
+const EMPTY = '';
+
+function parseOutputDirectory(content) {
+    const match = content.match(OUTPUT_VARIABLE_PATTERN);
+    return match ? match[1] : null;
+}
+
+function isAbsolutePath(target) {
+    return path.isAbsolute(target) || WINDOWS_DRIVE_PATTERN.test(target);
+}
+
+function updateEleventyConfig(newPath) {
+    const content = readText(PATHS.eleventyConfig);
+    const updated = content.replace(OUTPUT_VARIABLE_PATTERN, `const ${OUTPUT_VARIABLE} = "${newPath}"`);
+
+    if (content === updated) {
+        log('output.variableMissing', { variable: OUTPUT_VARIABLE, file: settings.paths.eleventyConfig });
+        return;
+    }
+    writeText(PATHS.eleventyConfig, updated);
+    log('output.fileUpdated', { file: settings.paths.eleventyConfig, path: newPath });
+}
+
+function updatePackageJson(newPath, oldPath) {
+    const packageJson = readJson(PATHS.packageJson);
+    const entries = scriptEntries();
+
+    packageJson[settings.packageJson.outputKey] = newPath;
+    packageJson[settings.packageJson.scriptsKey] = packageJson[settings.packageJson.scriptsKey] || {};
+
+    const scripts = packageJson[settings.packageJson.scriptsKey];
+
+    for (const { name, marker, template } of settings.outputScripts) {
+        const current = scripts[name];
+        const token = oldPath ? `${oldPath}${marker}` : null;
+
+        if (current && token && current.includes(token)) {
+            scripts[name] = current.split(token).join(`${newPath}${marker}`);
+        } else {
+            scripts[name] = formatText(template, { output: newPath, entries });
+        }
+    }
+
+    writeJson(PATHS.packageJson, packageJson);
+    log('output.fileUpdated', { file: settings.paths.packageJson, path: newPath });
+}
+
+function updateTypeScriptConfig(newPath) {
+    if (!isTypeScriptProject()) return;
+
+    const prefix = isAbsolutePath(newPath) ? EMPTY : RELATIVE_PREFIX;
+    const outputDirectory = `${prefix}${newPath}${FORWARD_SLASH}${settings.typescript.outputSubdirectory}`;
+    const content = readText(PATHS.typescriptConfig);
+    const updated = content.replace(TYPESCRIPT_OUTPUT_PATTERN, `"${TYPESCRIPT_OUTPUT_KEY}": "${outputDirectory}"`);
+
+    if (content === updated) {
+        log('output.keyMissing', { key: TYPESCRIPT_OUTPUT_KEY, file: settings.paths.typescriptConfig });
+        return;
+    }
+    writeText(PATHS.typescriptConfig, updated);
+    log('output.fileUpdated', { file: settings.paths.typescriptConfig, path: outputDirectory });
+}
+
+function deleteOldOutput(oldPath) {
+    if (!oldPath) return;
+
+    const target = path.resolve(PATHS.root, oldPath);
+    const insideProject = target.startsWith(PATHS.root + path.sep);
+
+    if (!insideProject || target === PATHS.root) {
+        log('output.refuseDelete', { path: target });
+        return;
+    }
+    if (removeDirectory(target)) {
+        log('output.directoryDeleted', { path: target });
+    }
+}
+
+function normalizeOutputPath(rawPath) {
+    const trimmed = (rawPath ?? '').trim().replace(BACKSLASH_PATTERN, FORWARD_SLASH);
+    if (!trimmed) return null;
+
+    if (trimmed === settings.project.currentDirectory) return settings.project.defaultOutputDirectory;
+
+    const parent = trimmed.replace(TRAILING_SLASH_PATTERN, EMPTY);
+    return `${parent}${FORWARD_SLASH}${path.basename(PATHS.root)}${settings.project.outputSuffix}`;
+}
+
+function updateOutputPath(rawPath) {
+    const normalizedPath = normalizeOutputPath(rawPath);
+    if (!normalizedPath) {
+        log('output.emptyPath');
+        return;
+    }
+
+    let oldPath = null;
+    try {
+        oldPath = parseOutputDirectory(readText(PATHS.eleventyConfig));
+    } catch (error) {
+        log('output.readFailed', { file: settings.paths.eleventyConfig, error: error.message });
+        return;
+    }
+
+    deleteOldOutput(oldPath);
+    log('output.updating', { path: normalizedPath });
+
+    try {
+        updatePackageJson(normalizedPath, oldPath);
+        updateEleventyConfig(normalizedPath);
+        updateTypeScriptConfig(normalizedPath);
+    } catch (error) {
+        log('output.updateFailed', { error: error.message });
+    }
+}
+
+function getCurrentOutputPath() {
+    try {
+        return parseOutputDirectory(readText(PATHS.eleventyConfig));
+    } catch {
+        return null;
+    }
+}
+
+module.exports = { updateOutputPath, getCurrentOutputPath };

package/tools/lib/pageActions.js

@@ -0,0 +1,138 @@
+const path = require('path');
+const settings = require('../config/settings.json');
+const { PATHS } = require('./paths');
+const { exists, readText, writeText, copyFile, moveFile, removeFile, removeDirectory } = require('./files');
+const { log } = require('./logger');
+const { formatText } = require('./text');
+const { languageSettings } = require('./project');
+const { getPageArtifacts, pageExists } = require('./pageArtifacts');
+const { addSiteData, removeSiteData, renameSiteData } = require('./siteData');
+const { addPageBlock, removePageBlock, renamePageBlock } = require('./pageComponents');
+
+const FRONT_MATTER_PATTERNS = Object.freeze({
+    title:     /^title:.*$/m,
+    permalink: /^permalink:.*$/m,
+});
+
+function templatePath(name) {
+    return path.join(PATHS.templates, name);
+}
+
+function applyFrontMatter(filePath, values) {
+    let content = readText(filePath);
+
+    for (const [key, pattern] of Object.entries(FRONT_MATTER_PATTERNS)) {
+        content = content.replace(pattern, formatText(settings.frontMatter[key], values));
+    }
+
+    writeText(filePath, content);
+}
+
+function addPage(pageName) {
+    if (pageExists(pageName)) {
+        log('page.alreadyExists', { name: pageName });
+        return;
+    }
+
+    const { camelName, source } = getPageArtifacts(pageName);
+    const values = { camelName, pageName };
+
+    const creations = [
+        { destination: source.style,  template: settings.page.styleTemplate,  isRoute: false },
+        { destination: source.script, template: languageSettings().template,  isRoute: false },
+        { destination: source.route,  template: settings.page.routeTemplate,  isRoute: true  },
+    ];
+
+    try {
+        for (const { destination, template, isRoute } of creations) {
+            const templateFile = templatePath(template);
+
+            if (!exists(templateFile)) {
+                log('page.templateMissing', { path: templateFile });
+                continue;
+            }
+
+            copyFile(templateFile, destination);
+            if (isRoute) applyFrontMatter(destination, values);
+
+            log('page.fileCreated', { path: destination });
+        }
+    } catch (error) {
+        log('page.createFailed', { error: error.message });
+        return;
+    }
+
+    addPageBlock(pageName);
+    addSiteData(pageName);
+}
+
+function renamePage(oldName, newName) {
+    if (!pageExists(oldName)) {
+        log('page.doesNotExist', { name: oldName });
+        return;
+    }
+    if (pageExists(newName)) {
+        log('page.targetExists', { name: newName });
+        return;
+    }
+
+    const current = getPageArtifacts(oldName);
+    const next = getPageArtifacts(newName);
+    const values = { camelName: next.camelName, pageName: newName };
+
+    const moves = [
+        { source: current.source.style,  destination: next.source.style,  isRoute: false },
+        { source: current.source.script, destination: next.source.script, isRoute: false },
+        { source: current.source.route,  destination: next.source.route,  isRoute: true  },
+    ];
+
+    try {
+        for (const { source, destination, isRoute } of moves) {
+            if (!exists(source)) {
+                log('page.fileMissing', { path: source });
+                continue;
+            }
+
+            moveFile(source, destination);
+            log('page.fileRenamed', { source, destination });
+
+            if (isRoute) applyFrontMatter(destination, values);
+        }
+    } catch (error) {
+        log('page.renameFailed', { error: error.message });
+        return;
+    }
+
+    renamePageBlock(oldName, newName);
+    renameSiteData(oldName, newName);
+}
+
+function removePage(pageName) {
+    if (!pageExists(pageName)) {
+        log('page.doesNotExist', { name: pageName });
+    }
+
+    const { source, output } = getPageArtifacts(pageName);
+    const files = [source.style, source.script, source.route, ...output.files];
+
+    for (const file of files) {
+        try {
+            if (removeFile(file)) log('page.fileDeleted', { path: file });
+        } catch (error) {
+            log('page.deleteFailed', { path: file, error: error.message });
+        }
+    }
+
+    for (const directory of output.directories) {
+        try {
+            if (removeDirectory(directory)) log('page.fileDeleted', { path: directory });
+        } catch (error) {
+            log('page.deleteFailed', { path: directory, error: error.message });
+        }
+    }
+
+    removePageBlock(pageName);
+    removeSiteData(pageName);
+}
+
+module.exports = { addPage, removePage, renamePage };

package/tools/lib/pageArtifacts.js

@@ -0,0 +1,46 @@
+const path = require('path');
+const settings = require('../config/settings.json');
+const { PATHS } = require('./paths');
+const { exists } = require('./files');
+const { languageSettings, scriptPagesDirectory } = require('./project');
+const { getCurrentOutputPath } = require('./outputPath');
+const { toCamelCase, formatText } = require('./text');
+
+const PATH_SEPARATOR = '/';
+
+function outputRoot() {
+    return path.join(PATHS.root, getCurrentOutputPath() || settings.project.defaultOutputDirectory);
+}
+
+function resolveOutput(root, template, values) {
+    return path.join(root, ...formatText(template, values).split(PATH_SEPARATOR));
+}
+
+function routeFile(pageName) {
+    return path.join(PATHS.routes, `${pageName}.${settings.page.routeExtension}`);
+}
+
+function pageExists(pageName) {
+    return exists(routeFile(pageName));
+}
+
+function getPageArtifacts(pageName) {
+    const camelName = toCamelCase(pageName);
+    const values = { camelName, pageName };
+    const root = outputRoot();
+
+    return {
+        camelName,
+        source: {
+            style:  path.join(PATHS.stylePages, `${camelName}.${settings.page.styleExtension}`),
+            script: path.join(scriptPagesDirectory(), `${camelName}.${languageSettings().extension}`),
+            route:  routeFile(pageName),
+        },
+        output: {
+            files:       settings.page.outputFiles.map((template) => resolveOutput(root, template, values)),
+            directories: settings.page.outputDirectories.map((template) => resolveOutput(root, template, values)),
+        },
+    };
+}
+
+module.exports = { getPageArtifacts, pageExists };

package/tools/lib/pageComponents.js

@@ -0,0 +1,88 @@
+const path = require('path');
+const settings = require('../config/settings.json');
+const { PATHS } = require('./paths');
+const { exists, readText, writeText } = require('./files');
+const { log } = require('./logger');
+const { toCamelCase, formatText } = require('./text');
+
+const EXTRA_BLANK_LINES_PATTERN = /\n\s*\n\s*\n/g;
+const BLANK_LINES = '\n\n';
+const ANCHOR = settings.pageComponents.anchor;
+
+function blockPattern(camelName) {
+    return new RegExp(
+        `[ \\t]*\\{%\\s*elif\\s+title\\s*==\\s*"${camelName}"\\s*%\\}[\\s\\S]*?(?=[ \\t]*\\{%\\s*(?:elif|else|endif))`
+    );
+}
+
+function conditionFor(camelName) {
+    return formatText(settings.pageComponents.condition, { camelName });
+}
+
+function readPageComponents() {
+    if (!exists(PATHS.pageComponents)) {
+        log('components.fileMissing', { path: PATHS.pageComponents });
+        return null;
+    }
+    return readText(PATHS.pageComponents);
+}
+
+function writePageComponents(content) {
+    writeText(PATHS.pageComponents, content);
+}
+
+function addPageBlock(pageName) {
+    const content = readPageComponents();
+    if (content === null) return;
+
+    const camelName = toCamelCase(pageName);
+    const condition = conditionFor(camelName);
+    if (content.includes(condition)) return;
+
+    if (!content.includes(ANCHOR)) {
+        log('components.anchorMissing', { anchor: ANCHOR, file: path.basename(PATHS.pageComponents) });
+        return;
+    }
+
+    const block = `${condition}\n${settings.pageComponents.include}\n\n`;
+
+    writePageComponents(content.replace(ANCHOR, `${block}${ANCHOR}`));
+    log('components.blockAdded', { name: camelName });
+}
+
+function removePageBlock(pageName) {
+    const content = readPageComponents();
+    if (content === null) return;
+
+    const camelName = toCamelCase(pageName);
+    if (!blockPattern(camelName).test(content)) {
+        log('components.blockMissing', { name: camelName });
+        return;
+    }
+
+    const updated = content
+        .replace(blockPattern(camelName), '')
+        .replace(EXTRA_BLANK_LINES_PATTERN, BLANK_LINES);
+
+    writePageComponents(updated);
+    log('components.blockRemoved', { name: camelName });
+}
+
+function renamePageBlock(oldName, newName) {
+    const content = readPageComponents();
+    if (content === null) return;
+
+    const oldCamelName = toCamelCase(oldName);
+    const newCamelName = toCamelCase(newName);
+    const oldCondition = conditionFor(oldCamelName);
+
+    if (!content.includes(oldCondition)) {
+        log('components.blockMissing', { name: oldCamelName });
+        return;
+    }
+
+    writePageComponents(content.replace(oldCondition, conditionFor(newCamelName)));
+    log('components.blockRenamed', { source: oldCamelName, destination: newCamelName });
+}
+
+module.exports = { addPageBlock, removePageBlock, renamePageBlock };