@antscorp/antsomi-ui 1.3.3-beta.4 → 1.3.3-beta.40

package/es/components/atoms/Input/Input.d.ts

@@ -8,6 +8,9 @@ export interface InputProps extends AntdInputProps {
     onAfterChange?: (value: any) => void;
     errorArchive?: string;
     required?: boolean;
+    isReverseMask?: boolean;
+    labelColor?: string;
+    isHideErrMessage?: boolean;
     focused?: boolean;
     errorMsg?: string;
     disableUndo?: boolean;

package/es/components/atoms/Input/Input.js

@@ -24,7 +24,7 @@ import { StyledInput } from './styled';
 const PATH = '@antscorp/antsomi-ui/es/components/atoms/Input/Input.tsx';
 const OriginInput = props => {
     // Props
-    const { debounce, errorArchive, required, focused, label, onAfterChange, onChange, errorMsg } = props, restProps = __rest(props, ["debounce", "errorArchive", "required", "focused", "label", "onAfterChange", "onChange", "errorMsg"]);
+    const { debounce, errorArchive, required, labelColor, isReverseMask, isHideErrMessage, focused, label, onAfterChange, onChange, errorMsg } = props, restProps = __rest(props, ["debounce", "errorArchive", "required", "labelColor", "isReverseMask", "isHideErrMessage", "focused", "label", "onAfterChange", "onChange", "errorMsg"]);
     // State
     const [value, setValue] = useState(props.value);
     const [isFocused, setFocused] = useState(false);
@@ -68,7 +68,7 @@ const OriginInput = props => {
     };
     const renderRequiredLabel = (label) => {
         if (required) {
-            return (React.createElement(RequiredLabel, { color: "#666666", style: { marginBottom: 5 } }, label));
+            return (React.createElement(RequiredLabel, { isReverseMask: isReverseMask, color: labelColor || '#666666', style: { marginBottom: 5 } }, label));
         }
         return (React.createElement(Text, { color: "#666666", style: { marginBottom: 5 } }, label));
     };
@@ -84,10 +84,11 @@ const OriginInput = props => {
                 }
                 restProps.onBlur && restProps.onBlur(e);
             }, onChange: onChangeInput }, getPreventKeyboardAction(listDisableActions))),
-        restProps.status === 'error' || errorArchive || requiredMsg ? (React.createElement(Text, { color: "#ff4d4f", style: { marginLeft: 8, marginTop: 5 } }, errorMsg || errorArchive || requiredMsg)) : null));
+        (restProps.status === 'error' || errorArchive || requiredMsg) && !isHideErrMessage ? (React.createElement(Text, { color: "#ff4d4f", style: { marginLeft: 8, marginTop: 5 } }, errorMsg || errorArchive || requiredMsg)) : null));
 };
 OriginInput.defaultProps = {
     debounce: 400,
+    isHideErrMessage: false,
 };
 export const Input = OriginInput;
 Input.TextArea = StyledInput.TextArea;

package/es/components/atoms/InputDynamic/EditCaretPositioning.d.ts

@@ -0,0 +1,2 @@
+declare const EditCaretPositioning: any;
+export default EditCaretPositioning;

package/es/components/atoms/InputDynamic/EditCaretPositioning.js

