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

package/src/runtime/react-root-manager.ts

@@ -60,7 +60,7 @@ export class ReactRootManager {
    * @param componentId - Optional component ID for resource tracking
    * @returns The root ID for future operations
    */
-  createRoot(
+  CreateRoot(
     container: HTMLElement,
     createRootFn: (container: HTMLElement) => any,
     componentId?: string
@@ -83,7 +83,7 @@ export class ReactRootManager {
       resourceManager.registerReactRoot(
         componentId,
         root,
-        () => this.unmountRoot(rootId)
+        () => this.UnmountRoot(rootId)
       );
     }
 
@@ -99,6 +99,15 @@ export class ReactRootManager {
     
     return rootId;
   }
+
+  /** @deprecated Use {@link CreateRoot}. */
+  createRoot(
+    container: HTMLElement,
+    createRootFn: (container: HTMLElement) => any,
+    componentId?: string
+  ): string {
+    return this.CreateRoot(container, createRootFn, componentId);
+  }
   
   /**
    * Safely render content to a React root
@@ -160,7 +169,7 @@ export class ReactRootManager {
    * @param rootId - The root ID
    * @param force - Force unmount even if rendering
    */
-  unmountRoot(rootId: string, force: boolean = false): Promise<void> {
+  UnmountRoot(rootId: string, force: boolean = false): Promise<void> {
     return new Promise((resolve) => {
       const managedRoot = this.roots.get(rootId);
       if (!managedRoot) {
@@ -205,12 +214,17 @@ export class ReactRootManager {
       }
     });
   }
+
+  /** @deprecated Use {@link UnmountRoot}. */
+  unmountRoot(rootId: string, force: boolean = false): Promise<void> {
+    return this.UnmountRoot(rootId, force);
+  }
   
   /**
    * Unmount all roots associated with a component
    * @param componentId - The component ID
    */
-  async unmountComponentRoots(componentId: string): Promise<void> {
+  async UnmountComponentRoots(componentId: string): Promise<void> {
     const rootIds: string[] = [];
     
     for (const [rootId, managedRoot] of this.roots) {
@@ -219,7 +233,12 @@ export class ReactRootManager {
       }
     }
     
-    await Promise.all(rootIds.map(id => this.unmountRoot(id)));
+    await Promise.all(rootIds.map(id => this.UnmountRoot(id)));
+  }
+
+  /** @deprecated Use {@link UnmountComponentRoots}. */
+  async unmountComponentRoots(componentId: string): Promise<void> {
+    return this.UnmountComponentRoots(componentId);
   }
   
   /**
@@ -227,14 +246,19 @@ export class ReactRootManager {
    * @param rootId - The root ID
    * @returns true if rendering
    */
-  isRendering(rootId: string): boolean {
+  IsRendering(rootId: string): boolean {
     return this.renderingRoots.has(rootId);
   }
+
+  /** @deprecated Use {@link IsRendering}. */
+  isRendering(rootId: string): boolean {
+    return this.IsRendering(rootId);
+  }
   
   /**
    * Get statistics about managed roots
    */
-  getStats(): {
+  GetStats(): {
     totalRoots: number;
     renderingRoots: number;
     pendingUnmounts: number;
@@ -246,20 +270,34 @@ export class ReactRootManager {
     };
   }
 
+  /** @deprecated Use {@link GetStats}. */
+  getStats(): {
+    totalRoots: number;
+    renderingRoots: number;
+    pendingUnmounts: number;
+  } {
+    return this.GetStats();
+  }
+
   /**
    * Clean up all roots (for testing or shutdown)
    */
-  async cleanup(): Promise<void> {
+  async Cleanup(): Promise<void> {
     // Invoke cleanup hooks before unmounting roots
     this.invokeHooks('OnCleanup');
 
     const allRootIds = Array.from(this.roots.keys());
-    await Promise.all(allRootIds.map(id => this.unmountRoot(id, true)));
+    await Promise.all(allRootIds.map(id => this.UnmountRoot(id, true)));
 
     // Reset state so hooks fire again if runtime is re-initialized
     this.firstRootCreated = false;
   }
 
+  /** @deprecated Use {@link Cleanup}. */
+  async cleanup(): Promise<void> {
+    return this.Cleanup();
+  }
+
   /**
    * Safely invoke a lifecycle method on all registered hooks.
    * Errors in individual hooks are caught and logged so one
@@ -280,4 +318,4 @@ export class ReactRootManager {
 }
 
 // Singleton instance
-export const reactRootManager = new ReactRootManager();
+export const reactRootManager = new ReactRootManager();  // case-violation-ok-legacy-back-compat: the PascalCase name is already taken in this scope

package/src/utilities/cache-manager.ts

@@ -43,7 +43,7 @@ export class CacheManager<T = unknown> {
   /**
    * Set a value in the cache
    */
-  set(key: string, value: T, ttl?: number): void {
+  Set(key: string, value: T, ttl?: number): void {
     const size = this.estimateSize(value);
     const entry: CacheEntry<T> = {
       value,
@@ -83,22 +83,27 @@ export class CacheManager<T = unknown> {
       const timeout = ttl || this.options.defaultTTL;
       const timerId = setTimeout(() => {
         this.timers.delete(key);
-        this.delete(key);
+        this.Delete(key);
       }, timeout);
       this.timers.set(key, timerId);
     }
   }
 
+  /** @deprecated Use {@link Set}. */
+  set(key: string, value: T, ttl?: number): void {
+    return this.Set(key, value, ttl);
+  }
+
   /**
    * Get a value from the cache
    */
-  get(key: string): T | undefined {
+  Get(key: string): T | undefined {
     const entry = this.cache.get(key);
     if (!entry) return undefined;
 
     // Check if expired
     if (this.isExpired(entry)) {
-      this.delete(key);
+      this.Delete(key);
       return undefined;
     }
 
@@ -107,25 +112,35 @@ export class CacheManager<T = unknown> {
     return entry.value;
   }
 
+  /** @deprecated Use {@link Get}. */
+  get(key: string): T | undefined {
+    return this.Get(key);
+  }
+
   /**
    * Check if a key exists and is not expired
    */
-  has(key: string): boolean {
+  Has(key: string): boolean {
     const entry = this.cache.get(key);
     if (!entry) return false;
 
     if (this.isExpired(entry)) {
-      this.delete(key);
+      this.Delete(key);
       return false;
     }
 
     return true;
   }
 
+  /** @deprecated Use {@link Has}. */
+  has(key: string): boolean {
+    return this.Has(key);
+  }
+
   /**
    * Delete a key from the cache
    */
-  delete(key: string): boolean {
+  Delete(key: string): boolean {
     const timer = this.timers.get(key);
     if (timer !== undefined) {
       clearTimeout(timer);
@@ -139,10 +154,15 @@ export class CacheManager<T = unknown> {
     return false;
   }
 
+  /** @deprecated Use {@link Delete}. */
+  delete(key: string): boolean {
+    return this.Delete(key);
+  }
+
   /**
    * Clear all entries
    */
-  clear(): void {
+  Clear(): void {
     for (const timer of this.timers.values()) {
       clearTimeout(timer);
     }
@@ -151,10 +171,15 @@ export class CacheManager<T = unknown> {
     this.memoryUsage = 0;
   }
 
+  /** @deprecated Use {@link Clear}. */
+  clear(): void {
+    return this.Clear();
+  }
+
   /**
    * Get cache statistics
    */
-  getStats(): {
+  GetStats(): {
     size: number;
     memoryUsage: number;
     maxSize: number;
@@ -168,16 +193,26 @@ export class CacheManager<T = unknown> {
     };
   }
 
+  /** @deprecated Use {@link GetStats}. */
+  getStats(): {
+    size: number;
+    memoryUsage: number;
+    maxSize: number;
+    maxMemory: number;
+  } {
+    return this.GetStats();
+  }
+
   /**
    * Manually trigger cleanup
    */
-  cleanup(): number {
+  Cleanup(): number {
     let removed = 0;
     const now = Date.now();
 
     for (const [key, entry] of this.cache) {
       if (this.isExpired(entry, now)) {
-        this.delete(key);
+        this.Delete(key);
         removed++;
       }
     }
@@ -185,12 +220,22 @@ export class CacheManager<T = unknown> {
     return removed;
   }
 
+  /** @deprecated Use {@link Cleanup}. */
+  cleanup(): number {
+    return this.Cleanup();
+  }
+
   /**
    * Destroy the cache, cancel all entry timers, and stop the cleanup timer.
    */
-  destroy(): void {
+  Destroy(): void {
     this.stopCleanupTimer();
-    this.clear();
+    this.Clear();
+  }
+
+  /** @deprecated Use {@link Destroy}. */
+  destroy(): void {
+    return this.Destroy();
   }
 
   /**
@@ -217,7 +262,7 @@ export class CacheManager<T = unknown> {
     }
 
     if (lruKey) {
-      this.delete(lruKey);
+      this.Delete(lruKey);
     }
   }
 
@@ -232,7 +277,7 @@ export class CacheManager<T = unknown> {
     for (const [key, entry] of entries) {
       if (freedMemory >= requiredSize) break;
       freedMemory += entry.size || 0;
-      this.delete(key);
+      this.Delete(key);
     }
   }
 
@@ -259,7 +304,7 @@ export class CacheManager<T = unknown> {
    */
   private startCleanupTimer(): void {
     this.cleanupTimer = setInterval(() => {
-      this.cleanup();
+      this.Cleanup();
     }, this.options.cleanupInterval);
   }
 

package/src/utilities/component-error-analyzer.ts

@@ -95,7 +95,7 @@ export class ComponentErrorAnalyzer {
    * @param errors Array of error messages
    * @returns Array of failed component names
    */
-  static identifyFailedComponents(errors: string[]): string[] {
+  static IdentifyFailedComponents(errors: string[]): string[] {
     const failedComponents = new Set<string>();
     
     for (const error of errors) {
@@ -106,12 +106,17 @@ export class ComponentErrorAnalyzer {
     return Array.from(failedComponents);
   }
 
+  /** @deprecated Use {@link IdentifyFailedComponents}. */
+  static identifyFailedComponents(errors: string[]): string[] {
+    return this.IdentifyFailedComponents(errors);
+  }
+
   /**
    * Analyzes errors and returns detailed information about failures
    * @param errors Array of error messages
    * @returns Array of detailed failure information
    */
-  static analyzeComponentErrors(errors: string[]): FailedComponentInfo[] {
+  static AnalyzeComponentErrors(errors: string[]): FailedComponentInfo[] {
     const failures: FailedComponentInfo[] = [];
     
     for (const error of errors) {
@@ -131,6 +136,11 @@ export class ComponentErrorAnalyzer {
     return Array.from(uniqueFailures.values());
   }
 
+  /** @deprecated Use {@link AnalyzeComponentErrors}. */
+  static analyzeComponentErrors(errors: string[]): FailedComponentInfo[] {
+    return this.AnalyzeComponentErrors(errors);
+  }
+
   /**
    * Extract component names from a single error message
    */
@@ -291,7 +301,7 @@ export class ComponentErrorAnalyzer {
   /**
    * Format error analysis results for logging
    */
-  static formatAnalysisResults(failures: FailedComponentInfo[]): string {
+  static FormatAnalysisResults(failures: FailedComponentInfo[]): string {
     if (failures.length === 0) {
       return 'No component failures detected';
     }
@@ -312,4 +322,9 @@ export class ComponentErrorAnalyzer {
     
     return result;
   }
+
+  /** @deprecated Use {@link FormatAnalysisResults}. */
+  static formatAnalysisResults(failures: FailedComponentInfo[]): string {
+    return this.FormatAnalysisResults(failures);
+  }
 }

package/src/utilities/component-hash.ts

@@ -24,7 +24,7 @@ import { ComponentSpec } from '@memberjunction/interactive-component-types';
  * @param spec The root component spec.
  * @returns A short version string of the form `v1a2b3c4d`.
  */
-export function generateComponentHierarchyHash(spec: ComponentSpec): string {
+export function GenerateComponentHierarchyHash(spec: ComponentSpec): string {
   const codeStrings: string[] = [];
 
   const collectCode = (s: ComponentSpec): void => {
@@ -52,3 +52,8 @@ export function generateComponentHierarchyHash(spec: ComponentSpec): string {
   const hexHash = Math.abs(hash).toString(16).padStart(8, '0').substring(0, 8);
   return `v${hexHash}`;
 }
+
+/** @deprecated Use {@link GenerateComponentHierarchyHash}. */
+export function generateComponentHierarchyHash(spec: ComponentSpec): string {
+  return GenerateComponentHierarchyHash(spec);
+}

package/src/utilities/component-library-theming.ts

@@ -19,7 +19,7 @@
  */
 
 import { ComponentStyles } from '@memberjunction/interactive-component-types';
-import { unwrapLibraryComponent } from './component-unwrapper';
+import { UnwrapLibraryComponent } from './component-unwrapper';
 
 /** Relative luminance (0 = black, 1 = white) of a hex or rgb()/rgba() color; 1 if unparseable. */
 function colorLuminance(color: string | undefined): number {
@@ -57,12 +57,12 @@ function radiusToNumber(radius: ComponentStyles['borders']['radius'] | undefined
  * module (used only to read its `theme` algorithm namespace). Unmapped tokens are
  * omitted so antd falls back to its own defaults.
  */
-export function buildAntdThemeConfig(
+export function BuildAntdThemeConfig(
   styles: Partial<ComponentStyles> | undefined,
   antdLib: unknown,
 ): Record<string, unknown> {
   const colors = (styles?.colors || {}) as Record<string, string | undefined>;
-  const themeNS = antdLib ? unwrapLibraryComponent(antdLib, 'theme') : undefined;
+  const themeNS = antdLib ? UnwrapLibraryComponent(antdLib, 'theme') : undefined;
   const isDark = colorLuminance(colors['background']) < 0.5;
 
   const token: Record<string, unknown> = {
@@ -94,6 +94,14 @@ export function buildAntdThemeConfig(
   return config;
 }
 
+/** @deprecated Use {@link BuildAntdThemeConfig}. */
+export function buildAntdThemeConfig(
+  styles: Partial<ComponentStyles> | undefined,
+  antdLib: unknown,
+): Record<string, unknown> {
+  return BuildAntdThemeConfig(styles, antdLib);
+}
+
 /**
  * Wraps a React element in loaded component libraries' theme providers so their
  * built-in components inherit the MJ theme (including dark mode). Currently themes
@@ -106,7 +114,7 @@ export function buildAntdThemeConfig(
  * this one (antd merges nested configs), so this is safe alongside component-level
  * theming.
  */
-export function wrapWithLibraryThemeProviders(
+export function WrapWithLibraryThemeProviders(
   React: { createElement: (type: unknown, props: unknown, ...children: unknown[]) => unknown },
   element: unknown,
   libraries: Record<string, unknown> | undefined,
@@ -115,13 +123,23 @@ export function wrapWithLibraryThemeProviders(
   const antdLib = libraries?.['antd'];
   if (!antdLib) return element;
 
-  const ConfigProvider = unwrapLibraryComponent(antdLib, 'ConfigProvider');
+  const ConfigProvider = UnwrapLibraryComponent(antdLib, 'ConfigProvider');
   if (!ConfigProvider) return element;
 
   try {
-    return React.createElement(ConfigProvider, { theme: buildAntdThemeConfig(styles, antdLib) }, element);
+    return React.createElement(ConfigProvider, { theme: BuildAntdThemeConfig(styles, antdLib) }, element);
   } catch {
     // Never let theming wrap break rendering — fall back to the unwrapped element.
     return element;
   }
 }
+
+/** @deprecated Use {@link WrapWithLibraryThemeProviders}. */
+export function wrapWithLibraryThemeProviders(
+  React: { createElement: (type: unknown, props: unknown, ...children: unknown[]) => unknown },
+  element: unknown,
+  libraries: Record<string, unknown> | undefined,
+  styles: Partial<ComponentStyles> | undefined,
+): unknown {
+  return WrapWithLibraryThemeProviders(React, element, libraries, styles);
+}

package/src/utilities/component-styles.ts

@@ -150,7 +150,10 @@ export function SetupStyles(): ComponentStyles {
 }
 
 // Also export with the original name for backward compatibility
-export const createDefaultComponentStyles = SetupStyles;
+export const CreateDefaultComponentStyles = SetupStyles;
+
+/** @deprecated Use {@link CreateDefaultComponentStyles}. */
+export const createDefaultComponentStyles = CreateDefaultComponentStyles;
 
 /**
  * The `--mj-*` semantic token → `ComponentStyles` mapping used by the theme bridge.

package/src/utilities/component-unwrapper.ts

@@ -262,7 +262,7 @@ function coreUnwrapLogic(library: any, exportName: string, debug: boolean = fals
  * @param debug - Whether to log debug information
  * @returns The unwrapped export or undefined if not found
  */
-export function unwrapLibraryComponent(library: any, exportName: string, debug: boolean = false): any {
+export function UnwrapLibraryComponent(library: any, exportName: string, debug: boolean = false): any {
   try {
     return coreUnwrapLogic(library, exportName, debug);
   } catch (error: any) {
@@ -273,6 +273,11 @@ export function unwrapLibraryComponent(library: any, exportName: string, debug:
   }
 }
 
+/** @deprecated Use {@link UnwrapLibraryComponent}. */
+export function unwrapLibraryComponent(library: any, exportName: string, debug: boolean = false): any {
+  return UnwrapLibraryComponent(library, exportName, debug);
+}
+
 /**
  * Unwraps multiple exports from a UMD library using varargs
  * Works with any type of export: components, utilities, objects, functions, etc.
@@ -280,7 +285,7 @@ export function unwrapLibraryComponent(library: any, exportName: string, debug:
  * @param exportNames - Export names to unwrap (e.g., 'Button', 'utils', 'writeFile')
  * @returns Object with export names as keys and unwrapped values as values
  */
-export function unwrapLibraryComponents(
+export function UnwrapLibraryComponents(
   library: any,
   ...exportNames: string[]
 ): Record<string, any> {
@@ -370,6 +375,14 @@ export function unwrapLibraryComponents(
   return components;
 }
 
+/** @deprecated Use {@link UnwrapLibraryComponents}. */
+export function unwrapLibraryComponents(
+  library: any,
+  ...exportNames: string[]
+): Record<string, any> {
+  return UnwrapLibraryComponents(library, ...exportNames);
+}
+
 /**
  * Auto-detects and unwraps all components from a library
  * Uses PascalCase detection to identify likely component exports
@@ -377,7 +390,7 @@ export function unwrapLibraryComponents(
  * @param debug - Whether to log debug information
  * @returns Object with all detected components
  */
-export function unwrapAllLibraryComponents(library: any, debug: boolean = false): Record<string, any> {
+export function UnwrapAllLibraryComponents(library: any, debug: boolean = false): Record<string, any> {
   const components: Record<string, any> = {};
   
   // Handle simple function/class case
@@ -473,9 +486,23 @@ export function unwrapAllLibraryComponents(library: any, debug: boolean = false)
   return components;
 }
 
+/** @deprecated Use {@link UnwrapAllLibraryComponents}. */
+export function unwrapAllLibraryComponents(library: any, debug: boolean = false): Record<string, any> {
+  return UnwrapAllLibraryComponents(library, debug);
+}
+
 // Legacy exports for backward compatibility
-export const unwrapComponent = unwrapLibraryComponent;
-export const unwrapComponents = (library: any, exportNames: string[], debug: boolean = false) => {
-  return unwrapLibraryComponents(library, ...exportNames, debug as any);
+export const UnwrapComponent = UnwrapLibraryComponent;
+
+/** @deprecated Use {@link UnwrapComponent}. */
+export const unwrapComponent = UnwrapComponent;
+export const UnwrapComponents = (library: any, exportNames: string[], debug: boolean = false) => {
+  return UnwrapLibraryComponents(library, ...exportNames, debug as any);
 };
-export const unwrapAllComponents = unwrapAllLibraryComponents;
+
+/** @deprecated Use {@link UnwrapComponents}. */
+export const unwrapComponents = UnwrapComponents;
+export const UnwrapAllComponents = UnwrapAllLibraryComponents;
+
+/** @deprecated Use {@link UnwrapAllComponents}. */
+export const unwrapAllComponents = UnwrapAllComponents;

package/src/utilities/core-libraries.ts

@@ -44,7 +44,7 @@ function getReactDOMFallbackUrl(debug: boolean = false): string {
  * Get the core runtime libraries configuration
  * @param debug Whether to use development builds for better error messages
  */
-export function getCoreRuntimeLibraries(debug: boolean = false): ExternalLibraryConfig[] {
+export function GetCoreRuntimeLibraries(debug: boolean = false): ExternalLibraryConfig[] {
   return [
     {
       id: 'react',
@@ -91,10 +91,20 @@ export function getCoreRuntimeLibraries(debug: boolean = false): ExternalLibrary
   ];
 }
 
+/** @deprecated Use {@link GetCoreRuntimeLibraries}. */
+export function getCoreRuntimeLibraries(debug: boolean = false): ExternalLibraryConfig[] {
+  return GetCoreRuntimeLibraries(debug);
+}
+
 /**
  * Check if a library ID is a core runtime library
  */
-export function isCoreRuntimeLibrary(libraryId: string): boolean {
-  const coreLibraries = getCoreRuntimeLibraries();
+export function IsCoreRuntimeLibrary(libraryId: string): boolean {
+  const coreLibraries = GetCoreRuntimeLibraries();
   return coreLibraries.some((lib: ExternalLibraryConfig) => lib.id === libraryId);
+}
+
+/** @deprecated Use {@link IsCoreRuntimeLibrary}. */
+export function isCoreRuntimeLibrary(libraryId: string): boolean {
+  return IsCoreRuntimeLibrary(libraryId);
 }

package/src/utilities/entity-record-key.ts

@@ -86,7 +86,7 @@ function coerceToCompositeKey(key: EntityRecordKeyInput): CompositeKey | null {
  *   the global default, so a host on a non-default provider resolves against its own server.
  * @param contextUser The acting user, for server-side callers.
  */
-export async function resolveEntityRecordKey(
+export async function ResolveEntityRecordKey(
   entityName: string,
   key: EntityRecordKeyInput,
   provider: IMetadataProvider,
@@ -140,3 +140,13 @@ export async function resolveEntityRecordKey(
     entity.PrimaryKeys.map((pk) => ({ FieldName: pk.Name, Value: row[pk.Name] }) as KeyValuePair)
   );
 }
+
+/** @deprecated Use {@link ResolveEntityRecordKey}. */
+export async function resolveEntityRecordKey(
+  entityName: string,
+  key: EntityRecordKeyInput,
+  provider: IMetadataProvider,
+  contextUser?: UserInfo
+): Promise<CompositeKey | null> {
+  return ResolveEntityRecordKey(entityName, key, provider, contextUser);
+}