@memberjunction/react-runtime 6.2.0-edge.0 → 6.2.0-edge.1

package/src/utilities/library-dependency-resolver.ts

@@ -33,7 +33,7 @@ export class LibraryDependencyResolver {
    * @param json - JSON string containing dependencies
    * @returns Map of library name to version specification
    */
-  parseDependencies(json: string | null): Map<string, string> {
+  ParseDependencies(json: string | null): Map<string, string> {
     const dependencies = new Map<string, string>();
     
     if (!json || json.trim() === '') {
@@ -56,18 +56,23 @@ export class LibraryDependencyResolver {
     return dependencies;
   }
 
+  /** @deprecated Use {@link ParseDependencies}. */
+  parseDependencies(json: string | null): Map<string, string> {
+    return this.ParseDependencies(json);
+  }
+
   /**
    * Build a dependency graph from a collection of libraries
    * @param libraries - All available libraries
    * @returns Dependency graph structure
    */
-  buildDependencyGraph(libraries: MJComponentLibraryEntity[]): DependencyGraph {
+  BuildDependencyGraph(libraries: MJComponentLibraryEntity[]): DependencyGraph {
     const nodes = new Map<string, DependencyNode>();
     const roots = new Set<string>();
 
     // First pass: create nodes for all libraries
     for (const library of libraries) {
-      const dependencies = this.parseDependencies(library.Dependencies);
+      const dependencies = this.ParseDependencies(library.Dependencies);
       nodes.set(library.Name, {
         library,
         dependencies,
@@ -95,12 +100,17 @@ export class LibraryDependencyResolver {
     return { nodes, roots };
   }
 
+  /** @deprecated Use {@link BuildDependencyGraph}. */
+  buildDependencyGraph(libraries: MJComponentLibraryEntity[]): DependencyGraph {
+    return this.BuildDependencyGraph(libraries);
+  }
+
   /**
    * Detect circular dependencies in the graph
    * @param graph - Dependency graph
    * @returns Array of cycles found
    */
-  detectCycles(graph: DependencyGraph): string[][] {
+  DetectCycles(graph: DependencyGraph): string[][] {
     const cycles: string[][] = [];
     const visited = new Set<string>();
     const recursionStack = new Set<string>();
@@ -139,12 +149,17 @@ export class LibraryDependencyResolver {
     return cycles;
   }
 
+  /** @deprecated Use {@link DetectCycles}. */
+  detectCycles(graph: DependencyGraph): string[][] {
+    return this.DetectCycles(graph);
+  }
+
   /**
    * Perform topological sort to determine load order
    * @param graph - Dependency graph
    * @returns Sorted array of libraries to load in order
    */
-  topologicalSort(graph: DependencyGraph): MJComponentLibraryEntity[] {
+  TopologicalSort(graph: DependencyGraph): MJComponentLibraryEntity[] {
     const result: MJComponentLibraryEntity[] = [];
     const visited = new Set<string>();
     const tempMarked = new Set<string>();
@@ -190,6 +205,11 @@ export class LibraryDependencyResolver {
     return result;
   }
 
+  /** @deprecated Use {@link TopologicalSort}. */
+  topologicalSort(graph: DependencyGraph): MJComponentLibraryEntity[] {
+    return this.TopologicalSort(graph);
+  }
+
   /**
    * Parse a semver version string
    * @param version - Version string (e.g., "1.2.3")
@@ -332,7 +352,7 @@ export class LibraryDependencyResolver {
    * @param availableLibraries - All available libraries to choose from
    * @returns Resolved version information
    */
-  resolveVersionConflicts(
+  ResolveVersionConflicts(
     requirements: VersionRequirement[],
     availableLibraries: MJComponentLibraryEntity[]
   ): ResolvedVersion {
@@ -405,6 +425,14 @@ export class LibraryDependencyResolver {
     };
   }
 
+  /** @deprecated Use {@link ResolveVersionConflicts}. */
+  resolveVersionConflicts(
+    requirements: VersionRequirement[],
+    availableLibraries: MJComponentLibraryEntity[]
+  ): ResolvedVersion {
+    return this.ResolveVersionConflicts(requirements, availableLibraries);
+  }
+
   /**
    * Get the load order for a set of requested libraries
    * @param requestedLibs - Library names requested
@@ -412,7 +440,7 @@ export class LibraryDependencyResolver {
    * @param options - Resolution options
    * @returns Load order result
    */
-  getLoadOrder(
+  GetLoadOrder(
     requestedLibs: string[],
     allLibs: MJComponentLibraryEntity[],
     options?: DependencyResolutionOptions
@@ -492,7 +520,7 @@ export class LibraryDependencyResolver {
 
       // For now, use the first version found (should be resolved properly)
       const lib = libVersions[0];
-      const deps = this.parseDependencies(lib.Dependencies);
+      const deps = this.ParseDependencies(lib.Dependencies);
       
       if ((this.debug || options?.debug) && deps.size > 0) {
         console.log(`    📌 ${current} requires:`, Array.from(deps.entries()));
@@ -537,7 +565,7 @@ export class LibraryDependencyResolver {
 
       if (requirements.length > 0) {
         try {
-          const resolved = this.resolveVersionConflicts(requirements, versions);
+          const resolved = this.ResolveVersionConflicts(requirements, versions);
           const selectedLib = versions.find(lib => lib.Version === resolved.version);
           if (selectedLib) {
             resolvedLibraries.push(selectedLib);
@@ -557,10 +585,10 @@ export class LibraryDependencyResolver {
     }
 
     // Build dependency graph with resolved libraries
-    const graph = this.buildDependencyGraph(resolvedLibraries);
+    const graph = this.BuildDependencyGraph(resolvedLibraries);
 
     // Check for cycles
-    const cycles = this.detectCycles(graph);
+    const cycles = this.DetectCycles(graph);
     if (cycles.length > 0) {
       errors.push(`Circular dependencies detected: ${cycles.map(c => c.join(' -> ')).join(', ')}`);
       return {
@@ -572,7 +600,7 @@ export class LibraryDependencyResolver {
     }
 
     // Perform topological sort
-    const sorted = this.topologicalSort(graph);
+    const sorted = this.TopologicalSort(graph);
 
     if (this.debug || options?.debug) {
       console.log('✅ Load order determined:', sorted.map(lib => `${lib.Name}@${lib.Version}`));
@@ -586,13 +614,27 @@ export class LibraryDependencyResolver {
     };
   }
 
+  /** @deprecated Use {@link GetLoadOrder}. */
+  getLoadOrder(
+    requestedLibs: string[],
+    allLibs: MJComponentLibraryEntity[],
+    options?: DependencyResolutionOptions
+  ): LoadOrderResult {
+    return this.GetLoadOrder(requestedLibs, allLibs, options);
+  }
+
   /**
    * Get direct dependencies of a library
    * @param library - Library to get dependencies for
    * @returns Map of dependency names to version specs
    */
+  GetDirectDependencies(library: MJComponentLibraryEntity): Map<string, string> {
+    return this.ParseDependencies(library.Dependencies);
+  }
+
+  /** @deprecated Use {@link GetDirectDependencies}. */
   getDirectDependencies(library: MJComponentLibraryEntity): Map<string, string> {
-    return this.parseDependencies(library.Dependencies);
+    return this.GetDirectDependencies(library);
   }
 
   /**
@@ -602,7 +644,7 @@ export class LibraryDependencyResolver {
    * @param maxDepth - Maximum depth to traverse
    * @returns Set of all dependency names (including transitive)
    */
-  getTransitiveDependencies(
+  GetTransitiveDependencies(
     libraryName: string,
     allLibs: MJComponentLibraryEntity[],
     maxDepth: number = 10
@@ -626,7 +668,7 @@ export class LibraryDependencyResolver {
       const lib = libMap.get(current.toLowerCase());
       if (!lib) continue;
 
-      const deps = this.parseDependencies(lib.Dependencies);
+      const deps = this.ParseDependencies(lib.Dependencies);
       for (const [depName] of deps) {
         dependencies.add(depName);
         if (!processed.has(depName)) {
@@ -639,4 +681,13 @@ export class LibraryDependencyResolver {
 
     return dependencies;
   }
+
+  /** @deprecated Use {@link GetTransitiveDependencies}. */
+  getTransitiveDependencies(
+    libraryName: string,
+    allLibs: MJComponentLibraryEntity[],
+    maxDepth: number = 10
+  ): Set<string> {
+    return this.GetTransitiveDependencies(libraryName, allLibs, maxDepth);
+  }
 }

package/src/utilities/library-loader.ts

@@ -9,7 +9,7 @@ import {
   StandardLibraryManager
 } from './standard-libraries';
 import { LibraryConfiguration, ExternalLibraryConfig, LibraryLoadOptions as ConfigLoadOptions } from '../types/library-config';
-import { getCoreRuntimeLibraries, isCoreRuntimeLibrary } from './core-libraries';
+import { GetCoreRuntimeLibraries, IsCoreRuntimeLibrary } from './core-libraries';
 import { resourceManager } from './resource-manager';
 import { MJComponentLibraryEntity } from '@memberjunction/core-entities';
 import { LibraryDependencyResolver } from './library-dependency-resolver';
@@ -63,7 +63,7 @@ export class LibraryLoader {
   /**
    * Enable progressive delay for library initialization (useful for test harness)
    */
-  public static enableProgressiveDelay: boolean = false;
+  public static enableProgressiveDelay: boolean = false;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
 
   /**
    * Inject `<link rel="preload" as="script">` tags for core runtime libraries
@@ -77,10 +77,10 @@ export class LibraryLoader {
    *
    * @param debug Whether to preload development builds (default: false = production)
    */
-  static preloadCoreScripts(debug: boolean = false): void {
+  static PreloadCoreScripts(debug: boolean = false): void {
     if (typeof document === 'undefined') return; // SSR guard
 
-    const coreLibraries = getCoreRuntimeLibraries(debug);
+    const coreLibraries = GetCoreRuntimeLibraries(debug);
     for (const lib of coreLibraries) {
       // Skip if already preloaded or loaded
       if (document.querySelector(`link[href="${lib.cdnUrl}"]`) ||
@@ -97,6 +97,11 @@ export class LibraryLoader {
     }
   }
 
+  /** @deprecated Use {@link PreloadCoreScripts}. */
+  static preloadCoreScripts(debug: boolean = false): void {
+    return this.PreloadCoreScripts(debug);
+  }
+
   /**
    * Load all standard libraries (core + UI + CSS)
    * This is the main method that should be used by test harness and Angular wrapper
@@ -104,7 +109,7 @@ export class LibraryLoader {
    * @param additionalLibraries Optional additional libraries to merge with the configuration
    * @param options Optional options including debug mode flag
    */
-  static async loadAllLibraries(
+  static async LoadAllLibraries(
     config?: LibraryConfiguration, 
     additionalLibraries?: ExternalLibraryConfig[],
     options?: { debug?: boolean }
@@ -126,20 +131,29 @@ export class LibraryLoader {
       StandardLibraryManager.setConfiguration(mergedConfig);
     }
     
-    return this.loadLibrariesFromConfig(undefined, options?.debug);
+    return this.LoadLibrariesFromConfig(undefined, options?.debug);
+  }
+
+  /** @deprecated Use {@link LoadAllLibraries}. */
+  static async loadAllLibraries(
+    config?: LibraryConfiguration, 
+    additionalLibraries?: ExternalLibraryConfig[],
+    options?: { debug?: boolean }
+  ): Promise<LibraryLoadResult> {
+    return this.LoadAllLibraries(config, additionalLibraries, options);
   }
 
   /**
    * Load libraries based on the current configuration
    */
-  static async loadLibrariesFromConfig(options?: ConfigLoadOptions, debug?: boolean): Promise<LibraryLoadResult> {
+  static async LoadLibrariesFromConfig(options?: ConfigLoadOptions, debug?: boolean): Promise<LibraryLoadResult> {
     // Load core runtime libraries in dependency order.
     // ReactDOM's UMD factory captures `window.React` at execution time,
     // so React MUST execute before ReactDOM. Loading them in parallel with
     // async scripts causes an intermittent race condition where ReactDOM
     // executes first and gets `undefined` for React, permanently breaking
     // `createRoot` on that object instance.
-    const coreLibraries = getCoreRuntimeLibraries(debug);
+    const coreLibraries = GetCoreRuntimeLibraries(debug);
     const reactLib = coreLibraries.find(lib => lib.globalVariable === 'React');
     const reactDOMLib = coreLibraries.find(lib => lib.globalVariable === 'ReactDOM');
     const babelLib = coreLibraries.find(lib => lib.globalVariable === 'Babel');
@@ -190,7 +204,7 @@ export class LibraryLoader {
     const enabledLibraries = StandardLibraryManager.getEnabledLibraries();
     
     // Filter out any core runtime libraries from plugin configuration
-    let pluginLibraries = enabledLibraries.filter(lib => !isCoreRuntimeLibrary(lib.id));
+    let pluginLibraries = enabledLibraries.filter(lib => !IsCoreRuntimeLibrary(lib.id));
     
     // Apply options filters if provided
     if (options) {
@@ -233,6 +247,11 @@ export class LibraryLoader {
     };
   }
 
+  /** @deprecated Use {@link LoadLibrariesFromConfig}. */
+  static async loadLibrariesFromConfig(options?: ConfigLoadOptions, debug?: boolean): Promise<LibraryLoadResult> {
+    return this.LoadLibrariesFromConfig(options, debug);
+  }
+
   /**
    * Load libraries with specific options (backward compatibility)
    * @deprecated Use loadLibrariesFromConfig instead
@@ -254,7 +273,7 @@ export class LibraryLoader {
       categoriesToLoad.push('ui');
     }
     
-    const result = await this.loadLibrariesFromConfig({
+    const result = await this.LoadLibrariesFromConfig({
       categories: categoriesToLoad
     });
     
@@ -634,14 +653,19 @@ export class LibraryLoader {
   /**
    * Get all loaded resources (for cleanup)
    */
-  static getLoadedResources(): Map<string, LoadedResource> {
+  static GetLoadedResources(): Map<string, LoadedResource> {
     return this.loadedResources;
   }
 
+  /** @deprecated Use {@link GetLoadedResources}. */
+  static getLoadedResources(): Map<string, LoadedResource> {
+    return this.GetLoadedResources();
+  }
+
   /**
    * Clear loaded resources cache and cleanup DOM elements
    */
-  static clearCache(): void {
+  static ClearCache(): void {
     // Remove all script and link elements we added
     this.loadedResources.forEach((resource, url) => {
       if (resource.element && resource.element.parentNode) {
@@ -656,6 +680,11 @@ export class LibraryLoader {
     resourceManager.cleanupComponent(LIBRARY_LOADER_COMPONENT_ID);
   }
 
+  /** @deprecated Use {@link ClearCache}. */
+  static clearCache(): void {
+    return this.ClearCache();
+  }
+
   /**
    * Load a library with its dependencies
    * @param libraryName - Name of the library to load
@@ -664,7 +693,7 @@ export class LibraryLoader {
    * @param options - Dependency resolution options
    * @returns Promise resolving to the loaded library global object
    */
-  static async loadLibraryWithDependencies(
+  static async LoadLibraryWithDependencies(
     libraryName: string,
     allLibraries: MJComponentLibraryEntity[],
     requestedBy: string = 'user',
@@ -781,6 +810,16 @@ export class LibraryLoader {
     return (window as any)[targetLibrary.GlobalVariable];
   }
 
+  /** @deprecated Use {@link LoadLibraryWithDependencies}. */
+  static async loadLibraryWithDependencies(
+    libraryName: string,
+    allLibraries: MJComponentLibraryEntity[],
+    requestedBy: string = 'user',
+    options?: DependencyResolutionOptions
+  ): Promise<any> {
+    return this.LoadLibraryWithDependencies(libraryName, allLibraries, requestedBy, options);
+  }
+
   /**
    * Load multiple libraries with dependency resolution
    * @param libraryNames - Names of libraries to load
@@ -789,7 +828,7 @@ export class LibraryLoader {
    * @param options - Dependency resolution options
    * @returns Map of library names to their loaded global objects
    */
-  static async loadLibrariesWithDependencies(
+  static async LoadLibrariesWithDependencies(
     libraryNames: string[],
     allLibraries: MJComponentLibraryEntity[],
     requestedBy: string = 'user',
@@ -918,29 +957,54 @@ export class LibraryLoader {
     return result;
   }
 
+  /** @deprecated Use {@link LoadLibrariesWithDependencies}. */
+  static async loadLibrariesWithDependencies(
+    libraryNames: string[],
+    allLibraries: MJComponentLibraryEntity[],
+    requestedBy: string = 'user',
+    options?: DependencyResolutionOptions
+  ): Promise<Map<string, any>> {
+    return this.LoadLibrariesWithDependencies(libraryNames, allLibraries, requestedBy, options);
+  }
+
   /**
    * Get information about loaded libraries
    * @returns Map of loaded library states
    */
-  static getLoadedLibraryStates(): Map<string, LoadedLibraryState> {
+  static GetLoadedLibraryStates(): Map<string, LoadedLibraryState> {
     return new Map(this.loadedLibraryStates);
   }
 
+  /** @deprecated Use {@link GetLoadedLibraryStates}. */
+  static getLoadedLibraryStates(): Map<string, LoadedLibraryState> {
+    return this.GetLoadedLibraryStates();
+  }
+
   /**
    * Check if a library is loaded
    * @param libraryName - Name of the library
    * @returns True if the library is loaded
    */
-  static isLibraryLoaded(libraryName: string): boolean {
+  static IsLibraryLoaded(libraryName: string): boolean {
     return this.loadedLibraryStates.has(libraryName);
   }
 
+  /** @deprecated Use {@link IsLibraryLoaded}. */
+  static isLibraryLoaded(libraryName: string): boolean {
+    return this.IsLibraryLoaded(libraryName);
+  }
+
   /**
    * Get the version of a loaded library
    * @param libraryName - Name of the library
    * @returns Version string or undefined if not loaded
    */
-  static getLoadedLibraryVersion(libraryName: string): string | undefined {
+  static GetLoadedLibraryVersion(libraryName: string): string | undefined {
     return this.loadedLibraryStates.get(libraryName)?.version;
   }
+
+  /** @deprecated Use {@link GetLoadedLibraryVersion}. */
+  static getLoadedLibraryVersion(libraryName: string): string | undefined {
+    return this.GetLoadedLibraryVersion(libraryName);
+  }
 }

package/src/utilities/library-registry.ts

@@ -77,20 +77,25 @@ export class LibraryRegistry {
   /**
    * Get library definition by name
    */
-  static getLibrary(name: string): LibraryDefinition | undefined {
+  static GetLibrary(name: string): LibraryDefinition | undefined {
     if (!this._configured)
       throw new Error("LibraryRegistry is not configured, call LibraryRegistry.Config() before using!");
 
     return this.libraries.get(name?.trim().toLowerCase());
   }
 
+  /** @deprecated Use {@link GetLibrary}. */
+  static getLibrary(name: string): LibraryDefinition | undefined {
+    return this.GetLibrary(name);
+  }
+
   /**
    * Get CDN URL for a library
    * @param name Library name
    * @param version Optional version (uses default if not specified)
    * @returns CDN URL or undefined if library/version not found
    */
-  static getCdnUrl(name: string, version?: string): string | undefined {
+  static GetCdnUrl(name: string, version?: string): string | undefined {
     if (!this._configured)
       throw new Error("LibraryRegistry is not configured, call LibraryRegistry.Config() before using!");
 
@@ -101,22 +106,32 @@ export class LibraryRegistry {
     return library.versions[targetVersion]?.cdnUrl;
   }
 
+  /** @deprecated Use {@link GetCdnUrl}. */
+  static getCdnUrl(name: string, version?: string): string | undefined {
+    return this.GetCdnUrl(name, version);
+  }
+
   /**
    * Check if a library is approved
    */
-  static isApproved(name: string): boolean {
+  static IsApproved(name: string): boolean {
     if (!this._configured)
       throw new Error("LibraryRegistry is not configured, call LibraryRegistry.Config() before using!");
 
     return this.libraries.has(name?.trim().toLowerCase());
   }
 
+  /** @deprecated Use {@link IsApproved}. */
+  static isApproved(name: string): boolean {
+    return this.IsApproved(name);
+  }
+
   /**
    * Resolve library version based on semver-like pattern
    * For now, just returns exact match or default
    * TODO: Implement proper semver resolution
    */
-  static resolveVersion(name: string, versionPattern?: string): string | undefined {
+  static ResolveVersion(name: string, versionPattern?: string): string | undefined {
     if (!this._configured)
       throw new Error("LibraryRegistry is not configured, call LibraryRegistry.Config() before using!");
 
@@ -135,15 +150,25 @@ export class LibraryRegistry {
     return library.defaultVersion;
   }
 
+  /** @deprecated Use {@link ResolveVersion}. */
+  static resolveVersion(name: string, versionPattern?: string): string | undefined {
+    return this.ResolveVersion(name, versionPattern);
+  }
+
   /**
    * Add a library to the registry (for future extensibility)
    * This would typically be called during app initialization
    * with libraries loaded from a database
    */
-  static registerLibrary(definition: LibraryDefinition): void {
+  static RegisterLibrary(definition: LibraryDefinition): void {
     if (!this._configured)
       throw new Error("LibraryRegistry is not configured, call LibraryRegistry.Config() before using!");
 
     this.libraries.set(definition.name?.trim().toLowerCase(), definition);
   }
+
+  /** @deprecated Use {@link RegisterLibrary}. */
+  static registerLibrary(definition: LibraryDefinition): void {
+    return this.RegisterLibrary(definition);
+  }
 }