@memberjunction/react-runtime 2.70.0 → 2.72.0

package/dist/utilities/library-loader.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryLoader = void 0;
+const standard_libraries_1 = require("./standard-libraries");
+class LibraryLoader {
+    static async loadAllLibraries() {
+        return this.loadLibraries({
+            loadCore: true,
+            loadUI: true,
+            loadCSS: true
+        });
+    }
+    static async loadLibraries(options) {
+        const { loadCore = true, loadUI = true, loadCSS = true, customLibraries = [] } = options;
+        const [React, ReactDOM, Babel] = await Promise.all([
+            this.loadScript(standard_libraries_1.STANDARD_LIBRARY_URLS.REACT, 'React'),
+            this.loadScript(standard_libraries_1.STANDARD_LIBRARY_URLS.REACT_DOM, 'ReactDOM'),
+            this.loadScript(standard_libraries_1.STANDARD_LIBRARY_URLS.BABEL, 'Babel')
+        ]);
+        if (loadCSS) {
+            (0, standard_libraries_1.getCSSUrls)().forEach(url => this.loadCSS(url));
+        }
+        const libraryPromises = [];
+        const libraryNames = [];
+        if (loadCore) {
+            const coreUrls = (0, standard_libraries_1.getCoreLibraryUrls)();
+            coreUrls.forEach(url => {
+                const name = this.getLibraryNameFromUrl(url);
+                libraryNames.push(name);
+                libraryPromises.push(this.loadScript(url, name));
+            });
+        }
+        if (loadUI) {
+            const uiUrls = (0, standard_libraries_1.getUILibraryUrls)();
+            uiUrls.forEach(url => {
+                const name = this.getLibraryNameFromUrl(url);
+                libraryNames.push(name);
+                libraryPromises.push(this.loadScript(url, name));
+            });
+        }
+        customLibraries.forEach(({ url, globalName }) => {
+            libraryNames.push(globalName);
+            libraryPromises.push(this.loadScript(url, globalName));
+        });
+        const loadedLibraries = await Promise.all(libraryPromises);
+        const libraries = {
+            _: undefined
+        };
+        libraryNames.forEach((name, index) => {
+            if (name === '_') {
+                libraries._ = loadedLibraries[index];
+            }
+            else {
+                libraries[name] = loadedLibraries[index];
+            }
+        });
+        if (!libraries._)
+            libraries._ = window._;
+        if (!libraries.d3)
+            libraries.d3 = window.d3;
+        if (!libraries.Chart)
+            libraries.Chart = window.Chart;
+        if (!libraries.dayjs)
+            libraries.dayjs = window.dayjs;
+        if (!libraries.antd)
+            libraries.antd = window.antd;
+        if (!libraries.ReactBootstrap)
+            libraries.ReactBootstrap = window.ReactBootstrap;
+        return {
+            React,
+            ReactDOM,
+            Babel,
+            libraries
+        };
+    }
+    static async loadScript(url, globalName) {
+        const existing = this.loadedResources.get(url);
+        if (existing) {
+            return existing.promise;
+        }
+        const promise = new Promise((resolve, reject) => {
+            const existingGlobal = window[globalName];
+            if (existingGlobal) {
+                resolve(existingGlobal);
+                return;
+            }
+            const existingScript = document.querySelector(`script[src="${url}"]`);
+            if (existingScript) {
+                this.waitForScriptLoad(existingScript, globalName, resolve, reject);
+                return;
+            }
+            const script = document.createElement('script');
+            script.src = url;
+            script.async = true;
+            script.crossOrigin = 'anonymous';
+            script.onload = () => {
+                const global = window[globalName];
+                if (global) {
+                    resolve(global);
+                }
+                else {
+                    setTimeout(() => {
+                        const delayedGlobal = window[globalName];
+                        if (delayedGlobal) {
+                            resolve(delayedGlobal);
+                        }
+                        else {
+                            reject(new Error(`${globalName} not found after script load`));
+                        }
+                    }, 100);
+                }
+            };
+            script.onerror = () => {
+                reject(new Error(`Failed to load script: ${url}`));
+            };
+            document.head.appendChild(script);
+        });
+        this.loadedResources.set(url, {
+            element: document.querySelector(`script[src="${url}"]`),
+            promise
+        });
+        return promise;
+    }
+    static loadCSS(url) {
+        if (this.loadedResources.has(url)) {
+            return;
+        }
+        const existingLink = document.querySelector(`link[href="${url}"]`);
+        if (existingLink) {
+            return;
+        }
+        const link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = url;
+        document.head.appendChild(link);
+        this.loadedResources.set(url, {
+            element: link,
+            promise: Promise.resolve()
+        });
+    }
+    static waitForScriptLoad(script, globalName, resolve, reject) {
+        const checkGlobal = () => {
+            const global = window[globalName];
+            if (global) {
+                resolve(global);
+            }
+            else {
+                setTimeout(() => {
+                    const delayedGlobal = window[globalName];
+                    if (delayedGlobal) {
+                        resolve(delayedGlobal);
+                    }
+                    else {
+                        reject(new Error(`${globalName} not found after script load`));
+                    }
+                }, 100);
+            }
+        };
+        if (script.complete || script.readyState === 'complete') {
+            checkGlobal();
+            return;
+        }
+        const loadHandler = () => {
+            script.removeEventListener('load', loadHandler);
+            checkGlobal();
+        };
+        script.addEventListener('load', loadHandler);
+    }
+    static getLibraryNameFromUrl(url) {
+        if (url.includes('lodash'))
+            return '_';
+        if (url.includes('d3'))
+            return 'd3';
+        if (url.includes('Chart.js') || url.includes('chart'))
+            return 'Chart';
+        if (url.includes('dayjs'))
+            return 'dayjs';
+        if (url.includes('antd'))
+            return 'antd';
+        if (url.includes('react-bootstrap'))
+            return 'ReactBootstrap';
+        const match = url.match(/\/([^\/]+)(?:\.min)?\.js$/);
+        return match ? match[1] : 'unknown';
+    }
+    static getLoadedResources() {
+        return this.loadedResources;
+    }
+    static clearCache() {
+        this.loadedResources.clear();
+    }
+}
+exports.LibraryLoader = LibraryLoader;
+LibraryLoader.loadedResources = new Map();

