@equinor/fusion-framework-vite-plugin-spa 5.1.0 → 5.2.2

package/dist/html/bootstrap.js

@@ -1,4 +1,5 @@
-import { c as createErrorClass, _ as __extends, e as errorContext, E as EMPTY_SUBSCRIPTION, S as Subscription, a as arrRemove, O as Observable, b as __values, d as __spreadArray, f as __read, i as isFunction$1, g as SafeSubscriber, h as EmptyError, o as operate, j as executeSchedule, k as innerFrom, l as createOperatorSubscriber, m as map, n as mergeMap, p as identity, q as isArrayLike, r as isScheduler, s as popScheduler, t as popNumber, u as EMPTY, v as from, w as mergeInternals, x as scanInternals, y as noop, z as popResultSelector, A as reduce, B as lastValueFrom, M as ModuleEventLevel, C as filter, D as BaseModuleProvider, F as catchError, G as of, H as object, I as _instanceof, J as _enum, K as string, L as boolean, N as record, P as union, Q as __rest, R as __assign, T as switchMap, U as observeOn, V as deepmerge, W as BaseConfigBuilder, X as TelemetryExceptionSchema, Y as TelemetryItemNames, Z as TelemetryType, $ as TelemetryEventSchema, a0 as TelemetryMetricSchema, a1 as TelemetryCustomEventSchema, a2 as array, a3 as TelemetryLevel, a4 as enableMSAL } from '../module-DzjJ4gjy.js';
+import { c as createErrorClass, _ as __extends, e as errorContext, E as EMPTY_SUBSCRIPTION, S as Subscription, O as Observable, a as __values, b as arrRemove, d as __spreadArray, f as __read, i as isFunction$1, g as SafeSubscriber, h as EmptyError, o as operate, j as executeSchedule, k as innerFrom, l as createOperatorSubscriber, m as map, n as mergeMap, p as identity, q as isArrayLike, r as isScheduler, s as popScheduler, t as popNumber, u as EMPTY, v as from, w as mergeInternals, x as scanInternals, y as noop, z as popResultSelector, A as reduce, B as lastValueFrom, M as ModuleEventLevel, C as filter, D as BaseModuleProvider, F as catchError, G as of, H as object, I as _instanceof, J as _enum, K as string, L as boolean, N as record, P as union, Q as __rest, R as __assign, T as switchMap, U as observeOn, V as deepmerge, W as BaseConfigBuilder, X as TelemetryExceptionSchema, Y as TelemetryItemNames, Z as TelemetryType, $ as TelemetryEventSchema, a0 as TelemetryMetricSchema, a1 as TelemetryCustomEventSchema, a2 as array, a3 as TelemetryLevel, a4 as enableMSAL } from '../module-BR47HvRl.js';
+import { B as BaseTelemetryAdapter } from '../TelemetryAdapter-B6JH_RXA.js';
 
 var ObjectUnsubscribedError = createErrorClass(function (_super) {
     return function ObjectUnsubscribedErrorImpl() {
@@ -1830,7 +1831,7 @@ async function runDisposePhase(ctx, instance, ref) {
 }
 
 // Generated by genversion.
-const version$4 = '6.1.4';
+const version$4 = '6.1.5';
 
 // biome-ignore-all lint/suspicious/noExplicitAny: internal type-erased dispatch arrays — callbacks are registered with concrete module types but stored erased; the orchestrator never inspects these shapes itself
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -2993,7 +2994,7 @@ class HttpClientConfigurator {
 }
 
 // Generated by genversion.
-const version$3 = '8.1.2';
+const version$3 = '8.1.3';
 
 /** URL protocols accepted as valid ad-hoc base URIs. */
 const SUPPORTED_PROTOCOLS = ['http:', 'https:', 'ws:', 'wss:'];
@@ -4273,7 +4274,7 @@ var objectTraps = {
       const currentState = current2?.[DRAFT_STATE];
       if (currentState && currentState.base_ === value) {
         state.copy_[prop] = value;
-        state.assigned_.set(prop, false);
+        state.assigned_.delete(prop);
         return true;
       }
       if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
@@ -5354,7 +5355,7 @@ class TelemetryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$2 = '7.1.2';
+const version$2 = '7.2.1';
 
 /**
  * Represents a framework event with customizable details and behavior.
@@ -5745,7 +5746,9 @@ const applyMetadata = (metadata, args) => {
 class TelemetryProvider extends BaseModuleProvider {
     #items = new Subject();
     #initialized = false;
+    #disposal;
     #adapters = {};
+    #handledByChild = new WeakSet();
     #filters;
     #defaultScope;
     #eventProvider;
@@ -5830,6 +5833,51 @@ class TelemetryProvider extends BaseModuleProvider {
             this.#items.complete();
         });
     }
+    /**
+     * Stops telemetry subscriptions and waits for every adapter to flush and shut down.
+     *
+     * Repeated calls share the same completion promise so exporters are shut down only once.
+     * The telemetry module awaits this promise during framework module disposal.
+     *
+     * @returns Resolves after all adapter shutdowns settle.
+     * @throws {AggregateError} When any adapter fails to shut down; all adapters are still attempted.
+     * @example
+     * ```ts
+     * await provider.dispose();
+     * ```
+     */
+    dispose() {
+        // Direct disposal and module disposal must join the same pending shutdown.
+        if (this.#disposal) {
+            return this.#disposal;
+        }
+        super.dispose();
+        // Defer adapter callbacks until the shared promise is assigned, including reentrant disposal.
+        this.#disposal = Promise.resolve().then(async () => {
+            // Shut down all exporters even when one rejects or throws synchronously.
+            const results = await Promise.allSettled(Object.entries(this.#adapters).map(async ([identifier, adapter]) => {
+                try {
+                    await adapter.shutdown?.();
+                }
+                catch (cause) {
+                    throw new Error(`Failed to shut down telemetry adapter "${identifier}"`, { cause });
+                }
+            }));
+            const errors = [];
+            // Retain each failure for the module lifecycle's structured disposal error event.
+            for (const result of results) {
+                // Successful shutdowns must not obscure another exporter's failure.
+                if (result.status === 'rejected') {
+                    errors.push(result.reason);
+                }
+            }
+            // Reject only after all exporters have had a chance to release their resources.
+            if (errors.length) {
+                throw new AggregateError(errors, 'Failed to shut down telemetry adapters');
+            }
+        });
+        return this.#disposal;
+    }
     /**
      * Initializes all telemetry adapters that support async initialization.
      * Uses Promise.allSettled to ensure all adapters attempt initialization,
@@ -5879,6 +5927,11 @@ class TelemetryProvider extends BaseModuleProvider {
             }
             // Iterate through all registered adapters
             for (const [identifier, adapter] of Object.entries(this.#adapters)) {
+                // Explicit child exporters take precedence over inherited development exporters.
+                if (adapter.fallback && this.#handledByChild.has(item)) {
+                    // Keep application-owned records out of parent fallback exporters.
+                    continue;
+                }
                 try {
                     // Let the adapter process the telemetry item
                     Promise.resolve(adapter.processItem(item));
@@ -5910,7 +5963,16 @@ class TelemetryProvider extends BaseModuleProvider {
             if (relayFilter && !relayFilter(item)) {
                 return;
             }
-            target.track(item);
+            // Older/custom providers retain the original track-only relay contract.
+            if (target.trackRelayed) {
+                // Carry exporter ownership across intermediate providers without changing record metadata.
+                const hasAdapters = this.#handledByChild.has(item) ||
+                    Object.values(this.#adapters).some((adapter) => !adapter.fallback);
+                target.trackRelayed(item, hasAdapters);
+            }
+            else {
+                target.track(item);
+            }
         });
     }
     /**
@@ -5967,16 +6029,26 @@ class TelemetryProvider extends BaseModuleProvider {
                 break;
         }
     }
+    /**
+     * Tracks an already validated child record, suppressing fallback exporters when appropriate.
+     *
+     * @param item - Record emitted by a child telemetry provider.
+     * @param hasAdapters - Whether an explicit child adapter has already handled this record.
+     */
+    trackRelayed(item, hasAdapters) {
+        this._track(item, hasAdapters);
+    }
     /**
      * Tracks a telemetry item by merging the default scope with the item's scope (if provided),
      * ensuring that all telemetry items have the correct scope context. The merged item is then
      * emitted to downstream handlers.
      *
      * @param item - The telemetry item to be tracked, conforming to the input schema of `TelemetryItemSchema`.
+     * @param handledByChild - Whether fallback adapters should skip this relayed item.
      *
      * @protected
      */
-    async _track(item) {
+    async _track(item, handledByChild = false) {
         const mergedItem = mergeTelemetryItem(item, {
             scope: this.#defaultScope,
         });
@@ -5986,11 +6058,19 @@ class TelemetryProvider extends BaseModuleProvider {
                 modules: this.#modules,
                 item: mergedItem,
             }).subscribe((nextItem) => {
+                // Async metadata resolution creates new objects; retain ownership on the emitted record.
+                if (handledByChild) {
+                    this.#handledByChild.add(nextItem);
+                }
                 // Emit the item after applying metadata
                 this.#items.next(nextItem);
             });
         }
         else {
+            // Providers without metadata still need the same fallback precedence.
+            if (handledByChild) {
+                this.#handledByChild.add(mergedItem);
+            }
             // If no metadata extractor is provided or item is TelemetryMetadataError, emit directly
             this.#items.next(mergedItem);
         }
@@ -6114,6 +6194,15 @@ const module$2 = {
         });
         return provider;
     },
