@fleetbase/ember-core 0.1.4 → 0.1.6

package/addon/services/loader.js

@@ -2,31 +2,55 @@ import Service from '@ember/service';
 import { tracked } from '@glimmer/tracking';
 import { later } from '@ember/runloop';
 
+/**
+ * Service for managing loading overlays.
+ *
+ * @class LoaderService
+ * @extends Service
+ */
 export default class LoaderService extends Service {
+    /**
+     * Tracks the routes that have been loaded.
+     *
+     * @type {Array}
+     * @tracked
+     */
     @tracked routesLoaded = [];
 
+    /**
+     * Shows the loader based on a condition.
+     *
+     * @param {String|HTMLElement} target - The loader target.
+     * @param {Object} options - Options for controlling the loader.
+     * @param {Function|null} condition - The condition to evaluate.
+     */
     showOnCondition(target, options = {}, condition = null) {
-        const { loadingMessage, opacity } = options;
-
         if (typeof condition === 'function') {
             condition = condition();
         }
 
         if (condition) {
-            this.showLoader(target, loadingMessage, opacity);
+            this.showLoader(target, options);
         }
     }
 
-    showOnInitialTransition(transition, target, loadingMessage = 'Loading...', opacity = 0.1) {
+    /**
+     * Shows loader during the initial route transition.
+     *
+     * @param {Object} transition - The Ember.js transition object.
+     * @param {String|HTMLElement} target - The loader target.
+     * @param {Object} options - Options for controlling the loader.
+     */
+    showOnInitialTransition(transition, target, options = { loadingMessage: 'Loading...', opacity: 0.1 }) {
         const route = transition.to.name;
         const isSameRoute = transition.from ? transition.to.name === transition.from.name : false;
 
         if (!this.routesLoaded.includes(route) || !isSameRoute) {
-            if (document.querySelectorAll(`.overloader`).length > 0) {
+            if (document.querySelectorAll('.overloader').length > 0) {
                 return;
             }
 
-            this.showLoader(target, loadingMessage, opacity);
+            this.showLoader(target, options);
 
             transition.finally(() => {
                 this.removeLoader(target);
@@ -39,20 +63,25 @@ export default class LoaderService extends Service {
     /**
      * Creates an HTML element node for a loading overlay with a message.
      *
-     * @param {String|HTMLElement} targetSelector
-     * @param {String} loadingMessage
-     * @return {HTMLElement} loader
+     * @param {String|HTMLElement} targetSelector - The loader target.
+     * @param {Object} options - Options for controlling the loader.
+     * @returns {HTMLElement} - The loader element.
      */
-    showLoader(targetSelector, loadingMessage = 'Loading...', opacity = 0.1) {
+    showLoader(targetSelector, options = {}) {
         let target = typeof targetSelector === 'string' ? document.querySelector(targetSelector) : targetSelector;
 
         if (!target) {
             target = document.body;
         }
 
+        const loadingMessage = typeof options.loadingMessage === 'string' ? options.loadingMessage : 'Loading...';
+        const opacity = typeof options.opacity === 'number' ? options.opacity : 0.1;
         const isDarkMode = document.body.dataset.theme ? document.body.dataset.theme === 'dark' : true;
+        const preserveTargetPosition = options.preserveTargetPosition === true;
 
-        target.style.position = 'relative';
+        if (!preserveTargetPosition) {
+            target.style.position = 'relative';
+        }
 
         let loader = document.createElement('div');
         loader.classList.add('overloader');
@@ -71,15 +100,21 @@ export default class LoaderService extends Service {
         return loader;
     }
 
-    show(loadingMessage = 'Loading...', opacity = 0.1) {
-        return this.showLoader(document.body, loadingMessage, opacity);
+    /**
+     * Shows a loader on the document body.
+     *
+     * @param {Object} options - Options for controlling the loader.
+     * @returns {HTMLElement} - The loader element.
+     */
+    show(options = { loadingMessage: 'Loading...', opacity: 0.1 }) {
+        return this.showLoader(document.body, options);
     }
 
     /**
-     * Creates an HTML element node for a loading overlay with a message.
+     * Removes a loader from a target.
      *
-     * @param {String|HTMLElement} targetSelector
-     * @return {Service} this
+     * @param {String|HTMLElement} targetSelector - The loader target.
+     * @returns {Service} - The current service instance.
      */
     removeLoader(targetSelector) {
         let target = typeof targetSelector === 'string' ? document.querySelector(targetSelector) : targetSelector;
@@ -114,9 +149,10 @@ export default class LoaderService extends Service {
     }
 
     /**
-     * Removes the all loader instances.
+     * Removes all loader instances after a delay.
      *
-     * @return {Service} this
+     * @param {Number} delay - The delay in milliseconds.
+     * @returns {Service} - The current service instance.
      */
     remove(delay = 0) {
         const loaders = document.querySelectorAll(`.overloader`);

package/addon/services/universe.js

@@ -140,6 +140,19 @@ export default class UniverseService extends Service.extend(Evented) {
         return this;
     }
 
+    /**
+     * Triggers an event on for a universe registry.
+     *
+     * @memberof UniverseService
+     * @method createRegistryEvent
+     * @param {string} registryName - The name of the registry to trigger the event on.
+     * @param {string} event - The name of the event to trigger.
+     * @param {...*} params - Additional parameters to pass to the event handler.
+     */
+    @action createRegistryEvent(registryName, event, ...params) {
+        this.trigger(`${registryName}.${event}`, ...params);
+    }
+
     /**
      * @action
      * Retrieves the entire registry with the given name.
@@ -434,6 +447,14 @@ export default class UniverseService extends Service.extend(Evented) {
         // create menu item
         const menuItem = this._createMenuItem(title, route, options);
 
+        // register menu item
+        if (!this[internalRegistryName]) {
+            this[internalRegistryName] = {
+                menuItems: [],
+                menuPanels: [],
+            };
+        }
+
         // register menu item
         this[internalRegistryName].menuItems.pushObject(menuItem);
 
@@ -638,15 +659,9 @@ export default class UniverseService extends Service.extend(Evented) {
             view,
             index,
             section,
+            onClick,
         };
 
-        // send default params into onClick
-        if (typeof onClick === 'function') {
-            menuItem.onClick = () => {
-                return onClick(menuItem);
-            };
-        }
-
         return menuItem;
     }
 
@@ -679,6 +694,55 @@ export default class UniverseService extends Service.extend(Evented) {
         }
     }
 
+    /**
+     * Manually registers a service in a specified engine.
+     *
+     * @method registerComponentInEngine
+     * @public
+     * @memberof UniverseService
+     * @param {String} engineName - The name of the engine where the component should be registered.
+     * @param {Object} serviceClass - The service class to register, which should have a 'name' property.
+     */
+    registerServiceInEngine(targetEngineName, serviceName, currentEngineInstance) {
+        // Get the target engine instance
+        const targetEngineInstance = this.getEngineInstance(targetEngineName);
+
+        // Validate inputs
+        if (targetEngineInstance && currentEngineInstance && typeof serviceName === 'string') {
+            // Lookup the service instance from the current engine
+            const sharedService = currentEngineInstance.lookup(`service:${serviceName}`);
+
+            if (sharedService) {
+                // Register the service in the target engine
+                targetEngineInstance.register(`service:${serviceName}`, sharedService, { instantiate: false });
+            }
+        }
+    }
+
+    /**
+     * Retrieves a service instance from a specified Ember engine.
+     *
+     * @param {string} engineName - The name of the engine from which to retrieve the service.
+     * @param {string} serviceName - The name of the service to retrieve.
+     * @returns {Object|null} The service instance if found, otherwise null.
+     *
+     * @example
+     * const userService = universe.getServiceFromEngine('user-engine', 'user');
+     * if (userService) {
+     *   userService.doSomething();
+     * }
+     */
+    getServiceFromEngine(engineName, serviceName) {
+        const engineInstance = this.getEngineInstance(engineName);
+
+        if (engineInstance && typeof serviceName === 'string') {
+            const serviceInstance = engineInstance.lookup(`service:${serviceName}`);
+            return serviceInstance;
+        }
+
+        return null;
+    }
+
     /**
      * Load the specified engine. If it is not loaded yet, it will use assetLoader
      * to load it and then register it to the router.

package/addon/utils/auto-serialize.js

@@ -90,7 +90,7 @@ export default function autoSerialize(model, except = []) {
         }
 
         if (kind === 'hasMany') {
-            serialized[attr] = model[attr].toArray().map((instance) => serialize(instance));
+            serialized[attr] = [];
         } else {
             serialized[attr] = serialize(model[attr]);
         }

package/addon/utils/inject-engine-service.js

@@ -0,0 +1,15 @@
+import { getOwner } from '@ember/application';
+
+export default function injectEngineService(target, engineName, serviceName, key = null) {
+    const owner = getOwner(target);
+    const universe = owner.lookup('service:universe');
+    const service = universe.getServiceFromEngine(engineName, serviceName);
+    const effectiveServiceName = key || serviceName;
+
+    Object.defineProperty(target, effectiveServiceName, {
+        value: service,
+        writable: false,
+        configurable: true,
+        enumerable: true,
+    });
+}

package/app/utils/inject-engine-service.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/inject-engine-service';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/ember-core",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
     "keywords": [
         "fleetbase-core",