@equinor/fusion-framework-module-msal 4.0.8 → 4.1.0

package/dist/esm/versioning/VersionError.js

@@ -0,0 +1,78 @@
+import { VersionMessageType } from './static';
+import { createVersionMessage } from './create-version-message';
+/**
+ * Creates a VersionError instance with a formatted message.
+ *
+ * This is a helper function that creates a VersionError with a human-readable
+ * message based on the error type and version information.
+ *
+ * @param type - The type of version error
+ * @param requestedVersion - The version that was requested
+ * @param latestVersion - The latest available version
+ * @param options - Additional error options including the error type
+ * @returns A new VersionError instance with formatted message
+ */
+const createVersionError = (type, requestedVersion, latestVersion, options) => {
+    return new VersionError(createVersionMessage(type, requestedVersion, latestVersion), requestedVersion, latestVersion, { ...options, type });
+};
+/**
+ * Error class for version-related issues in the MSAL module.
+ *
+ * This error is thrown when there are version compatibility problems,
+ * such as requesting an incompatible major version or providing an invalid version string.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   resolveVersion('3.0.0'); // Assuming latest is 2.x
+ * } catch (error) {
+ *   if (error instanceof VersionError) {
+ *     console.error('Version error:', error.message);
+ *     console.error('Requested:', error.requestedVersion);
+ *     console.error('Latest:', error.latestVersion);
+ *     console.error('Type:', error.type);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a version error manually
+ * const error = VersionError.create(
+ *   VersionError.Type.MajorIncompatibility,
+ *   '3.0.0',
+ *   '2.1.0'
+ * );
+ * ```
+ */
+export class VersionError extends Error {
+    /** The version that was requested by the user */
+    requestedVersion;
+    /** The latest available version in the system */
+    latestVersion;
+    /** The specific type of version error that occurred */
+    type;
+    /** The error name for instanceof checks */
+    static Name = 'VersionError';
+    /** Reference to the VersionMessageType enum for convenience */
+    static Type = VersionMessageType;
+    /** Factory method for creating VersionError instances with formatted messages */
+    static create = createVersionError;
+    /**
+     * Creates a new VersionError instance.
+     *
+     * @param message - The error message describing the version issue
+     * @param requestedVersion - The version that was requested (will be stored as string)
+     * @param latestVersion - The latest available version (will be stored as string)
+     * @param options - Additional error options including the error type
+     */
+    constructor(message, requestedVersion, latestVersion, options) {
+        super(message, options);
+        this.name = VersionError.Name;
+        // Store versions as strings
+        this.requestedVersion = String(requestedVersion);
+        this.latestVersion = String(latestVersion);
+        this.type = options?.type;
+    }
+}
+//# sourceMappingURL=VersionError.js.map

package/dist/esm/versioning/VersionError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VersionError.js","sourceRoot":"","sources":["../../../src/versioning/VersionError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGhE;;;;;;;;;;;GAWG;AACH,MAAM,kBAAkB,GAAG,CACzB,IAAwB,EACxB,gBAAiC,EACjC,aAA8B,EAC9B,OAAsD,EACxC,EAAE;IAChB,OAAO,IAAI,YAAY,CACrB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,EAAE,aAAa,CAAC,EAC3D,gBAAgB,EAChB,aAAa,EACb,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,CACrB,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IACrC,iDAAiD;IACjC,gBAAgB,CAAS;IAEzC,iDAAiD;IACjC,aAAa,CAAS;IAEtC,uDAAuD;IACvC,IAAI,CAAsB;IAE1C,2CAA2C;IAC3C,MAAM,CAAC,IAAI,GAAG,cAAc,CAAC;IAE7B,+DAA+D;IAC/D,MAAM,CAAC,IAAI,GAAG,kBAAkB,CAAC;IAEjC,iFAAiF;IACjF,MAAM,CAAC,MAAM,GAA8B,kBAAkB,CAAC;IAE9D;;;;;;;OAOG;IACH,YACE,OAAe,EACf,gBAAiC,EACjC,aAA8B,EAC9B,OAAsD;QAEtD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC;QAE9B,4BAA4B;QAC5B,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACjD,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAE3C,IAAI,CAAC,IAAI,GAAG,OAAO,EAAE,IAAI,CAAC;IAC5B,CAAC"}

package/dist/esm/versioning/create-version-message.js

