@telia-ace/widget-ui 1.0.0

package/lib-esm/hooks/use-dispatch.d.ts

@@ -0,0 +1,3 @@
+export declare type DispatchAction = (key: string, data?: any) => Promise<any>;
+declare const useDispatch: () => DispatchAction;
+export default useDispatch;

package/lib-esm/hooks/use-dispatch.js

@@ -0,0 +1,59 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { ComponentQuery } from '@telia-ace/widget-core';
+import { uuid } from '@telia-ace/widget-utilities';
+import { useEffect, useState } from 'react';
+import useComponentDescriptor from './use-component-descriptor';
+import useComponentPlatform from './use-component-platform';
+var useDispatch = function () {
+    var components = useComponentPlatform();
+    var descriptor = useComponentDescriptor();
+    var _a = __read(useState([]), 2), queue = _a[0], setQueue = _a[1];
+    var _b = __read(useState(), 2), actions = _b[0], setActions = _b[1];
+    useEffect(function () {
+        if (components && descriptor) {
+            var component = new ComponentQuery(components).withId(descriptor.id);
+            var actions_1 = components.actions(component, descriptor.type || uuid());
+            setActions(actions_1);
+            // process the queue and set it to null
+            if (queue !== null) {
+                queue.forEach(function (item) {
+                    actions_1
+                        .dispatch(item.key, item.data)
+                        .then(function (value) { return item.resolve(value); })
+                        .catch(function (reason) { return item.reject(reason); });
+                });
+                setQueue(null);
+            }
+        }
+    }, [components, descriptor.id]);
+    return function (key, data) {
+        if (queue !== null) {
+            // if queue is available the actions controller is not yet created
+            return new Promise(function (resolve, reject) {
+                queue.push({
+                    key: key,
+                    data: data,
+                    resolve: resolve,
+                    reject: reject,
+                });
+            });
+        }
+        return actions.dispatch(key, data);
+    };
+};
+export default useDispatch;

package/lib-esm/hooks/use-event-listener.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (eventName: string, handler: Function, element?: HTMLElement | Window, condition?: () => boolean) => void;
+export default _default;

package/lib-esm/hooks/use-event-listener.js

@@ -0,0 +1,19 @@
+import { useEffect, useRef } from 'react';
+export default (function (eventName, handler, element, condition) {
+    if (element === void 0) { element = window; }
+    if (condition === void 0) { condition = function () { return true; }; }
+    var savedHandler = useRef(function () { });
+    useEffect(function () {
+        savedHandler.current = handler;
+    }, [handler]);
+    useEffect(function () {
+        var isSupported = element && condition();
+        if (!isSupported)
+            return;
+        var eventListener = function (event) { return savedHandler.current(event); };
+        element.addEventListener(eventName, eventListener);
+        return function () {
+            element.removeEventListener(eventName, eventListener);
+        };
+    }, [eventName, element]);
+});

package/lib-esm/hooks/use-events.d.ts

@@ -0,0 +1,3 @@
+import { Container, EventManager } from '@webprovisions/platform';
+declare const useEvents: (passedContainer?: Container | undefined) => EventManager;
+export default useEvents;

package/lib-esm/hooks/use-events.js

@@ -0,0 +1,7 @@
+import useContainer from './use-container';
+var useEvents = function (passedContainer) {
+    var container = useContainer();
+    var events = (passedContainer || container).get('$widget').events;
+    return events;
+};
+export default useEvents;

package/lib-esm/hooks/use-is-mounted.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const useIsMounted: () => import("react").MutableRefObject<boolean>;
+export default useIsMounted;

package/lib-esm/hooks/use-is-mounted.js

@@ -0,0 +1,12 @@
+import { useEffect, useRef } from 'react';
+var useIsMounted = function () {
+    var isMounted = useRef(false);
+    useEffect(function () {
+        isMounted.current = true;
+        return function () {
+            isMounted.current = false;
+        };
+    }, []);
+    return isMounted;
+};
+export default useIsMounted;

package/lib-esm/hooks/use-key-press.d.ts

@@ -0,0 +1,2 @@
+declare const useKeyPress: (targetKey: string, action?: ((event: KeyboardEvent) => void) | undefined) => boolean;
+export default useKeyPress;

