@equinor/fusion-framework-vite-plugin-spa 4.1.0 → 4.1.2

package/rollup.config.js

@@ -1,20 +0,0 @@
-import resolve from '@rollup/plugin-node-resolve';
-import commonjs from '@rollup/plugin-commonjs';
-
-/** @type {import('rollup').RollupOptions} */
-export default [
-  {
-    input: {
-      'html/bootstrap': 'dist/esm/html/bootstrap.js',
-      'html/sw': 'dist/esm/html/sw.js',
-    },
-    output: {
-      format: 'esm',
-      dir: 'dist',
-      entryFileNames: '[name].js',
-      sourcemap: true,
-      strict: false,
-    },
-    plugins: [resolve({ preferBuiltins: true }), commonjs()],
-  },
-];

package/src/html/bootstrap.ts

@@ -1,209 +0,0 @@
-import { ModulesConfigurator } from '@equinor/fusion-framework-module';
-
-import { configureHttpClient, type HttpModule } from '@equinor/fusion-framework-module-http';
-import { enableMSAL, type MsalModule } from '@equinor/fusion-framework-module-msal';
-import {
-  enableServiceDiscovery,
-  type ServiceDiscoveryModule,
-} from '@equinor/fusion-framework-module-service-discovery';
-
-import {
-  enableTelemetry,
-  TelemetryLevel,
-  type TelemetryModule,
-} from '@equinor/fusion-framework-module-telemetry';
-import { ConsoleAdapter } from '@equinor/fusion-framework-module-telemetry/console-adapter';
-
-import { createPortalEntryPoint } from './create-portal-entry-point.js';
-import { isEnabledEnvValue } from './is-enabled-env-value.js';
-import { registerServiceWorker } from './register-service-worker.js';
-
-import { version } from '../version.js';
-
-// TODO(#5065): add type for portal manifest when available
-type PortalManifest = {
-  build: {
-    config: Record<string, unknown>;
-    templateEntry: string;
-    assetPath?: string;
-  };
-};
-
-// Allow dynamic import without vite
-const importWithoutVite = <T>(path: string): Promise<T> => import(/* @vite-ignore */ path);
-
-// Create Fusion Framework configurator
-const configurator = new ModulesConfigurator();
-
-const serviceDiscoveryUrl = new URL(
-  import.meta.env.FUSION_SPA_SERVICE_DISCOVERY_URL,
-  import.meta.env.FUSION_SPA_SERVICE_DISCOVERY_URL.startsWith('http')
-    ? undefined
-    : window.location.origin,
-);
-
-// define service discovery client - this is used in the service discovery module
-configurator.addConfig(
-  configureHttpClient('service_discovery', {
-    baseUri: String(serviceDiscoveryUrl),
-    defaultScopes: import.meta.env.FUSION_SPA_SERVICE_DISCOVERY_SCOPES,
-  }),
-);
-
-// setup service discovery - enable service discovery for the framework
-enableServiceDiscovery(configurator, async (builder) => {
-  builder.configureServiceDiscoveryClientByClientKey('service_discovery');
-});
-
-// 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('@equinor/fusion-framework-module-msal/mock');
-
-  const mockToken = import.meta.env.FUSION_SPA_MSAL_MOCK_TOKEN;
-
-  enableMsalMock(configurator, (builder) => {
-    // Preserve the mock client's default identity when no backend-specific token is configured.
-    if (!mockToken) return;
-
-    builder.setToken(mockToken);
-  });
-} else {
-  enableMSAL(configurator, (builder) => {
-    builder.setClientConfig({
-      auth: {
-        clientId: import.meta.env.FUSION_SPA_MSAL_CLIENT_ID,
-        tenantId: import.meta.env.FUSION_SPA_MSAL_TENANT_ID,
-        redirectUri: import.meta.env.FUSION_SPA_MSAL_REDIRECT_URI,
-      },
-    });
-
-    builder.setRequiresAuth(isEnabledEnvValue(import.meta.env.FUSION_SPA_MSAL_REQUIRES_AUTH));
-  });
-}
-
-enableTelemetry(configurator, {
-  attachConfiguratorEvents: true,
-  configure: (builder) => {
-    const consoleLevel = Number(
-      import.meta.env.FUSION_SPA_TELEMETRY_CONSOLE_LEVEL ?? TelemetryLevel.Information,
-    );
-
-    const consoleAdapter = new ConsoleAdapter({
-      filter: Number.isNaN(consoleLevel) ? undefined : (item) => item.level >= consoleLevel,
-    });
-
-    builder.setAdapter('console', consoleAdapter);
-
-    builder.setMetadata(({ modules }) => {
-      const metadata = {
-        fusion: {
-          spa: {
-            version,
-          },
-        },
-        // biome-ignore lint/suspicious/noExplicitAny: we need to use any here to allow dynamic properties
-      } as Record<string, any>;
-      // Only attach user metadata when the auth module has resolved an account
-      if (modules?.auth) {
-        metadata.fusion.user = {
-          id: modules.auth.account?.homeAccountId,
-          name: modules.auth.account?.name,
-          email: modules.auth.account?.username,
-        };
-      }
-      return metadata;
-    });
-  },
-});
-
-(async () => {
-  // initialize the framework - this will create the framework instance and configure the modules
-  const ref =
-    await configurator.initialize<
-      [ServiceDiscoveryModule, HttpModule, MsalModule, TelemetryModule]
-    >();
-
-  const telemetry = ref.telemetry;
-
-  // attach service discovery to the framework - append auth token to configured endpoints
-  using measurement = telemetry.measure({
-    name: 'bootstrap',
-    level: TelemetryLevel.Information,
-  });
-
-  await measurement.clone().resolve(registerServiceWorker(ref), {
-    data: {
-      level: TelemetryLevel.Debug,
-      name: 'bootstrap::registerServiceWorker',
-    },
-  });
-
-  // create a client for the portal service - this is used to fetch the portal manifest
-  const portalClient = await ref.serviceDiscovery.createClient('portal-config');
-
-  // fetch the portal manifest - this is used to load the portal template
-  const portalId = import.meta.env.FUSION_SPA_PORTAL_ID;
-  const portalTag = import.meta.env.FUSION_SPA_PORTAL_TAG ?? 'latest';
-  const portalProxy = import.meta.env.FUSION_SPA_PORTAL_PROXY ?? false;
-  const portal_manifest = await measurement
-    .clone()
-    .resolve(portalClient.json<PortalManifest>(`/portals/${portalId}@${portalTag}`), {
-      data: (manifest: PortalManifest) => ({
-        name: 'bootstrap::loadPortalManifest',
-        level: TelemetryLevel.Debug,
-        properties: {
-          portalId,
-          portalTag,
-          templateEntry: manifest.build.templateEntry,
-          manifestVersion: manifest.build.config?.version,
-          assetPath: manifest.build.assetPath,
-        },
-      }),
-    });
-
-  const portal_config = await measurement
-    .clone()
-    .resolve(portalClient.json(`/portals/${portalId}@${portalTag}/config`), {
-      data: {
-        name: 'bootstrap::loadPortalConfig',
-        level: TelemetryLevel.Debug,
-        properties: {
-          portalId,
-          portalTag,
-        },
-      },
-    });
-
-  // create a entrypoint for the portal - this is used to render the portal
-  const el = document.createElement('div');
-  document.body.innerHTML = '';
-  document.body.appendChild(el);
-
-  const portalEntryPoint = createPortalEntryPoint(
-    portalProxy ? '/portal-proxy' : undefined,
-    portal_manifest.build.assetPath,
-    portal_manifest.build.templateEntry,
-  );
-
-  // TODO(#5066): should test if the entrypoint is external or internal
-  // TODO(#5066): add proper return type
-  const { render } = await measurement
-    .clone()
-    .resolve(
-      importWithoutVite<Promise<{ render: (...args: unknown[]) => void }>>(portalEntryPoint),
-      {
-        data: {
-          name: 'bootstrap::loadPortalSourceCode',
-          level: TelemetryLevel.Debug,
-          properties: {
-            portalId,
-            portalTag,
-            entryPoint: portalEntryPoint,
-          },
-        },
-      },
-    );
-
-  // render the portal - this will load the portal template and render it
-  render(el, { ref, manifest: portal_manifest, config: portal_config });
-})();