@@ -0,0 +1,89 @@
+/* eslint-disable no-cond-assign */
+/* eslint-disable no-plusplus */
+/* eslint-disable one-var */
+/* eslint-disable func-names */
+/* eslint-disable object-shorthand */
+/* eslint-disable prefer-const */
+const EditCaretPositioning = {};
+if (window.getSelection && document.createRange) {
+    // saves caret position(s)
+    EditCaretPositioning.saveSelection = function (containerEl) {
+        var _a;
+        try {
+            let range = (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.getRangeAt(0);
+            let preSelectionRange = range === null || range === void 0 ? void 0 : range.cloneRange();
+            preSelectionRange === null || preSelectionRange === void 0 ? void 0 : preSelectionRange.selectNodeContents(containerEl);
+            preSelectionRange === null || preSelectionRange === void 0 ? void 0 : preSelectionRange.setEnd(range === null || range === void 0 ? void 0 : range.startContainer, range === null || range === void 0 ? void 0 : range.startOffset);
+            let start = preSelectionRange === null || preSelectionRange === void 0 ? void 0 : preSelectionRange.toString().length;
+            return {
+                start: start,
+                end: start + (range === null || range === void 0 ? void 0 : range.toString().length),
+            };
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.log('err:>', e);
+        }
+        return {
+            start: 0,
+            end: 0,
+        };
+    };
+    // restores caret position(s)
+    EditCaretPositioning.restoreSelection = function (containerEl, savedSel) {
+        let charIndex = 0, range = document.createRange();
+        range.setStart(containerEl, 0);
+        range.collapse(true);
+        let nodeStack = [containerEl], node, foundStart = false, stop = false;
+        while (!stop && (node = nodeStack.pop())) {
+            if (node.nodeType === 3) {
+                let nextCharIndex = charIndex + node.length;
+                if (!foundStart &&
+                    savedSel &&
+                    savedSel.start >= charIndex &&
+                    savedSel.start <= nextCharIndex) {
+                    range.setStart(node, savedSel.start - charIndex);
+                    foundStart = true;
+                }
+                if (foundStart && savedSel.end >= charIndex && savedSel.end <= nextCharIndex) {
+                    range.setEnd(node, savedSel.end - charIndex);
+                    stop = true;
+                }
+                charIndex = nextCharIndex;
+            }
+            else {
+                let i = node.childNodes.length;
+                while (i--) {
+                    nodeStack.push(node.childNodes[i]);
+                }
+            }
+        }
+        let sel = window.getSelection();
+        sel === null || sel === void 0 ? void 0 : sel.removeAllRanges();
+        sel === null || sel === void 0 ? void 0 : sel.addRange(range);
+    };
+}
+else if (document.selection && document.body.createTextRange) {
+    // saves caret position(s)
+    EditCaretPositioning.saveSelection = function (containerEl) {
+        let selectedTextRange = document.selection.createRange();
+        let preSelectionTextRange = document.body.createTextRange();
+        preSelectionTextRange.moveToElementText(containerEl);
+        preSelectionTextRange.setEndPoint('EndToStart', selectedTextRange);
+        let start = preSelectionTextRange.text.length;
+        return {
+            start: start,
+            end: start + selectedTextRange.text.length,
+        };
+    };
+    // restores caret position(s)
+    EditCaretPositioning.restoreSelection = function (containerEl, savedSel) {
+        let textRange = document.body.createTextRange();
+        textRange.moveToElementText(containerEl);
+        textRange.collapse(true);
+        textRange.moveEnd('character', savedSel.end);
+        textRange.moveStart('character', savedSel.start);
+        textRange.select();
+    };
+}
+export default EditCaretPositioning;

package/es/components/atoms/InputDynamic/InputDynamic.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { DisableShortLinkTypeProps } from './PopupShortLink';
+export type KeyTagType = 'shortlink' | 'shortlink_static';
+export type SelectedPropertiesProps = {
+    keyTag: KeyTagType;
+    link: string;
+    urlDetected: string;
+};
+export type InputDynamicProps = {
+    value: string;
+    isViewMode?: boolean;
+    errors?: string[];
+    disabledOpts?: DisableShortLinkTypeProps;
+    canMultipleLine?: boolean;
+    onError?: Function;
+    onChange: (valueOut: string) => any;
+    addMessageToQueue?: Function;
+};
+export declare const InputDynamic: {
+    (props: InputDynamicProps): React.JSX.Element;
+    defaultProps: {
+        value: string;
+        isViewMode: boolean;
+        errors: never[];
+        canMultipleLine: boolean;
+        onError: () => void;
+        onChange: () => void;
+        addMessageToQueue: () => void;
+    };
+};

package/es/components/atoms/InputDynamic/InputDynamic.js

@@ -0,0 +1,320 @@
+// Libraries
+import React, { useState, useLayoutEffect, useEffect, useRef, useCallback, } from 'react';
+import classnames from 'classnames';
+// Components
+import CaretPositioning from './EditCaretPositioning';
+import { WrapperInputStyle, TooltipHover } from './styled';
+import { PopupShortLink } from './PopupShortLink';
+import Icon from '@antscorp/icons';
+// Utils
+import { getObjectPropSafely, random, safeParse } from '@antscorp/antsomi-ui/es/utils';
+import { convertBreakTag, convertDivToBreakTag, convertHtmlText, genShortLinkValue, getInsertLinkPatternWithAppendSpaceEnd, handleUpdateInputPersonalization, initialValue, pasteHtmlAtCaret, removeHtmlTag, spacingNonTracking, validateHTMLTags, } from './utils';
+// Hooks
+import { useDebounce } from '@antscorp/antsomi-ui/es/hooks/useDebounce';
+const PATH = 'src/components/atoms/InputDynamic/InputDynamic.tsx';
+const defaultProps = {
+    value: '',
+    isViewMode: false,
+    errors: [],
+    canMultipleLine: false,
+    onError: () => { },
+    onChange: () => { },
+    addMessageToQueue: () => { },
+};
+export const InputDynamic = (props) => {
+    const { value, isViewMode, errors, disabledOpts, canMultipleLine, onError, onChange, addMessageToQueue, } = props;
+    // States
+    const [textValue, setTextValue] = useState(initialValue(value));
+    const [initSelectedProperties, setInitSelectedProperties] = useState({
+        keyTag: 'shortlink_static',
+        link: '',
+        urlDetected: '',
+    });
+    const [popoverOpenShortLink, setPopoverOpenShortLink] = useState(false);
+    const [tooltipHoverDebounce, _tooltipHover, setTooltipHover] = useDebounce({ x: 0, y: 0 }, 200);
+    // Refs
+    const caretPositionRef = useRef(null);
+    const personalizationInputRef = useRef(null);
+    const onTriggerChange = (event = null) => {
+        var _a;
+        try {
+            let tmp = (_a = personalizationInputRef.current) === null || _a === void 0 ? void 0 : _a.innerHTML;
+            if (event !== null) {
+                caretPositionRef.current = CaretPositioning.saveSelection(event.currentTarget);
+                tmp = event.currentTarget.innerHTML;
+            }
+            tmp = tmp === null || tmp === void 0 ? void 0 : tmp.replace(
+            // replace old non tracking url to detect url
+            /<button(?=[^>]*class="insert-word")[^>]*value=['"]#(?:{nontrackurl\()?(https?:\/\/[0-9a-zA-Z-{}|"\./?_=&%:#*@;]+)(?:\)})?['"][^>]*>.*?<\/button>/g, match => {
+                const url = match.match(/(https?:\/\/[0-9a-zA-Z-\./?_=&%:#*@;]+)/);
+                if (url) {
+                    return `<span id="${random(5)}" class="detect-url">${url[1]}</span>`;
+                }
+                return match; // If no match found, return the original string
+            }).replace(
+            // replace url to detect url
+            /((?<!class="detect-url">|#{shortlink(?:_static)?\(|<span style="line-height: 20px;margin-right: 8px;pointer-events:none;">)\bhttps*:\/\/[0-9a-zA-Z-{}|"\./?_=&%:#*@;]+)/g, match => `<span id="${random(5)}" class="detect-url">${match}</span>`);
+            tmp = convertDivToBreakTag(tmp);
+            setTextValue(tmp);
+            const text = convertHtmlText(tmp, 'raw', {}, {}, 'input', 'add');
+            const textConverted = convertBreakTag(text);
+            onChange(removeHtmlTag(textConverted));
+        }
+        catch (error) {
+            if (typeof addMessageToQueue === 'function') {
+                addMessageToQueue({
+                    path: 'app/containers/UIDev/UIEditorPersonalization/Input/index.jsx',
+                    func: 'onTriggerChange',
+                    data: error,
+                });
+            }
+            // eslint-disable-next-line no-console
+            console.error(error);
+        }
+    };
+    const callback = (type, data) => {
+        var _a, _b;
+        switch (type) {
+            case 'REPLACE_DETECTED_URL': {
+                const innerHTML = getObjectPropSafely(() => { var _a; return (_a = personalizationInputRef.current) === null || _a === void 0 ? void 0 : _a.innerHTML; }, '');
+                if (innerHTML) {
+                    // remove span url và focus vào vị trí remove để add tag shortlink vào vị trí này.
+                    const index = Array.from((_a = personalizationInputRef.current) === null || _a === void 0 ? void 0 : _a.childNodes).findIndex((element) => element.id === data.id);
+                    const range = document.createRange(); // Tạo một đối tượng Range
+                    const sel = window.getSelection(); // Lấy đối tượng Selection hiện tại
+                    range.setStart((_b = personalizationInputRef.current) === null || _b === void 0 ? void 0 : _b.childNodes[index], 0); // Đặt điểm bắt đầu của Range
+                    range.collapse(true); // Thu gọn Range để tập trung vào điểm bắt đầu
+                    sel === null || sel === void 0 ? void 0 : sel.removeAllRanges(); // Xóa tất cả các Range hiện có
+                    sel === null || sel === void 0 ? void 0 : sel.addRange(range); // Thêm Range mới vào Selection
+                    caretPositionRef.current = CaretPositioning.saveSelection(personalizationInputRef.current);
+                    const newDataUpdate = innerHTML.replace(data.outerHTML, '');
+                    personalizationInputRef.current.innerHTML = newDataUpdate;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    };
+    const onPaste = (e) => {
+        // cancel paste
+        e.preventDefault();
+        // get text representation of clipboard
+        const text = (e.originalEvent || e).clipboardData.getData('text/plain');
+        // insert text manually
+        document.execCommand('insertHTML', false, text);
+    };
+    const handleInsertSortLink = (url, type) => {
+        try {
+            const { id, value: linkValue, label: linkLabel } = genShortLinkValue(url, type);
+            setPopoverOpenShortLink(false);
+            if (personalizationInputRef.current instanceof HTMLElement) {
+                CaretPositioning.restoreSelection(personalizationInputRef.current, caretPositionRef.current);
+                pasteHtmlAtCaret(getInsertLinkPatternWithAppendSpaceEnd(id, linkValue, linkLabel), null);
+                onTriggerChange();
+                caretPositionRef.current = CaretPositioning.saveSelection(personalizationInputRef.current);
+            }
+            setInitSelectedProperties({ link: '', keyTag: 'shortlink_static', urlDetected: '' });
+        }
+        catch (err) {
+            if (typeof addMessageToQueue === 'function') {
+                addMessageToQueue({
+                    path: 'app/containers/UIDev/UIEditorPersonalization/Input/index.jsx',
+                    func: 'handleInsertText',
+                    data: err,
+                });
+            }
+        }
+    };
+    const handleKeyPress = (e) => {
+        if (canMultipleLine)
+            return;
+        if (+e.charCode === 13) {
+            e.preventDefault();
+        }
+    };
+    const getDangerouslySetInnerHTML = (text) => {
+        if (text) {
+            const regex = /<[^<>]+>/g;
+            let tag;
+            // eslint-disable-next-line no-cond-assign
+            while ((tag = regex.exec(text))) {
+                if (!validateHTMLTags.isValidTag(tag[0])) {
+                    const finalTag = tag[0].replace('<', '&#60').replace('>', '&#62');
+                    text = text.replace(tag[0], finalTag);
+                }
+            }
+            text = text.replaceAll('\n', '<br>');
+            if (spacingNonTracking(text)) {
+                return text;
+            }
+            return safeParse(text, '').concat('<br />');
+        }
+        return '';
+    };
+    const toggleShortLinkModal = useCallback(() => {
+        setPopoverOpenShortLink(!popoverOpenShortLink);
+    }, [popoverOpenShortLink]);
+    /**
+     * [NOTE:open shortlink modal to edit]
+     */
+    useEffect(() => {
+        const handleClickTag = (e) => {
+            try {
+                e.stopPropagation();
+                if (e.target) {
+                    const { value = '' } = e.target;
+                    const shortLink = value.replace(/#|{|}|/g, '').split('(');
+                    if (shortLink && shortLink.length >= 2) {
+                        const link = shortLink[1].substring(0, shortLink[1].length - 1) || '';
+                        setInitSelectedProperties(prev => (Object.assign(Object.assign({}, prev), { link, keyTag: shortLink[0], urlDetected: e.currentTarget })));
+                        toggleShortLinkModal();
+                    }
+                }
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.log('err', err);
+            }
+        };
+        const listTags = Array.from(document.querySelectorAll('#ants-ui-input-personalization .input-personal .insert-word'));
+        if (listTags && listTags.length > 0) {
+            listTags.forEach((tag) => {
+                tag.addEventListener('click', handleClickTag);
+            });
+        }
+        return () => {
+            listTags.forEach((tag) => {
+                tag.removeEventListener('click', handleClickTag);
+            });
+        };
+    }, [textValue, toggleShortLinkModal]);
+    /** Anchor tooltip */
+    useEffect(() => {
+        let listElement = [];
+        const handleMouseOver = (e, targetRect) => {
+            e === null || e === void 0 ? void 0 : e.stopPropagation();
+            const viewportTop = window.pageYOffset;
+            const viewportLeft = window.pageXOffset;
+            const offsetWidth = targetRect.width / 2;
+            const offsetHeight = targetRect.height / 2;
+            const tooltipHeight = 16;
+            const x = targetRect.left - viewportLeft + offsetWidth;
+            const y = targetRect.top - viewportTop - offsetHeight - tooltipHeight;
+            setTooltipHover({
+                x,
+                y,
+            });
+        };
+        const handleMouseOut = (e) => {
+            e === null || e === void 0 ? void 0 : e.stopPropagation();
+            setTooltipHover({ x: 0, y: 0 });
+        };
+        const handleClickDetectUrl = (e) => {
+            e === null || e === void 0 ? void 0 : e.stopPropagation();
+            setInitSelectedProperties(prev => {
+                var _a;
+                return (Object.assign(Object.assign({}, prev), { link: ((_a = e === null || e === void 0 ? void 0 : e.currentTarget) === null || _a === void 0 ? void 0 : _a.textContent) || '', urlDetected: e === null || e === void 0 ? void 0 : e.currentTarget }));
+            });
+            toggleShortLinkModal();
+        };
+        if (!isViewMode) {
+            const elements = document.querySelectorAll('#ants-ui-input-personalization .detect-url');
+            listElement = Array.from(elements);
+            if (listElement.length) {
+                listElement.forEach((element) => {
+                    element.addEventListener('mouseover', e => handleMouseOver(e, element.getBoundingClientRect()));
+                    element.addEventListener('mouseout', handleMouseOut);
+                    /** Open shortlink modal */
+                    element.addEventListener('click', handleClickDetectUrl);
+                });
+            }
+        }
+        return () => {
+            listElement.forEach((element) => {
+                element.removeEventListener('mouseover', handleMouseOver);
+                element.removeEventListener('mouseout', handleMouseOut);
+            });
+        };
+    }, [textValue, isViewMode, setTooltipHover, toggleShortLinkModal]);
+    /** Style & remove for tag shortlink button & icon remove */
+    useLayoutEffect(() => {
+        // get button Els [x] to create hover and style it
+        const iconRemoveEls = document.querySelectorAll('.editor-icon-remove');
+        const listIconRemove = iconRemoveEls && Array.from(iconRemoveEls);
+        // get button elements
+        const buttonElement = document.querySelectorAll('.insert-word');
+        const listBtnElement = buttonElement && Array.from(buttonElement);
+        const handleRemoveTag = (e) => {
+            var _a, _b, _c, _d, _e;
+            if (e && ((_a = e.target) === null || _a === void 0 ? void 0 : _a.nodeName) === 'EM' && ((_b = e.target) === null || _b === void 0 ? void 0 : _b.className) === 'editor-icon-remove') {
+                e.stopPropagation();
+                (_d = (_c = e.target) === null || _c === void 0 ? void 0 : _c.parentElement) === null || _d === void 0 ? void 0 : _d.remove();
+                setTextValue(personalizationInputRef && ((_e = personalizationInputRef.current) === null || _e === void 0 ? void 0 : _e.innerHTML));
+            }
+        };
+        listIconRemove.forEach(eachIcon => {
+            eachIcon.addEventListener('click', handleRemoveTag);
+        });
+        handleUpdateInputPersonalization(listIconRemove, listBtnElement);
+        return () => {
+            listIconRemove.forEach(eachIcon => {
+                eachIcon.removeEventListener('click', handleRemoveTag);
+            });
+        };
+    }, [textValue]);
+    useLayoutEffect(() => {
+        try {
+            // save caret position
+            if (!personalizationInputRef.current) {
+                return;
+            }
+            // Perhaps React (whose VDOM gets outdated because we often prevent
+            // rerendering) did not update the DOM. So we update it manually now.
+            if (caretPositionRef && caretPositionRef.current) {
+                CaretPositioning.restoreSelection(personalizationInputRef.current, caretPositionRef.current);
+            }
+        }
+        catch (error) {
+            if (typeof addMessageToQueue === 'function') {
+                addMessageToQueue({
+                    path: PATH,
+                    func: 'useLayoutEffect',
+                    data: error,
+                });
+            }
+            if (typeof onError === 'function') {
+                onError(error, {
+                    component: PATH,
+                    action: 'useLayoutEffect saved caret position',
+                    args: {},
+                });
+            }
+        }
+    }, [addMessageToQueue, onError, textValue]);
+    return (React.createElement(WrapperInputStyle, { id: "ants-ui-input-personalization" },
+        React.createElement("div", { className: classnames({
+                'input-wrapper-outter': true,
+                'styles-input-wrapper': !isViewMode,
+                'input-error': (errors === null || errors === void 0 ? void 0 : errors.length) && (errors === null || errors === void 0 ? void 0 : errors.length) > 0,
+            }), style: Object.assign(Object.assign({}, (isViewMode && {
+                padding: 0,
+                minHeight: 0,
+                fontSize: 12,
+                border: 'none',
+            })), { width: '100%' }), onClick: () => { var _a; return (_a = personalizationInputRef.current) === null || _a === void 0 ? void 0 : _a.focus(); } },
+            React.createElement("div", { className: "input-personal", style: {
+                    display: textValue && textValue !== '<br>' ? 'inline-block' : undefined,
+                }, contentEditable: !isViewMode, onBlur: onTriggerChange, onKeyPress: handleKeyPress, ref: personalizationInputRef, 
+                // eslint-disable-next-line react/no-danger
+                dangerouslySetInnerHTML: {
+                    __html: getDangerouslySetInnerHTML(textValue),
+                }, onPaste: onPaste }),
+            React.createElement(Icon, { type: "icon-ants-search-2", onClick: e => {
+                    e.stopPropagation();
+                    toggleShortLinkModal();
+                }, className: "customize-antsomi-profile", style: { width: 24, height: 24 } })),
+        React.createElement(TooltipHover, { isShow: tooltipHoverDebounce.x > 0 && tooltipHoverDebounce.y > 0, top: tooltipHoverDebounce.y, left: tooltipHoverDebounce.x }, "Click on the link to convert it to a shortlink"),
+        popoverOpenShortLink && (React.createElement(PopupShortLink, { open: popoverOpenShortLink, disabledOpts: disabledOpts, onOk: handleInsertSortLink, onClose: toggleShortLinkModal, initSelectedProperties: initSelectedProperties, callback: callback }))));
+};
+InputDynamic.defaultProps = defaultProps;

package/es/components/atoms/InputDynamic/PopupShortLink.d.ts

@@ -0,0 +1,16 @@
+import { FC } from 'react';
+import type { SelectedPropertiesProps } from './InputDynamic';
+type PopupShortLinkProps = {
+    open: any;
+    onClose: Function;
+    onOk: Function;
+    disabledOpts?: DisableShortLinkTypeProps;
+    initSelectedProperties: SelectedPropertiesProps;
+    callback: Function;
+};
+export type ShortLinkType = 'individual' | 'general';
+export type DisableShortLinkTypeProps = {
+    [key in ShortLinkType]?: boolean;
+};
+export declare const PopupShortLink: FC<PopupShortLinkProps>;
+export {};

package/es/components/atoms/InputDynamic/PopupShortLink.js

@@ -0,0 +1,98 @@
+// Libraries
+import React, { useEffect } from 'react';
+import { Col, Row } from 'antd';
+import { useImmer } from 'use-immer';
+// Molecules
+import { Modal } from '../../molecules';
+// Components
+import { Radio } from '../Radio';
+// Styled
+import { InputShortLink, InputWrapper } from './styled';
+// Utils
+import { validateURL } from './utils';
+const OPTIONS = [
+    {
+        value: 'individual',
+        label: 'Individual',
+    },
+    {
+        value: 'general',
+        label: 'General',
+    },
+];
+export const PopupShortLink = props => {
+    const { open, onClose, onOk, disabledOpts, initSelectedProperties, callback } = props;
+    const [state, setState] = useImmer({
+        link: '',
+        type: 'individual',
+        error: '',
+    });
+    useEffect(() => {
+        let type = 'individual';
+        if (initSelectedProperties && initSelectedProperties.keyTag) {
+            type = initSelectedProperties.keyTag === 'shortlink' ? 'individual' : 'general';
+        }
+        setState(draft => {
+            draft.link = initSelectedProperties.link;
+            draft.type = type;
+        });
+    }, [initSelectedProperties, setState]);
+    const handleClose = () => {
+        setState(draft => {
+            draft.link = '';
+            draft.error = '';
+        });
+        if (onClose)
+            onClose();
+    };
+    const handleValidate = ({ urlString = state.link, afterValidate }) => {
+        const isValid = validateURL(urlString);
+        setState(draft => {
+            draft.error = isValid ? '' : 'Invalid URL';
+        });
+        if (typeof afterValidate === 'function')
+            afterValidate(isValid);
+    };
+    const handleOnChange = (value) => {
+        if (state.error)
+            handleValidate({ urlString: value });
+        setState(draft => {
+            draft.link = value;
+        });
+    };
+    const handleOnOK = () => {
+        handleValidate({
+            afterValidate: (isValid) => {
+                if (isValid && onOk) {
+                    if (initSelectedProperties.urlDetected) {
+                        callback('REPLACE_DETECTED_URL', initSelectedProperties.urlDetected);
+                    }
+                    onOk(state.link, state.type);
+                    handleClose();
+                }
+            },
+        });
+    };
+    const onChangeType = (event) => {
+        setState(draft => {
+            draft.type = event.target.value;
+        });
+    };
+    return (React.createElement(Modal, { open: open, onCancel: handleClose, title: React.createElement("div", { style: { color: 'rgba(0, 0, 0, 0.87)', fontWeight: 'normal', fontSize: '16px' } }, "Add Short Link"), okText: "OK", cancelText: "Cancel", closable: false, onOk: handleOnOK, okButtonProps: {
+            disabled: !validateURL(state.link),
+            type: !validateURL(state.link) ? 'default' : 'primary',
+        } },
+        React.createElement(Row, null,
+            React.createElement(Col, { span: 6 },
+                React.createElement("span", { style: { fontSize: 12, color: '#000' } }, "Short link type")),
+            React.createElement(Col, { span: 18 },
+                React.createElement(Radio.Group, { onChange: onChangeType, value: state.type }, OPTIONS.map(each => (React.createElement(Radio, { key: each.value, disabled: disabledOpts && disabledOpts[each.value], name: "shortlink-type", value: each.value }, each.label)))))),
+        React.createElement(Row, null,
+            React.createElement(Col, { span: 24 },
+                React.createElement(InputWrapper, null,
+                    React.createElement(InputShortLink, { required: true, isReverseMask: true, isHideErrMessage: true, labelColor: "#000000", id: "input-short-link-url", label: "Your URL", value: state.link, onAfterChange: handleOnChange })))),
+        !!state.error && (React.createElement(Row, null,
+            React.createElement(Col, { span: 6 }),
+            React.createElement(Col, { span: 18 },
+                React.createElement("div", null, state.error))))));
+};

package/es/components/atoms/InputDynamic/index.d.ts

@@ -0,0 +1,2 @@
+export { InputDynamic } from './InputDynamic';
+export type { InputDynamicProps } from './InputDynamic';

package/es/components/atoms/InputDynamic/index.js

@@ -0,0 +1 @@
+export { InputDynamic } from './InputDynamic';

package/es/components/atoms/InputDynamic/styled.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const WrapperInputStyle: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SpanIcon: import("styled-components").StyledComponent<"span", any, {
+    isDisabled?: boolean | undefined;
+}, never>;
+export declare const InputWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const InputShortLink: import("styled-components").StyledComponent<import("react").ComponentType<any> | keyof import("react").JSX.IntrinsicElements, any, import("../Input/Input").InputProps, any>;
+export declare const TooltipHover: import("styled-components").StyledComponent<"div", any, {
+    top: number;
+    left: number;
+    isShow: boolean;
+}, never>;