package/lib-esm/hooks/use-key-press.js

@@ -0,0 +1,41 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { useCallback, useState } from 'react';
+import useEventListener from './use-event-listener';
+var useKeyPress = function (targetKey, action) {
+    // State for keeping track of whether key is pressed
+    var _a = __read(useState(false), 2), keyPressed = _a[0], setKeyPressed = _a[1];
+    var onKeyDown = useCallback(function (event) {
+        var key = event.key;
+        if (key === targetKey) {
+            setKeyPressed(true);
+            if (action) {
+                action(event);
+            }
+        }
+    }, [setKeyPressed, action]);
+    var onKeyUp = useCallback(function (_a) {
+        var key = _a.key;
+        if (key === targetKey) {
+            setKeyPressed(false);
+        }
+    }, [setKeyPressed]);
+    useEventListener('keydown', onKeyDown, window);
+    useEventListener('keyup', onKeyUp, window);
+    return keyPressed;
+};
+export default useKeyPress;

package/lib-esm/hooks/use-layout.d.ts

@@ -0,0 +1,3 @@
+import { ComponentNodeLayout } from '@telia-ace/widget-core';
+declare const useLayout: (id?: string | undefined) => ComponentNodeLayout;
+export default useLayout;

package/lib-esm/hooks/use-layout.js

@@ -0,0 +1,45 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { useEffect, useState } from 'react';
+import useComponentNode from './use-component-node';
+import useComponentPlatform from './use-component-platform';
+import useIsMounted from './use-is-mounted';
+var useLayout = function (id) {
+    var node = useComponentNode(id);
+    var components = useComponentPlatform();
+    var _a = __read(useState({}), 2), layout = _a[0], setLayout = _a[1];
+    var isMounted = useIsMounted();
+    useEffect(function () {
+        if (node && isMounted.current) {
+            setLayout(node.attributes.layout);
+        }
+    }, [node, isMounted]);
+    useEffect(function () {
+        if (components) {
+            var unsubscribe_1 = components.events.subscribe('components:layout-changed', function (event, data) {
+                if (node === data.node && isMounted.current) {
+                    setLayout(data.node.attributes.layout);
+                }
+            });
+            return function () {
+                unsubscribe_1();
+            };
+        }
+    }, [components, isMounted]);
+    return layout;
+};
+export default useLayout;

package/lib-esm/hooks/use-previous.d.ts

@@ -0,0 +1,2 @@
+declare const usePrevious: <T>(value: T) => T | undefined;
+export default usePrevious;

package/lib-esm/hooks/use-previous.js

@@ -0,0 +1,9 @@
+import { useEffect, useRef } from 'react';
+var usePrevious = function (value) {
+    var ref = useRef();
+    useEffect(function () {
+        ref.current = value;
+    });
+    return ref.current;
+};
+export default usePrevious;

package/lib-esm/hooks/use-properties.d.ts

@@ -0,0 +1,6 @@
+import { ComponentNodeProperties } from '@telia-ace/widget-core';
+declare type DataProperties = {
+    loading?: boolean;
+};
+declare const useProperties: <T extends ComponentNodeProperties>() => Merge<DataProperties, T>;
+export default useProperties;

package/lib-esm/hooks/use-properties.js

@@ -0,0 +1,7 @@
+import { useContext } from 'react';
+import { ComponentPropertyContext } from '../contexts';
+var useProperties = function () {
+    var properties = useContext(ComponentPropertyContext);
+    return properties;
+};
+export default useProperties;

package/lib-esm/hooks/use-render-state.d.ts

@@ -0,0 +1,4 @@
+import { WidgetRenderState } from '@telia-ace/widget-core';
+import { Container } from '@webprovisions/platform';
+declare const useRenderState: (passedContainer?: Container | undefined) => WidgetRenderState | undefined;
+export default useRenderState;

package/lib-esm/hooks/use-render-state.js

