@peers-app/peers-ui 0.0.14

package/dist/ui-router/routes-loader.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAllRoutes = exports.allRoutesLoaded = exports.allPackages = void 0;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+require("../ui-defaults");
+exports.allPackages = (0, peers_sdk_1.observable)([]);
+exports.allRoutesLoaded = (0, peers_sdk_1.observable)(false);
+(0, peers_sdk_1.Packages)().dataChanged.subscribe(async (evt) => {
+    if (!(0, exports.allRoutesLoaded)())
+        return;
+    const _allPackages = (0, exports.allPackages)();
+    if (evt.op === 'insert') {
+        _allPackages.push(evt.dataObject);
+    }
+    else if (evt.op === 'delete') {
+        let idx = (0, exports.allPackages)().findIndex(p => p.packageId === evt.dataObject.packageId);
+        if (idx >= 0) {
+            _allPackages.splice(idx, 1);
+        }
+    }
+    else {
+        let idx = (0, exports.allPackages)().findIndex(p => p.packageId === evt.dataObject.packageId);
+        if (idx >= 0) {
+            _allPackages[idx] = evt.dataObject;
+        }
+    }
+    (0, exports.allPackages)([..._allPackages]);
+});
+const loadAllRoutes = async () => {
+    if ((0, exports.allRoutesLoaded)())
+        return;
+    // Filter packages that have UI bundles (routesBundleFileId or uiBundleFileId)
+    let packagesWithUI = await (0, peers_sdk_1.Packages)().list({
+        disabled: { $ne: true },
+        routesBundleFileId: { $exists: true },
+    });
+    (0, exports.allPackages)(packagesWithUI);
+    await Promise.all(packagesWithUI.map(pkg => loadRoutesBundle(pkg)));
+    (0, exports.allRoutesLoaded)(true);
+    return true;
+};
+exports.loadAllRoutes = loadAllRoutes;
+const routeLoadingPromises = {};
+function loadRoutesBundle(pkg, forceRefresh) {
+    // Dynamically import the bundle
+    let importPromise = routeLoadingPromises[pkg.packageId];
+    if (!importPromise || forceRefresh) {
+        console.log(`loading routes bundle for ${pkg.name}`);
+        // just importing the module (running it) should be registering all of the package UIs with the Peers App runtime
+        importPromise = (async () => {
+            try {
+                while (!window.registerPeersUIRoute) {
+                    console.log(`waiting for registerPeersUIRoute to be defined on the window object`);
+                    await new Promise((resolve) => setTimeout(resolve, 20));
+                }
+                let bundleCode = '';
+                if (pkg.routesBundleFileId) {
+                    bundleCode = await peers_sdk_1.rpcServerCalls.getFileContents(pkg.routesBundleFileId);
+                }
+                if (bundleCode) {
+                    const exportRoutes = (peerRoutes) => {
+                        peerRoutes.routes.forEach(route => {
+                            // TODO maybe add package that this came from
+                            window.registerPeersUIRoute(route);
+                        });
+                    };
+                    const bundleFunction = new Function('exportRoutes', bundleCode);
+                    bundleFunction(exportRoutes);
+                    return {};
+                }
+                else {
+                    console.warn(`Routes bundle file not found for ${pkg.name} (fileId: ${pkg.routesBundleFileId})`);
+                }
+                return null;
+            }
+            catch (err) {
+                console.error(`Error while loading routes bundle for ${pkg.name}`, err);
+                return null;
+            }
+        })();
+        routeLoadingPromises[pkg.packageId] = importPromise;
+    }
+    return importPromise;
+}
+const reloadPackage = (0, peers_sdk_1.debounceByArgs)(async (packageId) => {
+    const pkg = await (0, peers_sdk_1.Packages)().get(packageId);
+    if (pkg) {
+        await loadRoutesBundle(pkg, true);
+    }
+}, 200);
+(0, peers_sdk_1.Packages)().dataChanged.subscribe(evt => {
+    const pkg = evt.dataObject;
+    const loadingPromise = routeLoadingPromises[pkg.packageId];
+    if (!loadingPromise)
+        return;
+    reloadPackage(pkg.packageId);
+});

package/dist/ui-router/ui-loader.d.ts

@@ -0,0 +1,18 @@
+import { IPeersUIRoute, UIContext } from "@peers-app/peers-sdk";
+import React from "react";
+import "../ui-defaults";
+interface IProps extends UIContext {
+    props: Record<string, any>;
+}
+export declare const UIRouter: (props: IProps) => React.JSX.Element | undefined;
+export declare const peersSystemPackageId = "000peers0system000package";
+/**
+ * This is meant to make it easy to register components that are internal to peers
+ */
+export declare function registerInternalPeersUI(props: {
+    component: React.ComponentType<any>;
+    propsSchema?: any;
+    routes?: Omit<IPeersUIRoute, 'peersUIId' | 'packageId'>[];
+    peersUIId?: string;
+}): Promise<void>;
+export {};

