@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/PluginLoader.js

@@ -0,0 +1,218 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from 'react';
+import PropTypes from 'prop-types';
+import { getConfig, loadConfig, isConfigReady } from './config';
+import * as connectorActions from './redux/actions';
+import { getStore } from './redux/store';
+import { getHistory } from './redux/routerHistory';
+import { EventsTracking } from './libs/EventsTracking';
+import Globals from './Globals';
+import * as selectorsList from './redux/selectors';
+import * as connectorsList from './componentsConnectors';
+const globalAnchors = {};
+const reduxAnchors = {};
+const actionOverrideAnchor = {};
+const replacers = {};
+const PluginsAppStatesRegistrers = [];
+const PluginsPageAppStates = {};
+const PluginsAppStatesComponents = {};
+const PluginAdditionRoutes = {};
+const pluginAppStates = (declaration) => {
+    PluginsAppStatesRegistrers.push(declaration.register);
+    if (typeof declaration.pageAppState === 'object')
+        Object.keys(declaration.pageAppState).forEach((appState) => {
+            if (typeof declaration.pageAppState[appState] === 'string') {
+                const page = declaration.pageAppState[appState];
+                if (Object.prototype.hasOwnProperty.call(PluginsPageAppStates, appState)) {
+                    throw new Error(`Plugins AppState "${appState}" already declared.`);
+                }
+                const samePageAppStates = Object.keys(PluginsPageAppStates).filter((currentAppState) => PluginsPageAppStates[currentAppState] === page);
+                if (samePageAppStates.length > 0)
+                    throw new Error(`Plugins AppState page "${page}" already declared.`);
+                PluginsPageAppStates[appState] = page;
+            }
+        });
+    Object.keys(declaration.components).forEach((appState) => {
+        if (Object.prototype.hasOwnProperty.call(declaration, appState) === true)
+            throw new Error(`Plugin's appState ${appState} already declared previously`);
+        PluginsAppStatesComponents[appState] = declaration.components[appState];
+    });
+};
+export const registerPluginsAppStates = (currentAppStates) => {
+    let appStates = [...currentAppStates];
+    PluginsAppStatesRegistrers.forEach((register) => {
+        appStates = register(appStates);
+    });
+    return appStates;
+};
+export const loadPluginComponent = (name) => {
+    if (Object.prototype.hasOwnProperty.call(PluginsAppStatesComponents, name) ===
+        false) {
+        return undefined;
+    }
+    return PluginsAppStatesComponents[name];
+};
+export const pluginPageAppState = (page) => {
+    const appStates = Object.keys(PluginsPageAppStates).filter((appState) => PluginsPageAppStates[appState] === page);
+    if (appStates.length === 1)
+        return appStates[0];
+    if (appStates.length > 1)
+        throw new Error(`Found multipled appStates when checking for plugins page name`);
+    return false;
+};
+export const getPluginsPageAppStates = () => PluginsPageAppStates;
+const loadPluginFiles = (pluginsList, connectorSelectors, connectors) => __awaiter(void 0, void 0, void 0, function* () {
+    const plugins = Object.keys(pluginsList);
+    const pluginModules = yield Promise.all(plugins.map((plugin) => Globals.loadPlugin(plugin)));
+    plugins.forEach((plugin, index) => {
+        const pluginModule = pluginModules[index];
+        const anchors = pluginModule.default;
+        const { loader } = pluginModule;
+        if (loader !== undefined) {
+            loader(connectorSelectors, connectors, getStore().dispatch, connectorActions, getHistory(), getConfig(), EventsTracking);
+        }
+        Object.keys(anchors).forEach((anchor) => {
+            if (anchor === 'replace') {
+                Object.keys(anchors[anchor]).forEach((replacer) => {
+                    replacers[replacer] = anchors[anchor][replacer];
+                });
+                return;
+            }
+            if (anchor === 'appstates') {
+                pluginAppStates(anchors.appstates);
+            }
+            if (anchor === 'redux') {
+                Object.keys(anchors[anchor]).forEach((action) => {
+                    if (reduxAnchors[action] === undefined)
+                        reduxAnchors[action] = [];
+                    reduxAnchors[action].push(anchors[anchor][action]);
+                });
+                return;
+            }
+            if (anchor === 'actionOverride') {
+                Object.keys(anchors[anchor]).forEach((action) => {
+                    if (actionOverrideAnchor[action] === undefined)
+                        actionOverrideAnchor[action] = [];
+                    actionOverrideAnchor[action].push(anchors[anchor][action]);
+                });
+                return;
+            }
+            if (anchor === 'additionalRoutes') {
+                Object.keys(anchors[anchor]).forEach((route) => {
+                    PluginAdditionRoutes[anchors[anchor][route].path] =
+                        anchors[anchor][route].component;
+                });
+                return;
+            }
+            if (!Object.prototype.hasOwnProperty.call(globalAnchors, anchor))
+                globalAnchors[anchor] = [];
+            globalAnchors[anchor].push(anchors[anchor]);
+        });
+    });
+});
+let pluginsLoadingDone = false;
+export const loadPlugins = (plugins) => __awaiter(void 0, void 0, void 0, function* () {
+    let pluginsList;
+    if (!plugins)
+        pluginsList = getConfig().plugins;
+    else
+        pluginsList = plugins;
+    if (pluginsList === undefined) {
+        const config = isConfigReady() ? yield loadConfig() : getConfig();
+        pluginsList = config.plugins;
+    }
+    yield loadPluginFiles(pluginsList, selectorsList, connectorsList);
+    pluginsLoadingDone = true;
+});
+export const pluginsLoaded = () => pluginsLoadingDone;
+export const PluginLoader = (props) => {
+    const { anchor } = props;
+    const anchorsList = !Array.isArray(anchor) ? [anchor] : anchor;
+    let Plugins = [];
+    for (let i = 0; i < anchorsList.length; i += 1) {
+        const currentAnchor = anchorsList[i];
+        if (Object.prototype.hasOwnProperty.call(globalAnchors, currentAnchor) &&
+            globalAnchors[currentAnchor].length > 0) {
+            const currentPlugins = globalAnchors[currentAnchor];
+            Plugins = [
+                ...Plugins,
+                ...currentPlugins.map((Plugin) => (React.createElement(React.Suspense, { key: `lpwp-${currentAnchor}-${Math.random()}`, fallback: null },
+                    React.createElement(Plugin, Object.assign({}, props.props))))),
+            ];
+        }
+    }
+    if (Plugins.length > 0) {
+        return React.createElement(React.Fragment, null, Plugins);
+    }
+    return null;
+};
+PluginLoader.propTypes = {
+    anchor: PropTypes.arrayOf(PropTypes.string.isRequired).isRequired,
+    props: PropTypes.object,
+};
+PluginLoader.defaultProps = {
+    props: {},
+};
+const cache = {};
+export function ReplaceComponent(replacerName, OriginalComponent, componentName) {
+    const displayName = componentName ||
+        OriginalComponent.displayName ||
+        OriginalComponent.name ||
+        'Component';
+    const anchorsList = !Array.isArray(replacerName)
+        ? [replacerName]
+        : replacerName;
+    let Replacer = null;
+    const cacheKey = anchorsList.reduce((a, b) => a + b) + OriginalComponent.toString();
+    if (Object.prototype.hasOwnProperty.call(cache, cacheKey)) {
+        return cache[cacheKey];
+    }
+    for (let i = 0; i < anchorsList.length; i += 1) {
+        const currentAnchor = anchorsList[i];
+        if (Object.prototype.hasOwnProperty.call(replacers, currentAnchor)) {
+            Replacer = currentAnchor;
+            break;
+        }
+    }
+    let FinalComponent;
+    if (Replacer !== null) {
+        const ReplacerComponent = replacers[Replacer];
+        const FinalReplacedComponent = (props) => (React.createElement(React.Suspense, { fallback: null },
+            React.createElement(ReplacerComponent, Object.assign({}, props, { OriginalComponent: OriginalComponent }), props.children)));
+        FinalComponent = FinalReplacedComponent;
+        FinalComponent.displayName = `replacedComponent(${displayName})`;
+    }
+    else {
+        FinalComponent = OriginalComponent;
+        FinalComponent.displayName = `originalComponent(${displayName})`;
+    }
+    cache[cacheKey] = React.memo(FinalComponent);
+    return cache[cacheKey];
+}
+export function RunActionAnchor(anchor, ...args) {
+    if (Object.prototype.hasOwnProperty.call(reduxAnchors, anchor) &&
+        reduxAnchors[anchor].length > 0) {
+        reduxAnchors[anchor].forEach((currentFn) => {
+            currentFn.call(null, ...args);
+        });
+    }
+}
+export function RunOverrideActionAnchor(action) {
+    let overridedAction = action;
+    if (Object.prototype.hasOwnProperty.call(actionOverrideAnchor, action.type) &&
+        actionOverrideAnchor[action.type].length > 0) {
+        actionOverrideAnchor[action.type].forEach((currentFn) => {
+            overridedAction = currentFn.call(null, overridedAction);
+        });
+    }
+    return overridedAction;
+}
+export const getPluginsAdditionalRoutes = () => PluginAdditionRoutes;