+    /**
+     * Joins exporter shutdown before the framework completes module disposal.
+     * @param args - Module disposal context.
+     * @param args.instance - Telemetry provider whose subscriptions and exporters must be released.
+     * @returns Resolves after the provider finishes disposal.
+     */
+    dispose: async ({ instance }) => {
+        await instance.dispose?.();
+    },
 };
 
 /**
@@ -8409,6 +8498,51 @@ class Query {
     }
 }
 
+/**
+ * Error thrown by {@link ServiceDiscoveryClient} while service discovery is in a
+ * failure cooldown and no recent service list is available as a fallback.
+ *
+ * After a failed service discovery request the client pauses outgoing requests
+ * for a growing backoff period instead of calling the API again immediately.
+ * Calls made during that pause fail fast with this error, so a misbehaving caller
+ * (retry loop, reload loop, render loop) cannot flood the service discovery API.
+ *
+ * @remarks
+ * Use `cause` to inspect the original failure (for example an
+ * `HttpJsonResponseError` with status `401`) and `retryAt` to decide when it is
+ * worth trying again.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await serviceDiscovery.resolveService('people');
+ * } catch (error) {
+ *   if (error instanceof ServiceDiscoveryUnavailableError) {
+ *     console.warn(`service discovery paused until ${new Date(error.retryAt).toISOString()}`);
+ *   }
+ * }
+ * ```
+ */
+class ServiceDiscoveryUnavailableError extends Error {
+    /** Epoch milliseconds when the client will attempt a new service discovery request. */
+    retryAt;
+    /** Number of consecutive failed service discovery requests in the current failure streak. */
+    attempt;
+    /**
+     * @param args - Failure details for the current cooldown.
+     * @param args.cause - The error from the last failed service discovery request.
+     * @param args.retryAt - Epoch milliseconds when requests resume.
+     * @param args.attempt - Number of consecutive failures in the current streak.
+     */
+    constructor(args) {
+        const seconds = Math.max(0, Math.ceil((args.retryAt - Date.now()) / 1000));
+        super(`Service discovery is unavailable after ${args.attempt} failed attempt(s); requests are paused for ${seconds}s`, { cause: args.cause });
+        this.name = 'ServiceDiscoveryUnavailableError';
+        this.retryAt = args.retryAt;
+        this.attempt = args.attempt;
+    }
+}
+
 /**
  * Zod schema for a single service object returned by the service
  * discovery API.
@@ -8446,6 +8580,12 @@ const ApiServices = array(ApiService)
 
 /** Cache key used by the internal {@link Query} instance. */
 const queryKey = 'services';
