@fleetbase/ember-core 0.1.7 → 0.1.9

package/README.md

@@ -4,9 +4,9 @@ Ember Core Services, Utilities and Framework for building Fleetbase Extensions i
 
 ## Compatibility
 
-* Ember.js v3.24 or above
-* Ember CLI v3.24 or above
-* Node.js v14 or above
+* Ember.js v4.8 or above
+* Ember CLI v4.8 or above
+* Node.js v18 or above
 
 ## Installation
 

package/addon/adapters/application.js

@@ -1,4 +1,5 @@
 import RESTAdapter from '@ember-data/adapter/rest';
+import AdapterError from '@ember-data/adapter/error';
 import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
 import { storageFor } from 'ember-local-storage';
@@ -145,4 +146,27 @@ export default class ApplicationAdapter extends RESTAdapter {
     pathForType(type) {
         return dasherize(pluralize(type));
     }
+
+    /**
+     * Handles the response from an AJAX request in an Ember application.
+     *
+     * @param {number} status - The HTTP status code of the response.
+     * @param {object} headers - The headers of the response.
+     * @param {object} payload - The payload of the response.
+     * @return {Object | AdapterError} response - Returns a new `AdapterError` instance with detailed error information if the response is invalid; otherwise, it returns the result of the superclass's `handleResponse` method.
+     *
+     * This method first normalizes the error response and generates a detailed message.
+     * It then checks if the response is invalid based on the status code. If invalid, it constructs an `AdapterError` with the normalized errors and detailed message.
+     * For valid responses, it delegates the handling to the superclass's `handleResponse` method.
+     */
+    handleResponse(status, headers, payload) {
+        let errors = this.normalizeErrorResponse(status, headers, payload);
+        let detailedMessage = this.generatedDetailedMessage(...arguments);
+
+        if (this.isInvalid(status, headers, payload)) {
+            return new AdapterError(errors, detailedMessage);
+        }
+
+        return super.handleResponse(...arguments);
+    }
 }

package/addon/services/crud.js

@@ -1,12 +1,13 @@
 import Service from '@ember/service';
 import { inject as service } from '@ember/service';
-import { action } from '@ember/object';
+import { action, get } from '@ember/object';
 import { isArray } from '@ember/array';
 import { dasherize } from '@ember/string';
 import { later } from '@ember/runloop';
 import { pluralize } from 'ember-inflector';
 import { format as formatDate } from 'date-fns';
 import getModelName from '../utils/get-model-name';
+import getWithDefault from '../utils/get-with-default';
 import humanize from '../utils/humanize';
 import first from '../utils/first';
 