package/src/html/create-portal-entry-point.ts

@@ -1,25 +0,0 @@
-/**
- * Builds the portal template entrypoint URL used by the SPA bootstrap loader.
- *
- * @param segments - Ordered URL/path segments such as proxy prefix, asset path, and template entry.
- * @returns A normalized entrypoint string with single slashes between segments.
- */
-export const createPortalEntryPoint = (...segments: Array<string | undefined | null>): string => {
-  const normalized = segments
-    // Drop undefined/null segments before further processing
-    .filter((segment): segment is string => segment !== undefined && segment !== null)
-    // Trim stray whitespace from each segment
-    .map((segment) => segment.trim())
-    // Drop any segments that became empty after trimming
-    .filter(Boolean)
-    // Strip leading slashes from every segment (and trailing slashes from the first)
-    .map((segment, index) => {
-      // The first segment may have a trailing slash (e.g. a base URL) that needs stripping
-      if (index === 0) {
-        return segment.replace(/\/+$/g, '');
-      }
-      return segment.replace(/^\/+|\/+$/g, '');
-    });
-
-  return normalized.join('/');
-};

package/src/html/html.ts

@@ -1,55 +0,0 @@
-import { version } from '../version.js';
-
-/**
- * Represents an HTML template string used for generating the main structure of an SPA (Single Page Application).
- *
- * @see {@link https://vite.dev/guide/env-and-mode.html#html-constant-replacement}
- *
- * The template includes placeholders for dynamic values such as:
- * - `%FUSION_SPA_TITLE%`: The title of the SPA.
- * - `%MODE%`: The mode of the application (e.g., development, production).
- * - `%FUSION_SPA_BOOTSTRAP%`: The path to the bootstrap script for initializing the SPA.
- *
- * Additionally, it includes:
- * - A meta tag for the plugin version, dynamically populated using the `version` variable.
- * - A link to the Equinor font stylesheet hosted on a CDN.
- *
- * @constant
- * @type {string}
- */
-export const html = `
-  <!DOCTYPE html>
-  <html>
-    <head>
-      <title>%FUSION_SPA_TITLE%</title>
-      <meta name="mode" content="%MODE%">
-      <meta name="fusion-spa-plugin-version" content="${version}">
-      <link rel="stylesheet" href="https://cdn.eds.equinor.com/font/equinor-font.css" />
-      <script type="module" src="%FUSION_SPA_BOOTSTRAP%"></script>
-      <script>
-        // Set AG Grid license key globally if provided
-        window.FUSION_AG_GRID_KEY = '%FUSION_SPA_AG_GRID_KEY%';
-        
-        // suppress console error for custom elements already defined. 
-        // WebComponents should be added by the portal, but not removed from application
-        const _customElementsDefine = window.customElements.define;
-        window.customElements.define = (name, cl, conf) => {
-          if (!customElements.get(name)) {
-            _customElementsDefine.call(window.customElements, name, cl, conf);
-          }
-        };
-      </script>
-      <style>
-        html, body {
-          margin: 0;
-          padding: 0;
-          height: 100%;
-          font-family: 'EquinorFont', sans-serif;
-        }
-      </style>
-    </head>
-    <body></body>
-  </html>
-`;
-
-export default html;