@@ -0,0 +1,61 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { WidgetRenderState } from '@telia-ace/widget-core';
+import { useEffect, useState } from 'react';
+import useContainer from './use-container';
+import useIsMounted from './use-is-mounted';
+var useRenderState = function (passedContainer) {
+    var _a = __read(useState(), 2), renderState = _a[0], setRenderState = _a[1];
+    var container = useContainer();
+    var isMounted = useIsMounted();
+    useEffect(function () {
+        var unsubscribe;
+        var _a = (passedContainer || container).get('$widget'), name = _a.name, invoke = _a.invoke;
+        invoke('renderState').then(function (renderState) {
+            if (isMounted.current) {
+                setRenderState(renderState);
+            }
+        });
+        (passedContainer || container)
+            .getAsync('actionResolver')
+            .then(function (actionResolver) {
+            unsubscribe = actionResolver.subscribe(name, function (origin, action) {
+                switch (action) {
+                    case 'close':
+                    case 'open':
+                        if (isMounted.current) {
+                            setRenderState(action === 'open'
+                                ? WidgetRenderState.open
+                                : WidgetRenderState.closed);
+                        }
+                        break;
+                    case 'hide':
+                        if (isMounted.current) {
+                            setRenderState(WidgetRenderState.hidden);
+                        }
+                }
+            });
+        });
+        return function () {
+            if (unsubscribe) {
+                unsubscribe();
+            }
+        };
+    }, [isMounted]);
+    return renderState;
+};
+export default useRenderState;

package/lib-esm/hooks/use-route-data.d.ts

@@ -0,0 +1,4 @@
+import { RouteData } from '@telia-ace/widget-routing';
+import { Container } from '@webprovisions/platform';
+declare const useRouteData: (passedContainer?: Container | undefined) => RouteData;
+export default useRouteData;

package/lib-esm/hooks/use-route-data.js

@@ -0,0 +1,49 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { removeNullAndUndefinedValues } from '@telia-ace/widget-utilities';
+import { useEffect, useState } from 'react';
+import useContainer from './use-container';
+import useIsMounted from './use-is-mounted';
+import useRouter from './use-router';
+var useRouteData = function (passedContainer) {
+    var container = useContainer();
+    var router = useRouter();
+    var _a = __read(useState({ name: '', params: {} }), 2), routeData = _a[0], setRouteData = _a[1];
+    var isMounted = useIsMounted();
+    useEffect(function () {
+        var events = (passedContainer || container).get('$widget').events;
+        var unsubscribe = events.subscribe('router:change', function (e, _a) {
+            var routeData = _a.next.routeData;
+            if (isMounted.current) {
+                var name_1 = routeData.name, params = routeData.params;
+                removeNullAndUndefinedValues(params);
+                setRouteData({ name: name_1, params: params });
+            }
+        });
+        return unsubscribe;
+    }, [isMounted]);
+    useEffect(function () {
+        if (router && router.history && isMounted.current) {
+            var routeData_1 = router.getRouteData();
+            var name_2 = routeData_1.name, params = routeData_1.params;
+            removeNullAndUndefinedValues(params);
+            setRouteData({ name: name_2, params: params });
+        }
+    }, [router, isMounted]);
+    return routeData;
+};
+export default useRouteData;

package/lib-esm/hooks/use-router.d.ts

@@ -0,0 +1,3 @@
+import { RoutingService } from '@telia-ace/widget-routing';
+declare const useRouter: () => RoutingService | null;
+export default useRouter;

package/lib-esm/hooks/use-router.js

@@ -0,0 +1,7 @@
+import { useContext } from 'react';
+import { RoutingContext } from '../contexts';
+var useRouter = function () {
+    var router = useContext(RoutingContext);
+    return router;
+};
+export default useRouter;

package/lib-esm/hooks/use-scroll.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (scrollable: boolean) => [string, React.MutableRefObject<any>];
+export default _default;

package/lib-esm/hooks/use-scroll.js