package/dist/utilities/runtime-utilities.d.ts

@@ -0,0 +1,10 @@
+import { ComponentUtilities } from '@memberjunction/interactive-component-types';
+export declare class RuntimeUtilities {
+    buildUtilities(): ComponentUtilities;
+    private SetupUtilities;
+    private CreateSimpleMetadata;
+    private CreateSimpleRunQuery;
+    private CreateSimpleRunView;
+}
+export declare function createRuntimeUtilities(): RuntimeUtilities;
+//# sourceMappingURL=runtime-utilities.d.ts.map

package/dist/utilities/runtime-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-utilities.d.ts","sourceRoot":"","sources":["../../src/utilities/runtime-utilities.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,kBAAkB,EAAiD,MAAM,6CAA6C,CAAC;AAOhI,qBACa,gBAAgB;IAKpB,cAAc,IAAI,kBAAkB;IAQ3C,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,mBAAmB;CAwB5B;AAOD,wBAAgB,sBAAsB,IAAI,gBAAgB,CAmBzD"}

package/dist/utilities/runtime-utilities.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeUtilities = exports.RuntimeUtilities = void 0;
+const core_1 = require("@memberjunction/core");
+const global_1 = require("@memberjunction/global");
+let RuntimeUtilities = class RuntimeUtilities {
+    buildUtilities() {
+        const md = new core_1.Metadata();
+        return this.SetupUtilities(md);
+    }
+    SetupUtilities(md) {
+        const rv = new core_1.RunView();
+        const rq = new core_1.RunQuery();
+        const u = {
+            md: this.CreateSimpleMetadata(md),
+            rv: this.CreateSimpleRunView(rv),
+            rq: this.CreateSimpleRunQuery(rq)
+        };
+        return u;
+    }
+    CreateSimpleMetadata(md) {
+        return {
+            Entities: md.Entities,
+            GetEntityObject: (entityName) => {
+                return md.GetEntityObject(entityName);
+            }
+        };
+    }
+    CreateSimpleRunQuery(rq) {
+        return {
+            RunQuery: async (params) => {
+                try {
+                    const result = await rq.RunQuery(params);
+                    return result;
+                }
+                catch (error) {
+                    (0, core_1.LogError)(error);
+                    throw error;
+                }
+            }
+        };
+    }
+    CreateSimpleRunView(rv) {
+        return {
+            RunView: async (params) => {
+                try {
+                    const result = await rv.RunView(params);
+                    return result;
+                }
+                catch (error) {
+                    (0, core_1.LogError)(error);
+                    throw error;
+                }
+            },
+            RunViews: async (params) => {
+                try {
+                    const results = await rv.RunViews(params);
+                    return results;
+                }
+                catch (error) {
+                    (0, core_1.LogError)(error);
+                    throw error;
+                }
+            }
+        };
+    }
+};
+exports.RuntimeUtilities = RuntimeUtilities;
+exports.RuntimeUtilities = RuntimeUtilities = __decorate([
+    (0, global_1.RegisterClass)(RuntimeUtilities, 'RuntimeUtilities')
+], RuntimeUtilities);
+function createRuntimeUtilities() {
+    if (typeof window === 'undefined') {
+        try {
+            const obj = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(RuntimeUtilities);
+            if (!obj) {
+                throw new Error('Failed to create RuntimeUtilities instance');
+            }
+            return obj;
+        }
+        catch (e) {
+        }
+    }
+    return new RuntimeUtilities();
+}
+exports.createRuntimeUtilities = createRuntimeUtilities;