package/dist/PluginLoader.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/PluginLoader.test.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+import { render, waitFor } from '@testing-library/react';
+import { ReplaceComponent } from './PluginLoader';
+jest.mock('react', () => {
+    const rct = jest.requireActual('react');
+    const Loadable = jest.requireActual('@loadable/component');
+    rct.lazy = Loadable.lazy;
+    return rct;
+});
+jest.mock('./config', () => ({
+    getConfig: () => ({
+        plugins: {
+            jestTestPlugin: '1.0.0',
+        },
+    }),
+}));
+jest.mock('./Globals', () => ({
+    loadPlugin: (plugin) => import(`./tests-misc/plugins/${plugin}`),
+}));
+const { loadPlugins, PluginLoader } = require('./PluginLoader');
+loadPlugins();
+describe('<PluginLoader />', () => {
+    it('Loads "after" hook', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(React.createElement(PluginLoader, { anchor: ['after'] }));
+        yield waitFor(() => expect(container).toContainHTML('<div><div class="title">Hello world - AFTER</div></div>'));
+    }));
+    it('Loads "before" hook', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(React.createElement(PluginLoader, { anchor: ['before'] }));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Hello<b>world</b>!!!</h1></div>'));
+    }));
+    it('Tries to load non existing plugin', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { container } = render(React.createElement(PluginLoader, { anchor: ['myNonExistingPlugin'] }));
+        yield waitFor(() => expect(container).toContainHTML('<div></div>'));
+    }));
+    it('Loads replacement module', () => __awaiter(void 0, void 0, void 0, function* () {
+        const Component = ReplaceComponent('TitleComponent', () => {
+            return React.createElement("span", null, "Original");
+        });
+        const { container } = render(React.createElement(Component, null, "Replaced"));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1 style="color: red;">Replaced</h1></div>'));
+    }));
+});