@@ -0,0 +1,54 @@
+import { VersionMessageType } from './static';
+/**
+ * Creates a human-readable version message based on the version message type.
+ *
+ * This function generates descriptive error messages for different version compatibility
+ * scenarios, helping developers understand version-related issues.
+ *
+ * @param type - The type of version message to create
+ * @param requestedVersion - The version that was requested by the user
+ * @param latestVersion - The latest available version in the system
+ * @returns A formatted, human-readable version message string
+ *
+ * @example
+ * ```typescript
+ * const message = createVersionMessage(
+ *   VersionMessageType.MajorIncompatibility,
+ *   '3.0.0',
+ *   '2.1.0'
+ * );
+ * // Returns: "Requested major version 3.0.0 is greater than the latest major version 2.1.0"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const message = createVersionMessage(
+ *   VersionMessageType.MinorMismatch,
+ *   '2.1.0',
+ *   '2.2.0'
+ * );
+ * // Returns: "Minor version mismatch, requested 2.1.0, latest 2.2.0"
+ * ```
+ */
+export const createVersionMessage = (type, requestedVersion, latestVersion) => {
+    // Convert versions to strings for consistent formatting
+    const requestedVersionString = String(requestedVersion);
+    const latestVersionString = String(latestVersion);
+    switch (type) {
+        case VersionMessageType.MajorIncompatibility:
+            return `Requested major version ${requestedVersionString} is greater than the latest major version ${latestVersionString}`;
+        case VersionMessageType.InvalidVersion:
+            return `Invalid version ${requestedVersionString}`;
+        case VersionMessageType.InvalidLatestVersion:
+            return `Failed to parse latest version "${latestVersionString}" - this indicates the version.ts file was not generated correctly. Check for import errors in the build process.`;
+        case VersionMessageType.MinorMismatch:
+            return `Minor version mismatch, requested ${requestedVersionString}, latest ${latestVersionString}`;
+        case VersionMessageType.PatchDifference:
+            return `Patch version difference, requested ${requestedVersionString}, latest ${latestVersionString}`;
+        case VersionMessageType.IncompatibleVersion:
+            return `Incompatible version, requested ${requestedVersionString}, latest ${latestVersionString}`;
+        default:
+            return createVersionMessage(VersionMessageType.IncompatibleVersion, requestedVersion, latestVersion);
+    }
+};
+//# sourceMappingURL=create-version-message.js.map

package/dist/esm/versioning/create-version-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-version-message.js","sourceRoot":"","sources":["../../../src/versioning/create-version-message.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,IAAwB,EACxB,gBAAiC,EACjC,aAA8B,EACtB,EAAE;IACV,wDAAwD;IACxD,MAAM,sBAAsB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACxD,MAAM,mBAAmB,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;IAClD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,kBAAkB,CAAC,oBAAoB;YAC1C,OAAO,2BAA2B,sBAAsB,6CAA6C,mBAAmB,EAAE,CAAC;QAC7H,KAAK,kBAAkB,CAAC,cAAc;YACpC,OAAO,mBAAmB,sBAAsB,EAAE,CAAC;QACrD,KAAK,kBAAkB,CAAC,oBAAoB;YAC1C,OAAO,mCAAmC,mBAAmB,mHAAmH,CAAC;QACnL,KAAK,kBAAkB,CAAC,aAAa;YACnC,OAAO,qCAAqC,sBAAsB,YAAY,mBAAmB,EAAE,CAAC;QACtG,KAAK,kBAAkB,CAAC,eAAe;YACrC,OAAO,uCAAuC,sBAAsB,YAAY,mBAAmB,EAAE,CAAC;QACxG,KAAK,kBAAkB,CAAC,mBAAmB;YACzC,OAAO,mCAAmC,sBAAsB,YAAY,mBAAmB,EAAE,CAAC;QACpG;YACE,OAAO,oBAAoB,CACzB,kBAAkB,CAAC,mBAAmB,EACtC,gBAAgB,EAChB,aAAa,CACd,CAAC;IACN,CAAC;AACH,CAAC,CAAC"}

package/dist/esm/versioning/index.js

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Versioning module for MSAL module compatibility checking.
+ *
+ * This module provides comprehensive version resolution and validation functionality
+ * for the MSAL module, ensuring compatibility between different MSAL library versions.
+ *
+ * @example
+ * ```typescript
+ * import { resolveVersion, VersionError } from '@equinor/fusion-framework-module-msal/versioning';
+ *
+ * try {
+ *   const result = resolveVersion('2.1.0');
+ *   console.log('Version is compatible:', result.satisfiesLatest);
+ * } catch (error) {
+ *   if (error instanceof VersionError) {
+ *     console.error('Version error:', error.message);
+ *   }
+ * }
+ * ```
+ */
+// Core versioning functionality
+export { resolveVersion } from './resolve-version';
+// Error handling
+export { VersionError } from './VersionError';
+//# sourceMappingURL=index.js.map