@@ -0,0 +1,66 @@
+import { useCallback, useRef } from 'react';
+import { browser, Browsers } from '../utils';
+import useEventListener from './use-event-listener';
+export default (function (scrollable) {
+    var elem = useRef();
+    var previousY = useRef(0);
+    var timeoutId;
+    var onScroll = useCallback(function () {
+        var _a;
+        (_a = elem.current) === null || _a === void 0 ? void 0 : _a.classList.add('humany-scrolling');
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(function () {
+            var _a;
+            (_a = elem.current) === null || _a === void 0 ? void 0 : _a.classList.remove('humany-scrolling');
+        }, 500);
+    }, [elem]);
+    var onTouchStart = useCallback(function (event) {
+        previousY.current = event.touches[0].clientY;
+    }, [elem]);
+    var traverseScrollable = function (element) {
+        if (isScrollable(element)) {
+            if (element === elem.current) {
+                return element;
+            }
+            return null;
+        }
+        if (element.parentElement) {
+            return traverseScrollable(element.parentElement);
+        }
+        return null;
+    };
+    var isScrollable = function (element) {
+        return (element.scrollWidth > element.clientWidth || element.scrollHeight > element.clientHeight);
+    };
+    var onTouchMove = useCallback(function (event) {
+        if (!event.cancelable) {
+            return;
+        }
+        var top = event.touches[0].clientY;
+        var firstScrollable = traverseScrollable(event.target);
+        if (!firstScrollable) {
+            return;
+        }
+        var scrollTop = firstScrollable.scrollTop;
+        var direction = previousY.current - top < 0 ? 'up' : 'down';
+        var isAtTop = scrollTop <= 0 && direction === 'up';
+        var isAtBottom = scrollTop >= firstScrollable.scrollHeight - firstScrollable.offsetHeight &&
+            direction === 'down';
+        if (isAtTop || isAtBottom) {
+            // Don't scroll up if already at top,
+            // and don't scroll down if bottom has been reached
+            event.preventDefault();
+        }
+        previousY.current = top;
+    }, [elem, previousY]);
+    useEventListener('scroll', onScroll, elem.current, function () { return elem.current && scrollable; });
+    // This will prevent scrolling causing browser
+    // to freeze on Safari / Chrome on iOS
+    useEventListener('touchstart', onTouchStart, elem.current, function () { return elem.current && scrollable; });
+    useEventListener('touchmove', onTouchMove, elem.current, function () { return elem.current && scrollable; });
+    if (!scrollable) {
+        return ['', elem];
+    }
+    return [styling, elem];
+});
+var styling = "\n    overflow-y: ".concat(browser() === Browsers.Chrome || browser() === Browsers.EdgeChromium ? 'overlay' : 'auto', ";\n    overflow-x: hidden;\n    -ms-overflow-style: none; /* IE 10+ */\n    scrollbar-width: thin; /* Firefox */\n    scrollbar-color: transparent transparent; /* Firefox */\n\n    ::-webkit-scrollbar {\n        width: 3px !important;\n        background-color: transparent;\n        border-left: none;\n    }\n    ::-webkit-scrollbar-thumb {\n        background-color: transparent;\n    }\n    ::-webkit-scrollbar-track {\n        -webkit-box-shadow: none !important;\n        background-color: transparent;\n    }\n    &.humany-scrolling {\n        scrollbar-color: #7F7F7F transparent;\n        scrollbar-width: thin; /* Firefox */\n        -ms-overflow-style: none; /* IE 10+ */\n\n        ::-webkit-scrollbar-thumb {\n            background-color: #7F7F7F;\n        }\n    }\n");

package/lib-esm/hooks/use-settings.d.ts

@@ -0,0 +1,3 @@
+import { WidgetSettings } from '@telia-ace/widget-core';
+declare const useSettings: () => WidgetSettings | null;
+export default useSettings;

package/lib-esm/hooks/use-settings.js

@@ -0,0 +1,33 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { useEffect, useState } from 'react';
+import useContainer from './use-container';
+import useIsMounted from './use-is-mounted';
+var useSettings = function () {
+    var _a = __read(useState(null), 2), settings = _a[0], setSettings = _a[1];
+    var container = useContainer();
+    var isMounted = useIsMounted();
+    useEffect(function () {
+        container.get('settings').then(function (settings) {
+            if (isMounted.current) {
+                setSettings(settings);
+            }
+        });
+    }, [isMounted]);
+    return settings;
+};
+export default useSettings;

package/lib-esm/hooks/use-toggle.d.ts

@@ -0,0 +1,2 @@
+declare const useToggle: (initialValue?: boolean) => [boolean, (forced?: boolean | undefined) => void];
+export default useToggle;

package/lib-esm/hooks/use-toggle.js

