@luomus/laji-form 15.1.55 → 15.1.56

package/dist/styles.css

@@ -2820,6 +2820,9 @@ body .laji-form {
 	left: initial !important;
 	right: 5px;
 }
+.laji-form .laji-form-failed-jobs-list .list-group .btn {
+	padding: 0;
+}
 .laji-form .laji-form-error-list {
 	top: 5px;
 	left: 5px;
@@ -2865,13 +2868,13 @@ body .laji-form {
 .laji-form .laji-form-error-list .panel-title {
 	color: white;
 }
-.laji-form .laji-form-error-list .btn-link {
+.laji-form .laji-form-error-list .panel-title .btn-link {
 	color: white;
 }
-.laji-form .laji-form-error-list .btn-link:hover {
+.laji-form .laji-form-error-list .panel-title .btn-link:hover {
 	color: #dddddd;
 }
-.laji-form .laji-form-error-list .btn-link:focus {
+.laji-form .laji-form-error-list .panel-title .btn-link:focus {
 	outline: none;
 }
 .laji-form .btn-group.laji-form-checkbox-widget-tab-target:focus {

package/lib/ReactContext.js

@@ -1,5 +1,24 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const React = require("react");
+const React = __importStar(require("react"));
 const Context = React.createContext({});
 exports.default = Context;

package/lib/components/LajiForm.js

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -10,33 +29,36 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const React = require("react");
+const React = __importStar(require("react"));
 const react_dom_1 = require("react-dom");
-const PropTypes = require("prop-types");
-const validation_1 = require("../validation");
+const PropTypes = __importStar(require("prop-types"));
+const validation_1 = __importDefault(require("../validation"));
 const validation_2 = require("../validation");
 const components_1 = require("./components");
 const utils_1 = require("../utils");
 const equals = require("deep-equal");
-const validator_ajv6_1 = require("@rjsf/validator-ajv6");
-const merge = require("deepmerge");
-const ReactContext_1 = require("../ReactContext");
-const stub_1 = require("../themes/stub");
-const core_1 = require("@rjsf/core");
-const ApiClient_1 = require("../ApiClient");
-const Context_1 = require("../Context");
-const translations = require("../translations.json");
-const key_handler_service_1 = require("../services/key-handler-service");
-const settings_service_1 = require("../services/settings-service");
-const focus_service_1 = require("../services/focus-service");
-const blocker_service_1 = require("../services/blocker-service");
-const custom_event_service_1 = require("../services/custom-event-service");
-const submit_hook_service_1 = require("../services/submit-hook-service");
-const dom_id_service_1 = require("../services/dom-id-service");
-const id_service_1 = require("../services/id-service");
-const root_instance_service_1 = require("../services/root-instance-service");
-const singleton_map_service_1 = require("../services/singleton-map-service");
+const validator_ajv6_1 = __importDefault(require("@rjsf/validator-ajv6"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const ReactContext_1 = __importDefault(require("../ReactContext"));
+const stub_1 = __importDefault(require("../themes/stub"));
+const core_1 = __importDefault(require("@rjsf/core"));
+const ApiClient_1 = __importDefault(require("../ApiClient"));
+const Context_1 = __importDefault(require("../Context"));
+const translations_json_1 = __importDefault(require("../translations.json"));
+const key_handler_service_1 = __importDefault(require("../services/key-handler-service"));
+const settings_service_1 = __importDefault(require("../services/settings-service"));
+const focus_service_1 = __importDefault(require("../services/focus-service"));
+const blocker_service_1 = __importDefault(require("../services/blocker-service"));
+const custom_event_service_1 = __importDefault(require("../services/custom-event-service"));
+const submit_hook_service_1 = __importDefault(require("../services/submit-hook-service"));
+const dom_id_service_1 = __importDefault(require("../services/dom-id-service"));
+const id_service_1 = __importDefault(require("../services/id-service"));
+const root_instance_service_1 = __importDefault(require("../services/root-instance-service"));
+const singleton_map_service_1 = __importDefault(require("../services/singleton-map-service"));
 const fields = importLocalComponents("fields", [
     "SchemaField",
     { "ArraySchemaField": "SchemaField" },
@@ -286,12 +308,12 @@ class LajiForm extends React.Component {
             block && this.memoizedFormContext.services.blocker.push();
             return new Promise(resolve => Promise.all([validation_1.default(validations, formData), validation_1.default(liveValidations, formData)]).then(([_validations, _liveValidations]) => {
                 if (nonlive || onlySchema) {
-                    this.cachedNonliveValidations = merge(schemaErrors, _validations);
+                    this.cachedNonliveValidations = deepmerge_1.default(schemaErrors, _validations);
                     block && this.memoizedFormContext.services.blocker.pop();
                 }
-                const merged = merge(_liveValidations, !nonlive
+                const merged = deepmerge_1.default(_liveValidations, !nonlive
                     ? (this.cachedNonliveValidations || {})
-                    : merge(_validations, schemaErrors));
+                    : deepmerge_1.default(_validations, schemaErrors));
                 this.validating = false;
                 resolve(!Object.keys(merged).length);
                 !equals((this.state.extraErrors || {}), merged) && this.setState({ extraErrors: merged }, this.popErrorListIfNeeded);
@@ -558,7 +580,7 @@ class LajiForm extends React.Component {
         });
     }
     constructTranslations() {
-        return utils_1.constructTranslations(translations);
+        return utils_1.constructTranslations(translations_json_1.default);
     }
     render() {
         if (this.state.error)

package/lib/components/VirtualSchemaField.d.ts

@@ -14,10 +14,10 @@ export default function VirtualSchemaField<LFC extends Constructor<LajiFormCompo
         getUiOptions(): any;
         getStateFromProps: (props: FieldProps) => any;
         render: () => React.ReactNode;
-        context: any;
         readonly props: Readonly<FieldProps<import("../types").JSONSchema<any>>> & Readonly<{
             children?: React.ReactNode;
         }>;
+        context: any;
         state: Readonly<{}>;
         componentDidMount?: (() => void) | undefined;
         setState: <K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<FieldProps<import("../types").JSONSchema<any>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined) => void;

package/lib/components/VirtualSchemaField.js

@@ -1,16 +1,38 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPropsWithInnerUiSchema = void 0;
-const React = require("react");
+const React = __importStar(require("react"));
 const utils_1 = require("../utils");
-const BaseComponent_1 = require("./BaseComponent");
-const Context_1 = require("../Context");
+const BaseComponent_1 = __importDefault(require("./BaseComponent"));
+const Context_1 = __importDefault(require("../Context"));
 function getPropsWithInnerUiSchema(props) {
     return Object.assign(Object.assign({}, props), { uiSchema: utils_1.getInnerUiSchema(props.uiSchema) });
 }

package/lib/components/components/Affix.d.ts

@@ -0,0 +1,38 @@
+import * as React from "react";
+declare type Props = {
+    onAffixChange?: (changed: boolean) => void;
+    topOffset?: number;
+    bottomOffset?: number;
+    containerRef?: React.RefObject<HTMLElement>;
+    style?: React.CSSProperties;
+    className?: string;
+};
+declare enum AFFIX_STATE {
+    TOP = "TOP",
+    AFFIXED = "AFFIXED",
+    BOTTOM = "BOTTOM"
+}
+declare type State = {
+    affixState?: AFFIX_STATE | undefined;
+    change?: number;
+    width?: number;
+    top?: number;
+    affixHeight?: number;
+    fixerHeight?: number;
+};
+export declare class Affix extends React.Component<Props, State> {
+    constructor(props: Props);
+    containerRef: React.RefObject<HTMLDivElement>;
+    wrapperRef: React.RefObject<HTMLDivElement>;
+    positionerRef: React.RefObject<HTMLDivElement>;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    getState: (props: Props) => State;
+    _onScroll: () => void;
+    onScroll: () => void;
+    _onResize: () => void;
+    onResize: () => void;
+    render(): JSX.Element;
+}
+export {};

package/lib/components/components/Affix.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Affix = void 0;
+const React = __importStar(require("react"));
+const react_dom_1 = require("react-dom");
+var AFFIX_STATE;
+(function (AFFIX_STATE) {
+    AFFIX_STATE["TOP"] = "TOP";
+    AFFIX_STATE["AFFIXED"] = "AFFIXED";
+    AFFIX_STATE["BOTTOM"] = "BOTTOM";
+})(AFFIX_STATE || (AFFIX_STATE = {}));
+// const TOP = "TOP", AFFIXED = "AFFIXED", BOTTOM = "BOTTOM";
+class Affix extends React.Component {
+    constructor(props) {
+        super(props);
+        this.containerRef = React.createRef();
+        this.wrapperRef = React.createRef();
+        this.positionerRef = React.createRef();
+        this.getState = (props) => {
+            var _a;
+            const { topOffset = 0, bottomOffset = 0, containerRef } = props;
+            const container = react_dom_1.findDOMNode((containerRef || this.containerRef).current);
+            const wrapperElem = react_dom_1.findDOMNode(this.wrapperRef.current);
+            if (!container || !document.body.contains(container) || !wrapperElem) {
+                return {};
+            }
+            const containerTop = container.getBoundingClientRect().top;
+            const containerHeight = container.offsetHeight;
+            const containerVisibleHeight = containerHeight + containerTop;
+            const wrapperHeight = wrapperElem.offsetHeight;
+            const wrapperScrollHeight = wrapperElem.scrollHeight;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const scrolled = this.containerRef.current.getBoundingClientRect().top < topOffset;
+            const viewportHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+            const bottomDist = viewportHeight - container.getBoundingClientRect().top - containerHeight;
+            const bottomInvisibleHeight = Math.min(bottomDist, 0);
+            let affixState = AFFIX_STATE.TOP;
+            if (scrolled && containerVisibleHeight < wrapperScrollHeight + topOffset)
+                affixState = AFFIX_STATE.BOTTOM;
+            else if (scrolled)
+                affixState = AFFIX_STATE.AFFIXED;
+            const width = wrapperElem ? wrapperElem.offsetWidth : undefined;
+            const top = topOffset;
+            const affixHeight = affixState === AFFIX_STATE.BOTTOM
+                ? Math.max(containerVisibleHeight
+                    - topOffset
+                    + Math.min(bottomInvisibleHeight, 0)
+                    - (bottomDist < bottomOffset ? Math.min(bottomOffset - bottomDist, bottomOffset) : 0), 0)
+                : undefined;
+            const wrapperCutHeight = wrapperHeight - (affixHeight || 0);
+            let change = undefined;
+            if (affixState === AFFIX_STATE.BOTTOM) {
+                if (!this.state) {
+                    change = wrapperCutHeight;
+                }
+                else {
+                    if (this.state.affixState === AFFIX_STATE.BOTTOM) {
+                        const lastChange = (_a = this.state.change) !== null && _a !== void 0 ? _a : 0;
+                        const changeNow = wrapperCutHeight;
+                        change = lastChange + changeNow;
+                    }
+                    else {
+                        change = wrapperCutHeight;
+                    }
+                }
+            }
+            const fixerHeight = affixState === AFFIX_STATE.AFFIXED
+                ? wrapperHeight - (affixHeight || 0)
+                : affixState === AFFIX_STATE.BOTTOM
+                    ? (affixHeight !== null && affixHeight !== void 0 ? affixHeight : 0) + (change !== null && change !== void 0 ? change : 0)
+                    : 0;
+            return { affixState, width, top, affixHeight, fixerHeight, change };
+        };
+        this._onScroll = () => {
+            this.setState(this.getState(this.props));
+        };
+        this.onScroll = () => {
+            requestAnimationFrame(this._onScroll);
+        };
+        this._onResize = () => {
+            const positioner = react_dom_1.findDOMNode(this.positionerRef.current);
+            const width = positioner.getBoundingClientRect().width;
+            const nextState = { width };
+            const currentState = this.getState(this.props);
+            if (currentState.affixState !== AFFIX_STATE.TOP) {
+                nextState.top = currentState.top;
+            }
+            this.setState(nextState);
+        };
+        this.onResize = () => {
+            requestAnimationFrame(this._onResize);
+        };
+        this.state = this.getState(props);
+    }
+    componentDidMount() {
+        window.addEventListener("scroll", this.onScroll);
+        window.addEventListener("resize", this.onResize);
+    }
+    componentWillUnmount() {
+        window.removeEventListener("scroll", this.onScroll);
+        window.removeEventListener("resize", this.onResize);
+    }
+    componentDidUpdate(prevProps, prevState) {
+        if (!this.props.onAffixChange || !prevState || !this.state) {
+            return;
+        }
+        if (prevState.affixState !== AFFIX_STATE.AFFIXED && this.state.affixState === AFFIX_STATE.AFFIXED) {
+            this.props.onAffixChange(true);
+        }
+        else if (prevState.affixState === AFFIX_STATE.AFFIXED && this.state.affixState !== AFFIX_STATE.AFFIXED) {
+            this.props.onAffixChange(false);
+        }
+    }
+    render() {
+        const { children, style: containerStyle } = this.props;
+        const { top, width, affixState, affixHeight, fixerHeight } = this.state || {};
+        const style = {};
+        const fixerStyle = { position: "relative", zIndex: -1, height: fixerHeight };
+        style.position = "relative";
+        if (affixState === AFFIX_STATE.BOTTOM || affixState === AFFIX_STATE.AFFIXED) {
+            style.position = "fixed";
+            style.width = width;
+            style.top = top;
+            style.zIndex = 1000;
+            style.height = affixHeight;
+            if (affixState === AFFIX_STATE.BOTTOM) {
+                style.overflow = "hidden";
+            }
+        }
+        return (React.createElement("div", { style: containerStyle, ref: this.containerRef },
+            React.createElement("div", { ref: this.positionerRef }),
+            React.createElement("div", { ref: this.wrapperRef, style: style, className: this.props.className }, children),
+            React.createElement("div", { style: fixerStyle })));
+    }
+}
+exports.Affix = Affix;

package/lib/components/components/Button.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { ButtonProps as ThemedButtonProps } from "src/themes/theme";
+export declare type ButtonProps = ThemedButtonProps & {
+    tooltip?: string;
+    tooltipPlacement?: string;
+    tooltipTrigger?: string;
+    tooltipClass?: string;
+};
+export declare const Button: React.ForwardRefExoticComponent<Pick<ThemedButtonProps & {
+    tooltip?: string | undefined;
+    tooltipPlacement?: string | undefined;
+    tooltipTrigger?: string | undefined;
+    tooltipClass?: string | undefined;
+}, "small" | "active" | "style" | "disabled" | "block" | "tooltip" | "children" | "key" | "id" | "className" | "onKeyDown" | "onClick" | "tooltipPlacement" | "tooltipTrigger" | "tooltipClass" | "variant"> & React.RefAttributes<unknown>>;

package/lib/components/components/Button.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Button = void 0;
+const React = __importStar(require("react"));
+const ReactContext_1 = __importDefault(require("../../ReactContext"));
+const components_1 = require("../components");
+const react_1 = require("react");
+exports.Button = react_1.forwardRef((_a, ref) => {
+    var { tooltip, tooltipPlacement, tooltipTrigger, tooltipClass } = _a, _props = __rest(_a, ["tooltip", "tooltipPlacement", "tooltipTrigger", "tooltipClass"]);
+    const { Button: _Button } = React.useContext(ReactContext_1.default).theme;
+    return (React.createElement(components_1.TooltipComponent, { tooltip: tooltip, placement: tooltipPlacement, trigger: tooltipTrigger, className: tooltipClass },
+        React.createElement(_Button, Object.assign({}, _props, { ref: ref }), _props.children)));
+});

package/lib/components/components/DeleteButton.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { ButtonProps } from "../components";
+import { FormContext } from "../LajiForm";
+declare type Props = ButtonProps & {
+    confirmStyle?: "browser";
+    corner?: boolean;
+    tooltip?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    glyphButton?: boolean;
+    confirm?: boolean;
+    confirmPlacement?: string;
+    onClick: () => void;
+    style?: React.CSSProperties;
+    translations: FormContext["translations"];
+};
+declare type State = {
+    show?: boolean;
+};
+export declare class DeleteButton extends React.Component<Props, State> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    buttonRef: React.RefObject<any>;
+    constructor(props: Props);
+    onButtonKeyDown: ({ key }: React.KeyboardEvent) => void;
+    onHideConfirm: () => void;
+    onShowConfirm: (e: React.MouseEvent) => void;
+    onConfirmedClick: (e?: React.KeyboardEvent<Element> | React.MouseEvent<Element, MouseEvent> | undefined) => void;
+    onClick: (e: React.MouseEvent) => void;
+    setConfirmAutofocus: (elem?: React.ReactInstance | undefined) => void;
+    render(): JSX.Element;
+    renderConfirm: () => JSX.Element | null;
+    getOverlayTarget: () => Element | Text | null;
+    renderConfirmPopup(): JSX.Element;
+    browserConfirm(): void;
+}
+export {};

package/lib/components/components/DeleteButton.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteButton = void 0;
+const React = __importStar(require("react"));
+const react_dom_1 = require("react-dom");
+const ReactContext_1 = __importDefault(require("../../ReactContext"));
+const components_1 = require("../components");
+class DeleteButton extends React.Component {
+    constructor(props) {
+        super(props);
+        this.buttonRef = React.createRef();
+        this.onButtonKeyDown = ({ key }) => {
+            if (key === "Enter")
+                this.onConfirmedClick();
+            else if (key === "Escape")
+                this.setState({ show: false });
+        };
+        this.onHideConfirm = () => {
+            this.setState({ show: false });
+        };
+        this.onShowConfirm = (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            this.setState({ show: true }, () => {
+                if (this.props.confirmStyle === "browser") {
+                    this.browserConfirm();
+                }
+            });
+        };
+        this.onConfirmedClick = (e) => {
+            e && e.preventDefault();
+            e && e.stopPropagation();
+            this.props.onClick();
+            this.onHideConfirm();
+        };
+        this.onClick = (e) => {
+            this.props.confirm ? this.onShowConfirm(e) : this.onConfirmedClick(e);
+        };
+        this.setConfirmAutofocus = (elem) => {
+            setTimeout(() => {
+                var _a;
+                (_a = react_dom_1.findDOMNode(elem)) === null || _a === void 0 ? void 0 : _a.focus();
+            });
+        };
+        this.renderConfirm = () => {
+            const { show } = this.state;
+            if (!show) {
+                return null;
+            }
+            const { confirmStyle = "popup" } = this.props;
+            if (confirmStyle === "popup") {
+                return this.renderConfirmPopup();
+            }
+            return null;
+        };
+        this.getOverlayTarget = () => react_dom_1.findDOMNode(this.buttonRef.current);
+        this.state = { show: false };
+    }
+    render() {
+        const { props } = this;
+        const { corner, tooltip, disabled, readonly, glyphButton = true, confirm, confirmPlacement, confirmStyle } = props, maybeProps = __rest(props, ["corner", "tooltip", "disabled", "readonly", "glyphButton", "confirm", "confirmPlacement", "confirmStyle"]); // eslint-disable-line @typescript-eslint/no-unused-vars
+        let buttonClassName = glyphButton ? "glyph-button" : "";
+        buttonClassName += corner ? " button-corner" : "";
+        if (props.className) {
+            buttonClassName = `${buttonClassName} ${props.className}`;
+        }
+        if (props.id !== undefined) {
+            maybeProps.id = `${props.id}-delete`;
+        }
+        const button = React.createElement(React.Fragment, null,
+            React.createElement(components_1.Button, Object.assign({}, maybeProps, { disabled: disabled || readonly, variant: "danger", className: buttonClassName, style: this.props.style, ref: this.buttonRef, onKeyDown: this.onButtonKeyDown, onClick: this.onClick }),
+                this.props.children,
+                " ",
+                "✖"),
+            this.renderConfirm());
+        return tooltip ? React.createElement(components_1.TooltipComponent, { tooltip: tooltip }, button) : button;
+    }
+    renderConfirmPopup() {
+        const { translations, confirmPlacement = "left" } = this.props;
+        const { Overlay, Popover, ButtonGroup } = this.context.theme;
+        return (React.createElement(Overlay, { show: true, placement: confirmPlacement, rootClose: true, onHide: this.onHideConfirm, target: this.getOverlayTarget },
+            React.createElement(Popover, { id: `${this.props.id}-button-confirm` },
+                React.createElement("span", null, translations.ConfirmRemove),
+                React.createElement(ButtonGroup, null,
+                    React.createElement(components_1.Button, { variant: "danger", onClick: this.onConfirmedClick, ref: this.setConfirmAutofocus, id: `${this.props.id}-delete-confirm-yes` }, translations.Remove),
+                    React.createElement(components_1.Button, { variant: "default", onClick: this.onHideConfirm, id: `${this.props.id}-delete-confirm-no` }, translations.Cancel)))));
+    }
+    browserConfirm() {
+        const choice = confirm(this.props.translations.ConfirmRemove);
+        if (choice) {
+            this.onConfirmedClick();
+        }
+        else {
+            this.onHideConfirm();
+        }
+    }
+}
+exports.DeleteButton = DeleteButton;
+DeleteButton.contextType = ReactContext_1.default;