nibula 1.2.3 → 1.2.5

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 };

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

@@ -1,5 +1,7 @@
-// import { initExampleModule } from '../modules/exampleModule.js';
-
-document.addEventListener("DOMContentLoaded", () => {
-    // initExampleModule();
-});
+// import { initExampleModule } from '../modules/exampleModule.js';
+
+document.addEventListener("DOMContentLoaded", () => {
+    // initExampleModule();
+});
+
+// Page logic here

package/tools/res/templates/template.njk

@@ -1,9 +1,9 @@
----
-title: ""
-permalink: ""
-layout: page-components.njk
----
-
-<!-- !IMPORTANT -->
-<!-- DO NOT ADD ANYTHING HERE -->
+---
+title: ""
+permalink: ""
+layout: page-components.njk
+---
+
+<!-- !IMPORTANT -->
+<!-- DO NOT ADD ANYTHING HERE -->
 <!-- You should create a new component.njk into src/frontend and include that in layouts/page-components.njk -->

package/tools/res/templates/template.scss

@@ -1,23 +1,23 @@
-//==========================
-// CSS MODULES IMPORTS
-//==========================
-
-// Use @use with a namespace to avoid framework variable conflicts:
-// Example: root.$primary
-@use "../modules/root" as root;
-
-// This global module contains the import framework, necessary modules for each page and any other common styles
-@import "../modules/global";
-
-// Import any other module you need by import down here
-// @import "../modules/moduleName";
-
-//==========================
-// PAGE CUSTOM CSS RULES
-//==========================
-
-// Add any custom rule specific to this page below
-// These rules override the framework and module styles
-// body {
-//     background-color: root.$primary;
+//==========================
+// CSS MODULES IMPORTS
+//==========================
+
+// Use @use with a namespace to avoid framework variable conflicts:
+// Example: root.$primary
+@use "../modules/root" as root;
+
+// This global module contains the import framework, necessary modules for each page and any other common styles
+@import "../modules/global";
+
+// Import any other module you need by import down here
+// @import "../modules/moduleName";
+
+//==========================
+// PAGE CUSTOM CSS RULES
+//==========================
+
+// Add any custom rule specific to this page below
+// These rules override the framework and module styles
+// body {
+//     background-color: root.$primary;
 // }

package/tools/res/templates/template.ts

@@ -1,5 +1,7 @@
-// import { initExampleModule } from '../modules/exampleModule';
-
-document.addEventListener("DOMContentLoaded", (): void => {
-    // initExampleModule();
-});
+// import { initExampleModule } from '../modules/exampleModule';
+
+document.addEventListener("DOMContentLoaded", (): void => {
+    // initExampleModule();
+});
+
+// Page logic here

package/tsconfig.json

@@ -1,25 +1,25 @@
-{
-  // https://aka.ms/tsconfig
-  
-  // Add options by uncommenting or adding "<key>": <value> pairs inside compilerOptions
-
-  "include": ["src/frontend/ts/**/*.ts"], // DO NOT CHANGE
-  
-  "compilerOptions": {
-    "rootDir": "./src/frontend/ts", // DO NOT CHANGE
-    "outDir": "./out/ts", // DO NOT CHANGE
-    "module": "esnext",
-    "target": "esnext",
-    "types": [],
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-    "strict": true,
-    "jsx": "react-jsx",
-    "verbatimModuleSyntax": true,
-    "isolatedModules": true,
-    "noUncheckedSideEffectImports": true,
-    "moduleDetection": "force",
-    "skipLibCheck": true,
-    "experimentalDecorators": true
-  }
+{
+  // https://aka.ms/tsconfig
+  
+  // Add options by uncommenting or adding "<key>": <value> pairs inside compilerOptions
+
+  "include": ["src/frontend/ts/**/*.ts"], // DO NOT CHANGE
+  
+  "compilerOptions": {
+    "rootDir": "./src/frontend/ts", // DO NOT CHANGE
+    "outDir": "./out/ts", // DO NOT CHANGE
+    "module": "esnext",
+    "target": "esnext",
+    "types": [],
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "experimentalDecorators": true
+  }
 }

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 };