@@ -47,7 +48,7 @@ export default class CrudService extends Service {
      * @void
      */
     @action delete(model, options = {}) {
-        const modelName = getModelName(model, options?.modelName, { humanize: true, capitalizeWords: true });
+        const modelName = getModelName(model, get(options, 'modelName'), { humanize: true, capitalizeWords: true });
 
         this.modalsManager.confirm({
             title: `Are you sure to delete this ${modelName}?`,
@@ -98,7 +99,7 @@ export default class CrudService extends Service {
         }
 
         const firstModel = first(selected);
-        const modelName = getModelName(firstModel, options?.modelName, { humanize: true, capitalizeWords: true });
+        const modelName = getModelName(firstModel, get(options, 'modelName'), { humanize: true, capitalizeWords: true });
 
         // make sure all are the same type
         selected = selected.filter((m) => getModelName(m) === getModelName(firstModel));
@@ -126,9 +127,11 @@ export default class CrudService extends Service {
         }
 
         const firstModel = first(selected);
-        const modelName = getModelName(firstModel, options?.modelName, { humanize: true, capitalizeWords: true });
+        const modelName = getModelName(firstModel, get(options, 'modelName'), { humanize: true, capitalizeWords: true });
         const count = selected.length;
         const actionMethod = (typeof options.actionMethod === 'string' ? options.actionMethod : `POST`).toLowerCase();
+        const fetchParams = getWithDefault(options, 'fetchParams', {});
+        const fetchOptions = getWithDefault(options, 'fetchOptions', {});
 
         this.modalsManager.show('modals/bulk-action-model', {
             title: `Bulk ${verb} ${pluralize(modelName)}`,
@@ -152,9 +155,14 @@ export default class CrudService extends Service {
 
                 modal.startLoading();
 
-                return this.fetch[actionMethod](options.actionPath, {
-                    ids: selected.map((model) => model.id),
-                })
+                return this.fetch[actionMethod](
+                    options.actionPath,
+                    {
+                        ids: selected.map((model) => model.id),
+                        ...fetchParams,
+                    },
+                    fetchOptions
+                )
                     .then((response) => {
                         this.notifications.success(response.message ?? options.successNotification ?? `${count} ${pluralize(modelName, count)} were updated successfully.`);
 

package/addon/services/fetch.js

@@ -5,7 +5,6 @@ import { get, set } from '@ember/object';
 import { isBlank } from '@ember/utils';
 import { dasherize } from '@ember/string';
 import { isArray } from '@ember/array';
-import { assign } from '@ember/polyfills';
 import { singularize, pluralize } from 'ember-inflector';
 import { task } from 'ember-concurrency';
 import { storageFor } from 'ember-local-storage';
@@ -256,7 +255,7 @@ export default class FetchService extends Service {
      * @return {Promise}
      */
     request(path, method = 'GET', data = {}, options = {}) {
-        const headers = assign(this.getHeaders(), options.headers ?? {});
+        const headers = Object.assign(this.getHeaders(), options.headers ?? {});
         const host = options.host ?? this.host;
         const namespace = options.namespace ?? this.namespace;
         const url = options.externalRequest === true ? path : [host, namespace, path].filter(Boolean).join('/');
@@ -525,6 +524,12 @@ export default class FetchService extends Service {
         const { queue } = file;
         const headers = this.getHeaders();
 
+        // make sure this task runs once for this file in correct state
+        // this can occur when the task is called twice when upload button exists inside upload dropzone
+        if (['queued', 'failed', 'timed_out', 'aborted'].indexOf(file.state) === -1) {
+            return;
+        }
+
         // remove Content-Type header
         delete headers['Content-Type'];
 
@@ -540,7 +545,7 @@ export default class FetchService extends Service {
                 })
                 .then((response) => response.json())
                 .catch((error) => {
-                    this.notifications.serverError(error, `Upload failed.`);
+                    this.notifications.serverError(error, 'File upload failed.');
                 });
 
             const model = this.store.push(this.store.normalize('file', upload.file));
@@ -553,7 +558,7 @@ export default class FetchService extends Service {
             return model;
         } catch (error) {
             queue.remove(file);
-            this.notifications.serverError(error, `Upload failed.`);
+            this.notifications.serverError(error, 'File upload failed.');
 
             if (typeof errorCallback === 'function') {
                 errorCallback(error);
@@ -574,7 +579,7 @@ export default class FetchService extends Service {
      * @return {Promise}
      */
     download(path, query = {}, options = {}) {
-        const headers = assign(this.getHeaders(), options.headers ?? {});
+        const headers = Object.assign(this.getHeaders(), options.headers ?? {});
 
         return new Promise((resolve, reject) => {
             return fetch(`${options.host || this.host}/${options.namespace || this.namespace}/${path}?${!isBlank(query) ? new URLSearchParams(query).toString() : ''}`, {

package/addon/services/universe.js

@@ -4,7 +4,7 @@ import { tracked } from '@glimmer/tracking';
 import { inject as service } from '@ember/service';
 import { computed, action } from '@ember/object';
 import { isBlank } from '@ember/utils';
-import { isArray } from '@ember/array';
+import { A, isArray } from '@ember/array';
 import { later } from '@ember/runloop';
 import { dasherize, camelize } from '@ember/string';
 import { getOwner } from '@ember/application';
@@ -14,20 +14,20 @@ import RSVP from 'rsvp';
 export default class UniverseService extends Service.extend(Evented) {
     @service router;
     @service intl;
-    @tracked headerMenuItems = [];
-    @tracked organizationMenuItems = [];
-    @tracked userMenuItems = [];
+    @tracked headerMenuItems = A([]);
+    @tracked organizationMenuItems = A([]);
+    @tracked userMenuItems = A([]);
     @tracked adminRegistry = {
-        menuItems: [],
-        menuPanels: [],
+        menuItems: A([]),
+        menuPanels: A([]),
     };
     @tracked accountRegistry = {
-        menuItems: [],
-        menuPanels: [],
+        menuItems: A([]),
+        menuPanels: A([]),
     };
     @tracked settingsRegistry = {
-        menuItems: [],
-        menuPanels: [],
+        menuItems: A([]),
+        menuPanels: A([]),
     };
 
     /**
@@ -82,6 +82,130 @@ export default class UniverseService extends Service.extend(Evented) {
         return this.settingsRegistry.menuPanels;
     }
 
+    /**
+     * Transitions to a given route within a specified Ember engine.
+     *
+     * This action dynamically retrieves the specified engine's instance and its configuration to prepend the
+     * engine's route prefix to the provided route. If the engine instance or its route prefix is not found,
+     * it falls back to transitioning to the route without the prefix.
+     *
+     * @param {string} engineName - The name of the Ember engine.
+     * @param {string} route - The route to transition to within the engine.
+     * @param {...any} args - Additional arguments to pass to the router's transitionTo method.
+     * @returns {Promise} A Promise that resolves with the result of the router's transitionTo method.
+     *
+     * @example
+     * // Transitions to the 'management.fleets.index.new' route within the '@fleetbase/fleet-ops' engine.
+     * this.transitionToEngineRoute('@fleetbase/fleet-ops', 'management.fleets.index.new');
+     */
+    @action transitionToEngineRoute(engineName, route, ...args) {
+        const engineInstance = this.getEngineInstance(engineName);
+
+        if (engineInstance) {
+            const config = engineInstance.resolveRegistration('config:environment');
+
+            if (config) {
+                let mountedEngineRoutePrefix = config.mountedEngineRoutePrefix;
+
+                if (!mountedEngineRoutePrefix) {
+                    mountedEngineRoutePrefix = this._mountPathFromEngineName(engineName);
+                }
+
+                if (!mountedEngineRoutePrefix.endsWith('.')) {
+                    mountedEngineRoutePrefix = mountedEngineRoutePrefix + '.';
+                }
+
+                return this.router.transitionTo(`${mountedEngineRoutePrefix}${route}`, ...args);
+            }
+        }
+
+        return this.router.transitionTo(route, ...args);
+    }
+
+    /**
+     * Retrieves the mount point of a specified engine by its name.
+    
+     * @param {string} engineName - The name of the engine for which to get the mount point.
+     * @returns {string|null} The mount point of the engine or null if not found.
+     */
+    getEngineMountPoint(engineName) {
+        const engineInstance = this.getEngineInstance(engineName);
+        return this._getMountPointFromEngineInstance(engineInstance);
+    }
+
+    /**
+     * Determines the mount point from an engine instance by reading its configuration.
+
+     * @param {object} engineInstance - The instance of the engine.
+     * @returns {string|null} The resolved mount point or null if the instance is undefined or the configuration is not set.
+     * @private
+     */
+    _getMountPointFromEngineInstance(engineInstance) {
+        if (engineInstance) {
+            const config = engineInstance.resolveRegistration('config:environment');
+
+            if (config) {
+                let engineName = config.modulePrefix;
+                let mountedEngineRoutePrefix = config.mountedEngineRoutePrefix;
+
+                if (!mountedEngineRoutePrefix) {
+                    mountedEngineRoutePrefix = this._mountPathFromEngineName(engineName);
+                }
+
+                if (!mountedEngineRoutePrefix.endsWith('.')) {
+                    mountedEngineRoutePrefix = mountedEngineRoutePrefix + '.';
+                }
+
+                return mountedEngineRoutePrefix;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Extracts and formats the mount path from a given engine name.
+     *
+     * This function takes an engine name in the format '@scope/engine-name',
+     * extracts the 'engine-name' part, removes the '-engine' suffix if present,
+     * and formats it into a string that represents a console path.
+     *
+     * @param {string} engineName - The full name of the engine, typically in the format '@scope/engine-name'.
+     * @returns {string} A string representing the console path derived from the engine name.
+     * @example
+     * // returns 'console.some'
+     * _mountPathFromEngineName('@fleetbase/some-engine');
+     */
+    _mountPathFromEngineName(engineName) {
+        let engineNameSegments = engineName.split('/');
+        let mountName = engineNameSegments[1];
+
+        if (typeof mountName !== 'string') {
+            mountName = engineNameSegments[0];
+        }
+
+        const mountPath = mountName.replace('-engine', '');
+        return `console.${mountPath}`;
+    }
+
+    /**
+     * Refreshes the current route.
+     *
+     * This action is a simple wrapper around the router's refresh method. It can be used to re-run the
+     * model hooks and reset the controller properties on the current route, effectively reloading the route.
+     * This is particularly useful in scenarios where the route needs to be reloaded due to changes in
+     * state or data.
+     *
+     * @returns {Promise} A Promise that resolves with the result of the router's refresh method.
+     *
+     * @example
+     * // To refresh the current route
+     * this.refreshRoute();
+     */
+    @action refreshRoute() {
+        return this.router.refresh();
+    }
+
     /**
      * Action to transition to a specified route based on the provided menu item.
      *
@@ -756,7 +880,7 @@ export default class UniverseService extends Service.extend(Evented) {
     loadEngine(name) {
         const router = getOwner(this).lookup('router:main');
         const instanceId = 'manual'; // Arbitrary instance id, should be unique per engine
-        const mountPoint = null; // No mount point for manually loaded engines
+        const mountPoint = this._mountPathFromEngineName(name); // No mount point for manually loaded engines
 
         if (!router._enginePromises[name]) {
             router._enginePromises[name] = Object.create(null);
@@ -805,7 +929,6 @@ export default class UniverseService extends Service.extend(Evented) {
         assert("You attempted to load the engine '" + name + "', but the engine cannot be found.", owner.hasRegistration(`engine:${name}`));
 
         let engineInstances = owner.lookup('router:main')._engineInstances;
-
         if (!engineInstances[name]) {
             engineInstances[name] = Object.create(null);
         }
@@ -815,6 +938,18 @@ export default class UniverseService extends Service.extend(Evented) {
             mountPoint,
         });
 
+        // correct mountPoint using engine instance
+        let _mountPoint = this._getMountPointFromEngineInstance(engineInstance);
+        if (_mountPoint) {
+            engineInstance.mountPoint = _mountPoint;
+        }
+
+        // make sure to set dependencies from base instance
+        if (engineInstance.base) {
+            engineInstance.dependencies = this._setupEngineParentDependenciesBeforeBoot(engineInstance.base.dependencies);
+        }
+
+        // store loaded instance to engineInstances for booting
         engineInstances[name][instanceId] = engineInstance;
 
         return engineInstance.boot().then(() => {
@@ -822,6 +957,44 @@ export default class UniverseService extends Service.extend(Evented) {
         });
     }
 
+    _setupEngineParentDependenciesBeforeBoot(baseDependencies = {}) {
+        const dependencies = { ...baseDependencies };
+
+        // fix services
+        const servicesObject = {};
+        if (isArray(dependencies.services)) {
+            for (let i = 0; i < dependencies.services.length; i++) {
+                const service = dependencies.services.objectAt(i);
+
+                if (typeof service === 'object') {
+                    Object.assign(servicesObject, service);
+                    continue;
+                }
+
+                servicesObject[service] = service;
+            }
+        }
+
+        // fix external routes
+        const externalRoutesObject = {};
+        if (isArray(dependencies.externalRoutes)) {
+            for (let i = 0; i < dependencies.externalRoutes.length; i++) {
+                const externalRoute = dependencies.externalRoutes.objectAt(i);
+
+                if (typeof externalRoute === 'object') {
+                    Object.assign(externalRoutesObject, externalRoute);
+                    continue;
+                }
+
+                externalRoutesObject[externalRoute] = externalRoute;
+            }
+        }
+
+        dependencies.externalRoutes = externalRoutesObject;
+        dependencies.services = servicesObject;
+        return dependencies;
+    }
+
     /**
      * Retrieve an existing engine instance by its name and instanceId.
      *

package/addon/utils/array-unique-by.js

@@ -0,0 +1,8 @@
+export default function arrayUniqueBy(arr, key) {
+    return arr.reduce((unique, item) => {
+        if (!unique.some((existingItem) => existingItem[key] === item[key])) {
+            unique.push(item);
+        }
+        return unique;
+    }, []);
+}

package/addon/utils/get-mounted-engine-route-prefix.js

@@ -0,0 +1,8 @@
+export default function getMountedEngineRoutePrefix(defaultName, fleetbase = {}) {
+    let mountedEngineRoutePrefix = defaultName;
+    if (fleetbase && typeof fleetbase.route === 'string') {
+        mountedEngineRoutePrefix = fleetbase.route;
+    }
+
+    return `console.${mountedEngineRoutePrefix}.`;
+}

package/addon/utils/get-resource-name-from-transition.js

@@ -0,0 +1,12 @@
+export default function getResourceNameFromTransition(transition) {
+    const { to } = transition;
+
+    if (typeof to.name === 'string') {
+        let routePathSegments = to.name.split('.');
+        let resourceName = routePathSegments[3];
+
+        return resourceName;
+    }
+
+    return null;
+}

package/addon/utils/is-nested-route-transition.js

@@ -0,0 +1,11 @@
+import { get } from '@ember/object';
+
+export default function isNestedRouteTransition(transition) {
+    const toRoute = get(transition, 'to.name');
+    const fromRouteParent = get(transition, 'from.parent.name');
+    const toRouteParent = get(transition, 'to.parent.name');
+    const isNested = toRoute.startsWith(fromRouteParent);
+    const isMatchingParents = fromRouteParent && toRouteParent && fromRouteParent === toRouteParent;
+
+    return isNested || isMatchingParents;
+}

package/addon/utils/is-object.js

@@ -1,3 +1,3 @@
 export default function isObject(obj) {
-    return typeof obj === 'object';
+    return obj && typeof obj === 'object' && Object.prototype.toString.call(obj) === '[object Object]';
 }

package/addon/utils/map-engines.js

@@ -1,9 +1,19 @@
 import { dasherize } from '@ember/string';
 import hostServices from '../exports/host-services';
 
-function routeNameFromExtension(extension) {
-    const mountName = extension.name.split('/')[1];
-    const mountPath = mountName.replace('-engine', '');
+export function getExtensionMountPath(extensionName) {
+    let extensionNameSegments = extensionName.split('/');
+    let mountName = extensionNameSegments[1];
+
+    if (typeof mountName !== 'string') {
+        mountName = extensionNameSegments[0];
+    }
+
+    return mountName.replace('-engine', '');
+}
+
+export function routeNameFromExtension(extension) {
+    const mountPath = getExtensionMountPath(extension.name);
     let route = mountPath;
 
     if (extension.fleetbase && extension.fleetbase.route) {
@@ -18,6 +28,7 @@ export default function mapEngines(extensions, withServices = []) {
     const externalRoutes = {
         console: 'console.home',
         extensions: 'console.extensions',
+        notifications: 'console.notifications',
     };
 
     for (let i = 0; i < extensions.length; i++) {

package/addon/utils/set-component-arg.js

@@ -0,0 +1,9 @@
+import { set } from '@ember/object';
+
+export default function setComponentArg(component, property, value) {
+    if (value !== undefined) {
+        set(component, property, value);
+    }
+
+    return component;
+}

package/app/utils/array-unique-by.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/array-unique-by';

package/app/utils/get-mounted-engine-route-prefix.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/get-mounted-engine-route-prefix';

package/app/utils/get-resource-name-from-transition.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/get-resource-name-from-transition';

package/app/utils/is-nested-route-transition.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/is-nested-route-transition';

package/app/utils/set-component-arg.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/ember-core/utils/set-component-arg';

package/index.js

@@ -21,6 +21,16 @@ module.exports = {
                 useSessionSetupMethod: true,
             };
         }
+
+        if (app.options['ember-cli-notifications'] !== undefined) {
+            app.options['ember-cli-notifications'].autoClear = true;
+            app.options['ember-cli-notifications'].clearDuration = 1000 * 5;
+        } else {
+            app.options['ember-cli-notifications'] = {
+                autoClear: true,
+                clearDuration: 1000 * 5,
+            };
+        }
     },
 
     treeForPublic: function () {

package/package.json

@@ -1,121 +1,127 @@
 {
-    "name": "@fleetbase/ember-core",
-    "version": "0.1.7",
-    "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
-    "keywords": [
-        "fleetbase-core",
-        "fleetbase-services",
-        "fleetbase",
-        "ember-addon"
-    ],
-    "repository": "https://github.com/fleetbase/ember-core",
-    "license": "MIT",
-    "author": "Fleetbase Pte Ltd <hello@fleetbase.io>",
-    "directories": {
-        "app": "app",
-        "addon": "addon",
-        "tests": "tests"
-    },
-    "scripts": {
-        "build": "ember build --environment=production",
-        "lint": "npm-run-all --aggregate-output --continue-on-error --parallel \"lint:!(fix)\"",
-        "lint:fix": "npm-run-all --aggregate-output --continue-on-error --parallel lint:*:fix",
-        "lint:hbs": "ember-template-lint .",
-        "lint:hbs:fix": "ember-template-lint . --fix",
-        "lint:js": "eslint . --cache",
-        "lint:js:fix": "eslint . --fix",
-        "start": "ember serve",
-        "test": "npm-run-all lint test:*",
-        "test:ember": "ember test",
-        "test:ember-compatibility": "ember try:each",
-        "publish:npm": "npm config set registry https://registry.npmjs.org/ && npm publish",
-        "publish:github": "npm config set '@fleetbase:registry' https://npm.pkg.github.com/ && npm publish"
-    },
-    "dependencies": {
-        "date-fns": "^2.30.0",
-        "ember-intl": "^6.0.0-beta.6",
-        "ember-auto-import": "^2.4.2",
-        "ember-cli-babel": "^7.26.11",
-        "ember-cli-htmlbars": "^6.1.0",
-        "ember-cli-notifications": "^8.0.0",
-        "ember-concurrency": "^2.3.2",
-        "ember-concurrency-decorators": "^2.0.3",
-        "ember-decorators": "^6.1.1",
-        "ember-get-config": "^2.1.1",
-        "ember-inflector": "^4.0.2",
-        "ember-loading": "^2.0.0",
-        "ember-local-storage": "^2.0.4",
-        "ember-simple-auth": "^4.2.2",
-        "ember-wormhole": "^0.6.0",
-        "socketcluster-client": "^17.1.1"
-    },
-    "devDependencies": {
-        "@ember-data/serializer": "^4.11.3",
-        "@ember-data/store": "^4.11.3",
-        "@ember/optional-features": "^2.0.0",
-        "@ember/test-helpers": "^2.8.1",
-        "@embroider/test-setup": "^1.8.3",
-        "@glimmer/component": "^1.1.2",
-        "@glimmer/tracking": "^1.1.2",
-        "babel-eslint": "^10.1.0",
-        "broccoli-asset-rev": "^3.0.0",
-        "broccoli-funnel": "^3.0.8",
-        "broccoli-merge-trees": "^4.2.0",
-        "broccoli-persistent-filter": "^3.1.3",
-        "ember-cli": "~4.6.0",
-        "ember-cli-dependency-checker": "^3.3.1",
-        "ember-cli-inject-live-reload": "^2.1.0",
-        "ember-cli-sri": "^2.1.1",
-        "ember-cli-terser": "^4.0.2",
-        "ember-disable-prototype-extensions": "^1.1.3",
-        "ember-file-upload": "^7.1.0",
-        "ember-load-initializers": "^2.1.2",
-        "ember-page-title": "^7.0.0",
-        "ember-qunit": "^5.1.5",
-        "ember-resolver": "^8.0.3",
-        "ember-source": "~4.6.0",
-        "ember-source-channel-url": "^3.0.0",
-        "ember-template-lint": "^4.10.1",
-        "ember-try": "^2.0.0",
-        "eslint": "^7.32.0",
-        "eslint-config-prettier": "^8.5.0",
-        "eslint-plugin-ember": "^11.0.2",
-        "eslint-plugin-node": "^11.1.0",
-        "eslint-plugin-prettier": "^4.2.1",
-        "eslint-plugin-qunit": "^7.3.1",
-        "loader.js": "^4.7.0",
-        "npm-run-all": "^4.1.5",
-        "prettier": "^2.7.1",
-        "qunit": "^2.19.1",
-        "qunit-dom": "^2.0.0",
-        "resolve": "^1.22.2",
-        "webpack": "^5.74.0"
-    },
-    "overrides": {
-        "broccoli-persistent-filter": "^3.1.3"
-    },
-    "engines": {
-        "node": "14.* || >= 16"
-    },
-    "ember": {
-        "edition": "octane"
-    },
-    "ember-addon": {
-        "configPath": "tests/dummy/config"
-    },
-    "prettier": {
-        "trailingComma": "es5",
-        "tabWidth": 4,
-        "semi": true,
-        "singleQuote": true,
-        "printWidth": 190,
-        "overrides": [
-            {
-                "files": "*.hbs",
-                "options": {
-                    "singleQuote": false
-                }
-            }
-        ]
-    }
+  "name": "@fleetbase/ember-core",
+  "version": "0.1.9",
+  "description": "Provides all the core services, decorators and utilities for building a Fleetbase extension for the Console.",
+  "keywords": [
+    "fleetbase-core",
+    "fleetbase-services",
+    "fleetbase",
+    "ember-addon"
+  ],
+  "repository": "https://github.com/fleetbase/ember-core",
+  "license": "MIT",
+  "author": "Fleetbase Pte Ltd <hello@fleetbase.io>",
+  "directories": {
+    "app": "app",
+    "addon": "addon",
+    "tests": "tests"
+  },
+  "scripts": {
+    "build": "ember build --environment=production",
+    "lint": "concurrently \"npm:lint:*(!fix)\" --names \"lint:\"",
+    "lint:css": "stylelint \"**/*.css\"",
+    "lint:css:fix": "concurrently \"npm:lint:css -- --fix\"",
+    "lint:fix": "concurrently \"npm:lint:*:fix\" --names \"fix:\"",
+    "lint:hbs": "ember-template-lint .",
+    "lint:hbs:fix": "ember-template-lint . --fix",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "start": "ember serve",
+    "test": "concurrently \"npm:lint\" \"npm:test:*\" --names \"lint,test:\"",
+    "test:ember": "ember test",
+    "test:ember-compatibility": "ember try:each",
+    "publish:npm": "npm config set registry https://registry.npmjs.org/ && npm publish",
+    "publish:github": "npm config set '@fleetbase:registry' https://npm.pkg.github.com/ && npm publish"
+  },
+  "dependencies": {
+    "@babel/core": "^7.23.2",
+    "date-fns": "^2.30.0",
+    "ember-auto-import": "^2.6.3",
+    "ember-cli-babel": "^8.2.0",
+    "ember-cli-htmlbars": "^6.3.0",
+    "ember-cli-notifications": "^9.0.0",
+    "ember-concurrency": "^3.1.1",
+    "ember-concurrency-decorators": "^2.0.3",
+    "ember-decorators": "^6.1.1",
+    "ember-get-config": "^2.1.1",
+    "ember-inflector": "^4.0.2",
+    "ember-intl": "6.3.2",
+    "ember-loading": "^2.0.0",
+    "ember-local-storage": "^2.0.4",
+    "ember-simple-auth": "^6.0.0",
+    "ember-wormhole": "^0.6.0",
+    "socketcluster-client": "^17.1.1"
+  },
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.22.15",
+    "@babel/plugin-proposal-decorators": "^7.23.2",
+    "@ember/optional-features": "^2.0.0",
+    "@ember/test-helpers": "^3.2.0",
+    "@embroider/test-setup": "^3.0.2",
+    "@glimmer/component": "^1.1.2",
+    "@glimmer/tracking": "^1.1.2",
+    "broccoli-asset-rev": "^3.0.0",
+    "broccoli-funnel": "^3.0.8",
+    "broccoli-merge-trees": "^4.2.0",
+    "broccoli-persistent-filter": "^3.1.3",
+    "concurrently": "^8.2.2",
+    "ember-cli": "~5.4.1",
+    "ember-cli-clean-css": "^3.0.0",
+    "ember-cli-dependency-checker": "^3.3.2",
+    "ember-cli-inject-live-reload": "^2.1.0",
+    "ember-cli-sri": "^2.1.1",
+    "ember-cli-terser": "^4.0.2",
+    "ember-file-upload": "8.4.0",
+    "ember-load-initializers": "^2.1.2",
+    "ember-page-title": "^8.0.0",
+    "ember-qunit": "^8.0.1",
+    "ember-resolver": "^11.0.1",
+    "ember-source": "~5.4.0",
+    "ember-data": "^4.12.5",
+    "ember-source-channel-url": "^3.0.0",
+    "ember-template-lint": "^5.11.2",
+    "ember-try": "^3.0.0",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-ember": "^11.11.1",
+    "eslint-plugin-n": "^16.2.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "eslint-plugin-qunit": "^8.0.1",
+    "loader.js": "^4.7.0",
+    "prettier": "^3.0.3",
+    "qunit": "^2.20.0",
+    "qunit-dom": "^2.0.0",
+    "resolve": "^1.22.2",
+    "stylelint": "^15.11.0",
+    "stylelint-config-standard": "^34.0.0",
+    "stylelint-prettier": "^4.0.2",
+    "webpack": "^5.89.0"
+  },
+  "overrides": {
+    "broccoli-persistent-filter": "^3.1.3"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "configPath": "tests/dummy/config"
+  },
+  "prettier": {
+    "trailingComma": "es5",
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": true,
+    "printWidth": 190,
+    "overrides": [
+      {
+        "files": "*.hbs",
+        "options": {
+          "singleQuote": false
+        }
+      }
+    ]
+  }
 }

package/tsconfig.declarations.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declarationDir": "declarations",
+    "emitDeclarationOnly": true,
+    "noEmit": false,
+    "rootDir": "."
+  },
+  "include": ["addon", "addon-test-support"]
+}