@underpostnet/cyberia 3.3.0 → 3.3.76

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

@@ -1231,27 +1231,6 @@ class FileExplorer {
                     { headerName: '', width: 60, cellRenderer: LoadFolderActionsRenderer },
                   ],
                   rowSelection: 'single',
-                  onSelectionChanged: (event) => {
-                    return;
-                    const selectedRows = AgGrid.grids[gridFolderId].getSelectedRows();
-                    console.log('selectedRows', { event, selectedRows });
-                    if (selectedRows[0]) {
-                      const newLocation = selectedRows[0].location;
-                      if (newLocation === location) return;
-                      location = newLocation;
-                      setPath(`${window.location.pathname}?location=${location}`);
-                      s(`.file-explorer-query-nav`).value = location;
-                      const format = FileExplorer.documentDataFormat({ document: documentInstance, location });
-                      files = format.files;
-                      folders = format.folders;
-                      applySearchFilter();
-                      currentPage = 0;
-                      displayedFiles = getPagedFiles();
-                      AgGrid.grids[gridFileId].setGridOption('rowData', displayedFiles);
-                      AgGrid.grids[gridFolderId].setGridOption('rowData', folders);
-                      updatePaginationUI();
-                    }
-                  },
                 },
               })}
             </div>

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

@@ -415,6 +415,17 @@ class Modal {
               },
               { key: `slide-menu-${idModal}` },
             );
+            // The fixed hamburger only opens the menu: it shows while the top bar is collapsed
+            // and the menu is closed. An open menu (50px or full) carries its own controls and
+            // already pushes the views aside, so neither the button nor the title padding apply.
+            const syncFixedMenuButton = () => {
+              const fixed = s(`.main-btn-menu-top-fixed-container`);
+              if (!fixed) return;
+              const collapsed = s(`.main-body-btn-ui-close`) && s(`.main-body-btn-ui-close`).classList.contains('hide');
+              const active = collapsed && Modal.Data[idModal][options.mode].width === 0;
+              fixed.classList[active ? 'remove' : 'add']('hide');
+              s('body').classList[active ? 'add' : 'remove']('main-btn-menu-top-fixed-active');
+            };
             barConfig.buttons.menu.onClick = () => {
               Modal.Data[idModal][options.mode].width = slideMenuWidth;
               s(`.btn-menu-${idModal}`).classList.add('hide');
@@ -437,6 +448,7 @@ class Modal {
               } else {
                 s(`.${idModal}`).style.left = `0px`;
               }
+              syncFixedMenuButton();
               Responsive.triggerChanged(`slide-menu-${idModal}`);
             };
             barConfig.buttons.close.onClick = () => {
@@ -460,11 +472,12 @@ class Modal {
               } else {
                 s(`.${idModal}`).style.left = `-${originSlideMenuWidth}px`;
               }
+              syncFixedMenuButton();
               Responsive.triggerChanged(`slide-menu-${idModal}`);
             };
             transition += `, width 0.3s`;
 