package/dist/Shimmer.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+declare const _default: import("react-redux").ConnectedComponent<React.FC<{
+    fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking";
+    report: {
+        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
+        raw: string;
+    } | undefined;
+}>, import("react-redux").Omit<{
+    fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked" | "nonBlocking";
+    report: {
+        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
+        raw: string;
+    } | undefined;
+}, "fetchStatus" | "report">>;
+export default _default;

package/dist/Shimmer.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { connect } from 'react-redux';
+import { Loader } from '@legalplace/storybook';
+import { getThemeShimmer } from './ThemeLoader';
+import { PluginLoader } from './PluginLoader';
+import UserLockedComponent from './components/UserLocked/UserLockedComponent';
+const Shimmer = (props) => {
+    var _a;
+    if (props.fetchStatus === 'succeeded' ||
+        props.fetchStatus === 'nonBlocking') {
+        return React.createElement(React.Fragment, null, props.children);
+    }
+    const ThemeShimmer = getThemeShimmer();
+    const style = {
+        position: 'absolute',
+        left: '50%',
+        top: '50%',
+        transform: 'translate(-50%, -50%)',
+        color: '#AAA',
+        fontWeight: 'bold',
+        textTransform: 'uppercase',
+        fontSize: '12px',
+        userSelect: 'none',
+    };
+    const unhealthyStyle = {
+        color: '#AAA',
+        fontWeight: 'bold',
+        textTransform: 'uppercase',
+        fontSize: '24px',
+        width: '700px',
+        margin: 'auto',
+        textAlign: 'center',
+        padding: '20px',
+    };
+    const unhealthyStylePre = {
+        background: '#FDDCD0',
+        textAlign: 'left',
+        fontSize: '12px',
+        color: '#6B0435',
+        padding: '10px',
+        borderRadius: '4px',
+    };
+    if (ThemeShimmer !== null && props.fetchStatus === 'waiting') {
+        return React.createElement(ThemeShimmer, null);
+    }
+    return (React.createElement(React.Fragment, null,
+        ['waiting', 'failed'].includes(props.fetchStatus) && (React.createElement("div", { style: style },
+            props.fetchStatus === 'waiting' && React.createElement(Loader, null),
+            props.fetchStatus === 'failed' &&
+                'Une erreur a eu lieu pendant le chargement du questionnaire')),
+        props.fetchStatus === 'userLocked' && (React.createElement(React.Fragment, null,
+            React.createElement(PluginLoader, { anchor: [`userLockedScreen`], props: props }),
+            React.createElement(UserLockedComponent, { unhealthyStyle: unhealthyStyle }))),
+        props.fetchStatus === 'unhealthy' && (React.createElement("div", { style: unhealthyStyle },
+            "Le mod\u00E8le semble contenir des erreurs",
+            React.createElement("pre", { style: unhealthyStylePre }, (_a = props.report) === null || _a === void 0 ? void 0 : _a.raw)))));
+};
+const mapStateToProps = (state) => {
+    return {
+        fetchStatus: state.app.meta.fetchStatus === 'succeeded'
+            ? 'nonBlocking'
+            : state.app.meta.fetchStatus,
+        report: state.app.meta.report,
+    };
+};
+export default connect(mapStateToProps)(Shimmer);