package/dist/utilities/standard-libraries.d.ts

@@ -0,0 +1,27 @@
+export declare const STANDARD_LIBRARY_URLS: {
+    REACT: string;
+    REACT_DOM: string;
+    BABEL: string;
+    D3: string;
+    CHART_JS: string;
+    LODASH: string;
+    DAYJS: string;
+    ANTD: string;
+    REACT_BOOTSTRAP: string;
+    ANTD_CSS: string;
+    BOOTSTRAP_CSS: string;
+};
+export interface StandardLibraries {
+    _: any;
+    d3?: any;
+    Chart?: any;
+    dayjs?: any;
+    antd?: any;
+    ReactBootstrap?: any;
+    [key: string]: any;
+}
+export declare function getCoreLibraryUrls(): string[];
+export declare function getUILibraryUrls(): string[];
+export declare function getCSSUrls(): string[];
+export declare function createStandardLibraries(): StandardLibraries;
+//# sourceMappingURL=standard-libraries.d.ts.map

package/dist/utilities/standard-libraries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-libraries.d.ts","sourceRoot":"","sources":["../../src/utilities/standard-libraries.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;CAqBjC,CAAC;AAKF,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,GAAG,CAAC;IACP,EAAE,CAAC,EAAE,GAAG,CAAC;IACT,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,cAAc,CAAC,EAAE,GAAG,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAKD,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAO7C;AAKD,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAK3C;AAKD,wBAAgB,UAAU,IAAI,MAAM,EAAE,CAKrC;AAMD,wBAAgB,uBAAuB,IAAI,iBAAiB,CAgB3D"}

