@ember-eui/core 11.0.3 → 12.0.1

package/dist/components/eui-markdown-editor.js

@@ -1,6 +1,5 @@
-import { macroCondition, dependencySatisfies, importSync } from '@embroider/macros';
 import Component from '@glimmer/component';
-import { tracked } from '@glimmer/tracking';
+import { tracked, cached } from '@glimmer/tracking';
 import { hash } from '@ember/helper';
 import { on } from '@ember/modifier';
 import { action } from '@ember/object';
@@ -27,149 +26,148 @@ import './eui-markdown-format/markdown-tooltip.js';
 import { tooltipPlugin } from '../utils/markdown/plugins/markdown-tooltip/plugin.js';
 import EuiMarkdownEditorDropZone from './eui-markdown-editor-drop-zone.js';
 import EuiMarkdownEditorTextArea from './eui-markdown-editor-text-area.js';
-import EuiMarkdownEditorToolbarComponent from './eui-markdown-editor-toolbar.js';
-import EuiMarkdownEditorToolbarComponent$1 from './eui-markdown-format.js';
+import EuiMarkdownEditorToolbarComponent$1 from './eui-markdown-editor-toolbar.js';
+import EuiMarkdownEditorToolbarComponent from './eui-markdown-format.js';
 import EuiModal from './eui-modal.js';
 import { precompileTemplate } from '@ember/template-compilation';
 import { setComponentTemplate } from '@ember/component';
 import { g, i, n } from 'decorator-transforms/runtime';
 