package/dist/esm/versioning/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/versioning/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,gCAAgC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,iBAAiB;AACjB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/esm/versioning/resolve-version.js

@@ -0,0 +1,90 @@
+import semver from 'semver';
+import { MsalModuleVersion } from '../static';
+import { VersionError } from './VersionError';
+/**
+ * Resolves and validates a version string against the latest available MSAL version.
+ *
+ * This function performs comprehensive version checking including:
+ * - Parsing and validating the requested version
+ * - Checking major version compatibility (throws on incompatibility)
+ * - Warning on minor version mismatches (logs warning but continues)
+ * - Ignoring patch version differences for maximum compatibility
+ *
+ * @param version - The version string or SemVer object to resolve. If not provided, defaults to latest.
+ * @returns A ResolvedVersion object containing parsed versions and compatibility information
+ *
+ * @throws {VersionError} When the requested version is invalid or incompatible
+ *
+ * @example
+ * ```typescript
+ * // Resolve a specific version
+ * const result = resolveVersion('2.1.0');
+ * console.log(result.satisfiesLatest); // true if major version matches
+ *
+ * // Resolve with SemVer object
+ * const result2 = resolveVersion(new SemVer('2.0.0'));
+ *
+ * // Default to latest version
+ * const result3 = resolveVersion();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Error handling
+ * try {
+ *   const result = resolveVersion('3.0.0'); // Assuming latest is 2.x
+ * } catch (error) {
+ *   if (error instanceof VersionError) {
+ *     console.error('Version error:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export function resolveVersion(version) {
+    // Initialize warnings array to collect any version mismatches
+    const warnings = [];
+    // Parse the requested version, defaulting to latest if not provided
+    const versionString = version || MsalModuleVersion.Latest;
+    // Parse versions using coerce for backward compatibility
+    const wantedVersion = semver.coerce(versionString);
+    const latestVersion = semver.coerce(MsalModuleVersion.Latest);
+    // Validate that the requested version is a valid semver
+    if (!wantedVersion) {
+        throw VersionError.create(VersionError.Type.InvalidVersion, versionString, MsalModuleVersion.Latest);
+    }
+    // This should never happen! Indicates version.ts was not generated correctly
+    // This is a critical build-time issue that needs immediate attention
+    if (!latestVersion) {
+        throw VersionError.create(VersionError.Type.InvalidLatestVersion, versionString, MsalModuleVersion.Latest);
+    }
+    // Major version incompatibility check - this is a hard error
+    // Users cannot request a major version that doesn't exist yet
+    if (wantedVersion.major > latestVersion.major) {
+        throw VersionError.create(VersionError.Type.MajorIncompatibility, String(wantedVersion), String(latestVersion));
+    }
+    // Minor version mismatch - add warning but don't throw
+    // This helps developers stay aware of version differences without breaking functionality
+    if (wantedVersion.major === latestVersion.major && wantedVersion.minor !== latestVersion.minor) {
+        const minorMismatchWarning = VersionError.create(VersionError.Type.MinorMismatch, String(wantedVersion), String(latestVersion));
+        warnings.push(minorMismatchWarning.message);
+    }
+    // Find the corresponding enum version for the requested major version
+    // This is used for module configuration and feature detection
+    const enumVersion = Object.values(MsalModuleVersion).find((x) => semver.coerce(x)?.major === wantedVersion.major);
+    // If no matching enum version is found, this indicates a major version
+    // that doesn't have a corresponding enum value defined
+    if (!enumVersion) {
+        throw VersionError.create(VersionError.Type.MajorIncompatibility, String(wantedVersion), String(latestVersion));
+    }
+    // Return comprehensive version resolution result
+    return {
+        wantedVersion,
+        latestVersion,
+        isLatest: wantedVersion.compare(latestVersion) === 0,
+        satisfiesLatest: wantedVersion.major === latestVersion.major,
+        enumVersion,
+        warnings: warnings.length > 0 ? warnings : undefined,
+    };
+}
+export default resolveVersion;
+//# sourceMappingURL=resolve-version.js.map

package/dist/esm/versioning/resolve-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-version.js","sourceRoot":"","sources":["../../../src/versioning/resolve-version.ts"],"names":[],"mappings":"AAAA,OAAO,MAAuB,MAAM,QAAQ,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,cAAc,CAAC,OAAyB;IACtD,8DAA8D;IAC9D,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,oEAAoE;IACpE,MAAM,aAAa,GAAG,OAAO,IAAI,iBAAiB,CAAC,MAAM,CAAC;IAE1D,yDAAyD;IACzD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IACnD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAE9D,wDAAwD;IACxD,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,YAAY,CAAC,MAAM,CACvB,YAAY,CAAC,IAAI,CAAC,cAAc,EAChC,aAAa,EACb,iBAAiB,CAAC,MAAM,CACzB,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,qEAAqE;IACrE,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,YAAY,CAAC,MAAM,CACvB,YAAY,CAAC,IAAI,CAAC,oBAAoB,EACtC,aAAa,EACb,iBAAiB,CAAC,MAAM,CACzB,CAAC;IACJ,CAAC;IAED,6DAA6D;IAC7D,8DAA8D;IAC9D,IAAI,aAAa,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK,EAAE,CAAC;QAC9C,MAAM,YAAY,CAAC,MAAM,CACvB,YAAY,CAAC,IAAI,CAAC,oBAAoB,EACtC,MAAM,CAAC,aAAa,CAAC,EACrB,MAAM,CAAC,aAAa,CAAC,CACtB,CAAC;IACJ,CAAC;IAED,uDAAuD;IACvD,yFAAyF;IACzF,IAAI,aAAa,CAAC,KAAK,KAAK,aAAa,CAAC,KAAK,IAAI,aAAa,CAAC,KAAK,KAAK,aAAa,CAAC,KAAK,EAAE,CAAC;QAC/F,MAAM,oBAAoB,GAAG,YAAY,CAAC,MAAM,CAC9C,YAAY,CAAC,IAAI,CAAC,aAAa,EAC/B,MAAM,CAAC,aAAa,CAAC,EACrB,MAAM,CAAC,aAAa,CAAC,CACtB,CAAC;QACF,QAAQ,CAAC,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED,sEAAsE;IACtE,8DAA8D;IAC9D,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,IAAI,CACvD,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,aAAa,CAAC,KAAK,CACvD,CAAC;IAEF,uEAAuE;IACvE,uDAAuD;IACvD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,YAAY,CAAC,MAAM,CACvB,YAAY,CAAC,IAAI,CAAC,oBAAoB,EACtC,MAAM,CAAC,aAAa,CAAC,EACrB,MAAM,CAAC,aAAa,CAAC,CACtB,CAAC;IACJ,CAAC;IAED,iDAAiD;IACjD,OAAO;QACL,aAAa;QACb,aAAa;QACb,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC;QACpD,eAAe,EAAE,aAAa,CAAC,KAAK,KAAK,aAAa,CAAC,KAAK;QAC5D,WAAW;QACX,QAAQ,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS;KAC3B,CAAC;AAC9B,CAAC;AAED,eAAe,cAAc,CAAC"}

package/dist/esm/versioning/static.js

@@ -0,0 +1,10 @@
+export var VersionMessageType;
+(function (VersionMessageType) {
+    VersionMessageType["MajorIncompatibility"] = "major-incompatibility";
+    VersionMessageType["MinorMismatch"] = "minor-mismatch";
+    VersionMessageType["PatchDifference"] = "patch-difference";
+    VersionMessageType["InvalidVersion"] = "invalid-version";
+    VersionMessageType["InvalidLatestVersion"] = "invalid-latest-version";
+    VersionMessageType["IncompatibleVersion"] = "incompatible-version";
+})(VersionMessageType || (VersionMessageType = {}));
+//# sourceMappingURL=static.js.map

package/dist/esm/versioning/static.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.js","sourceRoot":"","sources":["../../../src/versioning/static.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,kBAOX;AAPD,WAAY,kBAAkB;IAC5B,oEAA8C,CAAA;IAC9C,sDAAgC,CAAA;IAChC,0DAAoC,CAAA;IACpC,wDAAkC,CAAA;IAClC,qEAA+C,CAAA;IAC/C,kEAA4C,CAAA;AAC9C,CAAC,EAPW,kBAAkB,KAAlB,kBAAkB,QAO7B"}

package/dist/esm/versioning/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/versioning/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/versioning/types.ts"],"names":[],"mappings":""}