@@ -0,0 +1,26 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { useCallback, useState } from 'react';
+var useToggle = function (initialValue) {
+    if (initialValue === void 0) { initialValue = false; }
+    var _a = __read(useState(initialValue), 2), value = _a[0], setValue = _a[1];
+    var toggle = useCallback(function (forced) {
+        setValue(typeof forced === 'boolean' ? forced : function (v) { return !v; });
+    }, []);
+    return [value, toggle];
+};
+export default useToggle;

package/lib-esm/hooks/use-transition-end.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (handler: (...args: any[]) => void) => void;
+export default _default;

package/lib-esm/hooks/use-transition-end.js

@@ -0,0 +1,60 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { useCallback, useEffect, useState } from 'react';
+import { useComponentPlatform, useContainer, useEventListener, useIsMounted } from '.';
+export default (function (handler) {
+    var container = useContainer();
+    var components = useComponentPlatform();
+    var widgetDOMElement = container.get('widgetDOMElement');
+    var _a = __read(useState(null), 2), viewDOMElement = _a[0], setViewDOMElement = _a[1];
+    var _b = __read(useState(null), 2), rootDOMElement = _b[0], setRootDOMElement = _b[1];
+    var isMounted = useIsMounted();
+    useEffect(function () {
+        if (components && isMounted.current) {
+            var rootArea = components.nodes.all.find(function (n) { return n.name === 'root-area'; });
+            var view = components.nodes.all.find(function (n) { return n.type === 'view'; });
+            if (!(view === null || view === void 0 ? void 0 : view.attributes.properties.animation) &&
+                !(rootArea === null || rootArea === void 0 ? void 0 : rootArea.attributes.properties.animation)) {
+                // if view and root does not use animations, call handler on render
+                handler();
+            }
+            else {
+                // else add elements to state for transitionend-event handling
+                var getElement = function (id) {
+                    if (id === void 0) { id = ''; }
+                    return widgetDOMElement === null || widgetDOMElement === void 0 ? void 0 : widgetDOMElement.querySelector("[data-node-id=\"".concat(id, "\"]"));
+                };
+                var viewDOMElement_1 = getElement(view === null || view === void 0 ? void 0 : view.id);
+                if (viewDOMElement_1) {
+                    setViewDOMElement(viewDOMElement_1);
+                }
+                var rootDOMElement_1 = getElement(rootArea === null || rootArea === void 0 ? void 0 : rootArea.id);
+                if (rootDOMElement_1) {
+                    setRootDOMElement(rootDOMElement_1);
+                }
+            }
+        }
+    }, [components, container, isMounted]);
+    var eventListener = useCallback(function (event) {
+        if (isMounted.current &&
+            (event.target === viewDOMElement || event.target === rootDOMElement)) {
+            handler();
+        }
+    }, [handler, isMounted, viewDOMElement, rootDOMElement]);
+    useEventListener('transitionend', eventListener, viewDOMElement);
+    useEventListener('transitionend', eventListener, rootDOMElement);
+});

package/lib-esm/hooks/use-unique-menu.d.ts

@@ -0,0 +1,2 @@
+declare const useUniqueMenu: (id: string, callback: () => void) => Function;
+export default useUniqueMenu;

package/lib-esm/hooks/use-unique-menu.js

@@ -0,0 +1,10 @@
+import useWidgetEvent from './use-widget-event';
+var useUniqueMenu = function (id, callback) {
+    var dispatch = useWidgetEvent('widget:menu-toggled', function (_, triggeredId) {
+        if (triggeredId !== id) {
+            callback();
+        }
+    });
+    return function () { return dispatch(id); };
+};
+export default useUniqueMenu;

package/lib-esm/hooks/use-widget-event.d.ts

@@ -0,0 +1,3 @@
+import { Container, EventListener } from '@webprovisions/platform';
+declare const useWidgetEvent: (event: string, callback: EventListener, dependencies?: any[], passedContainer?: Container | undefined) => (data: any) => void;
+export default useWidgetEvent;

package/lib-esm/hooks/use-widget-event.js