package/dist/ThemeLoader.d.ts

@@ -0,0 +1,27 @@
+import { LoadableComponent } from '@loadable/component';
+import { IWizardParamsTheme } from './types/config.type';
+export declare const loadTheme: (theme?: string | undefined, force?: boolean | undefined) => Promise<void>;
+export declare const getThemeShimmer: () => LoadableComponent<any> | null;
+export declare const setWizardTheme: (theme: IWizardParamsTheme) => Promise<void>;
+export declare const getThemeParams: () => {
+    [key: string]: any;
+    ui?: {
+        [key: string]: any;
+        topbar: {
+            [key: string]: any;
+            previewBtn: boolean;
+        };
+    } | undefined;
+    sidebar: {
+        [key: string]: any;
+        default: import("./types/config.type").SideBarType;
+        states: {
+            [key: string]: import("./types/config.type").SideBarType;
+            wizard?: import("./types/config.type").SideBarType;
+            email?: import("./types/config.type").SideBarType;
+        };
+    };
+    fonts?: import("@legalplace/storybook").IFonts | undefined;
+    style?: Record<string, any> | undefined;
+};
+export declare const loadThemeComponent: (name: string) => LoadableComponent<any>;

package/dist/ThemeLoader.js

@@ -0,0 +1,74 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import loadable from '@loadable/component';
+import { getConfig, loadConfig, isConfigReady, updateConfig } from './config';
+import * as connectorSelectors from './redux/selectors';
+import * as connectors from './componentsConnectors';
+import Globals from './Globals';
+let wizardTheme;
+let themeParams;
+let themeIndex;
+export const loadTheme = (theme, force) => __awaiter(void 0, void 0, void 0, function* () {
+    let currentTheme;
+    if (theme === undefined) {
+        currentTheme = force ? theme : wizardTheme;
+    }
+    else {
+        currentTheme = theme;
+    }
+    if (currentTheme === undefined) {
+        const config = isConfigReady() ? yield loadConfig() : getConfig();
+        wizardTheme = config.theme.name;
+        themeParams = config.theme.params;
+        currentTheme = wizardTheme;
+    }
+    let themeLoader = {
+        loader: undefined,
+    };
+    try {
+        themeLoader = yield Globals.loadTheme(currentTheme);
+    }
+    catch (e) {
+        throw new Error('We are unable to load the theme, please make sure the theme param is valid');
+    }
+    const { loader, default: themeDefault } = themeLoader;
+    if (typeof loader !== 'function' && typeof themeDefault === 'undefined')
+        throw new Error('Theme loader function not found');
+    if (typeof loader === 'function')
+        themeIndex = loader(themeParams, connectors, connectorSelectors);
+    else if (typeof themeDefault !== 'undefined')
+        themeIndex = themeDefault;
+    else
+        throw new Error('Unable to retrieve theme index');
+    if (typeof themeIndex !== 'object')
+        throw new Error('Theme loader function did not return components object');
+});
+const importThemeComponent = (name) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof themeIndex !== 'object')
+        yield loadTheme();
+    return themeIndex[name];
+});
+export const getThemeShimmer = () => {
+    var _a;
+    return ((_a = getConfig().theme) === null || _a === void 0 ? void 0 : _a.shimmer) === true
+        ? loadable(() => importThemeComponent('ShimmerComponent'))
+        : null;
+};
+export const setWizardTheme = (theme) => __awaiter(void 0, void 0, void 0, function* () {
+    const { name, params } = theme;
+    wizardTheme = name;
+    if (params)
+        themeParams = params;
+    yield loadTheme();
+    const previousConfig = getConfig();
+    updateConfig(Object.assign(Object.assign({}, previousConfig), { theme }));
+});
+export const getThemeParams = () => themeParams;
+export const loadThemeComponent = (name) => loadable(() => importThemeComponent(name));