+/** Pause after the first failed request; doubles per consecutive failure. */
+const failureBackoffInitialMs = 1_000;
+/** Upper bound for the pause between failed requests. */
+const failureBackoffMaxMs = 30_000;
+/** Maximum age of the last successful service list that may be returned when a refresh fails. */
+const staleIfErrorMs = 24 * 60 * 60 * 1_000;
 /**
  * Transforms a fetch {@link Response} into an observable that emits a
  * validated array of {@link Service} objects.
@@ -8479,9 +8619,20 @@ const serviceResponseSelector = (response, postProcess) => {
  * Results are cached for 5 minutes. When `allow_cache` is `true`,
  * {@link resolveServices} returns the first cached value immediately;
  * otherwise it waits for the latest API response.
+ *
+ * Failures are hardened so a broken caller cannot flood the service discovery API:
+ * - After a failed request the client pauses outgoing requests with exponential
+ *   backoff (1s, 2s, 4s … capped at 30s). The pause resets on the first
+ *   successful response.
+ * - When a refresh fails, or a call arrives during the pause, the last successful
+ *   service list is returned if it is younger than 24 hours.
+ * - Without a usable fallback, the request that failed rethrows the original error,
+ *   and calls made during the pause throw {@link ServiceDiscoveryUnavailableError}.
  */
 class ServiceDiscoveryClient {
     #query;
+    #failure;
+    #lastKnownGood;
     /** Sub-path appended to the HTTP client's base URI when fetching services. */
     endpoint;
     /** HTTP client used to call the service discovery API. */
@@ -8507,11 +8658,75 @@ class ServiceDiscoveryClient {
         });
     }
     /** {@inheritDoc IServiceDiscoveryClient.resolveServices} */
