@libs-ui/components-inputs-mention 0.1.1-1

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/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 { PathOf } from '@libs-ui/interfaces-types';\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\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) {\n    style.wordBreak = 'break-word';\n  } // 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 as PathOf<CSSStyleDeclaration>, 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)) {\n    style.overflowY = 'scroll';\n  }\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/template.define.mjs

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { deleteUnicode, get } from '@libs-ui/utils';
+export const PATTERN_INSERT = '\ufeff';
+export const buildTemplate = (value, id, feId) => {
+    return `<span class="libs-ui-components-mention-item" 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,279 @@
+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};\n"]}

package/esm2022/index.mjs

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

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=