@reldens/cms 0.20.0 → 0.21.0

package/lib/template-reloader.js

@@ -0,0 +1,307 @@
+/**
+ *
+ * Reldens - CMS - TemplateReloader
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { sc } = require('@reldens/utils');
+
+class TemplateReloader
+{
+
+    constructor(props = {})
+    {
+        this.reloadTime = sc.get(props, 'reloadTime', 0);
+        this.events = sc.get(props, 'events', false);
+        this.fileTracking = {};
+        this.reloadInterval = false;
+        this.isActive = -1 === this.reloadTime || 0 < this.reloadTime;
+        this.adminTemplatesLoader = sc.get(props, 'adminTemplatesLoader', false);
+        this.mappedAdminTemplates = sc.get(props, 'mappedAdminTemplates', {});
+        this.templatesPath = sc.get(props, 'templatesPath', '');
+        this.templateExtensions = sc.get(props, 'templateExtensions', []);
+        this.setupReloadInterval();
+    }
+
+    setupReloadInterval()
+    {
+        if(0 >= this.reloadTime){
+            return true;
+        }
+        if(this.reloadInterval){
+            clearInterval(this.reloadInterval);
+        }
+        this.reloadInterval = setInterval(() => {
+            this.checkAndReloadChangedTemplates();
+        }, this.reloadTime);
+    }
+
+    iterateTemplateFiles(templatesPaths, callback)
+    {
+        if(!templatesPaths){
+            return false;
+        }
+        if(sc.isString(templatesPaths)){
+            return callback(templatesPaths);
+        }
+        if(Array.isArray(templatesPaths)){
+            let result = false;
+            for(let filePath of templatesPaths){
+                if(callback(filePath)){
+                    result = true;
+                }
+            }
+            return result;
+        }
+        if(sc.isObject(templatesPaths)){
+            let result = false;
+            for(let key of Object.keys(templatesPaths)){
+                let templateData = templatesPaths[key];
+                if(sc.isObject(templateData)){
+                    if(this.iterateTemplateFiles(templateData, callback)){
+                        result = true;
+                    }
+                    continue;
+                }
+                if(callback(templateData)){
+                    result = true;
+                }
+            }
+            return result;
+        }
+        return false;
+    }
+
+    trackTemplateFiles(templatesPaths)
+    {
+        if(0 === this.reloadTime){
+            return true;
+        }
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            if(!FileHandler.exists(filePath)){
+                return false;
+            }
+            let modTime = FileHandler.getFileModificationTime(filePath);
+            if(!modTime){
+                return false;
+            }
+            this.fileTracking[filePath] = {
+                lastModified: modTime,
+                isChanged: false
+            };
+            return true;
+        });
+    }
+
+    checkTemplateChanges(templatesPaths)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            if(!FileHandler.exists(filePath)){
+                return false;
+            }
+            let trackedFile = this.fileTracking[filePath];
+            if(!trackedFile){
+                this.trackTemplateFiles(filePath);
+                return false;
+            }
+            let currentModTime = FileHandler.getFileModificationTime(filePath);
+            if(!currentModTime){
+                return false;
+            }
+            if(currentModTime.getTime() > trackedFile.lastModified.getTime()){
+                if(-1 !== this.reloadTime){
+                    trackedFile.lastModified = currentModTime;
+                }
+                trackedFile.isChanged = true;
+                return true;
+            }
+            return false;
+        });
+    }
+
+    hasChangedTemplates(templatesPaths)
+    {
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            let trackedFile = this.fileTracking[filePath];
+            return trackedFile ? trackedFile.isChanged : false;
+        });
+    }
+
+    markTemplatesAsReloaded(templatesPaths)
+    {
+        if(0 === this.reloadTime){
+            return true;
+        }
+        return this.iterateTemplateFiles(templatesPaths, (filePath) => {
+            let trackedFile = this.fileTracking[filePath];
+            if(trackedFile){
+                trackedFile.isChanged = false;
+            }
+            return true;
+        });
+    }
+
+    shouldReloadAdminTemplates(mappedAdminTemplates)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        if(-1 === this.reloadTime){
+            return this.checkTemplateChanges(mappedAdminTemplates);
+        }
+        return this.hasChangedTemplates(mappedAdminTemplates);
+    }
+
+    shouldReloadFrontendTemplates(templatesPath, templateExtensions)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        let templateFiles = this.collectTemplateFiles(templatesPath, templateExtensions);
+        if(-1 === this.reloadTime){
+            return this.checkTemplateChanges(templateFiles);
+        }
+        return this.hasChangedTemplates(templateFiles);
+    }
+
+    collectTemplateFiles(templatesPath, templateExtensions)
+    {
+        let templateFiles = [];
+        if(!FileHandler.exists(templatesPath)){
+            return templateFiles;
+        }
+        let partialsPath = FileHandler.joinPaths(templatesPath, 'partials');
+        if(FileHandler.exists(partialsPath)){
+            let partialFiles = FileHandler.getFilesInFolder(partialsPath, templateExtensions);
+            for(let file of partialFiles){
+                templateFiles.push(FileHandler.joinPaths(partialsPath, file));
+            }
+        }
+        let domainsPath = FileHandler.joinPaths(templatesPath, 'domains');
+        if(FileHandler.exists(domainsPath)){
+            let domainFolders = FileHandler.fetchSubFoldersList(domainsPath);
+            for(let domain of domainFolders){
+                let domainPath = FileHandler.joinPaths(domainsPath, domain);
+                let domainPartialsPath = FileHandler.joinPaths(domainPath, 'partials');
+                if(FileHandler.exists(domainPartialsPath)){
+                    let domainPartialFiles = FileHandler.getFilesInFolder(domainPartialsPath, templateExtensions);
+                    for(let file of domainPartialFiles){
+                        templateFiles.push(FileHandler.joinPaths(domainPartialsPath, file));
+                    }
+                }
+            }
+        }
+        return templateFiles;
+    }
+
+    checkAndReloadChangedTemplates()
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        let hasChanges = false;
+        for(let filePath of Object.keys(this.fileTracking)){
+            if(this.checkTemplateChanges(filePath)){
+                hasChanges = true;
+            }
+        }
+        if(hasChanges && this.events){
+            this.events.emit('reldens.templateReloader.templatesChanged', {
+                reloader: this,
+                changedFiles: this.getChangedFiles()
+            });
+        }
+        return hasChanges;
+    }
+
+    getChangedFiles()
+    {
+        let changedFiles = [];
+        for(let filePath of Object.keys(this.fileTracking)){
+            let trackedFile = this.fileTracking[filePath];
+            if(trackedFile && trackedFile.isChanged){
+                changedFiles.push(filePath);
+            }
+        }
+        return changedFiles;
+    }
+
+    destroy()
+    {
+        if(this.reloadInterval){
+            clearInterval(this.reloadInterval);
+            this.reloadInterval = false;
+        }
+        this.fileTracking = {};
+    }
+
+    async checkAndReloadAdminTemplates()
+    {
+        if(!this.adminTemplatesLoader){
+            return false;
+        }
+        if(!this.shouldReloadAdminTemplates(this.mappedAdminTemplates)){
+            return false;
+        }
+        let newAdminFilesContents = await this.adminTemplatesLoader.fetchAdminFilesContents(this.mappedAdminTemplates);
+        if(!newAdminFilesContents){
+            return false;
+        }
+        this.markTemplatesAsReloaded(this.mappedAdminTemplates);
+        return newAdminFilesContents;
+    }
+
+    async checkAndReloadFrontendTemplates()
+    {
+        if(!this.shouldReloadFrontendTemplates(this.templatesPath, this.templateExtensions)){
+            return false;
+        }
+        let templateFiles = this.collectTemplateFiles(this.templatesPath, this.templateExtensions);
+        this.markTemplatesAsReloaded(templateFiles);
+        return true;
+    }
+
+    async updateAdminContentsAfterReload(newAdminFilesContents, adminManager)
+    {
+        if(!newAdminFilesContents || !adminManager){
+            return false;
+        }
+        adminManager.adminFilesContents = newAdminFilesContents;
+        adminManager.contentsBuilder.adminFilesContents = newAdminFilesContents;
+        adminManager.routerContents.adminFilesContents = newAdminFilesContents;
+        adminManager.addCacheButtonSubscriber.cacheCleanButton = newAdminFilesContents.cacheCleanButton;
+        adminManager.addCacheButtonSubscriber.clearAllCacheButton = newAdminFilesContents.clearAllCacheButton;
+        await adminManager.contentsBuilder.buildAdminContents();
+        return true;
+    }
+
+    async handleAdminTemplateReload(adminManager)
+    {
+        if(0 === this.reloadTime){
+            return false;
+        }
+        let reloadedContents = await this.checkAndReloadAdminTemplates();
+        if(reloadedContents){
+            await this.updateAdminContentsAfterReload(reloadedContents, adminManager);
+        }
+        return reloadedContents;
+    }
+
+    async handleFrontendTemplateReload(templateCache, templateResolver)
+    {
+        let reloadResult = await this.checkAndReloadFrontendTemplates();
+        if(reloadResult){
+            await templateCache.loadPartials();
+            await templateCache.setupDomainTemplates();
+            templateResolver.domainTemplatesMap = templateCache.getDomainTemplatesMap();
+        }
+        return reloadResult;
+    }
+
+}
+
+module.exports.TemplateReloader = TemplateReloader;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/cms",
     "scope": "@reldens",
-    "version": "0.20.0",
+    "version": "0.21.0",
     "description": "Reldens - CMS",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -33,10 +33,10 @@
         "url": "https://github.com/damian-pastorini/reldens-cms/issues"
     },
     "dependencies": {
-        "@reldens/server-utils": "^0.21.0",
-        "@reldens/storage": "^0.61.0",
+        "@reldens/server-utils": "^0.23.0",
+        "@reldens/storage": "^0.62.0",
         "@reldens/utils": "^0.50.0",
-        "dotenv": "^17.0.1",
+        "dotenv": "^17.2.0",
         "mustache": "^4.2.0"
     }
 }

package/templates/{browserconfig.xml → assets/favicons/default/browserconfig.xml}

@@ -2,7 +2,7 @@
 <browserconfig>
     <msapplication>
         <tile>
-            <square150x150logo src="/assets/favicons/mstile-150x150.png"/>
+            <square150x150logo src="/assets/favicons/default/mstile-150x150.png"/>
             <TileColor>#000000</TileColor>
         </tile>
     </msapplication>

package/templates/{site.webmanifest → assets/favicons/default/site.webmanifest}

@@ -7,18 +7,18 @@
     "background_color": "#000000",
     "icons": [
         {
-            "src": "assets/favicons/android-icon-144x144.png",
+            "src": "/assets/favicons/default/android-icon-144x144.png",
             "sizes": "144x144",
             "type": "image/png",
             "purpose": "any"
         },
         {
-            "src": "assets/favicons/android-icon-192x192.png",
+            "src": "/assets/favicons/default/android-icon-192x192.png",
             "sizes": "192x192",
             "type": "image/png"
         },
         {
-            "src": "assets/favicons/android-icon-512x512.png",
+            "src": "/assets/favicons/default/android-icon-512x512.png",
             "sizes": "512x512",
             "type": "image/png",
             "purpose": "maskable"

package/templates/js/functions.js

@@ -0,0 +1,144 @@
+/**
+ *
+ * Reldens - Functions
+ *
+ */
+
+function getCookie(name)
+{
+    let value = `; ${document.cookie}`;
+    let parts = value.split(`; ${name}=`);
+    if(2 === parts.length){
+        return parts.pop().split(';').shift()
+    }
+}
+
+function deleteCookie(name)
+{
+    document.cookie = name + '=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';
+}
+
+function escapeHTML(str)
+{
+    return str.replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}
+
+function cloneElement(element)
+{
+    if(element instanceof HTMLCanvasElement){
+        let clonedCanvas = document.createElement('canvas');
+        clonedCanvas.width = element.width;
+        clonedCanvas.height = element.height;
+        let ctx = clonedCanvas.getContext('2d');
+        ctx.drawImage(element, 0, 0);
+        return clonedCanvas
+    }
+    return element.cloneNode(true);
+}
+
+function showConfirmDialog(callback)
+{
+    let dialog = document.querySelector('.confirm-dialog');
+    if(!dialog){
+        return callback(false);
+    }
+    dialog.showModal();
+    let confirmButton = dialog.querySelector('.dialog-confirm');
+    let cancelButton = dialog.querySelector('.dialog-cancel');
+    let onConfirm = () => {
+        dialog.close();
+        callback(true);
+        confirmButton.removeEventListener('click', onConfirm);
+        cancelButton.removeEventListener('click', onCancel);
+    };
+    let onCancel = () => {
+        dialog.close();
+        callback(false);
+        confirmButton.removeEventListener('click', onConfirm);
+        cancelButton.removeEventListener('click', onCancel);
+    };
+    confirmButton.addEventListener('click', onConfirm);
+    cancelButton.addEventListener('click', onCancel);
+}
+
+function activateExpandCollapse()
+{
+    let expandCollapseButtons = document.querySelectorAll('[data-expand-collapse]');
+    if(expandCollapseButtons){
+        return;
+    }
+    for(let expandCollapseButton of expandCollapseButtons){
+        expandCollapseButton.addEventListener('click', (event) => {
+            let expandCollapseElement = document.querySelector(event.currentTarget.dataset.expandCollapse);
+            if(expandCollapseElement){
+                expandCollapseElement.classList.toggle('hidden');
+            }
+        });
+    }
+}
+
+function createModalContent(modalElement)
+{
+    if(modalElement.hasAttribute('data-modal-zoom-image')){
+        let modalContent = document.createElement('img');
+        modalContent.src = modalElement.getAttribute('data-modal-zoom-image');
+        modalContent.alt = modalElement.alt || 'Modal Image';
+        modalContent.classList.add('modal-zoom-image');
+        return modalContent;
+    }
+    return cloneElement(modalElement);
+}
+
+function activateModalElements()
+{
+    let modalElements = document.querySelectorAll('[data-toggle="modal"]');
+    if(!modalElements){
+        return;
+    }
+    for(let modalElement of modalElements){
+        if(!modalElement.id){
+            modalElement.id = 'modal-'+Math.random().toString(36).substr(2, 9);
+        }
+        modalElement.addEventListener('click', () => {
+            let overlayId = 'overlay-'+modalElement.id;
+            let existingOverlay = document.querySelector('#'+overlayId);
+            if(existingOverlay){
+                existingOverlay.style.display = 'block';
+                document.body.style.overflow = 'hidden';
+                return;
+            }
+            let overlay = document.createElement('div');
+            overlay.id = overlayId;
+            overlay.classList.add('modal-overlay');
+            let modal = document.createElement('div');
+            modal.classList.add('modal');
+            modal.classList.add('clickable');
+            let modalContent = createModalContent(modalElement);
+            modalContent.classList.add('clickable');
+            modal.appendChild(modalContent);
+            overlay.appendChild(modal);
+            document.body.appendChild(overlay);
+            document.body.style.overflow = 'hidden';
+            modalContent.addEventListener('click', () => {
+                document.body.style.overflow = '';
+                document.body.removeChild(overlay);
+            });
+            modal.addEventListener('click', (e) => {
+                if(modal === e.target){
+                    document.body.style.overflow = '';
+                    document.body.removeChild(overlay);
+                }
+            });
+            overlay.addEventListener('click', (e) => {
+                if(overlay === e.target){
+                    document.body.style.overflow = '';
+                    document.body.removeChild(overlay);
+                }
+            });
+        });
+    }
+}