package/dist/utilities/standard-libraries.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStandardLibraries = exports.getCSSUrls = exports.getUILibraryUrls = exports.getCoreLibraryUrls = exports.STANDARD_LIBRARY_URLS = void 0;
+exports.STANDARD_LIBRARY_URLS = {
+    REACT: 'https://unpkg.com/react@18/umd/react.development.js',
+    REACT_DOM: 'https://unpkg.com/react-dom@18/umd/react-dom.development.js',
+    BABEL: 'https://unpkg.com/@babel/standalone/babel.min.js',
+    D3: 'https://cdnjs.cloudflare.com/ajax/libs/d3/7.8.5/d3.min.js',
+    CHART_JS: 'https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.0/chart.umd.js',
+    LODASH: 'https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js',
+    DAYJS: 'https://unpkg.com/dayjs@1.11.10/dayjs.min.js',
+    ANTD: 'https://unpkg.com/antd@5.11.5/dist/antd.min.js',
+    REACT_BOOTSTRAP: 'https://unpkg.com/react-bootstrap@2.9.1/dist/react-bootstrap.min.js',
+    ANTD_CSS: 'https://unpkg.com/antd@5.11.5/dist/reset.css',
+    BOOTSTRAP_CSS: 'https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css'
+};
+function getCoreLibraryUrls() {
+    return [
+        exports.STANDARD_LIBRARY_URLS.LODASH,
+        exports.STANDARD_LIBRARY_URLS.D3,
+        exports.STANDARD_LIBRARY_URLS.CHART_JS,
+        exports.STANDARD_LIBRARY_URLS.DAYJS
+    ];
+}
+exports.getCoreLibraryUrls = getCoreLibraryUrls;
+function getUILibraryUrls() {
+    return [
+        exports.STANDARD_LIBRARY_URLS.ANTD,
+        exports.STANDARD_LIBRARY_URLS.REACT_BOOTSTRAP
+    ];
+}
+exports.getUILibraryUrls = getUILibraryUrls;
+function getCSSUrls() {
+    return [
+        exports.STANDARD_LIBRARY_URLS.ANTD_CSS,
+        exports.STANDARD_LIBRARY_URLS.BOOTSTRAP_CSS
+    ];
+}
+exports.getCSSUrls = getCSSUrls;
+function createStandardLibraries() {
+    if (typeof window === 'undefined') {
+        return {
+            _: undefined
+        };
+    }
+    return {
+        _: window._,
+        d3: window.d3,
+        Chart: window.Chart,
+        dayjs: window.dayjs,
+        antd: window.antd,
+        ReactBootstrap: window.ReactBootstrap
+    };
+}
+exports.createStandardLibraries = createStandardLibraries;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/react-runtime",
-  "version": "2.70.0",
+  "version": "2.72.0",
   "description": "Platform-agnostic React component runtime for MemberJunction. Provides core compilation, registry, and execution capabilities for React components in any JavaScript environment.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,6 +25,9 @@
   },
   "homepage": "https://github.com/MemberJunction/MJ#readme",
   "dependencies": {
+    "@memberjunction/core": "2.72.0",
+    "@memberjunction/global": "2.72.0",
+    "@memberjunction/interactive-component-types": "2.72.0",
     "@babel/standalone": "^7.23.5"
   },
   "devDependencies": {

package/src/index.ts

@@ -74,6 +74,37 @@ export {
   HierarchyRegistrationOptions
 } from './runtime';
 
+// Export utilities
+export { 
+  RuntimeUtilities, 
+  createRuntimeUtilities 
+} from './utilities/runtime-utilities';
+
+export { 
+  SetupStyles,
+  createDefaultComponentStyles 
+} from './utilities/component-styles';
+
+export {
+  STANDARD_LIBRARY_URLS,
+  StandardLibraries,
+  getCoreLibraryUrls,
+  getUILibraryUrls,
+  getCSSUrls,
+  createStandardLibraries
+} from './utilities/standard-libraries';
+
+export {
+  LibraryLoader,
+  LibraryLoadOptions,
+  LibraryLoadResult
+} from './utilities/library-loader';
+
+export {
+  ComponentErrorAnalyzer,
+  FailedComponentInfo
+} from './utilities/component-error-analyzer';
+
 // Version information
 export const VERSION = '2.69.1';