package/dist/ThemeLoader.test.d.ts

@@ -0,0 +1,2 @@
+import 'regenerator-runtime/runtime';
+import '@testing-library/jest-dom/extend-expect';

package/dist/ThemeLoader.test.js

@@ -0,0 +1,64 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import 'regenerator-runtime/runtime';
+import React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+import { render, cleanup, waitFor } from '@testing-library/react';
+afterEach(cleanup);
+jest.mock('./config', () => ({
+    __esModule: true,
+    getConfig: () => ({
+        theme: { name: 'jestTestTheme' },
+        plugins: {},
+    }),
+    loadConfig: () => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            theme: { name: 'jestTestTheme' },
+            plugins: {},
+        });
+    }),
+    isConfigReady: () => true,
+}));
+jest.mock('./Globals', () => ({
+    loadTheme: (theme) => import(`./tests-misc/themes/${theme}`),
+}));
+let loadThemeComponent;
+let loadTheme;
+describe('<ThemeLoader />', () => {
+    beforeEach(() => {
+        loadThemeComponent = require('./ThemeLoader').loadThemeComponent;
+        loadTheme = require('./ThemeLoader').loadTheme;
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    it('Loads WizardComponent properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        const WizardComponent = loadThemeComponent('WizardComponent');
+        const { container } = render(React.createElement(WizardComponent, null));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Wizard test theme, WizardComponent</h1></div>'));
+    }));
+    it('Loads TermsheetComponent properly', () => __awaiter(void 0, void 0, void 0, function* () {
+        const TermsheetComponent = loadThemeComponent('TermsheetComponent');
+        const { container } = render(React.createElement(TermsheetComponent, null));
+        yield waitFor(() => expect(container).toContainHTML('<div><h1>Wizard test theme, TermsheetComponent</h1></div>'));
+    }));
+});
+describe('loadTheme', () => {
+    it("loadTheme reloads theme properly if it's not yet loaded", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme(undefined, true)).resolves.toEqual(undefined);
+    }));
+    it('loadTheme throws an error if theme param is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme('madeUpTheme')).rejects.toEqual(new Error('We are unable to load the theme, please make sure the theme param is valid'));
+    }));
+    it('loadTheme throws an error if theme param is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme('jestTestTheme/faltyIndexLoader')).rejects.toEqual(new Error('We are unable to load the theme, please make sure the theme param is valid'));
+    }));
+    it('loadTheme throws an error if loader result is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(loadTheme('jestTestTheme/faltyIndex')).rejects.toEqual(new Error('Theme loader function did not return components object'));
+    }));
+});

