@memberjunction/react-runtime 2.93.0 → 2.95.0

package/src/runtime/prop-builder.ts

@@ -4,8 +4,8 @@
  * @module @memberjunction/react-runtime/runtime
  */
 
-import { ComponentStyles } from '@memberjunction/interactive-component-types';
-import { ComponentProps, ComponentCallbacks } from '../types';
+import { ComponentStyles, ComponentCallbacks } from '@memberjunction/interactive-component-types';
+import { ComponentProps } from '../types';
 import { Subject, debounceTime, Subscription } from 'rxjs';
 
 /**
@@ -39,7 +39,10 @@ export function buildComponentProps(
   data: any = {},
   userState: any = {},
   utilities: any = {},
-  callbacks: ComponentCallbacks = {},
+  callbacks: ComponentCallbacks = {
+    OpenEntityRecord: () => {},
+    RegisterMethod: () => {}
+  },
   components: Record<string, any> = {},
   styles?: ComponentStyles,
   options: PropBuilderOptions = {},
@@ -116,15 +119,19 @@ function deepEqual(obj1: any, obj2: any): boolean {
  * @returns Normalized callbacks
  */
 export function normalizeCallbacks(callbacks: any, debounceMs: number = 3000): ComponentCallbacks {
-  const normalized: ComponentCallbacks = {};
-
-  // Ensure all callbacks are functions
-  if (callbacks.RefreshData && typeof callbacks.RefreshData === 'function') {
-    normalized.RefreshData = callbacks.RefreshData;
-  }
+  // Provide default implementations for required callbacks
+  const normalized: ComponentCallbacks = {
+    OpenEntityRecord: callbacks?.OpenEntityRecord || (() => {}),
+    RegisterMethod: callbacks?.RegisterMethod || (() => {})
+  };
 
-  if (callbacks.OpenEntityRecord && typeof callbacks.OpenEntityRecord === 'function') {
-    normalized.OpenEntityRecord = callbacks.OpenEntityRecord;
+  // Copy any additional callbacks that might exist
+  if (callbacks) {
+    Object.keys(callbacks).forEach(key => {
+      if (typeof callbacks[key] === 'function' && !normalized.hasOwnProperty(key)) {
+        (normalized as any)[key] = callbacks[key];
+      }
+    });
   }
 
   return normalized;
@@ -264,14 +271,20 @@ export function wrapCallbacksWithLogging(
   callbacks: ComponentCallbacks,
   componentName: string
 ): ComponentCallbacks {
-  const wrapped: ComponentCallbacks = {};
+  const wrapped: ComponentCallbacks = {
+    OpenEntityRecord: callbacks?.OpenEntityRecord || (() => {}),
+    RegisterMethod: callbacks?.RegisterMethod || (() => {})
+  };
 
-  if (callbacks.RefreshData) {
-    wrapped.RefreshData = () => {
-      console.log(`[${componentName}] RefreshData called`);
-      callbacks.RefreshData!();
-    };
-  }
+  // Wrap any additional callbacks that might exist
+  Object.keys(callbacks).forEach(key => {
+    if (key !== 'OpenEntityRecord' && key !== 'RegisterMethod' && typeof (callbacks as any)[key] === 'function') {
+      (wrapped as any)[key] = (...args: any[]) => {
+        console.log(`[${componentName}] ${key} called with args:`, args);
+        return (callbacks as any)[key](...args);
+      };
+    }
+  });
 
   if (callbacks.OpenEntityRecord) {
     wrapped.OpenEntityRecord = (entityName: string, key: any) => {
@@ -280,6 +293,13 @@ export function wrapCallbacksWithLogging(
     };
   }
 
+  if (callbacks.RegisterMethod) {
+    wrapped.RegisterMethod = (methodName: any, handler: any) => {
+      console.log(`[${componentName}] RegisterMethod called for:`, methodName);
+      callbacks.RegisterMethod!(methodName, handler);
+    };
+  }
+
   return wrapped;
 }
 

package/src/types/dependency-types.ts

@@ -0,0 +1,110 @@
+/**
+ * @fileoverview Type definitions for library dependency management
+ * @module @memberjunction/react-runtime/types
+ */
+
+import { ComponentLibraryEntity } from '@memberjunction/core-entities';
+
+/**
+ * Represents a parsed dependency with name and version specification
+ */
+export interface ParsedDependency {
+  name: string;
+  versionSpec: string;
+}
+
+/**
+ * Represents a version requirement for a library
+ */
+export interface VersionRequirement {
+  library: string;
+  versionSpec: string;
+  requestedBy: string; // Which library requested this dependency
+}
+
+/**
+ * Represents a resolved version after conflict resolution
+ */
+export interface ResolvedVersion {
+  library: string;
+  version: string;
+  satisfies: VersionRequirement[];
+  warnings?: string[];
+}
+
+/**
+ * Node in the dependency graph
+ */
+export interface DependencyNode {
+  library: ComponentLibraryEntity;
+  dependencies: Map<string, string>; // dependency name -> version spec
+  dependents: Set<string>; // libraries that depend on this one
+}
+
+/**
+ * Dependency graph structure
+ */
+export interface DependencyGraph {
+  nodes: Map<string, DependencyNode>;
+  roots: Set<string>; // libraries with no dependents
+}
+
+/**
+ * Result of determining load order
+ */
+export interface LoadOrderResult {
+  success: boolean;
+  order?: ComponentLibraryEntity[];
+  cycles?: string[][];
+  errors?: string[];
+  warnings?: string[];
+}
+
+/**
+ * Semver version range types
+ */
+export type VersionRangeType = 'exact' | 'tilde' | 'caret' | 'range' | 'any';
+
+/**
+ * Parsed semver version
+ */
+export interface ParsedVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease?: string;
+  build?: string;
+}
+
+/**
+ * Version range specification
+ */
+export interface VersionRange {
+  type: VersionRangeType;
+  operator?: string;
+  version?: ParsedVersion;
+  raw: string;
+}
+
+/**
+ * Library load state tracking
+ */
+export interface LoadedLibraryState {
+  name: string;
+  version: string;
+  globalVariable: string;
+  loadedAt: Date;
+  requestedBy: string[];
+  dependencies: string[];
+}
+
+/**
+ * Options for dependency resolution
+ */
+export interface DependencyResolutionOptions {
+  allowPrerelease?: boolean;
+  preferLatest?: boolean;
+  strict?: boolean; // Fail on any version conflict
+  maxDepth?: number; // Maximum dependency depth to prevent infinite recursion
+  debug?: boolean;
+}

package/src/types/index.ts

@@ -6,14 +6,14 @@
 
 import { UserInfo } from '@memberjunction/core';
 import { ComponentLibraryEntity } from '@memberjunction/core-entities';
-import { ComponentLibraryDependency, ComponentStyles } from '@memberjunction/interactive-component-types';
+import { ComponentLibraryDependency, ComponentStyles, ComponentObject } from '@memberjunction/interactive-component-types';
 
 /**
  * Represents a compiled React component with its metadata
  */
 export interface CompiledComponent {
-  /** The compiled React component function or class */
-  component: any;
+  /** Factory function that creates a ComponentObject when called with context */
+  factory: (context: RuntimeContext, styles?: ComponentStyles, components?: Record<string, any>) => ComponentObject;
   /** Unique identifier for the component */
   id: string;
   /** Original component name */
@@ -58,8 +58,8 @@ export interface CompileOptions {
  * Registry entry for a compiled component
  */
 export interface RegistryEntry {
-  /** The compiled component */
-  component: any;
+  /** The compiled component object with all methods */
+  component: ComponentObject;
   /** Component metadata */
   metadata: ComponentMetadata;
   /** Last access time for LRU cache */
@@ -113,7 +113,7 @@ export interface ComponentProps {
   /** Utility functions available to the component */
   utilities: any;
   /** Callback functions */
-  callbacks: ComponentCallbacks;
+  callbacks: any;
   /** Child components available for use */
   components?: Record<string, any>;
   /** Component styles */
@@ -122,20 +122,6 @@ export interface ComponentProps {
   onStateChanged?: (stateUpdate: Record<string, any>) => void;
 }
 
-/**
- * Callbacks available to React components
- */
-export interface ComponentCallbacks {
-  /** Request data refresh */
-  RefreshData?: () => void;
-  /** Open an entity record */
-  OpenEntityRecord?: (entityName: string, key: any) => void;
-  /** Update user state */
-  UpdateUserState?: (state: any) => void;
-  /** Notify of a custom event */
-  NotifyEvent?: (event: string, data: any) => void;
-}
-
 /**
  * Configuration for the component compiler
  */
@@ -155,6 +141,8 @@ export interface CompilerConfig {
   cache: boolean;
   /** Maximum cache size */
   maxCacheSize: number;
+  /** Enable debug logging */
+  debug?: boolean;
 }
 
 /**
@@ -169,6 +157,8 @@ export interface RegistryConfig {
   useLRU: boolean;
   /** Namespace isolation */
   enableNamespaces: boolean;
+  /** Enable debug logging */
+  debug?: boolean;
 }
 
 /**
@@ -232,4 +222,10 @@ export interface ErrorBoundaryOptions {
 }
 
 // Export library configuration types
-export * from './library-config';
+export * from './library-config';
+
+// Export dependency types
+export * from './dependency-types';
+
+// Re-export ComponentObject for convenience
+export { ComponentObject } from '@memberjunction/interactive-component-types';

package/src/utilities/index.ts

@@ -7,6 +7,7 @@ export * from './component-styles';
 export * from './standard-libraries';
 export * from './library-loader';
 export * from './library-registry';
+export * from './library-dependency-resolver';
 export * from './component-error-analyzer';
 export * from './resource-manager';
 export * from './cache-manager';