@fluentui/react-charts 1.2.0 → 9.0.0

package/lib-commonjs/utilities/SVGTooltipText.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SVGTooltipText", {
+    enumerable: true,
+    get: function() {
+        return SVGTooltipText;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _reacttooltip = require("@fluentui/react-tooltip");
+const _asyncutils = require("./async-utils");
+const _KeyCodes = require("./KeyCodes");
+const _reactutilities = require("@fluentui/react-utilities");
+const SVGTooltipText = /*#__PURE__*/ _react.forwardRef((props, forwardedRef)=>{
+    const [isTooltipVisible, setIsTooltipVisible] = (0, _react.useState)(false);
+    const [isOverflowing, setIsOverflowing] = (0, _react.useState)(false);
+    const tooltipHostRef = (0, _react.useRef)(null);
+    const async = (0, _react.useRef)(new _asyncutils.Async()).current;
+    const dismissTimerId = (0, _react.useRef)();
+    const openTimerId = (0, _react.useRef)();
+    const tooltipHostId = (0, _react.useRef)((0, _reactutilities.useId)('tooltip-host')).current;
+    const ignoreNextFocusEvent = (0, _react.useRef)(false);
+    const portalMountNode = (0, _reactsharedcontexts.usePortalMountNode)();
+    const wrapContentCallback = (0, _react.useCallback)(()=>{
+        var _props_maxWidth;
+        if (props.content && props.wrapContent && props.wrapContent(props.content, tooltipHostId, (_props_maxWidth = props.maxWidth) !== null && _props_maxWidth !== void 0 ? _props_maxWidth : 100, props.maxHeight) // ToDo - Specify a correct fallback value here
+        ) {
+            setIsOverflowing(true);
+        } else {
+            setIsOverflowing(false);
+        }
+    }, [
+        props,
+        tooltipHostId
+    ]);
+    (0, _react.useEffect)(()=>{
+        wrapContentCallback();
+        return ()=>{
+            async.dispose();
+        };
+    }, [
+        wrapContentCallback,
+        async
+    ]);
+    (0, _react.useEffect)(()=>{
+        wrapContentCallback();
+    }, [
+        props.maxWidth,
+        props.maxHeight,
+        wrapContentCallback
+    ]);
+    const hideTooltip = (0, _react.useCallback)(()=>{
+        async.clearTimeout(openTimerId.current);
+        async.clearTimeout(dismissTimerId.current);
+        setIsTooltipVisible(false);
+    }, [
+        async
+    ]);
+    const onTooltipMouseEnter = (0, _react.useCallback)((ev)=>{
+        if (!isOverflowing) {
+            return;
+        }
+        if (ev.target && (portalMountNode === null || portalMountNode === void 0 ? void 0 : portalMountNode.contains(ev.target))) {
+            return;
+        }
+        async.clearTimeout(dismissTimerId.current);
+        async.clearTimeout(openTimerId.current);
+        if (props.delay !== 0) {
+            openTimerId.current = async.setTimeout(()=>{
+                setIsTooltipVisible(true);
+            }, props.delay);
+        } else {
+            setIsTooltipVisible(true);
+        }
+    }, [
+        isOverflowing,
+        portalMountNode,
+        async,
+        props.delay
+    ]);
+    const onTooltipMouseLeave = (0, _react.useCallback)((ev)=>{
+        async.clearTimeout(dismissTimerId.current);
+        async.clearTimeout(openTimerId.current);
+        if (props.closeDelay) {
+            dismissTimerId.current = async.setTimeout(()=>{
+                setIsTooltipVisible(false);
+            }, props.closeDelay);
+        } else {
+            setIsTooltipVisible(false);
+        }
+    }, [
+        async,
+        props.closeDelay
+    ]);
+    const onTooltipFocus = (0, _react.useCallback)((ev)=>{
+        if (ignoreNextFocusEvent.current) {
+            ignoreNextFocusEvent.current = false;
+            return;
+        }
+        onTooltipMouseEnter(ev);
+    }, [
+        onTooltipMouseEnter
+    ]);
+    const onTooltipBlur = (0, _react.useCallback)((ev)=>{
+        var _document;
+        ignoreNextFocusEvent.current = ((_document = document) === null || _document === void 0 ? void 0 : _document.activeElement) === ev.target;
+        dismissTimerId.current = async.setTimeout(()=>{
+            setIsTooltipVisible(false);
+        }, 0);
+    }, [
+        async
+    ]);
+    const onTooltipKeyDown = (0, _react.useCallback)((ev)=>{
+        if ((ev.which === _KeyCodes.KeyCodes.escape || ev.ctrlKey) && isTooltipVisible) {
+            hideTooltip();
+            ev.stopPropagation();
+        }
+    }, [
+        isTooltipVisible,
+        hideTooltip
+    ]);
+    const showTooltip = props.isTooltipVisibleProp && isOverflowing && !!props.content || isTooltipVisible && !!props.content;
+    return /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement(_reacttooltip.Tooltip, {
+        relationship: "description",
+        ...props.tooltipProps,
+        withArrow: true,
+        content: props.content,
+        // targetElement={getTargetElement()} ToDo - This assignment is causing build failure. Needs to be fixed.
+        visible: showTooltip
+    }, /*#__PURE__*/ _react.createElement("text", {
+        ...props.textProps,
+        id: tooltipHostId,
+        ref: tooltipHostRef,
+        onFocusCapture: onTooltipFocus,
+        onBlurCapture: onTooltipBlur,
+        onMouseEnter: onTooltipMouseEnter,
+        onMouseLeave: onTooltipMouseLeave,
+        onKeyDown: onTooltipKeyDown,
+        "data-is-focusable": props.shouldReceiveFocus && isOverflowing
+    }, props.content)));
+});
+SVGTooltipText.defaultProps = {
+    delay: 0
+};