-let cached = macroCondition(dependencySatisfies('ember-source', '>= 4.1.0-alpha.0')) ? importSync('@glimmer/tracking').cached : importSync('ember-cached-decorator-polyfill').cached;
-const getCursorNode = (textareaRef1, parsed1) => {
+const getCursorNode = (textareaRef, parsed) => {
   const {
-    selectionStart: selectionStart1
-  } = textareaRef1;
-  let node1 = parsed1.result ?? parsed1.contents;
+    selectionStart
+  } = textareaRef;
+  let node = parsed.result ?? parsed.contents;
   //eslint-disable-next-line
   outer: while (true) {
-    if (node1.children) {
-      for (let i1 = 0; i1 < node1.children.length; i1++) {
-        const child1 = node1.children[i1];
-        if (child1 && child1.position.start.offset < selectionStart1 && selectionStart1 < child1.position.end.offset) {
-          if (child1.type === 'text') break outer; // don't dive into `text` nodes
-          node1 = child1;
+    if (node.children) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        if (child && child.position.start.offset < selectionStart && selectionStart < child.position.end.offset) {
+          if (child.type === 'text') break outer; // don't dive into `text` nodes
+          node = child;
           continue outer;
         }
       }
     }
     break;
   }
-  return node1;
+  return node;
 };
-function wrapper(textarea1, parsed1, callback1) {
-  const node1 = getCursorNode(textarea1, parsed1);
-  callback1(node1);
+function wrapper(textarea, parsed, callback) {
+  const node = getCursorNode(textarea, parsed);
+  callback(node);
 }
-const getCursorNodeModifier = modifier(function getCursorNodeModifier1(textarea1, [parsed1, onSelectedNode1]) {
+const getCursorNodeModifier = modifier(function getCursorNodeModifier(textarea, [parsed, onSelectedNode]) {
   //@ts-expect-error
-  const fn1 = wrapper.bind(null, textarea1, parsed1, onSelectedNode1);
-  textarea1.addEventListener('keyup', fn1);
-  textarea1.addEventListener('mouseup', fn1);
+  const fn = wrapper.bind(null, textarea, parsed, onSelectedNode);
+  textarea.addEventListener('keyup', fn);
+  textarea.addEventListener('mouseup', fn);
   return () => {
-    textarea1.removeEventListener('keyup', fn1);
-    textarea1.removeEventListener('mouseup', fn1);
+    textarea.removeEventListener('keyup', fn);
+    textarea.removeEventListener('mouseup', fn);
   };
 });
-function isNewLine(char1) {
-  if (char1 == null) return true;
-  return !!char1.match(/[\r\n]/);
+function isNewLine(char) {
+  if (char == null) return true;
+  return !!char.match(/[\r\n]/);
 }
-function padWithNewlinesIfNeeded(textarea1, text1) {
-  const selectionStart1 = textarea1.selectionStart;
-  const selectionEnd1 = textarea1.selectionEnd;
+function padWithNewlinesIfNeeded(textarea, text) {
+  const selectionStart = textarea.selectionStart;
+  const selectionEnd = textarea.selectionEnd;
   // block parsing requires two leading new lines and none trailing, but we add an extra trailing line for readability
-  const isPrevNewLine1 = isNewLine(textarea1.value[selectionStart1 - 1]);
-  const isPrevPrevNewLine1 = isNewLine(textarea1.value[selectionStart1 - 2]);
-  const isNextNewLine1 = isNewLine(textarea1.value[selectionEnd1]);
+  const isPrevNewLine = isNewLine(textarea.value[selectionStart - 1]);
+  const isPrevPrevNewLine = isNewLine(textarea.value[selectionStart - 2]);
+  const isNextNewLine = isNewLine(textarea.value[selectionEnd]);
   // pad text with newlines as needed
-  text1 = `${isPrevNewLine1 ? '' : '\n'}${isPrevPrevNewLine1 ? '' : '\n'}${text1}${isNextNewLine1 ? '' : '\n'}`;
-  return text1;
+  text = `${isPrevNewLine ? '' : '\n'}${isPrevPrevNewLine ? '' : '\n'}${text}${isNextNewLine ? '' : '\n'}`;
+  return text;
 }
 class EuiMarkdownEditorComponent extends Component {
   static {
     g(this.prototype, "pluginEditorPlugin", [tracked]);
   }
-  #pluginEditorPlugin = (i(this, "pluginEditorPlugin"), void 0);
+  #pluginEditorPlugin = (i(this, "pluginEditorPlugin"), undefined);
   static {
     g(this.prototype, "parsingPluginList", [argOrDefaultDecorator(defaultParsingPlugins)]);
   }
-  #parsingPluginList = (i(this, "parsingPluginList"), void 0); // Defaults
+  #parsingPluginList = (i(this, "parsingPluginList"), undefined); // Defaults
   static {
     g(this.prototype, "height", [argOrDefaultDecorator(250)]);
   }
-  #height = (i(this, "height"), void 0);
+  #height = (i(this, "height"), undefined);
   static {
     g(this.prototype, "maxHeight", [argOrDefaultDecorator(500)]);
   }
-  #maxHeight = (i(this, "maxHeight"), void 0);
+  #maxHeight = (i(this, "maxHeight"), undefined);
   static {
     g(this.prototype, "autoExpandPreview", [argOrDefaultDecorator(true)]);
   }
-  #autoExpandPreview = (i(this, "autoExpandPreview"), void 0);
+  #autoExpandPreview = (i(this, "autoExpandPreview"), undefined);
   static {
     g(this.prototype, "processingPluginList", [argOrDefaultDecorator(defaultProcessingPlugins)]);
   }
-  #processingPluginList = (i(this, "processingPluginList"), void 0);
+  #processingPluginList = (i(this, "processingPluginList"), undefined);
   static {
     g(this.prototype, "selectedNode", [tracked], function () {
       return null;
     });
   }
-  #selectedNode = (i(this, "selectedNode"), void 0);
+  #selectedNode = (i(this, "selectedNode"), undefined);
   static {
     g(this.prototype, "editorId", [tracked], function () {
       return this.args.editorId ?? guidFor({});
     });
   }
-  #editorId = (i(this, "editorId"), void 0);
+  #editorId = (i(this, "editorId"), undefined);
   static {
     g(this.prototype, "viewMode", [tracked], function () {
       return this.args.initialViewMode || MODE_EDITING;
     });
   }
-  #viewMode = (i(this, "viewMode"), void 0);
+  #viewMode = (i(this, "viewMode"), undefined);
   static {
     g(this.prototype, "textareaRef", [tracked], function () {
       return null;
     });
   }
-  #textareaRef = (i(this, "textareaRef"), void 0);
+  #textareaRef = (i(this, "textareaRef"), undefined);
   static {
     g(this.prototype, "previewRef", [tracked], function () {
       return null;
     });
   }
-  #previewRef = (i(this, "previewRef"), void 0);
+  #previewRef = (i(this, "previewRef"), undefined);
   static {
     g(this.prototype, "editorToolbarRef", [tracked], function () {
       return null;
     });
   }
-  #editorToolbarRef = (i(this, "editorToolbarRef"), void 0);
+  #editorToolbarRef = (i(this, "editorToolbarRef"), undefined);
   static {
     g(this.prototype, "currentHeight", [tracked], function () {
       return 250;
     });
   }
-  #currentHeight = (i(this, "currentHeight"), void 0);
+  #currentHeight = (i(this, "currentHeight"), undefined);
   static {
     g(this.prototype, "editorFooterHeight", [tracked], function () {
       return 0;
     });
   }
-  #editorFooterHeight = (i(this, "editorFooterHeight"), void 0);
+  #editorFooterHeight = (i(this, "editorFooterHeight"), undefined);
   static {
     g(this.prototype, "editorToolbarHeight", [tracked], function () {
       return 0;
     });
   }
-  #editorToolbarHeight = (i(this, "editorToolbarHeight"), void 0);
+  #editorToolbarHeight = (i(this, "editorToolbarHeight"), undefined);
   markdownActions;
   get toolbarPlugins() {
     return [tooltipPlugin, ...(this.args.uiPlugins || [])];
   }
-  constructor(owner1, args1) {
-    super(owner1, args1);
+  constructor(owner, args) {
+    super(owner, args);
     this.markdownActions = new MarkdownActions(this.editorId, this.toolbarPlugins);
     this.currentHeight = this.height;
   }
@@ -190,11 +188,11 @@ class EuiMarkdownEditorComponent extends Component {
   }
   onResize() {
     if (this.textareaRef && this.isEditing && this.height !== 'full') {
-      const resizedTextareaHeight1 = this.textareaRef.offsetHeight + this.editorFooterHeight;
-      const update1 = () => {
-        this.currentHeight = resizedTextareaHeight1;
+      const resizedTextareaHeight = this.textareaRef.offsetHeight + this.editorFooterHeight;
+      const update = () => {
+        this.currentHeight = resizedTextareaHeight;
       };
-      scheduleOnce('afterRender', this, update1);
+      scheduleOnce('afterRender', this, update);
     }
   }
   static {
@@ -202,30 +200,30 @@ class EuiMarkdownEditorComponent extends Component {
   }
   updateCurrentHeight() {
     let {
-      isPreviewing: isPreviewing1,
-      autoExpandPreview: autoExpandPreview1,
-      height: height1,
-      previewRef: previewRef1,
-      currentHeight: currentHeight1
+      isPreviewing,
+      autoExpandPreview,
+      height,
+      previewRef,
+      currentHeight
     } = this;
-    if (isPreviewing1 && autoExpandPreview1 && height1 !== 'full' && previewRef1) {
+    if (isPreviewing && autoExpandPreview && height !== 'full' && previewRef) {
       //@ts-ignore
-      if (previewRef1.scrollHeight > currentHeight1) {
+      if (previewRef.scrollHeight > currentHeight) {
         // scrollHeight does not include the border or margin
         // so we ask for the computed value for those,
         // which is always in pixels because getComputedValue
         // returns the resolved values
-        const elementComputedStyle1 = window.getComputedStyle(previewRef1);
-        const borderWidth1 = parseFloat(elementComputedStyle1.borderTopWidth) + parseFloat(elementComputedStyle1.borderBottomWidth);
-        const marginWidth1 = parseFloat(elementComputedStyle1.marginTop) + parseFloat(elementComputedStyle1.marginBottom);
+        const elementComputedStyle = window.getComputedStyle(previewRef);
+        const borderWidth = parseFloat(elementComputedStyle.borderTopWidth) + parseFloat(elementComputedStyle.borderBottomWidth);
+        const marginWidth = parseFloat(elementComputedStyle.marginTop) + parseFloat(elementComputedStyle.marginBottom);
         // then add an extra pixel for safety and because the scrollHeight value is rounded
-        const extraHeight1 = borderWidth1 + marginWidth1 + 1;
-        const update1 = () => {
-          if (previewRef1) {
-            this.currentHeight = previewRef1.scrollHeight + extraHeight1;
+        const extraHeight = borderWidth + marginWidth + 1;
+        const update = () => {
+          if (previewRef) {
+            this.currentHeight = previewRef.scrollHeight + extraHeight;
           }
         };
-        scheduleOnce('afterRender', this, update1);
+        scheduleOnce('afterRender', this, update);
       }
     }
   }
@@ -233,24 +231,24 @@ class EuiMarkdownEditorComponent extends Component {
     n(this.prototype, "updateCurrentHeight", [action]);
   }
   getCursorNode = () => {};
-  setTextAreaRef(ref1) {
-    this.textareaRef = ref1;
+  setTextAreaRef(ref) {
+    this.textareaRef = ref;
   }
   static {
     n(this.prototype, "setTextAreaRef", [action]);
   }
-  setEditorToolbarRef(ref1) {
-    this.editorToolbarRef = ref1;
-    this.editorToolbarHeight = ref1.offsetHeight;
+  setEditorToolbarRef(ref) {
+    this.editorToolbarRef = ref;
+    this.editorToolbarHeight = ref.offsetHeight;
   }
   static {
     n(this.prototype, "setEditorToolbarRef", [action]);
   }
-  replaceNode(position1, next1) {
-    let value1 = this.args.value;
-    const leading1 = value1.substr(0, position1.start.offset);
-    const trailing1 = value1.substr(position1.end.offset);
-    this.args.onChange?.(`${leading1}${next1}${trailing1}`);
+  replaceNode(position, next) {
+    let value = this.args.value;
+    const leading = value.substr(0, position.start.offset);
+    const trailing = value.substr(position.end.offset);
+    this.args.onChange?.(`${leading}${next}${trailing}`);
   }
   static {
     n(this.prototype, "replaceNode", [action]);
@@ -268,24 +266,24 @@ class EuiMarkdownEditorComponent extends Component {
     n(this.prototype, "setViewMode", [action]);
   }
   get parser() {
-    const Compiler1 = tree1 => {
-      return tree1;
+    const Compiler = tree => {
+      return tree;
     };
-    function identityCompiler1(this1) {
+    function identityCompiler() {
       //eslint-disable-next-line
-      this.Compiler = Compiler1;
+      this.Compiler = Compiler;
     }
-    return unified().use(this.parsingPluginList).use(identityCompiler1);
+    return unified().use(this.parsingPluginList).use(identityCompiler);
   }
   static {
     n(this.prototype, "parser", [cached]);
   }
   get parsed() {
     try {
-      const parsed1 = this.parser.processSync(this.args.value);
-      return [parsed1, null];
-    } catch (e1) {
-      return [null, e1];
+      const parsed = this.parser.processSync(this.args.value);
+      return [parsed, null];
+    } catch (e) {
+      return [null, e];
     }
   }
   static {
@@ -296,53 +294,53 @@ class EuiMarkdownEditorComponent extends Component {
   }
   onParse() {
     if (this.args.onParse) {
-      const [parsed1, parseError1] = this.parsed;
-      const onParse1 = this.args.onParse;
-      const messages1 = parsed1 ? parsed1.messages : [];
-      const ast1 = parsed1 ? parsed1['result'] ?? parsed1.contents : null;
-      onParse1(parseError1, {
-        messages: messages1,
-        ast: ast1
+      const [parsed, parseError] = this.parsed;
+      const onParse = this.args.onParse;
+      const messages = parsed ? parsed.messages : [];
+      const ast = parsed ? parsed['result'] ?? parsed.contents : null;
+      onParse(parseError, {
+        messages,
+        ast
       });
     }
   }
   static {
     n(this.prototype, "onParse", [action]);
   }
-  setSelectedNode(node1) {
-    this.selectedNode = node1;
+  setSelectedNode(node) {
+    this.selectedNode = node;
   }
   static {
     n(this.prototype, "setSelectedNode", [action]);
   }
-  openPluginEditor = plugin1 => {
-    this.pluginEditorPlugin = plugin1;
+  openPluginEditor = plugin => {
+    this.pluginEditorPlugin = plugin;
   };
-  onEditorPluginSave = (markdown1, config1) => {
+  onEditorPluginSave = (markdown, config) => {
     let {
-      selectedNode: selectedNode1,
-      textareaRef: textareaRef1
+      selectedNode,
+      textareaRef
     } = this;
-    if (this.pluginEditorPlugin && selectedNode1 &&
+    if (this.pluginEditorPlugin && selectedNode &&
     // @ts-expect-error
-    selectedNode1.type === this.pluginEditorPlugin.name &&
+    selectedNode.type === this.pluginEditorPlugin.name &&
     // @ts-expect-error
-    selectedNode1.position) {
+    selectedNode.position) {
       // modifying an existing node
-      textareaRef1.setSelectionRange(
+      textareaRef.setSelectionRange(
       // @ts-expect-error
-      selectedNode1.position.start.offset,
+      selectedNode.position.start.offset,
       // @ts-expect-error
-      selectedNode1.position.end.offset);
+      selectedNode.position.end.offset);
     } else {
       // creating a new node
-      if (config1.block) {
+      if (config.block) {
         // inject newlines if needed
-        markdown1 = padWithNewlinesIfNeeded(textareaRef1, markdown1);
+        markdown = padWithNewlinesIfNeeded(textareaRef, markdown);
       }
     }
-    insertText(textareaRef1, {
-      text: markdown1,
+    insertText(textareaRef, {
+      text: markdown,
       selectionStart: undefined,
       selectionEnd: undefined
     });
@@ -355,12 +353,12 @@ class EuiMarkdownEditorComponent extends Component {
         classNames,
         eq,
         didUpdate,
-        EuiMarkdownEditorToolbar: EuiMarkdownEditorToolbarComponent,
+        EuiMarkdownEditorToolbar: EuiMarkdownEditorToolbarComponent$1,
         didInsert,
         set,
         style,
         hash,
-        EuiMarkdownFormat: EuiMarkdownEditorToolbarComponent$1,
+        EuiMarkdownFormat: EuiMarkdownEditorToolbarComponent,
         EuiMarkdownEditorDropZone,
         resizeObserver: ResizeObserver,
         EuiMarkdownEditorTextArea,