-    resolveServices(allow_cache) {
-        // firstValueFrom returns the cached snapshot; lastValueFrom waits for
-        // the freshest value from the query
-        const fn = allow_cache ? firstValueFrom : lastValueFrom;
-        return fn(Query.extractQueryValue(this.#query.query()));
+    async resolveServices(allow_cache) {
+        // Fail fast while cooling down so retry/reload/render loops never reach the network
+        if (this.#failure && Date.now() < this.#failure.retryAt) {
+            return this.#resolveFallback(new ServiceDiscoveryUnavailableError({
+                cause: this.#failure.error,
+                retryAt: this.#failure.retryAt,
+                attempt: this.#failure.attempt,
+            }));
+        }
+        const startedAt = Date.now();
+        try {
+            // firstValueFrom returns the cached snapshot; lastValueFrom waits for
+            // the freshest value from the query
+            const fn = allow_cache ? firstValueFrom : lastValueFrom;
+            const record = await fn(this.#query.query());
+            // Only a fresh response proves discovery works; a cached (possibly expired) snapshot must
+            // not reset the failure streak or renew the age of the fallback list
+            if (record.status === 'complete') {
+                this.#failure = undefined;
+                this.#lastKnownGood = { services: record.value, receivedAt: Date.now() };
+            }
+            return record.value;
+        }
+        catch (error) {
+            this.#registerFailure(error, startedAt);
+            return this.#resolveFallback(error);
+        }
+    }
+    /**
+     * Records a failed request and schedules the next allowed request time.
+     *
+     * Concurrent callers share one in-flight request through {@link Query}, so they all
+     * reject with the same failure; only the first one to settle may extend the streak,
+     * otherwise a single failed request would be counted once per waiting caller.
+     *
+     * @param error - The error from the failed request.
+     * @param startedAt - Epoch milliseconds when the caller started waiting for the request.
+     */
+    #registerFailure(error, startedAt) {
+        // A concurrent caller already recorded this same failed request
+        if (this.#failure && this.#failure.failedAt >= startedAt) {
+            return;
+        }
+        const attempt = (this.#failure?.attempt ?? 0) + 1;
+        const delay = Math.min(failureBackoffMaxMs, failureBackoffInitialMs * 2 ** (attempt - 1));
+        // Up to 20% jitter keeps many clients that failed together from retrying in lockstep
+        const jittered = Math.round(delay * (0.8 + Math.random() * 0.2));
+        const failedAt = Date.now();
+        this.#failure = { error, attempt, failedAt, retryAt: failedAt + jittered };
+        // Warn once per streak rather than once per call to keep consoles readable
+        if (attempt === 1) {
+            console.warn(`[service-discovery] request failed; pausing requests with backoff (max ${failureBackoffMaxMs}ms)`, error);
+        }
+    }
+    /**
+     * Returns the last successful service list when it is still fresh enough,
+     * otherwise rethrows the given error.
+     *
+     * @param error - Error to throw when no usable fallback exists.
+     * @returns The last known good service list.
+     * @throws The provided `error` when no service list younger than 24 hours exists.
+     */
+    #resolveFallback(error) {
+        const lastKnownGood = this.#lastKnownGood;
+        // Prefer a recent service list over an error so callers have nothing to retry
+        if (lastKnownGood && Date.now() - lastKnownGood.receivedAt <= staleIfErrorMs) {
+            return lastKnownGood.services;
+        }
+        throw error;
     }
     /** {@inheritDoc IServiceDiscoveryClient.resolveService} */
     async resolveService(key, allow_cache) {
@@ -8713,7 +8928,7 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$1 = '10.1.1';
+const version$1 = '10.2.0';
 
 /**
  * Default implementation of {@link IServiceDiscoveryProvider}.
@@ -8876,95 +9091,6 @@ const enableServiceDiscovery = (configurator, callback) => {
     configurator.addConfig(configureServiceDiscovery(callback ?? (() => Promise.resolve())));
 };
 
-/**
- * Abstract base class for telemetry adapters.
- *
- * Provides a common implementation for filtering telemetry items before processing.
- * Subclasses must implement the `_processItem` method to define how telemetry items are handled.
- *
- * @template TelemetryItem - The type representing a telemetry item.
- * @implements {ITelemetryAdapter}
- *
- * @remarks
- * - An optional filter function can be provided to determine which telemetry items should be processed.
- *
- * @example
- * class MyTelemetryAdapter extends BaseTelemetryAdapter {
- *   protected _processItem(item: TelemetryItem): void {
- *     // Custom processing logic
- *   }
- * }
- */
-class BaseTelemetryAdapter {
-    #filter;
-    #initialized = false;
-    /**
-     * Creates a new instance of the TelemetryAdapter.
-     *
-     * @param filter - An optional function to filter telemetry items. If provided, only items for which the function returns true will be processed.
-     */
-    constructor(filter) {
-        this.#filter = filter;
-    }
-    /**
-     * Processes a telemetry item by applying an optional filter before handling it.
-     *
-     * If a filter is defined and the item does not pass the filter, the method returns early.
-     * Otherwise, it delegates the processing of the item to the internal `_processItem` method.
-     *
-     * @param item - The telemetry item to be processed.
-     */
-    processItem(item) {
-        // If the adapter is not initialized, do not process the item
-        if (!this.#initialized) {
-            return;
-        }
-        // If a filter is defined and the item does not pass the filter, do not process the item
-        if (this.#filter && !this.#filter(item)) {
-            return;
-        }
-        // Delegate the processing of the item to the internal `_processItem` method
-        this._processItem(item);
-    }
-    /**
-     * Initializes the telemetry adapter asynchronously.
-     *
-     * This method can only be called once. Subsequent calls will return immediately
-     * without performing any initialization. It calls the protected `_initialize` method which
-     * subclasses can override to provide custom initialization logic.
-     *
-     * TODO(#5112): Consider changing return type from Promise<void> to Promise<TelemetryItem[]>
-     * to allow adapters to return telemetry items (errors/warnings) that occurred during
-     * initialization, eliminating the chicken-and-egg problem with reporting init errors.
-     *
-     * @returns A promise that resolves when initialization is complete.
-     * @sealed
-     */
-    async initialize() {
-        // If the adapter is already initialized, do not initialize it again
-        if (this.#initialized) {
-            return;
-        }
-        // Initialize the adapter
-        await this._initialize();
-        // Mark the adapter as initialized
-        this.#initialized = true;
-    }
-    /**
-     * Protected initialization method that subclasses can override.
-     *
-     * This method is called only once during the adapter's lifetime.
-     * Subclasses should override this method to perform any necessary async setup.
-     * The base implementation is a no-op for adapters that don't need initialization.
-     *
-     * @returns A promise that resolves when initialization is complete.
-     * @protected
-     */
-    async _initialize() {
-        // Default implementation - no-op for adapters that don't need initialization
-    }
-}
-
 /**
  * Telemetry adapter that outputs telemetry data to the browser console
  * with formatted titles and colour-coded log levels.
@@ -9402,7 +9528,7 @@ async function registerServiceWorker(framework) {
 }
 
 // Generated by genversion.
-const version = '5.1.0';
+const version = '5.2.2';
 
 // Allow dynamic import without vite
 const importWithoutVite = (path) => import(/* @vite-ignore */ path);