package/lib-commonjs/utilities/SVGTooltipText.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SVGTooltipText.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useState, useRef, useEffect, useCallback } from 'react';\nimport { usePortalMountNode } from '@fluentui/react-shared-contexts';\nimport { Tooltip } from '@fluentui/react-tooltip';\nimport { Async } from './async-utils';\nimport { KeyCodes } from './KeyCodes';\nimport { useId } from '@fluentui/react-utilities';\n\ninterface SVGTooltipTextProps {\n  closeDelay?: number;\n  content: string;\n  delay?: number;\n  tooltipProps?: React.ComponentProps<typeof Tooltip>;\n  textProps?: React.SVGAttributes<SVGTextElement>;\n  maxWidth?: number;\n  maxHeight?: number;\n  shouldReceiveFocus?: boolean;\n  isTooltipVisibleProp?: boolean;\n  wrapContent?: (content: string, id: string, maxWidth: number, maxHeight?: number) => boolean;\n}\n\nexport const SVGTooltipText: React.FunctionComponent<SVGTooltipTextProps> = React.forwardRef<\n  HTMLDivElement,\n  SVGTooltipTextProps\n>((props, forwardedRef) => {\n  const [isTooltipVisible, setIsTooltipVisible] = useState(false);\n  const [isOverflowing, setIsOverflowing] = useState(false);\n  const tooltipHostRef = useRef<SVGTextElement>(null);\n  const async = useRef(new Async()).current;\n  const dismissTimerId = useRef<number>();\n  const openTimerId = useRef<number>();\n  const tooltipHostId = useRef(useId('tooltip-host')).current;\n  const ignoreNextFocusEvent = useRef(false);\n  const portalMountNode = usePortalMountNode();\n\n  const wrapContentCallback = useCallback(() => {\n    if (\n      props.content &&\n      props.wrapContent &&\n      props.wrapContent(props.content, tooltipHostId, props.maxWidth ?? 100, props.maxHeight) // ToDo - Specify a correct fallback value here\n    ) {\n      setIsOverflowing(true);\n    } else {\n      setIsOverflowing(false);\n    }\n  }, [props, tooltipHostId]);\n\n  useEffect(() => {\n    wrapContentCallback();\n    return () => {\n      async.dispose();\n    };\n  }, [wrapContentCallback, async]);\n\n  useEffect(() => {\n    wrapContentCallback();\n  }, [props.maxWidth, props.maxHeight, wrapContentCallback]);\n\n  const hideTooltip = useCallback(() => {\n    async.clearTimeout(openTimerId.current!);\n    async.clearTimeout(dismissTimerId.current!);\n    setIsTooltipVisible(false);\n  }, [async]);\n\n  const onTooltipMouseEnter = useCallback(\n    (ev: React.MouseEvent<SVGElement>) => {\n      if (!isOverflowing) {\n        return;\n      }\n\n      if (ev.target && portalMountNode?.contains(ev.target as HTMLElement)) {\n        return;\n      }\n\n      async.clearTimeout(dismissTimerId.current!);\n      async.clearTimeout(openTimerId.current!);\n\n      if (props.delay !== 0) {\n        openTimerId.current = async.setTimeout(() => {\n          setIsTooltipVisible(true);\n        }, props.delay!);\n      } else {\n        setIsTooltipVisible(true);\n      }\n    },\n    [isOverflowing, portalMountNode, async, props.delay],\n  );\n\n  const onTooltipMouseLeave = useCallback(\n    (ev: React.MouseEvent<SVGElement>) => {\n      async.clearTimeout(dismissTimerId.current!);\n      async.clearTimeout(openTimerId.current!);\n\n      if (props.closeDelay) {\n        dismissTimerId.current = async.setTimeout(() => {\n          setIsTooltipVisible(false);\n        }, props.closeDelay);\n      } else {\n        setIsTooltipVisible(false);\n      }\n    },\n    [async, props.closeDelay],\n  );\n\n  const onTooltipFocus = useCallback(\n    (ev: React.FocusEvent<SVGElement>) => {\n      if (ignoreNextFocusEvent.current) {\n        ignoreNextFocusEvent.current = false;\n        return;\n      }\n      onTooltipMouseEnter(ev as unknown as React.MouseEvent<SVGElement>);\n    },\n    [onTooltipMouseEnter],\n  );\n\n  const onTooltipBlur = useCallback(\n    (ev: React.FocusEvent<SVGElement>) => {\n      ignoreNextFocusEvent.current = document?.activeElement === ev.target;\n      dismissTimerId.current = async.setTimeout(() => {\n        setIsTooltipVisible(false);\n      }, 0);\n    },\n    [async],\n  );\n\n  const onTooltipKeyDown = useCallback(\n    (ev: React.KeyboardEvent<SVGElement>) => {\n      if ((ev.which === KeyCodes.escape || ev.ctrlKey) && isTooltipVisible) {\n        hideTooltip();\n        ev.stopPropagation();\n      }\n    },\n    [isTooltipVisible, hideTooltip],\n  );\n\n  const showTooltip =\n    (props.isTooltipVisibleProp && isOverflowing && !!props.content) || (isTooltipVisible && !!props.content);\n\n  return (\n    <>\n      <Tooltip\n        relationship=\"description\"\n        {...props.tooltipProps}\n        withArrow\n        content={props.content}\n        // targetElement={getTargetElement()} ToDo - This assignment is causing build failure. Needs to be fixed.\n        visible={showTooltip}\n      >\n        <text\n          {...props.textProps}\n          id={tooltipHostId}\n          ref={tooltipHostRef}\n          onFocusCapture={onTooltipFocus}\n          onBlurCapture={onTooltipBlur}\n          onMouseEnter={onTooltipMouseEnter}\n          onMouseLeave={onTooltipMouseLeave}\n          onKeyDown={onTooltipKeyDown}\n          data-is-focusable={props.shouldReceiveFocus && isOverflowing}\n        >\n          {props.content}\n        </text>\n      </Tooltip>\n    </>\n  );\n});\n\nSVGTooltipText.defaultProps = {\n  delay: 0,\n};\n"],"names":["SVGTooltipText","React","forwardRef","props","forwardedRef","isTooltipVisible","setIsTooltipVisible","useState","isOverflowing","setIsOverflowing","tooltipHostRef","useRef","async","Async","current","dismissTimerId","openTimerId","tooltipHostId","useId","ignoreNextFocusEvent","portalMountNode","usePortalMountNode","wrapContentCallback","useCallback","content","wrapContent","maxWidth","maxHeight","useEffect","dispose","hideTooltip","clearTimeout","onTooltipMouseEnter","ev","target","contains","delay","setTimeout","onTooltipMouseLeave","closeDelay","onTooltipFocus","onTooltipBlur","document","activeElement","onTooltipKeyDown","which","KeyCodes","escape","ctrlKey","stopPropagation","showTooltip","isTooltipVisibleProp","createElement","Fragment","Tooltip","relationship","tooltipProps","withArrow","visible","text","textProps","id","ref","onFocusCapture","onBlurCapture","onMouseEnter","onMouseLeave","onKeyDown","data-is-focusable","shouldReceiveFocus","defaultProps"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/utilities/async-utils.js

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Async", {
+    enumerable: true,
+    get: function() {
+        return Async;
+    }
+});
+const _define_property = require("@swc/helpers/_/_define_property");
+const _getWindow = require("./getWindow");
+class Async {
+    /**
+   * Dispose function, clears all async operations.
+   */ dispose() {
+        let id;
+        this._isDisposed = true;
+        this._parent = null;
+        // Clear timeouts.
+        if (this._timeoutIds) {
+            for(id in this._timeoutIds){
+                if (this._timeoutIds.hasOwnProperty(id)) {
+                    this.clearTimeout(parseInt(id, 10));
+                }
+            }
+            this._timeoutIds = null;
+        }
+        // Clear immediates.
+        if (this._immediateIds) {
+            for(id in this._immediateIds){
+                if (this._immediateIds.hasOwnProperty(id)) {
+                    this.clearImmediate(parseInt(id, 10));
+                }
+            }
+            this._immediateIds = null;
+        }
+        // Clear intervals.
+        if (this._intervalIds) {
+            for(id in this._intervalIds){
+                if (this._intervalIds.hasOwnProperty(id)) {
+                    this.clearInterval(parseInt(id, 10));
+                }
+            }
+            this._intervalIds = null;
+        }
+        // Clear animation frames.
+        if (this._animationFrameIds) {
+            for(id in this._animationFrameIds){
+                if (this._animationFrameIds.hasOwnProperty(id)) {
+                    this.cancelAnimationFrame(parseInt(id, 10));
+                }
+            }
+            this._animationFrameIds = null;
+        }
+    }
+    /**
+   * SetTimeout override, which will auto cancel the timeout during dispose.
+   * @param callback - Callback to execute.
+   * @param duration - Duration in milliseconds.
+   * @returns The setTimeout id.
+   */ setTimeout(callback, duration) {
+        let timeoutId = 0;
+        if (!this._isDisposed) {
+            if (!this._timeoutIds) {
+                this._timeoutIds = {};
+            }
+            timeoutId = setTimeout(()=>{
+                // Time to execute the timeout, enqueue it as a foreground task to be executed.
+                try {
+                    // Now delete the record and call the callback.
+                    if (this._timeoutIds) {
+                        delete this._timeoutIds[timeoutId];
+                    }
+                    callback.apply(this._parent);
+                } catch (e) {
+                    this._logError(e);
+                }
+            }, duration);
+            this._timeoutIds[timeoutId] = true;
+        }
+        return timeoutId;
+    }
+    /**
+   * Clears the timeout.
+   * @param id - Id to cancel.
+   */ clearTimeout(id) {
+        if (this._timeoutIds && this._timeoutIds[id]) {
+            clearTimeout(id);
+            delete this._timeoutIds[id];
+        }
+    }
+    /**
+   * SetImmediate override, which will auto cancel the immediate during dispose.
+   * @param callback - Callback to execute.
+   * @param targetElement - Optional target element to use for identifying the correct window.
+   * @returns The setTimeout id.
+   */ setImmediate(callback, targetElement) {
+        let immediateId = 0;
+        const win = (0, _getWindow.getWindow)(targetElement);
+        if (!this._isDisposed) {
+            if (!this._immediateIds) {
+                this._immediateIds = {};
+            }
+            let setImmediateCallback = ()=>{
+                // Time to execute the timeout, enqueue it as a foreground task to be executed.
+                try {
+                    // Now delete the record and call the callback.
+                    if (this._immediateIds) {
+                        delete this._immediateIds[immediateId];
+                    }
+                    callback.apply(this._parent);
+                } catch (e) {
+                    this._logError(e);
+                }
+            };
+            immediateId = win.setTimeout(setImmediateCallback, 0);
+            this._immediateIds[immediateId] = true;
+        }
+        return immediateId;
+    }
+    /**
+   * Clears the immediate.
+   * @param id - Id to cancel.
+   * @param targetElement - Optional target element to use for identifying the correct window.
+   */ clearImmediate(id, targetElement) {
+        const win = (0, _getWindow.getWindow)(targetElement);
+        if (this._immediateIds && this._immediateIds[id]) {
+            win.clearTimeout(id);
+            delete this._immediateIds[id];
+        }
+    }
+    /**
+   * SetInterval override, which will auto cancel the timeout during dispose.
+   * @param callback - Callback to execute.
+   * @param duration - Duration in milliseconds.
+   * @returns The setTimeout id.
+   */ setInterval(callback, duration) {
+        let intervalId = 0;
+        if (!this._isDisposed) {
+            if (!this._intervalIds) {
+                this._intervalIds = {};
+            }
+            intervalId = setInterval(()=>{
+                // Time to execute the interval callback, enqueue it as a foreground task to be executed.
+                try {
+                    callback.apply(this._parent);
+                } catch (e) {
+                    this._logError(e);
+                }
+            }, duration);
+            this._intervalIds[intervalId] = true;
+        }
+        return intervalId;
+    }
+    /**
+   * Clears the interval.
+   * @param id - Id to cancel.
+   */ clearInterval(id) {
+        if (this._intervalIds && this._intervalIds[id]) {
+            clearInterval(id);
+            delete this._intervalIds[id];
+        }
+    }
+    /**
+   * Creates a function that, when executed, will only call the func function at most once per
+   * every wait milliseconds. Provide an options object to indicate that func should be invoked
+   * on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled
+   * function will return the result of the last func call.
+   *
+   * Note: If leading and trailing options are true func will be called on the trailing edge of
+   * the timeout only if the throttled function is invoked more than once during the wait timeout.
+   *
+   * @param func - The function to throttle.
+   * @param wait - The number of milliseconds to throttle executions to. Defaults to 0.
+   * @param options - The options object.
+   * @returns The new throttled function.
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    throttle(func, wait, options) {
+        if (this._isDisposed) {
+            return this._noop;
+        }
+        let waitMS = wait || 0;
+        let leading = true;
+        let trailing = true;
+        let lastExecuteTime = 0;
+        let lastResult;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let lastArgs;
+        let timeoutId = null;
+        if (options && typeof options.leading === 'boolean') {
+            leading = options.leading;
+        }
+        if (options && typeof options.trailing === 'boolean') {
+            trailing = options.trailing;
+        }
+        let callback = (userCall)=>{
+            let now = Date.now();
+            let delta = now - lastExecuteTime;
+            let waitLength = leading ? waitMS - delta : waitMS;
+            if (delta >= waitMS && (!userCall || leading)) {
+                lastExecuteTime = now;
+                if (timeoutId) {
+                    this.clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                lastResult = func.apply(this._parent, lastArgs);
+            } else if (timeoutId === null && trailing) {
+                timeoutId = this.setTimeout(callback, waitLength);
+            }
+            return lastResult;
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let resultFunction = (...args)=>{
+            lastArgs = args;
+            return callback(true);
+        };
+        return resultFunction;
+    }
+    /**
+   * Creates a function that will delay the execution of func until after wait milliseconds have
+   * elapsed since the last time it was invoked. Provide an options object to indicate that func
+   * should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls
+   * to the debounced function will return the result of the last func call.
+   *
+   * Note: If leading and trailing options are true func will be called on the trailing edge of
+   * the timeout only if the debounced function is invoked more than once during the wait
+   * timeout.
+   *
+   * @param func - The function to debounce.
+   * @param wait - The number of milliseconds to delay.
+   * @param options - The options object.
+   * @returns The new debounced function.
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    debounce(func, wait, options) {
+        if (this._isDisposed) {
+            let noOpFunction = ()=>{
+            /** Do nothing */ };
+            noOpFunction.cancel = ()=>{
+                return;
+            };
+            noOpFunction.flush = ()=>null;
+            noOpFunction.pending = ()=>false;
+            return noOpFunction;
+        }
+        let waitMS = wait || 0;
+        let leading = false;
+        let trailing = true;
+        let maxWait = null;
+        let lastCallTime = 0;
+        let lastExecuteTime = Date.now();
+        let lastResult;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let lastArgs;
+        let timeoutId = null;
+        if (options && typeof options.leading === 'boolean') {
+            leading = options.leading;
+        }
+        if (options && typeof options.trailing === 'boolean') {
+            trailing = options.trailing;
+        }
+        if (options && typeof options.maxWait === 'number' && !isNaN(options.maxWait)) {
+            maxWait = options.maxWait;
+        }
+        let markExecuted = (time)=>{
+            if (timeoutId) {
+                this.clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            lastExecuteTime = time;
+        };
+        let invokeFunction = (time)=>{
+            markExecuted(time);
+            lastResult = func.apply(this._parent, lastArgs);
+        };
+        let callback = (userCall)=>{
+            let now = Date.now();
+            let executeImmediately = false;
+            if (userCall) {
+                if (leading && now - lastCallTime >= waitMS) {
+                    executeImmediately = true;
+                }
+                lastCallTime = now;
+            }
+            let delta = now - lastCallTime;
+            let waitLength = waitMS - delta;
+            let maxWaitDelta = now - lastExecuteTime;
+            let maxWaitExpired = false;
+            if (maxWait !== null) {
+                // maxWait only matters when there is a pending callback
+                if (maxWaitDelta >= maxWait && timeoutId) {
+                    maxWaitExpired = true;
+                } else {
+                    waitLength = Math.min(waitLength, maxWait - maxWaitDelta);
+                }
+            }
+            if (delta >= waitMS || maxWaitExpired || executeImmediately) {
+                invokeFunction(now);
+            } else if ((timeoutId === null || !userCall) && trailing) {
+                timeoutId = this.setTimeout(callback, waitLength);
+            }
+            return lastResult;
+        };
+        let pending = ()=>{
+            return !!timeoutId;
+        };
+        let cancel = ()=>{
+            if (pending()) {
+                // Mark the debounced function as having executed
+                markExecuted(Date.now());
+            }
+        };
+        let flush = ()=>{
+            if (pending()) {
+                invokeFunction(Date.now());
+            }
+            return lastResult;
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let resultFunction = (...args)=>{
+            lastArgs = args;
+            return callback(true);
+        };
+        resultFunction.cancel = cancel;
+        resultFunction.flush = flush;
+        resultFunction.pending = pending;
+        return resultFunction;
+    }
+    requestAnimationFrame(callback, targetElement) {
+        let animationFrameId = 0;
+        const win = (0, _getWindow.getWindow)(targetElement);
+        if (!this._isDisposed) {
+            if (!this._animationFrameIds) {
+                this._animationFrameIds = {};
+            }
+            let animationFrameCallback = ()=>{
+                try {
+                    // Now delete the record and call the callback.
+                    if (this._animationFrameIds) {
+                        delete this._animationFrameIds[animationFrameId];
+                    }
+                    callback.apply(this._parent);
+                } catch (e) {
+                    this._logError(e);
+                }
+            };
+            animationFrameId = win.requestAnimationFrame ? win.requestAnimationFrame(animationFrameCallback) : win.setTimeout(animationFrameCallback, 0);
+            this._animationFrameIds[animationFrameId] = true;
+        }
+        return animationFrameId;
+    }
+    cancelAnimationFrame(id, targetElement) {
+        const win = (0, _getWindow.getWindow)(targetElement);
+        if (this._animationFrameIds && this._animationFrameIds[id]) {
+            win.cancelAnimationFrame ? win.cancelAnimationFrame(id) : win.clearTimeout(id);
+            delete this._animationFrameIds[id];
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _logError(e) {
+        if (this._onErrorHandler) {
+            this._onErrorHandler(e);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(parent, onError){
+        (0, _define_property._)(this, "_timeoutIds", null);
+        (0, _define_property._)(this, "_immediateIds", null);
+        (0, _define_property._)(this, "_intervalIds", null);
+        (0, _define_property._)(this, "_animationFrameIds", null);
+        (0, _define_property._)(this, "_isDisposed", void 0);
+        (0, _define_property._)(this, "_parent", void 0);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, _define_property._)(this, "_onErrorHandler", void 0);
+        (0, _define_property._)(this, "_noop", void 0);
+        this._isDisposed = false;
+        this._parent = parent || null;
+        this._onErrorHandler = onError;
+        this._noop = ()=>{
+        /* do nothing */ };
+    }
+}

package/lib-commonjs/utilities/async-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["async-utils.ts"],"sourcesContent":["import { getWindow } from './getWindow';\n\ndeclare function setTimeout(cb: Function, delay: number): number;\ndeclare function setInterval(cb: Function, delay: number): number;\n\n/**\n * Bugs often appear in async code when stuff gets disposed, but async operations don't get canceled.\n * This Async helper class solves these issues by tying async code to the lifetime of a disposable object.\n *\n * Usage: Anything class extending from BaseModel can access this helper via this.async. Otherwise create a\n * new instance of the class and remember to call dispose() during your code's dispose handler.\n *\n * @public\n */\nexport class Async {\n  private _timeoutIds: { [id: number]: boolean } | null = null;\n  private _immediateIds: { [id: number]: boolean } | null = null;\n  private _intervalIds: { [id: number]: boolean } | null = null;\n  private _animationFrameIds: { [id: number]: boolean } | null = null;\n  private _isDisposed: boolean;\n  private _parent: object | null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _onErrorHandler: ((e: any) => void) | undefined;\n  private _noop: () => void;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  constructor(parent?: object, onError?: (e: any) => void) {\n    this._isDisposed = false;\n    this._parent = parent || null;\n    this._onErrorHandler = onError;\n    this._noop = () => {\n      /* do nothing */\n    };\n  }\n\n  /**\n   * Dispose function, clears all async operations.\n   */\n  public dispose(): void {\n    let id;\n\n    this._isDisposed = true;\n    this._parent = null;\n\n    // Clear timeouts.\n    if (this._timeoutIds) {\n      for (id in this._timeoutIds) {\n        if (this._timeoutIds.hasOwnProperty(id)) {\n          this.clearTimeout(parseInt(id, 10));\n        }\n      }\n\n      this._timeoutIds = null;\n    }\n\n    // Clear immediates.\n    if (this._immediateIds) {\n      for (id in this._immediateIds) {\n        if (this._immediateIds.hasOwnProperty(id)) {\n          this.clearImmediate(parseInt(id, 10));\n        }\n      }\n\n      this._immediateIds = null;\n    }\n\n    // Clear intervals.\n    if (this._intervalIds) {\n      for (id in this._intervalIds) {\n        if (this._intervalIds.hasOwnProperty(id)) {\n          this.clearInterval(parseInt(id, 10));\n        }\n      }\n      this._intervalIds = null;\n    }\n\n    // Clear animation frames.\n    if (this._animationFrameIds) {\n      for (id in this._animationFrameIds) {\n        if (this._animationFrameIds.hasOwnProperty(id)) {\n          this.cancelAnimationFrame(parseInt(id, 10));\n        }\n      }\n\n      this._animationFrameIds = null;\n    }\n  }\n\n  /**\n   * SetTimeout override, which will auto cancel the timeout during dispose.\n   * @param callback - Callback to execute.\n   * @param duration - Duration in milliseconds.\n   * @returns The setTimeout id.\n   */\n  public setTimeout(callback: () => void, duration: number): number {\n    let timeoutId = 0;\n\n    if (!this._isDisposed) {\n      if (!this._timeoutIds) {\n        this._timeoutIds = {};\n      }\n\n      timeoutId = setTimeout(() => {\n        // Time to execute the timeout, enqueue it as a foreground task to be executed.\n\n        try {\n          // Now delete the record and call the callback.\n          if (this._timeoutIds) {\n            delete this._timeoutIds[timeoutId];\n          }\n          callback.apply(this._parent);\n        } catch (e) {\n          this._logError(e);\n        }\n      }, duration);\n\n      this._timeoutIds[timeoutId] = true;\n    }\n\n    return timeoutId;\n  }\n\n  /**\n   * Clears the timeout.\n   * @param id - Id to cancel.\n   */\n  public clearTimeout(id: number): void {\n    if (this._timeoutIds && this._timeoutIds[id]) {\n      clearTimeout(id);\n      delete this._timeoutIds[id];\n    }\n  }\n\n  /**\n   * SetImmediate override, which will auto cancel the immediate during dispose.\n   * @param callback - Callback to execute.\n   * @param targetElement - Optional target element to use for identifying the correct window.\n   * @returns The setTimeout id.\n   */\n  public setImmediate(callback: () => void, targetElement?: Element | null): number {\n    let immediateId = 0;\n    const win = getWindow(targetElement)!;\n\n    if (!this._isDisposed) {\n      if (!this._immediateIds) {\n        this._immediateIds = {};\n      }\n\n      let setImmediateCallback = () => {\n        // Time to execute the timeout, enqueue it as a foreground task to be executed.\n\n        try {\n          // Now delete the record and call the callback.\n          if (this._immediateIds) {\n            delete this._immediateIds[immediateId];\n          }\n          callback.apply(this._parent);\n        } catch (e) {\n          this._logError(e);\n        }\n      };\n\n      immediateId = win.setTimeout(setImmediateCallback, 0);\n\n      this._immediateIds[immediateId] = true;\n    }\n\n    return immediateId;\n  }\n\n  /**\n   * Clears the immediate.\n   * @param id - Id to cancel.\n   * @param targetElement - Optional target element to use for identifying the correct window.\n   */\n  public clearImmediate(id: number, targetElement?: Element | null): void {\n    const win = getWindow(targetElement)!;\n\n    if (this._immediateIds && this._immediateIds[id]) {\n      win.clearTimeout(id);\n      delete this._immediateIds[id];\n    }\n  }\n\n  /**\n   * SetInterval override, which will auto cancel the timeout during dispose.\n   * @param callback - Callback to execute.\n   * @param duration - Duration in milliseconds.\n   * @returns The setTimeout id.\n   */\n  public setInterval(callback: () => void, duration: number): number {\n    let intervalId = 0;\n\n    if (!this._isDisposed) {\n      if (!this._intervalIds) {\n        this._intervalIds = {};\n      }\n\n      intervalId = setInterval(() => {\n        // Time to execute the interval callback, enqueue it as a foreground task to be executed.\n        try {\n          callback.apply(this._parent);\n        } catch (e) {\n          this._logError(e);\n        }\n      }, duration);\n\n      this._intervalIds[intervalId] = true;\n    }\n\n    return intervalId;\n  }\n\n  /**\n   * Clears the interval.\n   * @param id - Id to cancel.\n   */\n  public clearInterval(id: number): void {\n    if (this._intervalIds && this._intervalIds[id]) {\n      clearInterval(id);\n      delete this._intervalIds[id];\n    }\n  }\n\n  /**\n   * Creates a function that, when executed, will only call the func function at most once per\n   * every wait milliseconds. Provide an options object to indicate that func should be invoked\n   * on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled\n   * function will return the result of the last func call.\n   *\n   * Note: If leading and trailing options are true func will be called on the trailing edge of\n   * the timeout only if the throttled function is invoked more than once during the wait timeout.\n   *\n   * @param func - The function to throttle.\n   * @param wait - The number of milliseconds to throttle executions to. Defaults to 0.\n   * @param options - The options object.\n   * @returns The new throttled function.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public throttle<T extends (...args: any[]) => any>(\n    func: T,\n    wait?: number,\n    options?: {\n      leading?: boolean;\n      trailing?: boolean;\n    },\n  ): T {\n    if (this._isDisposed) {\n      return this._noop as T;\n    }\n\n    let waitMS = wait || 0;\n    let leading = true;\n    let trailing = true;\n    let lastExecuteTime = 0;\n    let lastResult: T;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let lastArgs: any[];\n    let timeoutId: number | null = null;\n\n    if (options && typeof options.leading === 'boolean') {\n      leading = options.leading;\n    }\n\n    if (options && typeof options.trailing === 'boolean') {\n      trailing = options.trailing;\n    }\n\n    let callback = (userCall?: boolean) => {\n      let now = Date.now();\n      let delta = now - lastExecuteTime;\n      let waitLength = leading ? waitMS - delta : waitMS;\n      if (delta >= waitMS && (!userCall || leading)) {\n        lastExecuteTime = now;\n        if (timeoutId) {\n          this.clearTimeout(timeoutId);\n          timeoutId = null;\n        }\n        lastResult = func.apply(this._parent, lastArgs);\n      } else if (timeoutId === null && trailing) {\n        timeoutId = this.setTimeout(callback, waitLength);\n      }\n\n      return lastResult;\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let resultFunction = ((...args: any[]): any => {\n      lastArgs = args;\n      return callback(true);\n    }) as T;\n\n    return resultFunction;\n  }\n\n  /**\n   * Creates a function that will delay the execution of func until after wait milliseconds have\n   * elapsed since the last time it was invoked. Provide an options object to indicate that func\n   * should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls\n   * to the debounced function will return the result of the last func call.\n   *\n   * Note: If leading and trailing options are true func will be called on the trailing edge of\n   * the timeout only if the debounced function is invoked more than once during the wait\n   * timeout.\n   *\n   * @param func - The function to debounce.\n   * @param wait - The number of milliseconds to delay.\n   * @param options - The options object.\n   * @returns The new debounced function.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public debounce<T extends (...args: any[]) => any>(\n    func: T,\n    wait?: number,\n    options?: {\n      leading?: boolean;\n      maxWait?: number;\n      trailing?: boolean;\n    },\n  ): ICancelable<T> & T {\n    if (this._isDisposed) {\n      let noOpFunction = (() => {\n        /** Do nothing */\n      }) as ICancelable<T> & T;\n\n      noOpFunction.cancel = () => {\n        return;\n      };\n      noOpFunction.flush = (() => null) as unknown as () => ReturnType<T>;\n      noOpFunction.pending = () => false;\n\n      return noOpFunction;\n    }\n\n    let waitMS = wait || 0;\n    let leading = false;\n    let trailing = true;\n    let maxWait: number | null = null;\n    let lastCallTime = 0;\n    let lastExecuteTime = Date.now();\n    let lastResult: ReturnType<T>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let lastArgs: any[];\n    let timeoutId: number | null = null;\n\n    if (options && typeof options.leading === 'boolean') {\n      leading = options.leading;\n    }\n\n    if (options && typeof options.trailing === 'boolean') {\n      trailing = options.trailing;\n    }\n\n    if (options && typeof options.maxWait === 'number' && !isNaN(options.maxWait)) {\n      maxWait = options.maxWait;\n    }\n\n    let markExecuted = (time: number) => {\n      if (timeoutId) {\n        this.clearTimeout(timeoutId);\n        timeoutId = null;\n      }\n      lastExecuteTime = time;\n    };\n\n    let invokeFunction = (time: number) => {\n      markExecuted(time);\n      lastResult = func.apply(this._parent, lastArgs);\n    };\n\n    let callback = (userCall?: boolean) => {\n      let now = Date.now();\n      let executeImmediately = false;\n      if (userCall) {\n        if (leading && now - lastCallTime >= waitMS) {\n          executeImmediately = true;\n        }\n        lastCallTime = now;\n      }\n      let delta = now - lastCallTime;\n      let waitLength = waitMS - delta;\n      let maxWaitDelta = now - lastExecuteTime;\n      let maxWaitExpired = false;\n\n      if (maxWait !== null) {\n        // maxWait only matters when there is a pending callback\n        if (maxWaitDelta >= maxWait && timeoutId) {\n          maxWaitExpired = true;\n        } else {\n          waitLength = Math.min(waitLength, maxWait - maxWaitDelta);\n        }\n      }\n\n      if (delta >= waitMS || maxWaitExpired || executeImmediately) {\n        invokeFunction(now);\n      } else if ((timeoutId === null || !userCall) && trailing) {\n        timeoutId = this.setTimeout(callback, waitLength);\n      }\n\n      return lastResult;\n    };\n\n    let pending = (): boolean => {\n      return !!timeoutId;\n    };\n\n    let cancel = (): void => {\n      if (pending()) {\n        // Mark the debounced function as having executed\n        markExecuted(Date.now());\n      }\n    };\n\n    let flush = () => {\n      if (pending()) {\n        invokeFunction(Date.now());\n      }\n\n      return lastResult;\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let resultFunction = ((...args: any[]) => {\n      lastArgs = args;\n      return callback(true);\n    }) as ICancelable<T> & T;\n\n    resultFunction.cancel = cancel;\n    resultFunction.flush = flush;\n    resultFunction.pending = pending;\n\n    return resultFunction;\n  }\n\n  public requestAnimationFrame(callback: () => void, targetElement?: Element | null): number {\n    let animationFrameId = 0;\n    const win = getWindow(targetElement)!;\n\n    if (!this._isDisposed) {\n      if (!this._animationFrameIds) {\n        this._animationFrameIds = {};\n      }\n\n      let animationFrameCallback = () => {\n        try {\n          // Now delete the record and call the callback.\n          if (this._animationFrameIds) {\n            delete this._animationFrameIds[animationFrameId];\n          }\n\n          callback.apply(this._parent);\n        } catch (e) {\n          this._logError(e);\n        }\n      };\n\n      animationFrameId = win.requestAnimationFrame\n        ? win.requestAnimationFrame(animationFrameCallback)\n        : win.setTimeout(animationFrameCallback, 0);\n\n      this._animationFrameIds[animationFrameId] = true;\n    }\n\n    return animationFrameId;\n  }\n\n  public cancelAnimationFrame(id: number, targetElement?: Element | null): void {\n    const win = getWindow(targetElement)!;\n\n    if (this._animationFrameIds && this._animationFrameIds[id]) {\n      win.cancelAnimationFrame ? win.cancelAnimationFrame(id) : win.clearTimeout(id);\n      delete this._animationFrameIds[id];\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  protected _logError(e: any): void {\n    if (this._onErrorHandler) {\n      this._onErrorHandler(e);\n    }\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ICancelable<T extends (...args: any[]) => any> = {\n  flush: () => ReturnType<T>;\n  cancel: () => void;\n  pending: () => boolean;\n};\n"],"names":["Async","dispose","id","_isDisposed","_parent","_timeoutIds","hasOwnProperty","clearTimeout","parseInt","_immediateIds","clearImmediate","_intervalIds","clearInterval","_animationFrameIds","cancelAnimationFrame","setTimeout","callback","duration","timeoutId","apply","e","_logError","setImmediate","targetElement","immediateId","win","getWindow","setImmediateCallback","setInterval","intervalId","throttle","func","wait","options","_noop","waitMS","leading","trailing","lastExecuteTime","lastResult","lastArgs","userCall","now","Date","delta","waitLength","resultFunction","args","debounce","noOpFunction","cancel","flush","pending","maxWait","lastCallTime","isNaN","markExecuted","time","invokeFunction","executeImmediately","maxWaitDelta","maxWaitExpired","Math","min","requestAnimationFrame","animationFrameId","animationFrameCallback","_onErrorHandler","constructor","parent","onError","_define_property"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}