package/dist/ui-router/ui-loader.js

@@ -0,0 +1,481 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peersSystemPackageId = exports.UIRouter = void 0;
+exports.registerInternalPeersUI = registerInternalPeersUI;
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const lodash_1 = require("lodash");
+const react_1 = __importStar(require("react"));
+const loading_indicator_1 = require("../components/loading-indicator");
+const globals_1 = require("../globals");
+const hooks_1 = require("../hooks");
+require("../ui-defaults");
+const routes_loader_1 = require("./routes-loader");
+const peersUIs = {};
+class UIErrorBoundary extends react_1.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false, error: null, errorInfo: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error, errorInfo: null };
+    }
+    componentDidCatch(error, errorInfo) {
+        console.error('UIErrorBoundary caught an error:', error, errorInfo);
+        this.setState({
+            error,
+            errorInfo,
+        });
+    }
+    render() {
+        if (this.state.hasError) {
+            const { peersUIId, packageName, componentName } = this.props;
+            const { error, errorInfo } = this.state;
+            return (react_1.default.createElement("div", { style: {
+                    padding: '20px',
+                    border: '2px solid #ff6b6b',
+                    borderRadius: '8px',
+                    backgroundColor: '#fff5f5',
+                    color: '#721c24',
+                    fontFamily: 'monospace',
+                    margin: '10px 0'
+                } },
+                react_1.default.createElement("h3", { style: { color: '#c53030', marginTop: 0 } }, "UI Component Error"),
+                react_1.default.createElement("div", { style: { marginBottom: '15px' } },
+                    peersUIId && react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Peers UI ID:"),
+                        " ",
+                        peersUIId),
+                    packageName && react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Package:"),
+                        " ",
+                        packageName),
+                    componentName && react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Component:"),
+                        " ",
+                        componentName)),
+                react_1.default.createElement("details", { style: { marginBottom: '15px' } },
+                    react_1.default.createElement("summary", { style: { cursor: 'pointer', fontWeight: 'bold', marginBottom: '10px' } }, "Error Details"),
+                    react_1.default.createElement("div", { style: {
+                            backgroundColor: '#fed7d7',
+                            padding: '10px',
+                            borderRadius: '4px',
+                            whiteSpace: 'pre-wrap',
+                            overflow: 'auto',
+                            maxHeight: '200px'
+                        } },
+                        react_1.default.createElement("strong", null, "Error:"),
+                        " ",
+                        error?.message || 'Unknown error',
+                        error?.stack && (react_1.default.createElement(react_1.default.Fragment, null,
+                            react_1.default.createElement("br", null),
+                            react_1.default.createElement("br", null),
+                            react_1.default.createElement("strong", null, "Stack Trace:"),
+                            react_1.default.createElement("br", null),
+                            error.stack)))),
+                errorInfo && (react_1.default.createElement("details", null,
+                    react_1.default.createElement("summary", { style: { cursor: 'pointer', fontWeight: 'bold', marginBottom: '10px' } }, "Component Stack"),
+                    react_1.default.createElement("div", { style: {
+                            backgroundColor: '#fed7d7',
+                            padding: '10px',
+                            borderRadius: '4px',
+                            whiteSpace: 'pre-wrap',
+                            overflow: 'auto',
+                            maxHeight: '200px'
+                        } }, errorInfo.componentStack))),
+                react_1.default.createElement("button", { onClick: () => this.setState({ hasError: false, error: null, errorInfo: null }), style: {
+                        marginTop: '15px',
+                        padding: '8px 16px',
+                        backgroundColor: '#c53030',
+                        color: 'white',
+                        border: 'none',
+                        borderRadius: '4px',
+                        cursor: 'pointer'
+                    } }, "Try Again")));
+        }
+        return this.props.children;
+    }
+}
+const UIRouter = (props) => {
+    let matchingRoute;
+    const allRoutes = _window.getPeersUIRoutes();
+    const filteredRoutes = allRoutes.filter(r => {
+        if (props.uiEditMode && props.uiEditMode !== '*' && r.uiEditMode !== '*' && r.uiEditMode !== props.uiEditMode)
+            return false;
+        if (props.uiCategory && props.uiCategory !== '*' && r.uiCategory !== '*' && r.uiCategory !== props.uiCategory)
+            return false;
+        if (props.uiSubcategory && props.uiSubcategory !== '*' && r.uiSubcategory !== '*' && r.uiSubcategory !== props.uiSubcategory)
+            return false;
+        return true;
+    });
+    const context = {
+        ...props,
+        path: props.path || (0, globals_1.mainContentPath)(),
+    };
+    for (const route of filteredRoutes) {
+        // if (route.path && !context.path.startsWith(route.path)) continue;
+        // <todo> test this
+        if (route.path) {
+            // since `isMatch` can already be used to match the path, this might be overkill
+            // but if you just need a simple regex match this makes it nice instead of having to declare a whole function 
+            const match = route.path.match(/^\/(.+)\/([gimsuy]{0,6})$/);
+            if (match) {
+                const [, pattern, flags] = match;
+                try {
+                    const regex = new RegExp(pattern, flags);
+                    if (!regex.test(context.path))
+                        continue;
+                }
+                catch {
+                    // Invalid regex → treat as plain prefix
+                    if (!context.path.startsWith(route.path))
+                        continue;
+                }
+            }
+            else {
+                // TODO treating path as a prefix is confusing.
+                //      Now that we have regex matching, we should treat it as exact match if it's not a regex
+                if (!context.path.startsWith(route.path))
+                    continue;
+            }
+        }
+        // </todo>
+        if (!route.propsSchema || route.propsSchema.safeParse(props.props).success) {
+            if (!route.isMatch || route.isMatch(props.props, context)) {
+                matchingRoute = route;
+                break;
+            }
+        }
+    }
+    if (!matchingRoute) {
+        return undefined;
+    }
+    return UILoader({ peersUIId: matchingRoute.peersUIId, props: props.props });
+};
+exports.UIRouter = UIRouter;
+const UILoader = (args) => {
+    const { props, peersUIId } = args;
+    const [lastReloadTime] = (0, hooks_1.useObservable)(globals_1.packageReloaded);
+    args.props.__lastPackageReload = lastReloadTime;
+    // check if peersUIId maps to an in-memory react component
+    const peersUI = peersUIs[peersUIId];
+    if (peersUI?.content) {
+        const parseResult = peersUI.propsSchema.safeParse(props);
+        if (!parseResult.success) {
+            console.error('props did not match schema', { props, schema: peersUI.propsSchema, errors: parseResult.error });
+            return (react_1.default.createElement("div", null,
+                react_1.default.createElement("pre", null,
+                    "Peers UI could not be loaded ",
+                    react_1.default.createElement("br", null),
+                    "peersUIId: ",
+                    peersUI.peersUIId,
+                    " ",
+                    react_1.default.createElement("br", null),
+                    "Component name: ",
+                    peersUI.content?.name,
+                    " ",
+                    react_1.default.createElement("br", null),
+                    "Props did not match schema ",
+                    react_1.default.createElement("br", null),
+                    "Errors: ",
+                    JSON.stringify(parseResult.error, null, 2),
+                    " ",
+                    react_1.default.createElement("br", null),
+                    react_1.default.createElement("br", null),
+                    "Props ",
+                    JSON.stringify((0, peers_sdk_1.toJSON)(props), null, 2),
+                    react_1.default.createElement("br", null))));
+        }
+        const Component = peersUI.content;
+        return (react_1.default.createElement(UIErrorBoundary, { peersUIId: peersUIId, componentName: peersUI.content?.name },
+            react_1.default.createElement(Component, { ...args.props })));
+    }
+    return react_1.default.createElement(UIAsyncLoader, { ...args });
+};
+const uiLoadingPromises = {};
+function loadUIBundle(pkg, forceRefresh) {
+    // Dynamically import the bundle
+    let importPromise = uiLoadingPromises[pkg.packageId];
+    if (!importPromise || forceRefresh) {
+        console.log(`loading ui bundle for ${pkg.name}`);
+        importPromise = new Promise(async (resolve, reject) => {
+            try {
+                let bundleCode = '';
+                if (pkg.uiBundleFileId) {
+                    bundleCode = await peers_sdk_1.rpcServerCalls.getFileContents(pkg.uiBundleFileId);
+                }
+                if (bundleCode) {
+                    const exportUIs = (peerUIs) => {
+                        // TODO maybe add packageId that this came from
+                        peerUIs?.uis?.forEach(ui => {
+                            peersUIs[ui.peersUIId] = ui;
+                        });
+                    };
+                    const bundleFunction = new Function('exportUIs', bundleCode);
+                    await bundleFunction(exportUIs);
+                }
+                resolve();
+            }
+            catch (err) {
+                console.error(`Error while loading ui module for ${pkg.name}`, err);
+                reject(err);
+            }
+        });
+        uiLoadingPromises[pkg.packageId] = importPromise;
+    }
+    return importPromise;
+}
+const UIAsyncLoader = (props) => {
+    const { peersUIId } = props;
+    const [loaded, setLoaded] = react_1.default.useState(false);
+    const [loadError, setLoadError] = react_1.default.useState(null);
+    const allRoutes = _window.getPeersUIRoutes();
+    const uiPackageId = allRoutes.find(r => r.peersUIId === peersUIId)?.packageId;
+    (0, hooks_1.useObservable)(routes_loader_1.allPackages);
+    const pkg = (0, routes_loader_1.allPackages)().find(p => p.packageId === uiPackageId);
+    (0, react_1.useEffect)(() => {
+        if (!pkg)
+            return;
+        setLoadError(null);
+        loadUIBundle(pkg)
+            .then(() => setLoaded(true))
+            .catch((error) => {
+            console.error(`Failed to load UI bundle for package ${pkg.name}:`, error);
+            setLoadError(error);
+        });
+    }, [pkg?.packageId]);
+    if (!pkg) {
+        return react_1.default.createElement("div", null,
+            "Could not find package that owns peersUIId ",
+            peersUIId);
+    }
+    if (loadError) {
+        return (react_1.default.createElement("div", { style: {
+                padding: '20px',
+                border: '2px solid #ff6b6b',
+                borderRadius: '8px',
+                backgroundColor: '#fff5f5',
+                color: '#721c24',
+                fontFamily: 'monospace',
+                margin: '10px 0'
+            } },
+            react_1.default.createElement("h3", { style: { color: '#c53030', marginTop: 0 } }, "Bundle Loading Error"),
+            react_1.default.createElement("div", { style: { marginBottom: '15px' } },
+                react_1.default.createElement("div", null,
+                    react_1.default.createElement("strong", null, "Peers UI ID:"),
+                    " ",
+                    peersUIId),
+                react_1.default.createElement("div", null,
+                    react_1.default.createElement("strong", null, "Package:"),
+                    " ",
+                    pkg.name),
+                react_1.default.createElement("div", null,
+                    react_1.default.createElement("strong", null, "Package ID:"),
+                    " ",
+                    pkg.packageId)),
+            react_1.default.createElement("details", { style: { marginBottom: '15px' } },
+                react_1.default.createElement("summary", { style: { cursor: 'pointer', fontWeight: 'bold', marginBottom: '10px' } }, "Error Details"),
+                react_1.default.createElement("div", { style: {
+                        backgroundColor: '#fed7d7',
+                        padding: '10px',
+                        borderRadius: '4px',
+                        whiteSpace: 'pre-wrap',
+                        overflow: 'auto',
+                        maxHeight: '200px'
+                    } },
+                    react_1.default.createElement("strong", null, "Error:"),
+                    " ",
+                    loadError.message || 'Unknown error',
+                    loadError.stack && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement("br", null),
+                        react_1.default.createElement("br", null),
+                        react_1.default.createElement("strong", null, "Stack Trace:"),
+                        react_1.default.createElement("br", null),
+                        loadError.stack)))),
+            react_1.default.createElement("button", { onClick: () => {
+                    setLoadError(null);
+                    setLoaded(false);
+                    if (pkg) {
+                        loadUIBundle(pkg, true)
+                            .then(() => setLoaded(true))
+                            .catch(setLoadError);
+                    }
+                }, style: {
+                    marginTop: '15px',
+                    padding: '8px 16px',
+                    backgroundColor: '#c53030',
+                    color: 'white',
+                    border: 'none',
+                    borderRadius: '4px',
+                    cursor: 'pointer'
+                } }, "Retry Loading")));
+    }
+    if (!loaded) {
+        return (react_1.default.createElement(loading_indicator_1.LoadingIndicator, null));
+    }
+    const peersUI = peersUIs[peersUIId];
+    if (peersUI?.content) {
+        const _props = { ...props, uiVar: undefined };
+        try {
+            peersUI.propsSchema.parse(_props);
+            const Component = peersUI.content;
+            return (react_1.default.createElement(UIErrorBoundary, { peersUIId: peersUIId, packageName: pkg.name, componentName: peersUI.content?.name },
+                react_1.default.createElement(Component, { ..._props })));
+        }
+        catch (parseError) {
+            return (react_1.default.createElement("div", { style: {
+                    padding: '20px',
+                    border: '2px solid #ff6b6b',
+                    borderRadius: '8px',
+                    backgroundColor: '#fff5f5',
+                    color: '#721c24',
+                    fontFamily: 'monospace',
+                    margin: '10px 0'
+                } },
+                react_1.default.createElement("h3", { style: { color: '#c53030', marginTop: 0 } }, "Props Validation Error"),
+                react_1.default.createElement("div", { style: { marginBottom: '15px' } },
+                    react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Peers UI ID:"),
+                        " ",
+                        peersUIId),
+                    react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Package:"),
+                        " ",
+                        pkg.name),
+                    react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Component:"),
+                        " ",
+                        peersUI.content?.name)),
+                react_1.default.createElement("div", { style: {
+                        backgroundColor: '#fed7d7',
+                        padding: '10px',
+                        borderRadius: '4px',
+                        whiteSpace: 'pre-wrap',
+                        overflow: 'auto',
+                        maxHeight: '200px',
+                        marginBottom: '15px'
+                    } },
+                    react_1.default.createElement("strong", null, "Error:"),
+                    " Props did not match schema",
+                    react_1.default.createElement("br", null),
+                    react_1.default.createElement("strong", null, "Validation Error:"),
+                    " ",
+                    JSON.stringify(parseError, null, 2),
+                    react_1.default.createElement("br", null),
+                    react_1.default.createElement("br", null),
+                    react_1.default.createElement("strong", null, "Props:"),
+                    " ",
+                    JSON.stringify((0, peers_sdk_1.toJSON)(_props), null, 2))));
+        }
+    }
+    else {
+        return react_1.default.createElement("div", null, "Component not found");
+    }
+};
+let _window;
+if (typeof window !== 'undefined') {
+    _window = window;
+    if (!_window.registerPeersUIRoute) {
+        let uiRoutes = [];
+        Object.defineProperty(window, 'registerPeersUIRoute', {
+            value: (route) => {
+                uiRoutes = uiRoutes.filter(r => !(r.peersUIId === route.peersUIId));
+                uiRoutes.push(route);
+                uiRoutes = (0, lodash_1.orderBy)(uiRoutes, r => r.priority ?? 0, 'desc');
+            },
+            writable: false,
+            configurable: false
+        });
+        Object.defineProperty(window, 'getPeersUIRoutes', {
+            value: () => {
+                return [...uiRoutes];
+            },
+            writable: false,
+            configurable: false
+        });
+        Object.defineProperty(window, 'UIRouter', {
+            value: exports.UIRouter,
+            writable: false,
+            configurable: false
+        });
+        Object.defineProperty(window, 'UILoader', {
+            value: UILoader,
+            writable: false,
+            configurable: false
+        });
+    }
+}
+const reloadPackage = (0, peers_sdk_1.debounceByArgs)(async (packageId) => {
+    const pkg = await (0, peers_sdk_1.Packages)().get(packageId);
+    if (pkg) {
+        await loadUIBundle(pkg, true);
+        console.log(`reloaded UI bundle for ${pkg.name}`);
+        (0, globals_1.packageReloaded)(Date.now());
+    }
+}, 200);
+(0, peers_sdk_1.Packages)().dataChanged.subscribe(async (evt) => {
+    const pkg = evt.dataObject;
+    const loadingPromise = uiLoadingPromises[pkg.packageId];
+    if (!loadingPromise)
+        return;
+    reloadPackage(pkg.packageId);
+});
+exports.peersSystemPackageId = '000peers0system000package';
+/**
+ * This is meant to make it easy to register components that are internal to peers
+ */
+async function registerInternalPeersUI(props) {
+    while (!window.registerPeersUIRoute) {
+        console.log("Waiting for registerPeersUIRoute to be defined on the window object");
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    const peersUIId = props.peersUIId || (0, peers_sdk_1.newid)();
+    const peersUI = {
+        peersUIId,
+        content: props.component,
+        propsSchema: props.propsSchema || peers_sdk_1.zodAnyObject,
+    };
+    peersUIs[peersUIId] = peersUI;
+    if (props.routes?.length) {
+        props.routes.forEach(route => {
+            _window.registerPeersUIRoute({
+                packageId: exports.peersSystemPackageId,
+                peersUIId,
+                propsSchema: props.propsSchema,
+                ...route,
+            });
+        });
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function htmlToText(html: string): string;
+export declare function stripMentions(text: string): string;
+export declare function trimAndSanitizeHtml(value: string): string;
+export declare function isObject(x: any): x is Record<string, any>;
+export declare function js(jsCode: string, externalReferences?: any): any;
+export declare const AsyncFunction: any;
+export declare function jsAsync(jsCode: string, externalReferences?: any): any;
+export declare function toJSON(obj: any): any;
+export declare function fromJSON(obj: any, externalReferences?: any): any;