@@ -9422,7 +9548,7 @@ enableServiceDiscovery(configurator, async (builder) => {
 });
 // Avoid interactive Entra ID authentication when the SPA runs in CI or Playwright.
 if (isEnabledEnvValue(import.meta.env.FUSION_SPA_MSAL_MOCK)) {
-    const { enableMsalMock } = await import('../index-Df9EZ6lh.js');
+    const { enableMsalMock } = await import('../index-glg6-DFO.js');
     const mockServerUrl = import.meta.env.FUSION_SPA_MSAL_MOCK_SERVER_URL;
     enableMsalMock(configurator, (builder) => {
         // The SPA owns the HTTP adapter; MSAL owns applying the returned token and account.
@@ -9443,6 +9569,19 @@ else {
         builder.setRequiresAuth(isEnabledEnvValue(import.meta.env.FUSION_SPA_MSAL_REQUIRES_AUTH));
     });
 }
+// Initialize tracing before app startup so network requests and logs share active trace context.
+if (import.meta.env.FUSION_SPA_TELEMETRY_OTLP_TRACES_ENDPOINT) {
+    const { enableDevServerTracing } = await import('../enable-dev-server-tracing-GfRoCLxu.js');
+    enableDevServerTracing(new URL(import.meta.env.FUSION_SPA_TELEMETRY_OTLP_TRACES_ENDPOINT, window.location.origin).href);
+}
+// The dev-server environment bridge owns activation; the SPA only consumes its endpoint.
+const devServerOtlpAdapter = import.meta.env.FUSION_SPA_TELEMETRY_OTLP_ENDPOINT
+    ? new (await import('../index-CiqJ1Og1.js')).OtlpAdapter({
+        url: new URL(import.meta.env.FUSION_SPA_TELEMETRY_OTLP_ENDPOINT, window.location.origin).href,
+        fallback: true,
+        serviceName: 'fusion.dev-server',
+    })
+    : undefined;
 enableTelemetry(configurator, {
     attachConfiguratorEvents: true,
     configure: (builder) => {
@@ -9451,6 +9590,10 @@ enableTelemetry(configurator, {
             filter: Number.isNaN(consoleLevel) ? undefined : (item) => item.level >= consoleLevel,
         });
         builder.setAdapter('console', consoleAdapter);
+        // Only the dev-server environment bridge opts the shell into OTLP export.
+        if (devServerOtlpAdapter) {
+            builder.setAdapter('dev-server-otlp', devServerOtlpAdapter);
+        }
         builder.setMetadata(({ modules }) => {
             const metadata = {
                 fusion: {