@underpostnet/underpost 2.97.5 → 2.98.0

package/src/client/components/core/Input.js

@@ -43,7 +43,9 @@ const fileFormDataFactory = (e, extensions) => {
       logger.error('Invalid file extension', e.target.files[keyFile]);
       continue;
     }
-    form.append(e.target.files[keyFile].name, e.target.files[keyFile]);
+    // form.append(e.target.files[keyFile].name, e.target.files[keyFile]);
+    // Use standard 'file' field name for all files - server expects this format
+    form.append('file', e.target.files[keyFile]);
   }
   return form;
 };

package/src/client/components/core/Panel.js

@@ -348,7 +348,7 @@ const Panel = {
                       ? 'rgba(255,255,255,0.9)'
                       : 'rgba(0,0,0,0.85)'}; line-height: 1.4; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;"
                   >
-                    ${obj.userInfo.username || obj.userInfo.email || 'Unknown'}
+                    ${obj.userInfo.username || 'Unknown'}
                   </a>
                   <span
                     style="font-size: 11px; color: ${darkTheme
@@ -644,6 +644,7 @@ const Panel = {
           break;
         case 'file':
           setTimeout(() => {
+            if (!s(`.${modelData.id}`)) return;
             s(`.${modelData.id}`).fileNameInputExtDefaultContent = fileNameInputExtDefaultContent;
             s(`.${modelData.id}`).onchange = async (e) => {
               if (!Object.keys(e.target.files).length) return;

package/src/client/components/core/Responsive.js

@@ -46,13 +46,21 @@ const Responsive = {
     // alternative option
     // this.Observer = new ResizeObserver(this.resizeCallback);
     // this.Observer.observe(document.documentElement);
-    screen.orientation.addEventListener('change', (event) => {
-      const type = event.target.type; // landscape-primary | portrait-primary
-      const angle = event.target.angle; // 90 degrees.
-      logger.info(`ScreenOrientation change: ${type}, ${angle} degrees.`);
-      setTimeout(() => window.onresize({}, true));
-      Responsive.triggerEventsOrientation();
-    });
+
+    // Check if screen.orientation is available before adding event listener
+    if (
+      typeof screen !== 'undefined' &&
+      screen.orientation &&
+      typeof screen.orientation.addEventListener === 'function'
+    ) {
+      screen.orientation.addEventListener('change', (event) => {
+        const type = event.target.type; // landscape-primary | portrait-primary
+        const angle = event.target.angle; // 90 degrees.
+        logger.info(`ScreenOrientation change: ${type}, ${angle} degrees.`);
+        setTimeout(() => window.onresize({}, true));
+        Responsive.triggerEventsOrientation();
+      });
+    }
     Responsive.matchMediaOrientationInstance = matchMedia('screen and (orientation:portrait)');
 
     Responsive.matchMediaOrientationInstance.onchange = (e) => {

package/src/client/components/core/SearchBox.js

@@ -746,116 +746,6 @@ const SearchBox = {
     }, 0);
   },
 
-  /**
-   * Debounce helper for search-while-typing
-   */
-  debounce: function (func, wait) {
-    let timeout;
-    return function executedFunction(...args) {
-      const later = () => {
-        clearTimeout(timeout);
-        func(...args);
-      };
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-    };
-  },
-
-  /**
-   * Sets up a search input element with automatic search on typing.
-   * Attaches debounced input event handler and manages search lifecycle.
-   * @memberof SearchBoxClient.SearchBox
-   * @param {string} inputId - Input element ID or class name.
-   * @param {string} resultsContainerId - Results container element ID or class name.
-   * @param {object} [context={}] - Configuration context object.
-   * @param {number} [context.debounceTime=300] - Debounce delay in milliseconds.
-   * @param {number} [context.minQueryLength=1] - Minimum query length to trigger search.
-   * @returns {Function} Cleanup function to remove event listeners.
-   */
-  setupSearchInput: function (inputId, resultsContainerId, context = {}) {
-    const input = s(`#${inputId}`) || s(`.${inputId}`);
-    if (!input) {
-      logger.warn(`Input ${inputId} not found`);
-      return;
-    }
-
-    const debounceTime = context.debounceTime || 300;
-
-    const performSearch = this.debounce(async (query) => {
-      const trimmedQuery = query ? query.trim() : '';
-      const minLength = context.minQueryLength !== undefined ? context.minQueryLength : 1;
-
-      // Show recent results when query is empty
-      if (trimmedQuery.length === 0) {
-        const recentResults = this.RecentResults.getAll();
-        this.renderResults(recentResults, resultsContainerId, context);
-        return;
-      }
-
-      // Support single character searches by default (minQueryLength: 1)
-      // Can be configured via context.minQueryLength for different use cases
-      if (trimmedQuery.length < minLength) {
-        this.renderResults([], resultsContainerId, context);
-        return;
-      }
-
-      const results = await this.search(trimmedQuery, context);
-      this.renderResults(results, resultsContainerId, context);
-    }, debounceTime);
-
-    // Store the handler reference
-    const handlerId = `search-handler-${inputId}`;
-    if (this.Data[handlerId]) {
-      input.removeEventListener('input', this.Data[handlerId]);
-    }
-
-    this.Data[handlerId] = (e) => {
-      performSearch(e.target.value);
-    };
-
-    input.addEventListener('input', this.Data[handlerId]);
-
-    logger.info(`Setup search input: ${inputId}`);
-
-    return () => {
-      input.removeEventListener('input', this.Data[handlerId]);
-      delete this.Data[handlerId];
-    };
-  },
-
-  /**
-   * Debounces a function call to reduce excessive invocations.
-   * Used for search input to prevent searching on every keystroke.
-   * @memberof SearchBoxClient.SearchBox
-   * @param {Function} func - The function to debounce.
-   * @param {number} wait - Delay in milliseconds before invoking the function.
-   * @returns {Function} Debounced function that delays invocation.
-   */
-  debounce: function (func, wait) {
-    let timeout;
-
-    const later = function (...args) {
-      timeout = null;
-      func(...args);
-    };
-
-    return function (...args) {
-      if (timeout) clearTimeout(timeout);
-      timeout = setTimeout(() => later(...args), wait);
-    };
-  },
-
-  /**
-   * Clears all registered search providers.
-   * Useful for cleanup or resetting search functionality.
-   * @memberof SearchBoxClient.SearchBox
-   * @returns {void}
-   */
-  clearProviders: function () {
-    this.providers = [];
-    logger.info('Cleared all search providers');
-  },
-
   /**
    * Gets base CSS styles for SearchBox with theme-aware styling.
    * Uses subThemeManager colors for consistent theming across light and dark modes.

package/src/client/components/core/Translate.js

@@ -180,6 +180,7 @@ const TranslateCore = {
     Translate.Data['load'] = { en: 'load', es: 'Cargar' };
     Translate.Data['settings'] = { en: 'settings', es: 'configuraciones' };
     Translate.Data['search'] = { en: 'Search', es: 'Buscar' };
+    Translate.Data['filter-by-file-name'] = { en: 'Filter by file name', es: 'Filtrar por nombre de archivo' };
     Translate.Data['view'] = { en: 'view', es: 'ver' };
     Translate.Data['user'] = { en: 'User', es: 'Usuario' };
     Translate.Data['pass'] = { en: 'Password', es: 'Contraseña' };
@@ -397,6 +398,55 @@ const TranslateCore = {
     };
     Translate.Data['resend'] = { en: 'Resend', es: 'Reenviar' };
     Translate.Data['delete-account'] = { en: 'Delete Account', es: 'Borrar cuenta' };
+
+    Translate.Data['doc-title'] = {
+      en: 'Doc Title',
+      es: 'Título del documento',
+    };
+    Translate.Data['md-file-name'] = {
+      en: 'MD File Name',
+      es: 'Nombre de archivo MD',
+    };
+    Translate.Data['generic-file-name'] = {
+      en: 'Generic File Name',
+      es: 'Nombre de archivo genérico',
+    };
+    Translate.Data['edit-document'] = {
+      en: 'Edit Document',
+      es: 'Editar documento',
+    };
+    Translate.Data['location'] = {
+      en: 'Location',
+      es: 'Ubicación',
+    };
+    Translate.Data['save'] = {
+      en: 'Save',
+      es: 'Guardar',
+    };
+    Translate.Data['success-update-document'] = {
+      en: 'Document updated successfully.',
+      es: 'Documento actualizado con éxito.',
+    };
+    Translate.Data['error-update-document'] = {
+      en: 'Error updating document.',
+      es: 'Error al actualizar el documento.',
+    };
+    Translate.Data['error-title-required'] = {
+      en: 'Title is required.',
+      es: 'El título es obligatorio.',
+    };
+    Translate.Data['editing'] = {
+      en: 'Editing',
+      es: 'Editando',
+    };
+    Translate.Data['no-md-file-attached'] = {
+      en: 'No markdown file attached to this document',
+      es: 'No hay archivo markdown adjunto a este documento',
+    };
+    Translate.Data['no-generic-file-attached'] = {
+      en: 'No generic file attached to this document',
+      es: 'No hay archivo genérico adjunto a este documento',
+    };
     Translate.Data['success-delete-account'] = {
       en: 'Account deleted successfully.',
       es: 'Cuenta borrada con éxito.',

package/src/client/services/default/default.management.js

@@ -910,18 +910,9 @@ const DefaultManagement = {
                   s(`.management-table-btn-save-${id}`).click();
                 }
               } else {
-                const body = event.data ? event.data : {};
-                result = await ServiceProvider.put({ id: event.data._id, body });
-                NotificationManager.Push({
-                  html: result.status === 'error' ? result.message : `${Translate.Render('success-update-item')}`,
-                  status: result.status,
-                });
-                if (result.status === 'success') {
-                  AgGrid.grids[gridId].applyTransaction({
-                    update: [event.data],
-                  });
-                  DefaultManagement.loadTable(id, { reload: false });
-                }
+                // Skip update here - onCellValueChanged already handles auto-save for existing rows
+                // This prevents duplicate notifications and API calls
+                return;
               }
             },
             ...(options.gridOptions ? options.gridOptions : undefined),

package/src/client/sw/default.sw.js

@@ -6,199 +6,122 @@
  * @namespace PwaServiceWorker
  */
 
-/**
- * Class representing a Progressive Web App (PWA) Service Worker with caching strategies.
- * @class
- * @memberof PwaServiceWorker
- */
-class PwaServiceWorker {
-  /**
-   * Initializes the service worker configuration by reading from self.renderPayload.
-   * If properties are not found, defaults are used.
-   * @constructor
-   * @property {Array<string>} PRE_CACHED_RESOURCES - List of resources to precache.
-   * @property {string} CACHE_NAME - Name of the cache storage.
-   * @property {string} PROXY_PATH - Base path for proxying requests.
-   */
-  constructor() {
-    // Configuration properties equivalent to the original global constants
-    this.PRE_CACHED_RESOURCES = self.renderPayload?.PRE_CACHED_RESOURCES ?? [];
-    this.CACHE_NAME = self.renderPayload?.CACHE_NAME ?? 'app-cache';
-    this.PROXY_PATH = self.renderPayload?.PROXY_PATH ?? '/';
-
-    console.log(`Service Worker Initialized. Cache: ${this.CACHE_NAME}, Proxy: ${this.PROXY_PATH}`);
-  }
-
-  /**
-   * Registers event listeners for the service worker lifecycle and requests.
-   * @method
-   * @memberof PwaServiceWorker
-   */
-  run() {
-    // Bind methods to 'this' (the instance) before attaching to self
-    self.addEventListener('install', this._onInstall.bind(this));
-    self.addEventListener('activate', this._onActivate.bind(this));
-    self.addEventListener('fetch', this._onFetch.bind(this));
-  }
-
-  /**
-   * Handles the 'install' event. Skips waiting and precaches static assets.
-   * @param {ExtendableEvent} event
-   * @memberof PwaServiceWorker
-   */
-  _onInstall(event) {
-    // Activate right away
-    self.skipWaiting();
-
-    event.waitUntil(
-      (async () => {
-        // Open the app's cache using the configured name.
-        const cache = await caches.open(this.CACHE_NAME);
-        // Cache all static resources.
-        try {
-          console.log(`Precaching ${this.PRE_CACHED_RESOURCES.length} resources...`);
-          await cache.addAll(this.PRE_CACHED_RESOURCES);
-        } catch (error) {
-          console.error('Error during precaching resources:', error);
-        }
-      })(),
-    );
-  }
-
-  /**
-   * Handles the 'activate' event. Enables navigation preload and takes control
-   * of uncontrolled clients immediately.
-   * @param {ExtendableEvent} event
-   * @memberof PwaServiceWorker
-   */
-  _onActivate(event) {
-    event.waitUntil(
-      (async () => {
-        // Enable navigation preload if it's supported.
-        if ('navigationPreload' in self.registration) {
-          await self.registration.navigationPreload.enable();
-          console.log('Navigation Preload enabled.');
-        }
-      })(),
-    );
-    // Tell the active service worker to take control of the page immediately.
-    self.clients.claim();
-  }
-
-  /**
-   * Handles the 'fetch' event, implementing the Cache-First strategy with
-   * complex offline and maintenance fallbacks.
-   * @param {FetchEvent} event
-   * @memberof PwaServiceWorker
-   */
-  _onFetch(event) {
-    // Only handle HTTP/HTTPS requests that are not cross-origin (optional, but robust)
-    if (event.request.url.startsWith('http')) {
-      event.respondWith(this._handleFetchRequest(event));
-    }
-  }
-
-  /**
-   * Core logic to handle fetching, caching, and fallbacks.
-   * @param {FetchEvent} event
-   * @returns {Promise<Response>}
-   * @memberof PwaServiceWorker
-   */
-  async _handleFetchRequest(event) {
-    // 1. Try Navigation Preload (if available) or network first
-    try {
-      const preloadResponse = await event.preloadResponse;
-      if (preloadResponse) return preloadResponse;
-
-      // Fall through to network request if no preload response
-      const networkResponse = await fetch(event.request);
-
-      // OPTIONAL: If the network request is successful, cache it for future use (stale-while-revalidate logic)
-      // Omitted for strict equivalence, as original only had complex fallback, not runtime caching.
-
-      return networkResponse;
-    } catch (error) {
-      console.error('Network request failed. Attempting cache/fallback logic.', event.request.url, error);
-
-      // 2. Try to match the request in the cache
+const PRE_CACHED_RESOURCES = self.renderPayload?.PRE_CACHED_RESOURCES ? self.renderPayload.PRE_CACHED_RESOURCES : [];
+const CACHE_NAME = self.renderPayload?.CACHE_NAME ? self.renderPayload.CACHE_NAME : 'app-cache';
+const PROXY_PATH = self.renderPayload?.PROXY_PATH ? self.renderPayload.PROXY_PATH : '/';
+self.addEventListener('install', (event) => {
+  // Activate right away
+  self.skipWaiting();
+
+  event.waitUntil(
+    (async () => {
+      // Open the app's cache.
+      const cache = await caches.open(CACHE_NAME);
+      // Cache all static resources.
       try {
-        const cachedResponse = await caches.match(event.request);
-        if (cachedResponse) {
-          console.log(`Cache hit for: ${event.request.url}`);
-          return cachedResponse;
-        }
-
-        // 3. Try to match a precached resource path (e.g., if requesting /page, match /page/index.html)
-        const path = this.PRE_CACHED_RESOURCES.find((p) => event.request.url.match(p.replaceAll('/index.html', '')));
-
-        if (path) {
-          const cache = await caches.open(this.CACHE_NAME);
-          const preCachedResponse = await cache.match(path);
-          if (preCachedResponse) {
-            console.log(`Matched precached resource for: ${event.request.url} via path: ${path}`);
-            return preCachedResponse;
+        await cache.addAll(PRE_CACHED_RESOURCES);
+      } catch (error) {
+        console.error(error);
+      }
+      // for (const cacheKey of PRE_CACHED_RESOURCES) {
+      //   try {
+      //     await cache.add(cacheKey);
+      //   } catch (error) {
+      //     console.error(error, cacheKey);
+      //   }
+      // }
+    })(),
+  );
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    (async () => {
+      // Enable navigation preload if it's supported.
+      // See https://developers.google.com/web/updates/2017/02/navigation-preload
+      if ('navigationPreload' in self.registration) {
+        await self.registration.navigationPreload.enable();
+      }
+    })(),
+  );
+  // Tell the active service worker to take control of the page immediately.
+  self.clients.claim();
+});
+
+self.addEventListener('fetch', (event) => {
+  // Cache-First Strategy
+  event.respondWith(
+    (async () => {
+      // First, try to use the navigation preload response if it's supported.
+      try {
+        (async () => {
+          // Get the client.
+          if (event.request.url.match(location.origin)) {
+            const client = await clients.get(event.clientId);
+            if (client)
+              client.postMessage({
+                status: 'loader',
+                path: event.request.url.slice(location.origin.length),
+              });
           }
-        }
-
-        // If neither cache match nor precache path match worked, fall through to complex fallback
-        throw new Error('Cache miss and no precache match.');
-      } catch (cacheError) {
-        console.error('Error in primary cache lookup. Falling back to offline/maintenance pages.', {
-          url: event.request.url,
-          cacheError,
-          onLine: navigator.onLine,
-        });
+        })();
+        const preloadResponse = await event.preloadResponse;
+        if (preloadResponse) return preloadResponse;
+        return await fetch(event.request);
+      } catch (error) {
+        console.error('Fetch failed; returning offline page instead.', event.request.url, error);
+        // Fallback to the offline page.
+        const path = PRE_CACHED_RESOURCES.find((path) => event.request.url.match(path.replaceAll('/index.html', '')));
 
-        // 4. Complex Fallback Logic (Offline or Maintenance)
         try {
-          const cache = await caches.open(this.CACHE_NAME);
-
-          if (!navigator.onLine) {
-            // A. OFFLINE FALLBACK
+          const cachedResponse = await caches.match(event.request);
+          if (cachedResponse) return cachedResponse;
+          const cache = await caches.open(CACHE_NAME);
+          const preCachedResponse = await cache.match(path);
+          if (!preCachedResponse) throw new Error(error.message);
+          return preCachedResponse;
+        } catch (error) {
+          console.error('Error opening cache for pre cached page', {
+            url: event.request.url,
+            error,
+            onLine: navigator.onLine,
+          });
+          try {
+            if (!navigator.onLine) {
+              if (event.request.method.toUpperCase() === 'GET') {
+                const cache = await caches.open(CACHE_NAME);
+                const preCachedResponse = await cache.match(
+                  `${PROXY_PATH === '/' ? '' : PROXY_PATH}/offline/index.html`,
+                );
+                if (!preCachedResponse) throw new Error(error.message);
+                return preCachedResponse;
+              }
+              const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+              // response.status = 200;
+              response.headers.set('Content-Type', 'application/json');
+              return response;
+            }
             if (event.request.method.toUpperCase() === 'GET') {
-              const offlinePath = `${this.PROXY_PATH === '/' ? '' : this.PROXY_PATH}/offline/index.html`;
-              const preCachedResponse = await cache.match(offlinePath);
-
-              if (!preCachedResponse) throw new Error(`Offline page not found in cache: ${offlinePath}`);
-
-              console.log('Serving offline HTML page.');
+              const cache = await caches.open(CACHE_NAME);
+              const preCachedResponse = await cache.match(
+                `${PROXY_PATH === '/' ? '' : PROXY_PATH}/maintenance/index.html`,
+              );
+              if (!preCachedResponse) throw new Error(error.message);
               return preCachedResponse;
             }
-
-            // B. OFFLINE API FALLBACK (Non-GET requests)
-            console.log('Serving offline JSON response for non-GET request.');
-            const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+            const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
+            // response.status = 200;
+            response.headers.set('Content-Type', 'application/json');
+            return response;
+          } catch (error) {
+            console.error('Error opening cache for offline page', event.request.url, error);
+            const response = new Response(JSON.stringify({ status: 'error', message: error.message }));
+            // response.status = 200;
             response.headers.set('Content-Type', 'application/json');
             return response;
           }
-
-          // C. MAINTENANCE FALLBACK (Online, but network failed - interpreted as maintenance)
-          if (event.request.method.toUpperCase() === 'GET') {
-            const maintenancePath = `${this.PROXY_PATH === '/' ? '' : this.PROXY_PATH}/maintenance/index.html`;
-            const preCachedResponse = await cache.match(maintenancePath);
-
-            if (!preCachedResponse) throw new Error(`Maintenance page not found in cache: ${maintenancePath}`);
-
-            console.log('Serving maintenance HTML page.');
-            return preCachedResponse;
-          }
-
-          // D. MAINTENANCE API FALLBACK (Non-GET requests)
-          console.log('Serving maintenance JSON response for non-GET request.');
-          const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
-          response.headers.set('Content-Type', 'application/json');
-          return response;
-        } catch (finalError) {
-          // 5. Final fail-safe response
-          console.error('Final fail-safe execution failed.', event.request.url, finalError);
-          const response = new Response(JSON.stringify({ status: 'error', message: finalError.message }));
-          response.headers.set('Content-Type', 'application/json');
-          return response;
         }
       }
-    }
-  }
-}
-
-// Instantiate and run the service worker class
-new PwaServiceWorker().run();
+    })(),
+  );
+});

package/src/index.js

@@ -36,7 +36,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.97.5';
+  static version = 'v2.98.0';
   /**
    * Repository cli API
    * @static