-            setTimeout(() => {
+            setTimeout(async () => {
               setTimeout(btnCloseEvent);
               append(
                 'body',
@@ -517,6 +530,46 @@ class Modal {
                 Modal.actionBtnCenter();
               };
 
+              // Fixed top-left hamburger, shown only while the top bar is collapsed
+              // (main-body-btn-ui-close hidden). Not needed for 'top-bottom-bar' which
+              // keeps its own center action button in the bottom bar.
+              if (
+                idModal === 'modal-menu' &&
+                options.mode !== 'slide-menu-right' &&
+                options.barMode !== 'top-bottom-bar'
+              ) {
+                append(
+                  'body',
+                  html`
+                    <div
+                      class="fix main-btn-menu-top-fixed-container hide"
+                      style="top: 0px; left: 0px; z-index: 10; height: ${originHeightTopBar}px; width: ${originHeightTopBar}px"
+                    >
+                      ${await BtnIcon.instance({
+                        style: `height: 100%`,
+                        class: `in fll main-btn-menu-top action-bar-box action-btn-center-top-fixed`,
+                        label: html`<div class="abs center">${barConfig.buttons.menu.label}</div>`,
+                      })}
+                    </div>
+                    <style>
+                      /* View modals sit at top: 0 while the top bar is collapsed; keep their
+                         title clear of the fixed hamburger. The padding eases at the same pace
+                         the views slide so the title moves once, not a jump and a slide back. */
+                      .title-main-modal {
+                        transition: padding-left 0.3s;
+                      }
+                      body.main-btn-menu-top-fixed-active .title-main-modal {
+                        padding-left: ${originHeightTopBar}px;
+                      }
+                    </style>
+                  `,
+                );
+                EventsUI.onClick(`.action-btn-center-top-fixed`, (e) => {
+                  e.preventDefault();
+                  Modal.actionBtnCenter();
+                });
+              }
+
               s(`.main-body-btn-bar-custom`).onclick = () => {
                 if (s(`.main-body-btn-ui-close`).classList.contains('hide')) {
                   s(`.main-body-btn-ui`).click();
@@ -548,6 +601,7 @@ class Modal {
                   options.heightBottomBar = 0;
                   s(`.slide-menu-top-bar`).classList.add('hide');
                   s(`.bottom-bar`).classList.add('hide');
+                  syncFixedMenuButton();
                   s(`.modal-menu`).style.top = '0px';
                   s(`.main-body-btn-container`).style.top = '50px';
                   s(`.main-body`).style.top = '0px';
@@ -563,6 +617,7 @@ class Modal {
                   s(`.main-body-btn-container`).style.top = `${options.heightTopBar + 50}px`;
                   s(`.slide-menu-top-bar`).classList.remove('hide');
                   s(`.bottom-bar`).classList.remove('hide');
+                  syncFixedMenuButton();
                   s(`.main-body`).style.top = `${options.heightTopBar}px`;
                   s(`.main-body`).style.height = `${windowGetH() - options.heightTopBar}px`;
                   for (const event of Object.keys(Modal.Data[idModal].onBarUiOpen))

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

@@ -734,7 +734,7 @@ class PanelForm {
       panelData.loading = false;
       LoadingAnimation.spinner.stop(`.panel-placeholder-bottom-${idPanel}`);
     };
-    const renderSrrPanelData = async () =>
+    const renderSSRPanelData = async () =>
       await panelRender({
         data: range(0, 0).map((i) => ({
           id: i,
@@ -827,7 +827,7 @@ class PanelForm {
           // Always reset skip to 0 when reloading (whether cid exists or not)
           PanelForm.Data[idPanel].skip = 0;
           const containerSelector = `.${options.parentIdModal ? 'html-' + options.parentIdModal : 'main-body'}`;
-          htmls(containerSelector, await renderSrrPanelData());
+          htmls(containerSelector, await renderSSRPanelData());
           await getPanelData();
           htmls(
             containerSelector,
@@ -906,10 +906,10 @@ class PanelForm {
         };
     }
     if (options.parentIdModal) {
-      htmls(`.html-${options.parentIdModal}`, await renderSrrPanelData());
+      htmls(`.html-${options.parentIdModal}`, await renderSSRPanelData());
       return '';
     }
-    return await renderSrrPanelData();
+    return await renderSSRPanelData();
   }
 }
 export { PanelForm };

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

@@ -0,0 +1,56 @@
+/**
+ * Repository identity on the client.
+ *
+ * The owner is resolved at build time by `src/server/storage/repository.js` and travels
+ * in `renderPayload.repository`. Composing every GitHub, Pages and Coveralls URL
+ * from it is what keeps a fork's links pointing at the fork instead of upstream.
+ *
+ * @module src/client/components/core/Repository.js
+ * @namespace PwaRepository
+ */
+
+/**
+ * Identity injected by the build.
+ * @returns {{owner: string, name: string, template: string, packageSuffix: string}}
+ * @memberof PwaRepository
+ */
+const repositoryIdentity = () => window.renderPayload.repository;
+
+/**
+ * Repository holding the prebuilt package and its published demo.
+ * @returns {string}
+ * @memberof PwaRepository
+ */
+const packageRepository = () => {
+  const { template, packageSuffix } = repositoryIdentity();
+  return `${template}${packageSuffix}`;
+};
+
+/**
+ * Composes a github.com URL under the resolved owner.
+ * @param {...string} segments - Path segments after the owner.
+ * @returns {string}
+ * @memberof PwaRepository
+ */
+const githubUrl = (...segments) =>
+  `https://github.com/${[repositoryIdentity().owner, ...segments].filter(Boolean).join('/')}/`;
+
+/**
+ * Composes a GitHub Pages URL under the resolved owner.
+ * @param {string} repository - Repository publishing the page.
+ * @returns {string}
+ * @memberof PwaRepository
+ */
+const githubPagesUrl = (repository) => `https://${repositoryIdentity().owner}.github.io/${repository}/`;
+
+/**
+ * Coveralls report for the engine repository this build came from.
+ * @returns {string}
+ * @memberof PwaRepository
+ */
+const coverallsUrl = () => {
+  const { owner, name } = repositoryIdentity();
+  return `https://coveralls.io/github/${owner}/${name}`;
+};
+
+export { coverallsUrl, githubPagesUrl, githubUrl, packageRepository, repositoryIdentity };

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

@@ -42,6 +42,13 @@ class Translate {
   static hasChangedListener(key) {
     return translateEvents.has(key);
   }
+  static text(keyLang, options = { disableTextFormat: false }) {
+    const translations = Translate.Data[keyLang];
+    if (!translations) return options.disableTextFormat ? keyLang : textFormatted(keyLang);
+    const lang = s('html')?.lang || 'en';
+    const value = translations[lang] ?? translations.en ?? keyLang;
+    return options.disableTextFormat ? value : textFormatted(value);
+  }
   static async emitChanged(detail) {
     await translateEvents.emit(TranslateEventType.changed, detail);
   }

package/src/client/components/core/{FullScreen.js → ViewModeController.js}

@@ -1,20 +1,20 @@
 /**
  * Utility module for fullscreen mode management with cross-browser and PWA compatibility.
  * Provides robust fullscreen detection, event handling, and UI synchronization.
- * @module src/client/components/core/FullScreen.js
- * @namespace FullScreenClient
+ * @module src/client/components/core/ViewModeController.js
+ * @namespace ViewModeControllerClient
  */
 import { Responsive } from './Responsive.js';
 import { ToggleSwitch } from './ToggleSwitch.js';
 import { Translate } from './Translate.js';
-import { checkFullScreen, fullScreenIn, fullScreenOut, s } from './VanillaJs.js';
+import { fullScreenIn, fullScreenOut, s } from './VanillaJs.js';
 /**
  * Manages fullscreen mode state, event handling, and UI synchronization.
  * Supports all major browsers and PWA/Nativefier environments with comprehensive
  * vendor-prefixed API detection.
- * @memberof FullScreenClient
+ * @memberof ViewModeControllerClient
  */
-class FullScreen {
+class ViewModeController {
   /**
    * Internal state flag tracking the intended fullscreen mode.
    * @type {boolean}
@@ -43,7 +43,7 @@ class FullScreen {
    * - Mozilla (Firefox)
    * - Microsoft (IE/Edge)
    * @private
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {boolean} True if currently in fullscreen mode, false otherwise.
    */
   static _isFullScreen() {
@@ -62,16 +62,16 @@ class FullScreen {
    * Prevents race conditions using the _syncInProgress flag.
    * Updates the toggle switch only if there's a mismatch between UI and actual state.
    * @private
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {void}
    */
   static _syncToggleState() {
-    if (FullScreen._syncInProgress) return;
-    FullScreen._syncInProgress = true;
-    const actualFullScreen = FullScreen._isFullScreen();
+    if (ViewModeController._syncInProgress) return;
+    ViewModeController._syncInProgress = true;
+    const actualFullScreen = ViewModeController._isFullScreen();
     // Only update if there's a mismatch
-    if (FullScreen._fullScreenSwitch !== actualFullScreen) {
-      FullScreen._fullScreenSwitch = actualFullScreen;
+    if (ViewModeController._fullScreenSwitch !== actualFullScreen) {
+      ViewModeController._fullScreenSwitch = actualFullScreen;
       // Update toggle switch UI if it exists
       const toggle = s('.fullscreen');
       if (toggle && ToggleSwitch.Tokens[`fullscreen`]) {
@@ -82,18 +82,18 @@ class FullScreen {
       }
     }
     setTimeout(() => {
-      FullScreen._syncInProgress = false;
+      ViewModeController._syncInProgress = false;
     }, 100);
   }
   /**
    * Event handler for fullscreen change events.
    * Triggers UI state synchronization when fullscreen mode changes.
    * @private
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {void}
    */
   static _handleFullScreenChange() {
-    FullScreen._syncToggleState();
+    ViewModeController._syncToggleState();
   }
   /**
    * Attaches all necessary event listeners for fullscreen mode detection.
@@ -103,20 +103,20 @@ class FullScreen {
    * - ESC key detection (fallback for manual fullscreen exit)
    * Only attaches listeners once to prevent duplicates.
    * @private
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {void}
    */
   static _addEventListeners() {
-    if (FullScreen._eventListenersAdded) return;
+    if (ViewModeController._eventListenersAdded) return;
     const events = ['fullscreenchange', 'webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange'];
     events.forEach((eventName) => {
-      document.addEventListener(eventName, () => FullScreen._handleFullScreenChange(), false);
+      document.addEventListener(eventName, () => ViewModeController._handleFullScreenChange(), false);
     });
     // Additional check for PWA/Nativefier window resize events
     window.addEventListener(
       'resize',
       () => {
-        setTimeout(() => FullScreen._syncToggleState(), 150);
+        setTimeout(() => ViewModeController._syncToggleState(), 150);
       },
       false,
     );
@@ -125,77 +125,80 @@ class FullScreen {
       'keydown',
       (e) => {
         if (e.key === 'Escape' || e.keyCode === 27) {
-          setTimeout(() => FullScreen._syncToggleState(), 100);
+          setTimeout(() => ViewModeController._syncToggleState(), 100);
         }
       },
       false,
     );
-    FullScreen._eventListenersAdded = true;
+    ViewModeController._eventListenersAdded = true;
   }
   /**
    * Enters fullscreen mode if not already in fullscreen.
    * Updates internal state and triggers fullscreen API.
    * Verifies the state change after a delay to ensure synchronization.
    * @private
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {void}
    */
   static _enterFullScreen() {
-    if (FullScreen._isFullScreen()) return;
-    FullScreen._fullScreenSwitch = true;
+    if (ViewModeController._isFullScreen()) return;
+    ViewModeController._fullScreenSwitch = true;
     fullScreenIn();
     // Verify after attempt
-    setTimeout(() => FullScreen._syncToggleState(), 300);
+    setTimeout(() => ViewModeController._syncToggleState(), 300);
   }
   /**
    * Exits fullscreen mode if currently in fullscreen.
    * Updates internal state and triggers fullscreen exit API.
    * Verifies the state change after a delay to ensure synchronization.
    * @private
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {void}
    */
   static _exitFullScreen() {
-    if (!FullScreen._isFullScreen()) return;
-    FullScreen._fullScreenSwitch = false;
+    if (!ViewModeController._isFullScreen()) return;
+    ViewModeController._fullScreenSwitch = false;
     fullScreenOut();
     // Verify after attempt
-    setTimeout(() => FullScreen._syncToggleState(), 300);
+    setTimeout(() => ViewModeController._syncToggleState(), 300);
   }
   /**
    * Renders the fullscreen toggle setting UI component.
    * Initializes fullscreen state detection, sets up event listeners,
    * and creates a toggle switch for user interaction.
    * Integrates with the Responsive system for dynamic updates.
-   * @memberof FullScreenClient.FullScreen
+   * @memberof ViewModeControllerClient.ViewModeController
    * @returns {Promise<string>} A promise resolving to the HTML string for the fullscreen setting component.
    */
   static async RenderSetting() {
     // Initialize state from actual fullscreen status
-    FullScreen._fullScreenSwitch = FullScreen._isFullScreen();
+    ViewModeController._fullScreenSwitch = ViewModeController._isFullScreen();
     // Setup event listeners once
-    FullScreen._addEventListeners();
+    ViewModeController._addEventListeners();
     // Update responsive event
-    Responsive.onChanged(() => {
-      FullScreen._syncToggleState();
-    }, { key: 'full-screen-settings' });
+    Responsive.onChanged(
+      () => {
+        ViewModeController._syncToggleState();
+      },
+      { key: 'full-screen-settings' },
+    );
     return html`<div class="in section-mp">
       ${await ToggleSwitch.instance({
         wrapper: true,
         wrapperLabel: html`<i class="fa-solid fa-expand"></i> ${Translate.instance('fullscreen')}`,
         id: 'fullscreen',
         disabledOnClick: true,
-        checked: FullScreen._fullScreenSwitch,
+        checked: ViewModeController._fullScreenSwitch,
         on: {
           unchecked: () => {
-            FullScreen._exitFullScreen();
+            ViewModeController._exitFullScreen();
           },
           checked: () => {
-            FullScreen._enterFullScreen();
+            ViewModeController._enterFullScreen();
           },
         },
       })}
     </div>`;
   }
 }
-export { FullScreen };
+export { ViewModeController };

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

@@ -1,5 +1,4 @@
 import { CryptoService } from '../../services/crypto/crypto.service.js';
-import { UserService } from '../../services/user/user.service.js';
 import { Auth } from './Auth.js';
 import { BtnIcon } from './BtnIcon.js';
 import { getId } from './CommonJs.js';
@@ -21,16 +20,6 @@ class Wallet {
           hash: 'SHA-256',
         };
         const format = 'jwk';
-        (async () => {
-          return;
-          const { data: payload } = await UserService.get({ id: 'public-key-sign-token' });
-          const signature = await window.crypto.subtle.sign(
-            algorithm,
-            keyPair.privateKey,
-            new TextEncoder().encode(payload),
-          );
-          const base64Signature = btoa(String.fromCharCode(...new Uint8Array(signature)));
-        })();
         const keyPair = await window.crypto.subtle.generateKey(algorithm, true, ['sign', 'verify']);
         const privateKey = await window.crypto.subtle.exportKey(format, keyPair.privateKey);
         const publicKey = await window.crypto.subtle.exportKey(format, keyPair.publicKey);

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

@@ -150,7 +150,13 @@ class PwaWorker {
     }
     const run = async () => {
       const registration = await this.getRegistration();
-      if (!registration) await this.register();
+      if (registration) {
+        try {
+          await registration.update();
+        } catch (error) {
+          logger.error('Error updating service worker:', error);
+        }
+      } else await this.register();
     };
     if (document.readyState === 'complete') run();
     else window.addEventListener('load', run, { once: true });

package/src/client/components/cryptokoyn/SettingsCryptokoyn.js

@@ -1,11 +1,11 @@
 import { Css } from '../core/Css.js';
-import { FullScreen } from '../core/FullScreen.js';
+import { ViewModeController } from '../core/ViewModeController.js';
 import { Translate } from '../core/Translate.js';
 import { Worker } from '../core/Worker.js';
 
 class SettingsCryptokoyn {
   static async instance() {
-    let render = await FullScreen.RenderSetting();
+    let render = await ViewModeController.RenderSetting();
     render += await Css.RenderSetting();
     render += await Translate.RenderSetting();
     render += await Worker.RenderSetting();

package/src/client/components/cyberia/ActionEngineCyberia.js

@@ -13,7 +13,7 @@ import { CyberiaQuestService } from '../../services/cyberia-quest/cyberia-quest.
 import { CyberiaActionService } from '../../services/cyberia-action/cyberia-action.service.js';
 import { CyberiaDialogueService } from '../../services/cyberia-dialogue/cyberia-dialogue.service.js';
 import { CyberiaSkillService } from '../../services/cyberia-skill/cyberia-skill.service.js';
-import { QUEST_STEPS_TYPES, getDefaultCyberiaItemById, SKILL_LOGIC_IDS } from './SharedDefaultsCyberia.js';
+import { QUEST_STEPS_TYPES, SKILL_LOGIC_IDS } from './SharedDefaultsCyberia.js';
 
 const textFilter = (filter) => ({ filterType: 'text', type: 'equals', filter });
 // DropDown invokes optionData.onClick on selection, so every option (including
@@ -90,8 +90,8 @@ class ActionEngineCyberia {
       containerClass: 'inl',
       serviceProvider: async (q) => {
         const result = await ObjectLayerService.searchItemIds({ q });
-        if (result.status === 'success' && result.data?.itemIds) {
-          return result.data.itemIds.map((itemId) => dropdownOption(itemId));
+        if (result.status === 'success' && result.data?.items) {
+          return result.data.items.map(({ id }) => dropdownOption(id));
         }
         return [];
       },
@@ -139,40 +139,16 @@ class ActionEngineCyberia {
     if (ActionEngineCyberia.imageCache[itemId]) return;
     ActionEngineCyberia.imageCache[itemId] = { img: null, loaded: false, error: false };
 
-    const loadImage = (type, id) => {
-      const img = new Image();
-      img.onload = () => {
-        ActionEngineCyberia.imageCache[itemId].img = img;
-        ActionEngineCyberia.imageCache[itemId].loaded = true;
-        if (onLoad) onLoad();
-      };
-      img.onerror = () => {
-        ActionEngineCyberia.imageCache[itemId].error = true;
-      };
-      img.src = `${getProxyPath()}assets/${type}/${id}/08/0.png`;
+    const img = new Image();
+    img.onload = () => {
+      ActionEngineCyberia.imageCache[itemId].img = img;
+      ActionEngineCyberia.imageCache[itemId].loaded = true;
+      if (onLoad) onLoad();
     };
-
-    const sharedItem = getDefaultCyberiaItemById(itemId)?.item;
-    if (sharedItem?.type && sharedItem?.id) {
-      loadImage(sharedItem.type, sharedItem.id);
-      return;
-    }
-
-    ObjectLayerService.get({
-      limit: 1,
-      filterModel: { 'data.item.id': { filterType: 'text', type: 'equals', filter: itemId } },
-    })
-      .then((res) => {
-        const doc = res?.data?.data?.[0];
-        if (!doc || !doc.data?.item?.type || !doc.data?.item?.id) {
-          ActionEngineCyberia.imageCache[itemId].error = true;
-          return;
-        }
-        loadImage(doc.data.item.type, doc.data.item.id);
-      })
-      .catch(() => {
-        ActionEngineCyberia.imageCache[itemId].error = true;
-      });
+    img.onerror = () => {
+      ActionEngineCyberia.imageCache[itemId].error = true;
+    };
+    img.src = `${getProxyPath()}api/atlas-sprite-sheet/idle-preview/${itemId}`;
   }
 
   static preloadMapObjectLayers(onLoad) {