@hitachivantara/app-shell-services 2.0.0-next.1 → 2.0.0-next.2

package/dist/bundles/app-shell-services.esm.js

@@ -1,29 +1,4 @@
-import { useState, useEffect, createElement, createContext, useMemo, useContext, useCallback, useRef } from "react";
-function isEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (a == null || b == null || typeof a !== typeof b || typeof a !== "object" || Array.isArray(a) !== Array.isArray(b)) {
-    return false;
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false;
-    }
-    return a.every((item, index) => isEqual(item, b[index]));
-  }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  return keysA.every(
-    (key) => isEqual(
-      a[key],
-      b[key]
-    )
-  );
-}
+import { useState, useEffect, createElement, useMemo, createContext, useContext, useCallback, useRef } from "react";
 function useAsync(promiseFactory, options) {
   const dataProp = options?.dataProp ?? "data";
   const pendingData = options?.pendingData;
@@ -71,6 +46,31 @@ function useAsync(promiseFactory, options) {
     [dataProp]: data
   };
 }
+function isEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null || typeof a !== typeof b || typeof a !== "object" || Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((item, index) => isEqual(item, b[index]));
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  return keysA.every(
+    (key) => isEqual(
+      a[key],
+      b[key]
+    )
+  );
+}
 function createServiceReferenceBase(serviceId, serviceConfig, getService) {
   return {
     serviceId,
@@ -209,17 +209,17 @@ function createComponentReference(serviceId, config) {
   };
   return createServiceReferenceBase(serviceId, config, serviceLoader);
 }
-function createServiceReference(serviceId, serviceConfig) {
-  if ("instance" in serviceConfig) {
-    return createInstanceReference(serviceId, serviceConfig);
+function createServiceReference(serviceId, serviceProviderConfig) {
+  if ("instance" in serviceProviderConfig) {
+    return createInstanceReference(serviceId, serviceProviderConfig);
   }
-  if ("factory" in serviceConfig) {
-    return createFactoryReference(serviceId, serviceConfig);
+  if ("factory" in serviceProviderConfig) {
+    return createFactoryReference(serviceId, serviceProviderConfig);
   }
-  if ("component" in serviceConfig) {
+  if ("component" in serviceProviderConfig) {
     return createComponentReference(
       serviceId,
-      serviceConfig
+      serviceProviderConfig
     );
   }
   throw new Error(
@@ -235,9 +235,9 @@ function bindComponent(Component, configProps) {
 }
 function createServiceReferenceMap(services = {}) {
   return Object.entries(services).reduce(
-    (map, [serviceId, serviceConfigs]) => {
-      const serviceReferences = serviceConfigs.map(
-        (serviceConfig) => createServiceReference(serviceId, serviceConfig)
+    (map, [serviceId, serviceProviderConfigs]) => {
+      const serviceReferences = serviceProviderConfigs.map(
+        (serviceProviderConfig) => createServiceReference(serviceId, serviceProviderConfig)
       ).sort((a, b) => b.ranking - a.ranking);
       map.set(serviceId, serviceReferences);
       return map;
@@ -245,9 +245,7 @@ function createServiceReferenceMap(services = {}) {
     /* @__PURE__ */ new Map()
   );
 }
-function createServiceManager({
-  services
-}) {
+function createServiceManager(services = {}) {
   const serviceReferenceMap = createServiceReferenceMap(services);
   function queryServiceReferences(serviceId, _options) {
     return serviceReferenceMap.get(serviceId) ?? [];
@@ -281,7 +279,7 @@ function createServiceManager({
       );
       const successful = [];
       const errors = [];
-      results.forEach((result) => {
+      for (const result of results) {
         if (result.status === "fulfilled") {
           successful.push(result.value);
         } else {
@@ -289,7 +287,7 @@ function createServiceManager({
             result.reason instanceof Error ? result.reason : new Error(String(result.reason))
           );
         }
-      });
+      }
       switch (errorHandling) {
         case "reject-on-any-failure":
           if (errors.length > 0) {
@@ -312,7 +310,9 @@ const ServicesContext = createContext(
   void 0
 );
 const ServiceManagerProvider = ({ config, children }) => {
-  const serviceManager = useMemo(() => createServiceManager(config), [config]);
+  const serviceManager = useMemo(() => {
+    return createServiceManager(config.services);
+  }, [config.services]);
   return createElement(
     ServicesContext.Provider,
     { value: serviceManager },
@@ -366,6 +366,7 @@ function isServiceReference(value) {
 }
 export {
   ServiceManagerProvider as default,
+  useAsync,
   useService,
   useServiceReference,
   useServiceReferences,

package/dist/index.d.ts

@@ -2,16 +2,44 @@ import { FC } from 'react';
 import { PropsWithChildren } from 'react';
 import { ServiceManager as ServiceManager_2 } from '..';
 
+export declare type AsyncBaseResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = {
+    isPending: boolean;
+    error: TError | null;
+} & PropertyWithName<TDataProp, TData | TDataPending | undefined>;
+
+export declare type AsyncErrorResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = AsyncBaseResult<TData, TError, TDataProp, TDataPending> & {
+    isPending: false;
+    error: TError;
+} & PropertyWithName<TDataProp, undefined>;
+
+declare type AsyncOptions<TData, TDataProp extends string, TPending extends TData | undefined> = {
+    dataProp?: TDataProp;
+    pendingData?: TPending;
+};
+
+export declare type AsyncPendingResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = AsyncBaseResult<TData, TError, TDataProp> & {
+    isPending: true;
+    error: null;
+} & PropertyWithName<TDataProp, TDataPending>;
+
+export declare type AsyncResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = AsyncPendingResult<TData, TError, TDataProp, TDataPending> | AsyncErrorResult<TData, TError, TDataProp, TDataPending> | AsyncSuccessResult<TData, TError, TDataProp, TDataPending>;
+
+export declare type AsyncSuccessResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = AsyncBaseResult<TData, TError, TDataProp, TDataPending> & {
+    isPending: false;
+    error: null;
+} & PropertyWithName<TDataProp, TData>;
+
 /** Bundle for lazy loading */
-export declare type Bundle = {
+export declare interface Bundle {
     bundle: string;
-};
+}
 
-export declare type BundleConfig = Record<string, unknown>;
+export declare interface BundleConfig extends Record<string, unknown> {
+}
 
-export declare type ComponentServiceConfig = ServiceConfigBase & {
+export declare interface ComponentServiceProviderConfig extends ServiceConfigBase {
     component: ComponentValueOrBundle;
-};
+}
 
 export declare type ComponentValueOrBundle<TBundleConfig = BundleConfig> = Value | (Bundle & {
     config?: TBundleConfig;
@@ -21,12 +49,12 @@ export declare type ErrorBase = NonNullable<unknown>;
 
 export declare type FactoryExport<TService = unknown, TConfig = BundleConfig> = FactoryServiceFunction<TService, TConfig>;
 
-export declare type FactoryServiceConfig = ServiceConfigBase & {
-    factory: FactoryValueOrBundle;
-};
-
 export declare type FactoryServiceFunction<TService = unknown, TConfig = BundleConfig> = (config?: TConfig) => TService;
 
+export declare interface FactoryServiceProviderConfig extends ServiceConfigBase {
+    factory: FactoryValueOrBundle;
+}
+
 export declare type FactoryValueOrBundle<TBundleConfig = BundleConfig> = {
     value: FactoryServiceFunction;
 } | (Bundle & {
@@ -61,9 +89,9 @@ export declare type GetServicesOptions = GetServiceBaseOptions & {
     errorHandling?: ServicesErrorHandling;
 };
 
-export declare type InstanceServiceConfig = ServiceConfigBase & {
+export declare interface InstanceServiceProviderConfig extends ServiceConfigBase {
     instance: InstanceValueOrBundle;
-};
+}
 
 export declare type InstanceValueOrBundle = Value | Bundle;
 
@@ -75,17 +103,9 @@ declare interface Props extends PropsWithChildren {
     config: ServiceManagerConfig;
 }
 
-/**
- * A service configuration can be one of several kinds (instance, factory, component),
- * each of which supports two declaration modes:
- *  - Value: directly provide the instance, factory or component
- *  - Bundle: module to be lazy loaded with optional config object
- */
-export declare type ServiceConfig = InstanceServiceConfig | FactoryServiceConfig | ComponentServiceConfig;
-
-export declare type ServiceConfigBase = {
+export declare interface ServiceConfigBase {
     ranking?: number;
-};
+}
 
 export declare type ServiceId = string;
 
@@ -120,6 +140,14 @@ declare type ServiceManagerConfig = {
 declare const ServiceManagerProvider: FC<Props>;
 export default ServiceManagerProvider;
 
+/**
+ * A service configuration can be one of several kinds (instance, factory, component),
+ * each of which supports two declaration modes:
+ *  - Value: directly provide the instance, factory or component
+ *  - Bundle: module to be lazy loaded with optional config object
+ */
+export declare type ServiceProviderConfig = InstanceServiceProviderConfig | FactoryServiceProviderConfig | ComponentServiceProviderConfig;
+
 /**
  * Reference to a service, including metadata and a loader function.
  * Can be used to access service details and also resolve its service instance.
@@ -130,7 +158,8 @@ export declare type ServiceReference<TService = unknown> = {
     getService(): Promise<TService>;
 };
 
-export declare type ServicesConfig = Record<ServiceId, ServiceConfig[]>;
+export declare interface ServicesConfig extends Record<ServiceId, ServiceProviderConfig[]> {
+}
 
 /**
  * Error handling strategies that determine how errors are managed when loading services:
@@ -140,27 +169,31 @@ export declare type ServicesConfig = Record<ServiceId, ServiceConfig[]>;
  */
 export declare type ServicesErrorHandling = "reject-on-any-failure" | "reject-on-all-failures" | "ignore-failures";
 
-export declare type UseAsyncBaseResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = {
-    isPending: boolean;
-    error: TError | null;
-} & PropertyWithName<TDataProp, TData | TDataPending | undefined>;
-
-export declare type UseAsyncErrorResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = UseAsyncBaseResult<TData, TError, TDataProp, TDataPending> & {
-    isPending: false;
-    error: TError;
-} & PropertyWithName<TDataProp, undefined>;
-
-export declare type UseAsyncPendingResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = UseAsyncBaseResult<TData, TError, TDataProp> & {
-    isPending: true;
-    error: null;
-} & PropertyWithName<TDataProp, TDataPending>;
-
-export declare type UseAsyncResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = UseAsyncPendingResult<TData, TError, TDataProp, TDataPending> | UseAsyncErrorResult<TData, TError, TDataProp, TDataPending> | UseAsyncSuccessResult<TData, TError, TDataProp, TDataPending>;
-
-export declare type UseAsyncSuccessResult<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TDataPending extends TData | undefined = undefined> = UseAsyncBaseResult<TData, TError, TDataProp, TDataPending> & {
-    isPending: false;
-    error: null;
-} & PropertyWithName<TDataProp, TData>;
+/**
+ * Generic hook that runs an async factory and returns a discriminated result.
+ *
+ * Responsibilities:
+ *  - Invoke the provided `promiseFactory` when mounted (and when it changes).
+ *  - Track pending state, resolved data and typed error.
+ *  - Prevent state updates after unmount to avoid memory leaks (see {@link https://reactjs.org/docs/hooks-effect.html | React's useEffect}).
+ *
+ * Returns a {@link AsyncResult} which is a discriminated union:
+ *  - {@link AsyncPendingResult} — pending: `isPending: true`, `error: null`, and the pending data property.
+ *  - {@link AsyncSuccessResult} — success: `isPending: false`, `error: null`, and the resolved data property.
+ *  - {@link AsyncErrorResult} — error: `isPending: false`, `error: TError`, and the data property set to `undefined`.
+ *
+ * Type references:
+ *  - Error type: {@link ErrorBase}
+ *  - Result shapes: {@link AsyncResult}, {@link AsyncPendingResult}, {@link AsyncSuccessResult}, {@link AsyncErrorResult}
+ *
+ * Defaults:
+ *  - `dataProp` = `"data"`
+ *  - `pendingData` = `undefined`
+ *
+ * Example:
+ *  - `useAsync(() => fetchServices(), { pendingData: [] })`
+ */
+export declare function useAsync<TData, TError extends ErrorBase = Error, TDataProp extends string = "data", TPending extends TData | undefined = undefined>(promiseFactory: () => Promise<TData>, options?: AsyncOptions<TData, TDataProp, TPending>): AsyncResult<TData, TError, TDataProp, TPending>;
 
 /**
  * Resolves and returns the service instance for a given service id or reference.
@@ -218,7 +251,7 @@ export declare type UseServiceReferencesOptions = GetServiceReferencesOptions;
 /**
  * Result type for the {@link useService} hook that represents the async state of a single service fetch operation.
  */
-export declare type UseServiceResult<TService> = UseAsyncResult<TService, Error, "service">;
+export declare type UseServiceResult<TService> = AsyncResult<TService, Error, "service">;
 
 /**
  * Gets all service instances for a given service id.
@@ -239,11 +272,11 @@ export declare type UseServicesOptions = GetServicesOptions;
 /**
  * Result type for the {@link useServices} hook that represents the async state of fetching multiple services.
  */
-export declare type UseServicesResult<TService> = UseAsyncResult<TService[], Error, "services", TService[]>;
+export declare type UseServicesResult<TService> = AsyncResult<TService[], Error, "services", TService[]>;
 
 /** Directly provided value */
-export declare type Value = {
+export declare interface Value {
     value: unknown;
-};
+}
 
 export { }

package/dist/index.js

@@ -1,8 +1,10 @@
+import { useAsync } from "./hooks/useAsync.js";
 import { useService, useServiceReference, useServiceReferences, useServices } from "./hooks/Hooks.js";
 import { useServicesContext } from "./hooks/useServicesContext.js";
 import { default as default2 } from "./providers/ServiceManagerProvider.js";
 export {
   default2 as default,
+  useAsync,
   useService,
   useServiceReference,
   useServiceReferences,

package/dist/providers/ServiceManagerProvider.js

@@ -1,10 +1,10 @@
-import { createContext, useMemo, createElement } from "react";
+import { useMemo, createElement, createContext } from "react";
 import { createServiceReference } from "../utils/serviceReference.js";
 function createServiceReferenceMap(services = {}) {
   return Object.entries(services).reduce(
-    (map, [serviceId, serviceConfigs]) => {
-      const serviceReferences = serviceConfigs.map(
-        (serviceConfig) => createServiceReference(serviceId, serviceConfig)
+    (map, [serviceId, serviceProviderConfigs]) => {
+      const serviceReferences = serviceProviderConfigs.map(
+        (serviceProviderConfig) => createServiceReference(serviceId, serviceProviderConfig)
       ).sort((a, b) => b.ranking - a.ranking);
       map.set(serviceId, serviceReferences);
       return map;
@@ -12,9 +12,7 @@ function createServiceReferenceMap(services = {}) {
     /* @__PURE__ */ new Map()
   );
 }
-function createServiceManager({
-  services
-}) {
+function createServiceManager(services = {}) {
   const serviceReferenceMap = createServiceReferenceMap(services);
   function queryServiceReferences(serviceId, _options) {
     return serviceReferenceMap.get(serviceId) ?? [];
@@ -48,7 +46,7 @@ function createServiceManager({
       );
       const successful = [];
       const errors = [];
-      results.forEach((result) => {
+      for (const result of results) {
         if (result.status === "fulfilled") {
           successful.push(result.value);
         } else {
@@ -56,7 +54,7 @@ function createServiceManager({
             result.reason instanceof Error ? result.reason : new Error(String(result.reason))
           );
         }
-      });
+      }
       switch (errorHandling) {
         case "reject-on-any-failure":
           if (errors.length > 0) {
@@ -79,7 +77,9 @@ const ServicesContext = createContext(
   void 0
 );
 const ServiceManagerProvider = ({ config, children }) => {
-  const serviceManager = useMemo(() => createServiceManager(config), [config]);
+  const serviceManager = useMemo(() => {
+    return createServiceManager(config.services);
+  }, [config.services]);
   return createElement(
     ServicesContext.Provider,
     { value: serviceManager },

package/dist/utils/serviceReference.js

@@ -137,17 +137,17 @@ function createComponentReference(serviceId, config) {
   };
   return createServiceReferenceBase(serviceId, config, serviceLoader);
 }
-function createServiceReference(serviceId, serviceConfig) {
-  if ("instance" in serviceConfig) {
-    return createInstanceReference(serviceId, serviceConfig);
+function createServiceReference(serviceId, serviceProviderConfig) {
+  if ("instance" in serviceProviderConfig) {
+    return createInstanceReference(serviceId, serviceProviderConfig);
   }
-  if ("factory" in serviceConfig) {
-    return createFactoryReference(serviceId, serviceConfig);
+  if ("factory" in serviceProviderConfig) {
+    return createFactoryReference(serviceId, serviceProviderConfig);
   }
-  if ("component" in serviceConfig) {
+  if ("component" in serviceProviderConfig) {
     return createComponentReference(
       serviceId,
-      serviceConfig
+      serviceProviderConfig
     );
   }
   throw new Error(

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@hitachivantara/app-shell-services",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
   "type": "module",
   "private": false,
   "author": "Hitachi Vantara UI Kit Team",
   "description": "AppShell Services",
-  "homepage": "https://github.com/lumada-design/hv-uikit-react",
+  "homepage": "https://github.com/pentaho/hv-uikit-react",
   "sideEffects": false,
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/lumada-design/hv-uikit-react.git",
+    "url": "git+https://github.com/pentaho/hv-uikit-react.git",
     "directory": "packages/app-shell-services"
   },
-  "bugs": "https://github.com/lumada-design/hv-uikit-react/issues",
+  "bugs": "https://github.com/pentaho/hv-uikit-react/issues",
   "peerDependencies": {
     "react": "^18.2.0"
   },
@@ -33,7 +33,7 @@
     "access": "public",
     "directory": "package"
   },
-  "gitHead": "0b07240fb2ef75e046d8e6aaf0ff71bf2415c73f",
+  "gitHead": "f404f47dd2c0a9d4033b9acccc87282aa9e42119",
   "types": "./dist/index.d.ts",
   "module": "dist/index.js"
 }