package/dist/components/PluginRoute.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { RouteComponentProps } from 'react-router-dom';
+export interface IRouteProps {
+    path: string;
+}
+export declare type IProps = RouteComponentProps<IRouteProps>;
+export declare const PluginRoute: ({ match: { params: { path }, }, }: IProps) => JSX.Element;

package/dist/components/PluginRoute.js

@@ -0,0 +1,34 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React, { Suspense, useCallback, useEffect, useState } from 'react';
+import { getPluginsAdditionalRoutes, loadPlugins } from '../PluginLoader';
+import Shimmer from '../Shimmer';
+export const PluginRoute = ({ match: { params: { path }, }, }) => {
+    const [RenderComponent, setRenderComponent] = useState(null);
+    const loadRouteComponent = useCallback((routePath) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            let routes = getPluginsAdditionalRoutes();
+            if (!routes.length) {
+                yield loadPlugins({ authentication: '1.0.0' });
+                routes = getPluginsAdditionalRoutes();
+            }
+            if (routes[routePath])
+                setRenderComponent(routes[routePath]);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }), []);
+    useEffect(() => {
+        loadRouteComponent(path);
+    }, [path, loadRouteComponent]);
+    return (React.createElement(Suspense, { fallback: () => Shimmer },
+        React.createElement(React.Fragment, null, RenderComponent && React.createElement(RenderComponent, null))));
+};

package/dist/components/SmartScript.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import { Action } from 'redux';
+import moment from 'moment-business-days';
+import { SmartScriptStore } from '../libs/SmartScriptStore';
+import { StateType } from '../types/State.type';
+export declare type TInitTriggersCallback = (triggers: StateType.SmartScript['triggers'], actions: Action[]) => void;
+declare global {
+    interface Window {
+        onInit: typeof SmartScriptStore.onInit;
+        onLoad: typeof SmartScriptStore.onLoad;
+        onOptionChange: typeof SmartScriptStore.onOptionChange;
+        onVariableChange: typeof SmartScriptStore.onVariableChange;
+        updateOptionInput: typeof SmartScriptStore.updateOptionInput;
+        updateVariableInput: typeof SmartScriptStore.updateVariableInput;
+        updateOptionMeta: typeof SmartScriptStore.updateOptionMeta;
+        updateVariableMeta: typeof SmartScriptStore.updateVariableMeta;
+        option: (id: number, index: number) => boolean;
+        variable: (id: number, index: number) => string | number;
+        optionAll: (id: number) => boolean[];
+        variableAll: (id: number) => (string | number)[];
+        hideOption: typeof SmartScriptStore.hideOption;
+        displayOption: typeof SmartScriptStore.displayOption;
+        hideVariable: typeof SmartScriptStore.hideVariable;
+        displayVariable: typeof SmartScriptStore.displayVariable;
+        moment: typeof moment;
+        triggerListeners: (type: 'option' | 'variable', id: number, inputs: StateType.Inputs) => Action[];
+        initTriggers: (callback: TInitTriggersCallback, inputs: StateType.Inputs, newInstance: boolean) => void;
+    }
+}
+declare const SmartScriptComponent: () => JSX.Element;
+export default SmartScriptComponent;