@libs-ui/components-inputs-mention 0.2.10-6.2

package/README.md

@@ -0,0 +1,3 @@
+# inputs-mention
+
+This library was generated with [Nx](https://nx.dev).

package/defines/caret-coords.define.d.ts

@@ -0,0 +1,5 @@
+export declare const getCaretCoordinates: (element: Element, position: number | null) => {
+    top: number;
+    left: number;
+    height: number;
+};

package/defines/keyboard.define.d.ts

@@ -0,0 +1,9 @@
+export declare const KEY_BACKSPACE = 8;
+export declare const KEY_TAB = 9;
+export declare const KEY_ENTER = 13;
+export declare const KEY_SHIFT = 16;
+export declare const KEY_ESCAPE = 27;
+export declare const KEY_SPACE = 32;
+export declare const KEY_UP = 38;
+export declare const KEY_DOWN = 40;
+export declare const KEY_BUFFERED = 229;

package/defines/template.define.d.ts

@@ -0,0 +1,4 @@
+import { IMentionConfig } from "../interfaces/mention.interface";
+export declare const PATTERN_INSERT = "\uFEFF";
+export declare const buildTemplate: (value: string, id: string, feId: string) => string;
+export declare const DEFAULT_CONFIG: IMentionConfig;

package/defines/utils.define.d.ts

@@ -0,0 +1,18 @@
+export declare const getValue: (el: HTMLInputElement) => string | null;
+export declare const insertValue: (el: HTMLInputElement, start: number, end: number, text: string, iframe: HTMLIFrameElement, noRecursion?: boolean) => ChildNode | undefined | null;
+export declare const getTextBeforeCursor: () => string | undefined;
+export declare const isInputOrTextAreaElement: (el: HTMLElement) => boolean;
+export declare const isTextElement: (el: HTMLElement) => boolean;
+export declare const setCaretPosition: (el: HTMLInputElement, pos: number, iframe: HTMLIFrameElement) => void;
+export declare const getCaretPosition: (el: HTMLInputElement, iframe?: HTMLIFrameElement) => number;
+export declare const getWindowSelection: (iframe?: HTMLIFrameElement) => Selection | null;
+export declare const getContentEditableCaretCoords: (ctx: {
+    iframe: HTMLIFrameElement | undefined;
+    parent: Element | null;
+    windowParent?: boolean;
+}) => {
+    left: number;
+    top: number;
+    bottom: number;
+};
+export declare const insertTextAtCaret: (element: HTMLInputElement, text: string) => void;

package/esm2022/defines/caret-coords.define.mjs

@@ -0,0 +1,115 @@
+/* From: https://github.com/component/textarea-caret-position */
+import { get, isNil, set } from "@libs-ui/utils";
+// We'll copy the properties below into the mirror div.
+// Note that some browsers, such as Firefox, do not concatenate properties
+// into their shorthand (e.g. padding-top, padding-bottom etc. -> padding),
+// so we have to list every single property explicitly.
+const properties = [
+    'direction', // RTL support
+    'boxSizing',
+    'width', // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
+    'height',
+    'overflowX',
+    'overflowY', // copy the scrollbar for IE
+    'borderTopWidth',
+    'borderRightWidth',
+    'borderBottomWidth',
+    'borderLeftWidth',
+    'borderStyle',
+    'paddingTop',
+    'paddingRight',
+    'paddingBottom',
+    'paddingLeft',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/font
+    'fontStyle',
+    'fontVariant',
+    'fontWeight',
+    'fontStretch',
+    'fontSize',
+    'fontSizeAdjust',
+    'lineHeight',
+    'fontFamily',
+    'textAlign',
+    'textTransform',
+    'textIndent',
+    'textDecoration', // might not make a difference, but better be safe
+    'letterSpacing',
+    'wordSpacing',
+    'tabSize',
+    'MozTabSize'
+];
+const isBrowser = (typeof window !== 'undefined');
+const isFirefox = (isBrowser && get(window, 'mozInnerScreenX') !== null);
+export const getCaretCoordinates = (element, position) => {
+    if (!isBrowser) {
+        throw new Error('textarea-caret-position#getCaretCoordinates should only be called in a browser');
+    }
+    // The mirror div will replicate the textarea's style
+    const div = document.createElement('div');
+    div.id = 'input-textarea-caret-position-mirror-div';
+    document.body.appendChild(div);
+    const style = div.style;
+    const computed = window.getComputedStyle ? window.getComputedStyle(element) : get(element, 'currentStyle'); // currentStyle for IE < 9
+    const isInput = element.nodeName === 'INPUT';
+    // Default textarea styles
+    style.whiteSpace = 'pre-wrap';
+    if (!isInput) {
+        style.wordBreak = 'break-word';
+    } // only for textarea-s
+    // Position off-screen
+    style.position = 'absolute'; // required to return coordinates properly
+    // Transfer the element's properties to the div
+    properties.forEach(prop => {
+        if (isInput && prop === 'lineHeight') {
+            // Special case for <input>s because text is rendered centered and line height may be != height
+            if (computed.boxSizing !== "border-box") {
+                style.lineHeight = computed.height;
+                return;
+            }
+            const height = parseInt(computed.height);
+            const outerHeight = parseInt(computed.paddingTop) + parseInt(computed.paddingBottom) + parseInt(computed.borderTopWidth) + parseInt(computed.borderBottomWidth);
+            const targetHeight = outerHeight + parseInt(computed.lineHeight);
+            if (height > targetHeight) {
+                style.lineHeight = height - outerHeight + "px";
+                return;
+            }
+            if (height === targetHeight) {
+                style.lineHeight = computed.lineHeight;
+                return;
+            }
+            style.lineHeight = '0';
+            return;
+        }
+        set(style, prop, computed[prop]);
+    });
+    if (!isFirefox) {
+        style.overflow = 'hidden';
+        // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
+    }
+    const value = get(element, 'value');
+    if (isFirefox && element.scrollHeight > parseInt(computed.height)) {
+        style.overflowY = 'scroll';
+    }
+    div.textContent = value.substring(0, position);
+    // The second special handling for input type="text" vs textarea:
+    // spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
+    if (isInput && !isNil(div.textContent)) {
+        div.textContent = div.textContent.replace(/\s/g, '\u00a0');
+    }
+    const span = document.createElement('span');
+    // Wrapping must be replicated *exactly*, including when a long word gets
+    // onto the next line, with whitespace at the end of the line before (#7).
+    // The  *only* reliable way to do that is to copy the *entire* rest of the
+    // textarea's content into the <span> created at the caret position.
+    // For inputs, just '.' would be enough, but no need to bother.
+    span.textContent = value.substring(position) || '.'; // || because a completely empty faux span doesn't render at all
+    div.appendChild(span);
+    const coordinates = {
+        top: span.offsetTop + parseInt(computed['borderTopWidth']),
+        left: span.offsetLeft + parseInt(computed['borderLeftWidth']),
+        height: parseInt(computed['lineHeight'])
+    };
+    document.body.removeChild(div);
+    return coordinates;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"caret-coords.define.js","sourceRoot":"","sources":["../../../../../../../libs-ui/components/inputs/mention/src/defines/caret-coords.define.ts"],"names":[],"mappings":"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","sourcesContent":["/* From: https://github.com/component/textarea-caret-position */\n\nimport { get, isNil, set } from \"@libs-ui/utils\";\n\n// We'll copy the properties below into the mirror div.\n// Note that some browsers, such as Firefox, do not concatenate properties\n// into their shorthand (e.g. padding-top, padding-bottom etc. -> padding),\n// so we have to list every single property explicitly.\nconst properties = [\n  'direction', // RTL support\n  'boxSizing',\n  'width', // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does\n  'height',\n  'overflowX',\n  'overflowY', // copy the scrollbar for IE\n\n  'borderTopWidth',\n  'borderRightWidth',\n  'borderBottomWidth',\n  'borderLeftWidth',\n  'borderStyle',\n\n  'paddingTop',\n  'paddingRight',\n  'paddingBottom',\n  'paddingLeft',\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/font\n  'fontStyle',\n  'fontVariant',\n  'fontWeight',\n  'fontStretch',\n  'fontSize',\n  'fontSizeAdjust',\n  'lineHeight',\n  'fontFamily',\n\n  'textAlign',\n  'textTransform',\n  'textIndent',\n  'textDecoration', // might not make a difference, but better be safe\n\n  'letterSpacing',\n  'wordSpacing',\n\n  'tabSize',\n  'MozTabSize'\n\n];\n\nconst isBrowser = (typeof window !== 'undefined');\nconst isFirefox = (isBrowser && get(window, 'mozInnerScreenX') !== null);\n\nexport const getCaretCoordinates = (element: Element, position: number | null) => {\n  if (!isBrowser) {\n    throw new Error('textarea-caret-position#getCaretCoordinates should only be called in a browser');\n  }\n\n  // The mirror div will replicate the textarea's style\n  const div: HTMLDivElement = document.createElement('div');\n\n  div.id = 'input-textarea-caret-position-mirror-div';\n  document.body.appendChild(div);\n\n  const style = div.style;\n  const computed = window.getComputedStyle ? window.getComputedStyle(element) : get(element, 'currentStyle'); // currentStyle for IE < 9\n  const isInput = element.nodeName === 'INPUT';\n\n  // Default textarea styles\n  style.whiteSpace = 'pre-wrap';\n  if (!isInput) { style.wordBreak = 'break-word' } // only for textarea-s\n\n  // Position off-screen\n  style.position = 'absolute'; // required to return coordinates properly\n\n  // Transfer the element's properties to the div\n  properties.forEach(prop => {\n    if (isInput && prop === 'lineHeight') {\n      // Special case for <input>s because text is rendered centered and line height may be != height\n      if (computed.boxSizing !== \"border-box\") {\n        style.lineHeight = computed.height;\n\n        return;\n      }\n      const height = parseInt(computed.height);\n      const outerHeight = parseInt(computed.paddingTop) + parseInt(computed.paddingBottom) + parseInt(computed.borderTopWidth) + parseInt(computed.borderBottomWidth);\n      const targetHeight = outerHeight + parseInt(computed.lineHeight);\n\n      if (height > targetHeight) {\n        style.lineHeight = height - outerHeight + \"px\";\n\n        return;\n      }\n      if (height === targetHeight) {\n        style.lineHeight = computed.lineHeight;\n\n        return;\n      }\n      style.lineHeight = '0';\n\n      return;\n    }\n    set(style, prop, computed[prop]);\n  });\n\n  if (!isFirefox) {\n    style.overflow = 'hidden';\n    // Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275\n  }\n  const value = get(element, 'value');\n  if (isFirefox && element.scrollHeight > parseInt(computed.height)) { style.overflowY = 'scroll' }\n  div.textContent = value.substring(0, position);\n  // The second special handling for input type=\"text\" vs textarea:\n  // spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037\n  if (isInput && !isNil(div.textContent)) {\n    div.textContent = div.textContent.replace(/\\s/g, '\\u00a0');\n  }\n  const span = document.createElement('span');\n\n  // Wrapping must be replicated *exactly*, including when a long word gets\n  // onto the next line, with whitespace at the end of the line before (#7).\n  // The  *only* reliable way to do that is to copy the *entire* rest of the\n  // textarea's content into the <span> created at the caret position.\n  // For inputs, just '.' would be enough, but no need to bother.\n  span.textContent = value.substring(position) || '.'; // || because a completely empty faux span doesn't render at all\n  div.appendChild(span);\n\n  const coordinates = {\n    top: span.offsetTop + parseInt(computed['borderTopWidth']),\n    left: span.offsetLeft + parseInt(computed['borderLeftWidth']),\n    height: parseInt(computed['lineHeight'])\n  };\n\n  document.body.removeChild(div);\n\n  return coordinates;\n};\n"]}

package/esm2022/defines/keyboard.define.mjs

@@ -0,0 +1,10 @@
+export const KEY_BACKSPACE = 8;
+export const KEY_TAB = 9;
+export const KEY_ENTER = 13;
+export const KEY_SHIFT = 16;
+export const KEY_ESCAPE = 27;
+export const KEY_SPACE = 32;
+export const KEY_UP = 38;
+export const KEY_DOWN = 40;
+export const KEY_BUFFERED = 229;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Ym9hcmQuZGVmaW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy11aS9jb21wb25lbnRzL2lucHV0cy9tZW50aW9uL3NyYy9kZWZpbmVzL2tleWJvYXJkLmRlZmluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsQ0FBQyxDQUFDO0FBQy9CLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxDQUFDLENBQUM7QUFDekIsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLEVBQUUsQ0FBQztBQUM1QixNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsRUFBRSxDQUFDO0FBQzVCLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxFQUFFLENBQUM7QUFDN0IsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLEVBQUUsQ0FBQztBQUM1QixNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDO0FBQ3pCLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxFQUFFLENBQUM7QUFDM0IsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLEdBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBLRVlfQkFDS1NQQUNFID0gODtcbmV4cG9ydCBjb25zdCBLRVlfVEFCID0gOTtcbmV4cG9ydCBjb25zdCBLRVlfRU5URVIgPSAxMztcbmV4cG9ydCBjb25zdCBLRVlfU0hJRlQgPSAxNjtcbmV4cG9ydCBjb25zdCBLRVlfRVNDQVBFID0gMjc7XG5leHBvcnQgY29uc3QgS0VZX1NQQUNFID0gMzI7XG5leHBvcnQgY29uc3QgS0VZX1VQID0gMzg7XG5leHBvcnQgY29uc3QgS0VZX0RPV04gPSA0MDtcbmV4cG9ydCBjb25zdCBLRVlfQlVGRkVSRUQgPSAyMjk7Il19

package/esm2022/defines/template.define.mjs

@@ -0,0 +1,25 @@
+import { deleteUnicode, get } from "@libs-ui/utils";
+export const PATTERN_INSERT = '\ufeff';
+export const buildTemplate = (value, id, feId) => {
+    return `<span class="mo-lib-shared-mention" style="font-weight: 600;-moz-osx-font-smoothing: grayscale;-webkit-font-smoothing: antialiased; color: #7239EA" contenteditable="false" id="${id}" feId="${feId}" value="${value}">${value}</span>&nbsp;`;
+};
+export const DEFAULT_CONFIG = {
+    items: [],
+    triggerChar: '@',
+    labelKey: 'email',
+    allowSpace: true,
+    returnTrigger: false,
+    limitSpaceSearchQuery: 3,
+    mentionEventName: 'click',
+    mentionActionByEvent: (item, trigger) => console.log(item, trigger),
+    mentionSelect: (item) => `@${get(item, 'email')}`,
+    mentionFilter: (search, items) => {
+        const searchString = deleteUnicode(search.toLowerCase());
+        return items?.filter(item => {
+            const name = deleteUnicode(get(item, 'name').toLowerCase());
+            const userName = deleteUnicode(get(item, 'username').toLowerCase());
+            return name.includes(searchString) || userName.includes(searchString);
+        });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/defines/utils.define.mjs

@@ -0,0 +1,280 @@
+import { get } from "@libs-ui/utils";
+import { PATTERN_INSERT } from "./template.define";
+const setValue = (el, value) => {
+    if (isInputOrTextAreaElement(el)) {
+        el.value = value;
+        return;
+    }
+    el.textContent = value;
+};
+export const getValue = (el) => {
+    return isInputOrTextAreaElement(el) ? el.value : el.textContent;
+};
+export const insertValue = (el, start, end, text, iframe, noRecursion = false) => {
+    if (isTextElement(el)) {
+        const val = getValue(el);
+        text = noRecursion ? PATTERN_INSERT : text;
+        setValue(el, val?.substring(0, start) + text + val?.substring(end, val.length));
+        setCaretPosition(el, start + text.length, iframe);
+        return;
+    }
+    if (noRecursion) {
+        return;
+    }
+    return insertValueToContentEditable(start, end, text);
+};
+const insertValueToContentEditable = (start, end, text) => {
+    if (!window.getSelection) {
+        return;
+    }
+    const sel = window.getSelection();
+    if (!sel || !sel.anchorNode || !sel.getRangeAt || !sel.rangeCount) {
+        return;
+    }
+    let range = sel.getRangeAt(0);
+    const anchorNode = sel.anchorNode;
+    const numberTextBeforeCursor = (getTextBeforeCursor() || '').length;
+    range.setStart(anchorNode, numberTextBeforeCursor - (end - start));
+    range.setEnd(anchorNode, numberTextBeforeCursor);
+    range.deleteContents();
+    // Range.createContextualFragment() would be useful here but is
+    // only relatively recently standardized and is not supported in
+    // some browsers (IE9, for one)
+    const el = document.createElement("SPAN");
+    el.innerHTML = text;
+    const frag = document.createDocumentFragment();
+    let node, lastNode, nodeHandlerEvent;
+    while ((node = el.firstChild)) {
+        if (get(node, 'getAttribute')) {
+            nodeHandlerEvent = node;
+        }
+        lastNode = frag.appendChild(node);
+    }
+    range.insertNode(frag);
+    // Preserve the selection
+    if (lastNode) {
+        range = range.cloneRange();
+        range.setStartAfter(lastNode);
+        range.collapse(true);
+        sel.removeAllRanges();
+        sel.addRange(range);
+    }
+    return nodeHandlerEvent;
+};
+export const getTextBeforeCursor = () => {
+    const sel = window.getSelection();
+    if (!sel || !sel.anchorNode) {
+        return undefined;
+    }
+    const range = sel.getRangeAt(0);
+    const anchorNode = sel.anchorNode;
+    const rangeNew = document.createRange();
+    rangeNew.selectNodeContents(anchorNode);
+    rangeNew.setEnd(range.startContainer, range.startOffset);
+    const fragNew = rangeNew.cloneContents();
+    const elmPrev = document.createElement("SPAN");
+    elmPrev.appendChild(fragNew);
+    return elmPrev.innerText;
+};
+export const isInputOrTextAreaElement = (el) => {
+    return el !== null && (el.nodeName === 'INPUT' || el.nodeName === 'TEXTAREA');
+};
+export const isTextElement = (el) => {
+    return el !== null && (el.nodeName === 'INPUT' || el.nodeName === 'TEXTAREA' || el.nodeName === '#text');
+};
+export const setCaretPosition = (el, pos, iframe) => {
+    if (isInputOrTextAreaElement(el) && el.selectionStart) {
+        el.focus();
+        el.setSelectionRange(pos, pos);
+        return;
+    }
+    const range = getDocument(iframe)?.createRange();
+    range?.setStart(el, pos);
+    range?.collapse(true);
+    const sel = getWindowSelection(iframe);
+    if (!sel) {
+        return;
+    }
+    sel.removeAllRanges();
+    if (range) {
+        sel.addRange(range);
+    }
+    ;
+};
+export const getCaretPosition = (el, iframe) => {
+    if (isInputOrTextAreaElement(el)) {
+        const val = el.value;
+        return val.slice(0, el.selectionStart || undefined).length;
+    }
+    const selObj = getWindowSelection(iframe); //window.getSelection();
+    if (selObj && selObj.rangeCount > 0) {
+        const selRange = selObj.getRangeAt(0);
+        const preCaretRange = selRange.cloneRange();
+        preCaretRange.selectNodeContents(el);
+        preCaretRange.setEnd(selRange.endContainer, selRange.endOffset);
+        const position = preCaretRange.toString().length;
+        return position;
+    }
+    return 0;
+};
+// Based on ment.io functions...
+//
+const getDocument = (iframe) => {
+    if (!iframe) {
+        return document;
+    }
+    return iframe.contentWindow?.document;
+};
+export const getWindowSelection = (iframe) => {
+    if (!iframe) {
+        return window.getSelection();
+    }
+    return iframe.contentWindow?.getSelection() || null;
+};
+export const getContentEditableCaretCoords = (ctx) => {
+    const markerTextChar = '\ufeff';
+    const markerId = 'sel_' + new Date().getTime() + '_' + Math.random().toString().substring(2);
+    const doc = getDocument(ctx.iframe);
+    const sel = getWindowSelection(ctx.iframe);
+    if (!sel) {
+        return {
+            left: 0,
+            top: 0,
+            bottom: 0
+        };
+    }
+    const prevRange = sel.getRangeAt(0);
+    // create new range and set postion using prevRange
+    const range = doc.createRange();
+    const anchorNode = sel.anchorNode;
+    range.setStart(anchorNode, prevRange.startOffset);
+    range.setEnd(anchorNode, prevRange.startOffset);
+    range.collapse(false);
+    // Create the marker element containing a single invisible character
+    // using DOM methods and insert it at the position in the range
+    const markerEl = doc.createElement('span');
+    markerEl.id = markerId;
+    markerEl.appendChild(doc.createTextNode(markerTextChar));
+    range.insertNode(markerEl);
+    sel.removeAllRanges();
+    sel.addRange(prevRange);
+    const coordinates = {
+        left: 0,
+        top: markerEl.offsetHeight,
+        bottom: -1
+    };
+    localToRelativeCoordinates(ctx, markerEl, coordinates);
+    markerEl.parentNode?.removeChild(markerEl);
+    const widthScreen = (ctx.windowParent ? window.parent.innerWidth : window.innerWidth) || document.documentElement.clientWidth || document.body.clientWidth;
+    if (coordinates.left + 315 > widthScreen) {
+        coordinates.left = coordinates.left - 300;
+    }
+    const heightScreen = (ctx.windowParent ? window.parent.innerHeight : window.innerHeight) || document.documentElement.clientHeight || document.body.clientHeight;
+    if (coordinates.top + 190 > heightScreen) {
+        coordinates.bottom = heightScreen - coordinates.top + 15;
+        coordinates.top = -1;
+    }
+    return coordinates;
+};
+const localToRelativeCoordinates = (ctx, element, coordinates) => {
+    let obj = element;
+    let iframe = ctx ? ctx.iframe : null;
+    while (obj) {
+        if (ctx.parent !== null && ctx.parent === obj) {
+            break;
+        }
+        coordinates.left += obj.offsetLeft + obj.clientLeft;
+        coordinates.top += obj.offsetTop + obj.clientTop;
+        obj = obj.offsetParent;
+        if (!obj && iframe) {
+            obj = iframe;
+            iframe = null;
+        }
+    }
+    obj = element;
+    iframe = ctx ? ctx.iframe : null;
+    while ((obj !== getDocument(undefined)?.body || ctx.windowParent) && obj !== null) {
+        if (ctx.parent !== null && ctx.parent === obj) {
+            break;
+        }
+        if (obj.scrollTop && obj.scrollTop > 0) {
+            coordinates.top -= obj.scrollTop;
+        }
+        if (obj.scrollLeft && obj.scrollLeft > 0) {
+            coordinates.left -= obj.scrollLeft;
+        }
+        obj = ctx.windowParent ? obj.offsetParent : obj.parentNode;
+        if (!obj && iframe) {
+            obj = iframe;
+            iframe = null;
+        }
+    }
+};
+const setEndOfContentEditable = (contentEditableElement) => {
+    if (document.createRange) {
+        const range = document.createRange(); //Create a range (a range is a like the selection but invisible)
+        const selection = window.getSelection(); //get the selection object (allows you to change selection)
+        range.selectNodeContents(contentEditableElement); //Select the entire contents of the element with the range
+        range.collapse(false); //collapse the range to the end point. false means collapse to end rather than the start
+        selection?.removeAllRanges(); //remove any selections already made
+        selection?.addRange(range); //make the range you have just created the visible selection
+    }
+    return;
+};
+export const insertTextAtCaret = (element, text) => {
+    if (window.getSelection) {
+        if (!elementContainsSelection(element)) {
+            setEndOfContentEditable(element);
+            insertTextAtCaret(element, text);
+            return;
+        }
+        const sel = window.getSelection();
+        if (sel?.getRangeAt && sel.rangeCount) {
+            let range = sel.getRangeAt(0);
+            const el = document.createElement("SPAN");
+            range.deleteContents();
+            el.innerHTML = text;
+            const frag = document.createDocumentFragment();
+            let node;
+            let lastNode;
+            while ((node = el.firstChild)) {
+                lastNode = frag.appendChild(node);
+            }
+            range.insertNode(frag);
+            if (lastNode) {
+                range = range.cloneRange();
+                range.setStartAfter(lastNode);
+                range.collapse(true);
+                sel.removeAllRanges();
+                sel.addRange(range);
+            }
+        }
+    }
+};
+const elementContainsSelection = (el) => {
+    if (!window.getSelection) {
+        return false;
+    }
+    const sel = window.getSelection();
+    if (sel && sel.rangeCount > 0) {
+        for (let i = 0; i < sel.rangeCount; ++i) {
+            if (!isOrContains(sel.getRangeAt(i).commonAncestorContainer, el)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+};
+const isOrContains = (node, container) => {
+    while (node) {
+        if (node === container) {
+            return true;
+        }
+        if (node.parentNode) {
+            node = node.parentNode;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.define.js","sourceRoot":"","sources":["../../../../../../../libs-ui/components/inputs/mention/src/defines/utils.define.ts"],"names":[],"mappings":"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","sourcesContent":["import { get } from \"@libs-ui/utils\";\nimport { PATTERN_INSERT } from \"./template.define\";\n\nconst setValue = (el: HTMLInputElement, value: string) => {\n  if (isInputOrTextAreaElement(el)) {\n    el.value = value;\n\n    return;\n  }\n  el.textContent = value;\n};\n\nexport const getValue = (el: HTMLInputElement) => {\n  return isInputOrTextAreaElement(el) ? el.value : el.textContent;\n};\n\nexport const insertValue = (el: HTMLInputElement, start: number, end: number, text: string, iframe: HTMLIFrameElement, noRecursion = false): ChildNode | undefined | null => {\n  if (isTextElement(el)) {\n    const val = getValue(el);\n\n    text = noRecursion ? PATTERN_INSERT : text;\n    setValue(el, val?.substring(0, start) + text + val?.substring(end, val.length));\n    setCaretPosition(el, start + text.length, iframe);\n\n    return;\n  }\n  if (noRecursion) {\n    return;\n  }\n\n  return insertValueToContentEditable(start, end, text);\n};\n\nconst insertValueToContentEditable = (start: number, end: number, text: string): ChildNode | undefined | null => {\n  if (!window.getSelection) {\n    return;\n  }\n  const sel = window.getSelection();\n\n  if (!sel || !sel.anchorNode || !sel.getRangeAt || !sel.rangeCount) {\n    return;\n  }\n  let range = sel.getRangeAt(0);\n  const anchorNode = sel.anchorNode;\n  const numberTextBeforeCursor = (getTextBeforeCursor() || '').length;\n\n  range.setStart(anchorNode, numberTextBeforeCursor - (end - start));\n  range.setEnd(anchorNode, numberTextBeforeCursor);\n  range.deleteContents();\n  // Range.createContextualFragment() would be useful here but is\n  // only relatively recently standardized and is not supported in\n  // some browsers (IE9, for one)\n  const el = document.createElement(\"SPAN\");\n\n  el.innerHTML = text;\n  const frag = document.createDocumentFragment();\n  let node, lastNode, nodeHandlerEvent;\n\n  while ((node = el.firstChild)) {\n    if (get(node, 'getAttribute')) {\n      nodeHandlerEvent = node;\n    }\n\n    lastNode = frag.appendChild(node);\n  }\n  range.insertNode(frag);\n\n  // Preserve the selection\n  if (lastNode) {\n    range = range.cloneRange();\n    range.setStartAfter(lastNode);\n    range.collapse(true);\n    sel.removeAllRanges();\n    sel.addRange(range);\n  }\n\n  return nodeHandlerEvent;\n};\n\nexport const getTextBeforeCursor = () => {\n  const sel = window.getSelection();\n\n  if (!sel || !sel.anchorNode) {\n    return undefined;\n  }\n  const range = sel.getRangeAt(0);\n  const anchorNode = sel.anchorNode;\n  const rangeNew = document.createRange();\n\n  rangeNew.selectNodeContents(anchorNode);\n  rangeNew.setEnd(range.startContainer, range.startOffset);\n\n  const fragNew = rangeNew.cloneContents();\n  const elmPrev = document.createElement(\"SPAN\");\n\n  elmPrev.appendChild(fragNew);\n\n  return elmPrev.innerText;\n};\n\nexport const isInputOrTextAreaElement = (el: HTMLElement): boolean => {\n  return el !== null && (el.nodeName === 'INPUT' || el.nodeName === 'TEXTAREA');\n};\n\nexport const isTextElement = (el: HTMLElement): boolean => {\n  return el !== null && (el.nodeName === 'INPUT' || el.nodeName === 'TEXTAREA' || el.nodeName === '#text');\n};\n\nexport const setCaretPosition = (el: HTMLInputElement, pos: number, iframe: HTMLIFrameElement) => {\n  if (isInputOrTextAreaElement(el) && el.selectionStart) {\n    el.focus();\n    el.setSelectionRange(pos, pos);\n\n    return;\n  }\n  const range = getDocument(iframe)?.createRange();\n\n  range?.setStart(el, pos);\n  range?.collapse(true);\n  const sel = getWindowSelection(iframe);\n\n  if (!sel) {\n    return;\n  }\n  sel.removeAllRanges();\n  if (range) {\n    sel.addRange(range)\n  };\n};\n\nexport const getCaretPosition = (el: HTMLInputElement, iframe?: HTMLIFrameElement): number => {\n  if (isInputOrTextAreaElement(el)) {\n    const val = el.value;\n\n    return val.slice(0, el.selectionStart || undefined).length;\n  }\n  const selObj = getWindowSelection(iframe); //window.getSelection();\n\n  if (selObj && selObj.rangeCount > 0) {\n    const selRange = selObj.getRangeAt(0);\n    const preCaretRange = selRange.cloneRange();\n\n    preCaretRange.selectNodeContents(el);\n    preCaretRange.setEnd(selRange.endContainer, selRange.endOffset);\n    const position = preCaretRange.toString().length;\n\n    return position;\n  }\n  return 0;\n};\n\n// Based on ment.io functions...\n//\n\nconst getDocument = (iframe?: HTMLIFrameElement) => {\n  if (!iframe) {\n    return document;\n  }\n\n  return iframe.contentWindow?.document;\n};\n\nexport const getWindowSelection = (iframe?: HTMLIFrameElement): Selection | null => {\n  if (!iframe) {\n    return window.getSelection();\n  }\n\n  return iframe.contentWindow?.getSelection() || null;\n};\n\nexport const getContentEditableCaretCoords = (ctx: { iframe: HTMLIFrameElement | undefined, parent: Element | null, windowParent?: boolean }) => {\n  const markerTextChar = '\\ufeff';\n  const markerId = 'sel_' + new Date().getTime() + '_' + Math.random().toString().substring(2);\n  const doc = getDocument(ctx.iframe) as Document;\n  const sel = getWindowSelection(ctx.iframe) as Selection;\n\n  if (!sel) {\n    return {\n      left: 0,\n      top: 0,\n      bottom: 0\n    };\n  }\n  const prevRange = sel.getRangeAt(0);\n\n  // create new range and set postion using prevRange\n  const range = doc.createRange();\n  const anchorNode = sel.anchorNode as Node;\n  range.setStart(anchorNode, prevRange.startOffset);\n  range.setEnd(anchorNode, prevRange.startOffset);\n  range.collapse(false);\n\n  // Create the marker element containing a single invisible character\n  // using DOM methods and insert it at the position in the range\n  const markerEl = doc.createElement('span');\n\n  markerEl.id = markerId;\n  markerEl.appendChild(doc.createTextNode(markerTextChar));\n  range.insertNode(markerEl);\n  sel.removeAllRanges();\n  sel.addRange(prevRange);\n\n  const coordinates = {\n    left: 0,\n    top: markerEl.offsetHeight,\n    bottom: -1\n  };\n\n  localToRelativeCoordinates(ctx, markerEl, coordinates);\n  markerEl.parentNode?.removeChild(markerEl);\n  const widthScreen = (ctx.windowParent ? window.parent.innerWidth : window.innerWidth) || document.documentElement.clientWidth || document.body.clientWidth;\n\n  if (coordinates.left + 315 > widthScreen) {\n    coordinates.left = coordinates.left - 300;\n  }\n  const heightScreen = (ctx.windowParent ? window.parent.innerHeight : window.innerHeight) || document.documentElement.clientHeight || document.body.clientHeight;\n\n  if (coordinates.top + 190 > heightScreen) {\n    coordinates.bottom = heightScreen - coordinates.top + 15;\n    coordinates.top = -1;\n  }\n\n  return coordinates;\n};\n\nconst localToRelativeCoordinates = (ctx: { iframe: HTMLIFrameElement | undefined, parent: Element | null, windowParent?: boolean }, element: Element, coordinates: { top: number; left: number, bottom: number }) => {\n  let obj = <HTMLElement>element;\n  let iframe = ctx ? ctx.iframe : null;\n\n  while (obj) {\n    if (ctx.parent !== null && ctx.parent === obj) {\n      break;\n    }\n    coordinates.left += obj.offsetLeft + obj.clientLeft;\n    coordinates.top += obj.offsetTop + obj.clientTop;\n    obj = <HTMLElement>obj.offsetParent;\n    if (!obj && iframe) {\n      obj = iframe;\n      iframe = null;\n    }\n  }\n  obj = <HTMLElement>element;\n  iframe = ctx ? ctx.iframe : null;\n  while ((obj !== getDocument(undefined)?.body || ctx.windowParent) && obj !== null) {\n    if (ctx.parent !== null && ctx.parent === obj) {\n      break;\n    }\n    if (obj.scrollTop && obj.scrollTop > 0) {\n      coordinates.top -= obj.scrollTop;\n    }\n    if (obj.scrollLeft && obj.scrollLeft > 0) {\n      coordinates.left -= obj.scrollLeft;\n    }\n    obj = ctx.windowParent ? <HTMLElement>obj.offsetParent : <HTMLElement>obj.parentNode;\n    if (!obj && iframe) {\n      obj = iframe;\n      iframe = null;\n    }\n  }\n};\n\nconst setEndOfContentEditable = (contentEditableElement: Node) => {\n  if (document.createRange) {\n    const range = document.createRange(); //Create a range (a range is a like the selection but invisible)\n    const selection = window.getSelection(); //get the selection object (allows you to change selection)\n\n    range.selectNodeContents(contentEditableElement); //Select the entire contents of the element with the range\n    range.collapse(false); //collapse the range to the end point. false means collapse to end rather than the start\n    selection?.removeAllRanges(); //remove any selections already made\n    selection?.addRange(range); //make the range you have just created the visible selection\n  }\n\n  return;\n};\n\nexport const insertTextAtCaret = (element: HTMLInputElement, text: string) => {\n  if (window.getSelection) {\n    if (!elementContainsSelection(element)) {\n      setEndOfContentEditable(element);\n      insertTextAtCaret(element, text);\n\n      return;\n    }\n    const sel = window.getSelection();\n\n    if (sel?.getRangeAt && sel.rangeCount) {\n      let range = sel.getRangeAt(0);\n      const el = document.createElement(\"SPAN\");\n\n      range.deleteContents();\n      el.innerHTML = text;\n      const frag = document.createDocumentFragment();\n      let node: Node | null;\n      let lastNode!: Node;\n\n      while ((node = el.firstChild)) {\n        lastNode = frag.appendChild(node);\n      }\n      range.insertNode(frag);\n\n      if (lastNode) {\n        range = range.cloneRange();\n        range.setStartAfter(lastNode);\n        range.collapse(true);\n        sel.removeAllRanges();\n        sel.addRange(range);\n      }\n    }\n  }\n};\n\nconst elementContainsSelection = (el: HTMLInputElement) => {\n  if (!window.getSelection) {\n    return false;\n  }\n  const sel = window.getSelection();\n\n  if (sel && sel.rangeCount > 0) {\n    for (let i = 0; i < sel.rangeCount; ++i) {\n      if (!isOrContains(sel.getRangeAt(i).commonAncestorContainer, el)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return false;\n};\n\nconst isOrContains = (node: Node, container: HTMLInputElement) => {\n  while (node) {\n    if (node === container) {\n      return true;\n    }\n    if (node.parentNode) {\n      node = node.parentNode;\n    }\n  }\n\n  return false;\n};"]}

package/esm2022/index.mjs

@@ -0,0 +1,3 @@
+export * from './mention.directive';
+export * from './interfaces/mention.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzLXVpL2NvbXBvbmVudHMvaW5wdXRzL21lbnRpb24vc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWVudGlvbi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzL21lbnRpb24uaW50ZXJmYWNlJzsiXX0=

package/esm2022/interfaces/mention.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs-ui-components-inputs-mention.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlicy11aS1jb21wb25lbnRzLWlucHV0cy1tZW50aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy11aS9jb21wb25lbnRzL2lucHV0cy9tZW50aW9uL3NyYy9saWJzLXVpLWNvbXBvbmVudHMtaW5wdXRzLW1lbnRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=