package/src/html/index.ts

@@ -1,10 +0,0 @@
-/**
- * Public API surface of the `@equinor/fusion-framework-vite-plugin-spa/html`
- * sub-path export.
- *
- * @remarks
- * Re-exports the {@link registerServiceWorker} function so that custom
- * bootstrap files can register the SPA service worker without importing
- * internal paths.
- */
-export { registerServiceWorker } from './register-service-worker.js';

package/src/html/is-enabled-env-value.ts

@@ -1,9 +0,0 @@
-/**
- * Resolves a Vite environment toggle that may arrive as a parsed boolean or raw string.
- *
- * @param value - Environment value supplied through plugin configuration or a custom Vite define.
- * @returns `true` only for the boolean `true` or the string `'true'`.
- */
-export function isEnabledEnvValue(value: unknown): boolean {
-  return value === true || value === 'true';
-}

package/src/html/register-service-worker.ts

@@ -1,228 +0,0 @@
-import type { ModulesInstance } from '@equinor/fusion-framework-module';
-import type { MsalModule } from '@equinor/fusion-framework-module-msal';
-import { TelemetryLevel, type TelemetryModule } from '@equinor/fusion-framework-module-telemetry';
-
-/**
- * Registers the Fusion SPA service worker and wires token acquisition.
- *
- * @remarks
- * The service worker intercepts outgoing fetch requests that match
- * the configured {@link ResourceConfiguration | resource patterns},
- * rewrites URLs, and injects Bearer tokens obtained from the MSAL
- * module. This function:
- *
- * 1. Registers `/@fusion-spa-sw.js` as a module service worker.
- * 2. Listens for `GET_TOKEN` messages from the worker and responds
- *    with MSAL access tokens.
- * 3. Sends the `INIT_CONFIG` message containing resource configurations
- *    to the active worker once it is ready and controlling the page.
- *
- * @param framework - An initialized Fusion Framework instance that
- *   includes the {@link MsalModule} (for token acquisition) and
- *   {@link TelemetryModule} (for structured logging).
- * @throws {Error} When service workers are not supported by the browser.
- * @throws {Error} When the `FUSION_SPA_SERVICE_WORKER_RESOURCES`
- *   environment variable is not defined.
- *
- * @example
- * ```ts
- * import { registerServiceWorker } from '@equinor/fusion-framework-vite-plugin-spa/html';
- *
- * const framework = await configurator.initialize();
- * await registerServiceWorker(framework);
- * ```
- */
-export async function registerServiceWorker(
-  framework: ModulesInstance<[MsalModule, TelemetryModule]>,
-) {
-  const telemetry = framework.telemetry;
-  // Bail out early when the browser has no service worker support at all
-  if ('serviceWorker' in navigator === false) {
-    const exception = new Error('Service workers are not supported in this browser.');
-    exception.name = 'ServiceWorkerNotSupported';
-    telemetry.trackException({
-      name: `registerServiceWorker.${exception.name}`,
-      exception,
-    });
-    throw exception;
-  }
-
-  const resourceConfigs = import.meta.env.FUSION_SPA_SERVICE_WORKER_RESOURCES;
-  // The worker needs a resource config to know which requests to intercept
-  if (!resourceConfigs) {
-    const exception = new Error('Service worker config is not defined.');
-    exception.name = 'ServiceWorkerConfigNotDefined';
-    telemetry.trackException({
-      name: `registerServiceWorker.${exception.name}`,
-      exception,
-    });
-    throw exception;
-  }
-
-  /**
-   * Helper function to send configuration to the service worker
-   */
-  const sendConfigToServiceWorker = (worker: ServiceWorker) => {
-    worker.postMessage({
-      type: 'INIT_CONFIG',
-      config: resourceConfigs,
-    });
-  };
-
-  try {
-    // allow the service worker to start receiving messages early
-    navigator.serviceWorker.startMessages();
-
-    // listen for messages from the service worker (set up before registration)
-    navigator.serviceWorker.addEventListener('message', async (event) => {
-      // Only the GET_TOKEN message type requests a token from this handler
-      if (event.data.type === 'GET_TOKEN') {
-        try {
-          // extract scopes from the event data
-          const scopes = event.data.scopes as string[];
-          // Scopes must be a real array before they can be used to request a token
-          if (!scopes || !Array.isArray(scopes)) {
-            const error = new Error('Invalid scopes provided');
-            error.name = 'InvalidScopesProvided';
-            throw error;
-          }
-
-          // request a token from the MSAL module
-          const token = await framework.auth.acquireToken({ request: { scopes } });
-
-          // A missing token means acquisition failed and the worker can't proceed
-          if (!token) {
-            const error = new Error('Failed to acquire token');
-            error.name = 'FailedToAcquireToken';
-
-            throw error;
-          }
-
-          // send the token back to the service worker
-          event.ports[0].postMessage({
-            accessToken: token.accessToken,
-            expiresOn: token.expiresOn?.getTime(),
-          });
-        } catch (error) {
-          const exception = error as Error;
-          telemetry.trackException({
-            name: `serviceWorker.onMessage.${exception.name}`,
-            exception,
-          });
-          event.ports[0].postMessage({
-            error: (error as Error).message,
-          });
-        }
-      }
-    });
-
-    // register the service worker with telemetry
-    // updateViaCache: 'none' ensures the service worker script is always fetched fresh
-    // This is important during development to pick up code changes
-    using measurement = telemetry.measure({
-      name: 'registerServiceWorker',
-      level: TelemetryLevel.Information,
-    });
-    const registration = await measurement.clone().resolve(
-      navigator.serviceWorker.register('/@fusion-spa-sw.js', {
-        type: 'module',
-        scope: '/',
-        updateViaCache: 'none',
-      }),
-      {
-        data: {
-          name: 'registerServiceWorker.register',
-          level: TelemetryLevel.Debug,
-        },
-      },
-    );
-
-    // Handle service worker updates/installations
-    // If there's a service worker waiting or installing, send config when it activates
-    if (registration.waiting) {
-      sendConfigToServiceWorker(registration.waiting);
-    }
-    // A worker still installing needs to reach the 'activated' state before it can receive config
-    if (registration.installing) {
-      registration.installing.addEventListener('statechange', (event) => {
-        const worker = event.target as ServiceWorker;
-        // Only send config once the worker has fully activated
-        if (worker.state === 'activated') {
-          sendConfigToServiceWorker(worker);
-        }
-      });
-    }
-
-    // Listen for controller changes (happens during hard refresh or updates)
-    navigator.serviceWorker.addEventListener('controllerchange', () => {
-      // Only send config once this page is actually controlled by a worker
-      if (navigator.serviceWorker.controller) {
-        sendConfigToServiceWorker(navigator.serviceWorker.controller);
-      }
-    });
-
-    // wait for the service worker to be ready
-    const readyRegistration = await measurement.clone().resolve(navigator.serviceWorker.ready, {
-      data: {
-        name: 'registerServiceWorker.ready',
-        level: TelemetryLevel.Debug,
-      },
-    });
-
-    // ensure we have an active service worker before sending config
-    const activeWorker = readyRegistration.active;
-    // Without an active worker there's nothing to send config to
-    if (!activeWorker) {
-      console.error('[Service Worker Registration] Service worker is not active after ready state');
-      return;
-    }
-
-    // CRITICAL: Wait for the service worker to become the controller
-    // This ensures the service worker can intercept fetch requests
-    if (!navigator.serviceWorker.controller) {
-      await measurement.clone().resolve(
-        new Promise<void>((resolve) => {
-          let checkInterval: NodeJS.Timeout;
-
-          const finish = () => {
-            clearInterval(checkInterval);
-            navigator.serviceWorker.removeEventListener('controllerchange', onControllerChange);
-            resolve();
-          };
-
-          const onControllerChange = () => finish();
-
-          // If controllerchange fires, the service worker has taken control
-          navigator.serviceWorker.addEventListener('controllerchange', onControllerChange);
-
-          // Polling fallback and timeout to prevent infinite waiting
-          checkInterval = setInterval(() => {
-            // Stop polling once a controller has taken over
-            if (navigator.serviceWorker.controller) finish();
-          }, 200);
-
-          setTimeout(finish, 5000);
-        }),
-        {
-          data: {
-            name: 'registerServiceWorker.controllerWait',
-            level: TelemetryLevel.Debug,
-          },
-        },
-      );
-    }
-
-    // send the config to the active service worker
-    sendConfigToServiceWorker(activeWorker);
-
-    // Also send to the controller if it exists and is different from active
-    if (navigator.serviceWorker.controller && navigator.serviceWorker.controller !== activeWorker) {
-      sendConfigToServiceWorker(navigator.serviceWorker.controller);
-    }
-  } catch (error) {
-    telemetry.trackException({
-      name: `registerServiceWorker.${(error as Error).name}`,
-      exception: error as Error,
-    });
-  }
-}