@@ -0,0 +1,16 @@
+import { useEffect } from 'react';
+import useEvents from './use-events';
+var useWidgetEvent = function (event, callback, dependencies, passedContainer) {
+    if (dependencies === void 0) { dependencies = []; }
+    var events = useEvents(passedContainer);
+    useEffect(function () {
+        if (events) {
+            var unsubscribe_1 = events.subscribe(event, callback);
+            return function () {
+                unsubscribe_1();
+            };
+        }
+    }, [events].concat(dependencies));
+    return function (data) { return events === null || events === void 0 ? void 0 : events.dispatch(event, data); };
+};
+export default useWidgetEvent;

package/lib-esm/index.d.ts

@@ -0,0 +1,9 @@
+import { AnchorLink, Button, ButtonProps, Checkbox, CheckboxProps, Confirm, DateFormats, Drawer, DrawerAnimationType, Dropdown, DropdownProps, Empty, EmptyProps, Grid, GridProps, Html, HtmlIconProps, HtmlParseInstruction, HtmlProps, Icon, IconProps, Input, InputProps, ItemList, ItemListProps, ItemRenderer, ItemTree, ItemTreeProps, Lightbox, LightboxProps, Link, LinkProps, List, ListProps, Modal, ModalProps, NotFound, NotFoundProps, Overlay, OverlayProps, Paragraph, ParagraphProps, Portal, PortalProps, RouteLink, RouteLinkProps, Symbol, SymbolBadge, SymbolBadgeProps, TabStop, TabStopProps, Text, TextLink, TextLinkProps, TextProps, Timestamp, TimestampProps, Tooltip, TooltipProps, TransitionComponent, TransitionComponentProps, Typography, TypographyProps, WidgetLink, WidgetLinkProps } from './components';
+import { ColumnContext, ComponentNodeContext, ComponentPropertyContext, ContainerContext, RoutingContext } from './contexts';
+import { default as createReactComponent } from './create-react-component';
+import { DispatchAction, useAction, useChildren, useColumns, useComponent, useComponentDescriptor, useComponentNode, useComponentPlatform, useContainer, useContext, useDispatch, useEventListener, useEvents, useIsMounted, useKeyPress, useLayout, usePrevious, useProperties, useRenderState, useRouteData, useRouter, useScroll, useSettings, useToggle, useTransitionEnd, useUniqueMenu, useWidgetEvent } from './hooks';
+import { borderTabStyle, buttonCss, contentBox, invertedHoverButton, itemList, linkTabStyle, list, paddedBorderTabStyle, StyledText } from './styles';
+import { createEmptyComponent, filterCssProps, filterCssPropsStyle, headingElement, transitionComposer } from './utils';
+export { AnchorLink, borderTabStyle, Button, buttonCss, Checkbox, ColumnContext, ComponentNodeContext, ComponentPropertyContext, Confirm, ContainerContext, contentBox, createEmptyComponent, createReactComponent, DateFormats, Drawer, DrawerAnimationType, Dropdown, filterCssProps, filterCssPropsStyle, Grid, headingElement, Html, Icon, Input, invertedHoverButton, ItemList, ItemTree, Lightbox, Link, linkTabStyle, List, paddedBorderTabStyle, RoutingContext, SymbolBadge, Text, TextLink, TransitionComponent, transitionComposer, Typography, useChildren, useColumns, useComponent, useComponentDescriptor, useComponentNode, useComponentPlatform, useContainer, useContext, useDispatch, useIsMounted, useLayout, useProperties, useRenderState, useRouteData, useRouter, useScroll, useTransitionEnd, useAction, useEventListener, useEvents, useKeyPress, usePrevious, useSettings, useToggle, useUniqueMenu, useWidgetEvent, Empty, Modal, NotFound, Overlay, Paragraph, Portal, RouteLink, TabStop, Timestamp, Tooltip, WidgetLink, itemList, list, StyledText, };
+export type { ButtonProps, CheckboxProps, DropdownProps, EmptyProps, GridProps, HtmlIconProps, HtmlParseInstruction, HtmlProps, IconProps, InputProps, ItemListProps, ItemRenderer, ItemTreeProps, LightboxProps, LinkProps, ListProps, ModalProps, NotFoundProps, OverlayProps, ParagraphProps, PortalProps, RouteLinkProps, Symbol, SymbolBadgeProps, TabStopProps, TextLinkProps, TextProps, TimestampProps, TooltipProps, TransitionComponentProps, TypographyProps, WidgetLinkProps, };
+export type { DispatchAction };