package/templates/js/scripts.js

@@ -16,4 +16,9 @@ document.addEventListener('DOMContentLoaded', function() {
     if(copyRightYear){
         copyRightYear.innerHTML = String((new Date()).getFullYear());
     }
+
+    activateExpandCollapse();
+
+    activateModalElements();
+
 });

package/templates/page.html

@@ -29,13 +29,19 @@
     {{#canonical_url}}
     <link rel="canonical" href="{{canonical_url}}"/>
     {{/canonical_url}}
+    <!-- favicons -->
+    <meta name="msapplication-config" content="[asset(/favicons/default/browserconfig.xml)]"/>
+    <link rel="icon" href="[asset(/favicons/default/favicon.ico)]" type="image/x-icon"/>
+    <link rel="shortcut icon" href="[asset(/favicons/default/favicon.ico)]" type="image/x-icon">
+    <link rel="manifest" href="[asset(/favicons/default/site.webmanifest)]"/>
     <!-- CSS and JS -->
-    <link href="/css/styles.css" rel="stylesheet"/>
-    <script src="/js/cookie-consent.js"></script>
+    <link rel="stylesheet" href="[url(/css/styles.css)]"/>
+    <script defer src="[url(/js/cookie-consent.js)]"></script>
 </head>
 <body class="{{siteHandle}}">
-    {{&content}}
-    {{>cookie-consent}}
-    <script type="text/javascript" defer src="/js/scripts.js"></script>
+{{&content}}
+{{>cookie-consent}}
+<script defer type="text/javascript" src="[url(/js/functions.js)]"></script>
+<script defer type="text/javascript" src="[url(/js/scripts.js)]"></script>
 </body>
 </html>

package/templates/partials/pagedCollection.html

@@ -3,7 +3,7 @@
     {{&collectionContentForCurrentPage}}
 </div>
 <div class="row pager-container">
-    <div class="pagination col-lg-12 mt-2 mb-2">
+    <div class="pagination col-lg-12">
         <ul>
             {{#prevPageUrl}}
             <li class="previous previous-page"><a href="{{ prevPageUrl }}">{{&prevPageLabel }}</a></li>

package/lib/admin-translations.js

@@ -1,56 +0,0 @@
-/**
- *
- * Reldens - AdminTranslations
- *
- */
-
-class AdminTranslations
-{
-
-    static appendTranslations(translations)
-    {
-        // @TODO - BETA - Fix translations, use snippets, include new snippets under the basic config script.
-        let adminTranslations = {
-            messages: {
-                loginWelcome: 'CMS - Login',
-                reldensTitle: 'Reldens - CMS',
-                reldensSlogan: 'You can do it',
-                reldensDiscordTitle: 'Join our Discord server!',
-                reldensDiscordText: 'Talk with the creators and other Reldens users',
-                reldensGithubTitle: 'Find us on GitHub!',
-                reldensGithubText: 'Need a new feature?'
-                    +' Would you like to contribute with code?'
-                    +' Find the source code or create an issue in GitHub',
-                reldensLoading: 'Loading...',
-                confirmClearCacheMessage: 'Are you sure you want to clear all cache? This action cannot be undone.',
-                clearCacheWarning: 'This will clear all cached routes and may impact site performance temporarily.'
-            },
-            labels: {
-                navigation: 'Reldens - CMS',
-                adminVersion: 'Admin: {{version}}',
-                loginWelcome: 'Reldens',
-                pages: 'Server Management',
-                management: 'Management',
-                shuttingDown: 'Server is shutting down in:',
-                submitShutdownLabel: 'Shutdown Server',
-                submitCancelLabel: 'Cancel Server Shutdown',
-                cleanCache: 'Clean Cache',
-                clearAllCache: 'Clear All Cache',
-                confirmClearCache: 'Confirm Clear Cache',
-                warning: 'Warning:',
-                cancel: 'Cancel',
-                confirm: 'Continue',
-            }
-        };
-        for(let i of Object.keys(translations)){
-            if(!adminTranslations[i]){
-                adminTranslations[i] = {};
-            }
-            Object.assign(adminTranslations[i], translations[i]);
-        }
-        return adminTranslations;
-    }
-
-}
-
-module.exports.AdminTranslations = AdminTranslations;