@lion/ui 0.7.4 → 0.7.6

package/components/form/src/LionForm.js

@@ -10,6 +10,15 @@ const throwFormNodeError = () => {
   );
 };
 
+/**
+ * @param {FormRegistrarHost} formEl
+ * @returns {boolean}
+ */
+function hasFocusableChildren(formEl) {
+  // this implies all children have the same type (either all of them are focusable or none of them are)
+  return formEl.formElements?.some(child => child._focusableNode);
+}
+
 /**
  * LionForm: form wrapper providing extra features and integration with lion-field elements.
  *
@@ -63,7 +72,7 @@ export class LionForm extends LionFieldset {
     this.dispatchEvent(new Event('submit', { bubbles: true }));
 
     if (this.hasFeedbackFor?.includes('error')) {
-      this._setFocusOnFirstErroneousFormElement(this);
+      this._setFocusOnFirstErroneousFormElement(/** @type { * & FormRegistrarHost } */ (this));
     }
   }
 
@@ -95,7 +104,7 @@ export class LionForm extends LionFieldset {
       element.formElements.find(child => child.hasFeedbackFor.includes('error')) ||
       element.formElements[0];
 
-    if (firstFormElWithError.formElements?.length > 0) {
+    if (hasFocusableChildren(firstFormElWithError)) {
       this._setFocusOnFirstErroneousFormElement(firstFormElWithError);
     } else {
       firstFormElWithError._focusableNode.focus();

package/components/form/test/lion-form.test.js

@@ -3,7 +3,8 @@ import '@lion/ui/define/lion-fieldset.js';
 import { LionField, Required } from '@lion/ui/form-core.js';
 import '@lion/ui/define/lion-field.js';
 import '@lion/ui/define/lion-validation-feedback.js';
-
+import '@lion/ui/define/lion-listbox.js';
+import '@lion/ui/define/lion-option.js';
 import '@lion/ui/define/lion-form.js';
 import {
   aTimeout,
@@ -223,7 +224,7 @@ describe('<lion-form>', () => {
     expect(document.activeElement).to.equal(el.formElements[1]._inputNode);
   });
 
-  it('sets focus on submit to the first erroneous form element with a fieldset', async () => {
+  it('sets focus on submit to the first erroneous form element within a fieldset', async () => {
     const el = await fixture(html`
       <lion-form>
         <form>
@@ -266,4 +267,22 @@ describe('<lion-form>', () => {
     // @ts-ignore [allow-protected] in test
     expect(document.activeElement).to.equal(fieldset.formElements[0]._inputNode);
   });
+
+  it('sets focus on submit to the first form element within a erroneous listbox', async () => {
+    const el = await fixture(html`
+      <lion-form>
+        <form>
+          <lion-listbox name="name" .validators="${[new Required()]}">
+            <lion-option value="a">a</lion-option>
+            <lion-option value="b">b</lion-option>
+          </lion-listbox>
+          <button type="submit">submit</button>
+        </form>
+      </lion-form>
+    `);
+    const button = /** @type {HTMLButtonElement} */ (el.querySelector('button'));
+    button.click();
+    const listboxEl = el.formElements[0];
+    expect(document.activeElement).to.equal(listboxEl._inputNode);
+  });
 });

package/components/input-stepper/src/LionInputStepper.js

@@ -1,5 +1,5 @@
 import { html, css, render } from 'lit';
-import { LocalizeMixin } from '@lion/ui/localize-no-side-effects.js';
+import { formatNumber, LocalizeMixin, parseNumber } from '@lion/ui/localize-no-side-effects.js';
 import { LionInput } from '@lion/ui/input.js';
 import { IsNumber, MinNumber, MaxNumber } from '@lion/ui/form-core.js';
 import { localizeNamespaceLoader } from './localizeNamespaceLoader.js';
@@ -52,7 +52,7 @@ export class LionInputStepper extends LocalizeMixin(LionInput) {
    * @returns {number}
    */
   get currentValue() {
-    return parseFloat(this.value) || 0;
+    return this.modelValue || 0;
   }
 
   get _inputNode() {
@@ -62,7 +62,8 @@ export class LionInputStepper extends LocalizeMixin(LionInput) {
   constructor() {
     super();
     /** @param {string} modelValue */
-    this.parser = modelValue => parseFloat(modelValue);
+    this.parser = parseNumber;
+    this.formatter = formatNumber;
     this.min = Infinity;
     this.max = Infinity;
     this.step = 1;
@@ -229,7 +230,7 @@ export class LionInputStepper extends LocalizeMixin(LionInput) {
     const { step, min, max } = this.values;
     const newValue = this.currentValue + step;
     if (newValue <= max || max === Infinity) {
-      this.value = newValue < min && min !== Infinity ? `${min}` : `${newValue}`;
+      this.modelValue = newValue < min && min !== Infinity ? `${min}` : `${newValue}`;
       this.__toggleSpinnerButtonsState();
       this._proxyInputEvent();
     }
@@ -243,7 +244,7 @@ export class LionInputStepper extends LocalizeMixin(LionInput) {
     const { step, min, max } = this.values;
     const newValue = this.currentValue - step;
     if (newValue >= min || min === Infinity) {
-      this.value = newValue > max && max !== Infinity ? `${max}` : `${newValue}`;
+      this.modelValue = newValue > max && max !== Infinity ? `${max}` : `${newValue}`;
       this.__toggleSpinnerButtonsState();
       this._proxyInputEvent();
     }

package/components/input-stepper/test/lion-input-stepper-integrations.test.js

@@ -0,0 +1,20 @@
+import {
+  runInteractionStateMixinSuite,
+  runFormatMixinSuite,
+} from '@lion/ui/form-core-test-suites.js';
+
+import '@lion/ui/define/lion-input-stepper.js';
+
+const tagString = 'lion-input-stepper';
+
+describe('<lion-input-stepper> integrations', () => {
+  runInteractionStateMixinSuite({
+    tagString,
+    allowedModelValueTypes: [Number],
+  });
+
+  runFormatMixinSuite({
+    tagString,
+    modelValueType: Number,
+  });
+});

package/components/input-stepper/test/lion-input-stepper.test.js

@@ -1,6 +1,7 @@
 import { expect, fixture as _fixture, nextFrame } from '@open-wc/testing';
 import { html } from 'lit/static-html.js';
 import sinon from 'sinon';
+import { formatNumber } from '@lion/ui/localize-no-side-effects.js';
 import '@lion/ui/define/lion-input-stepper.js';
 
 /**
@@ -49,6 +50,50 @@ describe('<lion-input-stepper>', () => {
     });
   });
 
+  describe('Formatter', () => {
+    it('uses formatNumber for formatting', async () => {
+      const el = await fixture(defaultInputStepper);
+      expect(el.formatter).to.equal(formatNumber);
+    });
+
+    it('formatNumber uses locale provided in formatOptions', async () => {
+      let el = await fixture(html`
+        <lion-input-stepper
+          .formatOptions="${{ locale: 'en-GB' }}"
+          .modelValue="${1234.56}"
+        ></lion-input-stepper>
+      `);
+      expect(el.formattedValue).to.equal('1,234.56');
+      el = await fixture(html`
+        <lion-input-stepper
+          .formatOptions="${{ locale: 'nl-NL' }}"
+          .modelValue="${1234.56}"
+        ></lion-input-stepper>
+      `);
+      expect(el.formattedValue).to.equal('1.234,56');
+    });
+
+    it('supports overriding decimalSeparator in formatOptions', async () => {
+      const el = await fixture(
+        html`<lion-input-stepper
+          .formatOptions="${{ locale: 'nl-NL', decimalSeparator: '.' }}"
+          .modelValue="${12.34}"
+        ></lion-input-stepper>`,
+      );
+      expect(el.formattedValue).to.equal('12.34');
+    });
+
+    it('supports overriding groupSeparator in formatOptions', async () => {
+      const el = await fixture(
+        html`<lion-input-stepper
+          .formatOptions="${{ locale: 'nl-NL', groupSeparator: ',', decimalSeparator: '.' }}"
+          .modelValue="${1234.56}"
+        ></lion-input-stepper>`,
+      );
+      expect(el.formattedValue).to.equal('1,234.56');
+    });
+  });
+
   describe('User interaction', () => {
     it('should increment the value to 1 on [ArrowUp]', async () => {
       const el = await fixture(defaultInputStepper);
@@ -71,7 +116,7 @@ describe('<lion-input-stepper>', () => {
       expect(el.value).to.equal('');
       el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown' }));
       await el.updateComplete;
-      expect(el.value).to.equal('-1');
+      expect(el.value).to.equal('−1');
     });
 
     it('should increment the value to minValue on [ArrowDown] if value is below min', async () => {
@@ -95,7 +140,7 @@ describe('<lion-input-stepper>', () => {
       expect(el.value).to.equal('');
       const decrementButton = el.querySelector('[slot=prefix]');
       decrementButton?.dispatchEvent(new Event('click'));
-      expect(el.value).to.equal('-1');
+      expect(el.value).to.equal('−1');
     });
 
     it('fires one "user-input-changed" event on + button click', async () => {
@@ -143,7 +188,7 @@ describe('<lion-input-stepper>', () => {
       decrementButton?.dispatchEvent(new Event('focus'));
       decrementButton?.dispatchEvent(new Event('click'));
       decrementButton?.dispatchEvent(new Event('blur'));
-      expect(el.value).to.equal('-1');
+      expect(el.value).to.equal('−1');
       expect(blurSpy.calledOnce).to.be.true;
       expect(el.touched).to.be.true;
 

package/components/overlays/src/OverlayController.js

@@ -201,6 +201,8 @@ export class OverlayController extends EventTarget {
     this.__hasActiveBackdrop = true;
     /** @private */
     this.__escKeyHandler = this.__escKeyHandler.bind(this);
+    /** @private */
+    this.__cancelHandler = this.__cancelHandler.bind(this);
   }
 
   /**
@@ -510,6 +512,8 @@ export class OverlayController extends EventTarget {
       this.__contentHasBeenInitialized = true;
     }
 
+    this.__wrappingDialogNode?.addEventListener('cancel', this.__cancelHandler);
+
     // Reset all positioning styles (local, c.q. Popper) and classes (global)
     this.contentWrapperNode.removeAttribute('style');
     this.contentWrapperNode.removeAttribute('class');
@@ -1126,6 +1130,17 @@ export class OverlayController extends EventTarget {
     }
   }
 
+  /**
+   * When the overlay is a modal dialog hidesOnEsc works out of the box, so we prevent that.
+   *
+   * There is currently a bug in chrome that makes the dialog close when pressing Esc the second time
+   * @private
+   */
+  // eslint-disable-next-line class-methods-use-this
+  __cancelHandler(/** @type {Event} */ ev) {
+    ev.preventDefault();
+  }
+
   /** @private */
   __escKeyHandler(/** @type {KeyboardEvent} */ ev) {
     return ev.key === 'Escape' && this.hide();
@@ -1292,6 +1307,7 @@ export class OverlayController extends EventTarget {
   teardown() {
     this.__handleOverlayStyles({ phase: 'teardown' });
     this._handleFeatures({ phase: 'teardown' });
+    this.__wrappingDialogNode?.removeEventListener('cancel', this.__cancelHandler);
   }
 
   /** @private */

package/components/overlays/src/utils/deep-contains.js

@@ -1,20 +1,149 @@
+/**
+ * A number, or a string containing a number.
+ * @typedef {{element: HTMLElement; deepContains: boolean} | null} CacheItem
+ */
+
 /**
  * Whether first element contains the second element, also goes through shadow roots
  * @param {HTMLElement|ShadowRoot} el
  * @param {HTMLElement|ShadowRoot} targetEl
+ * @param {{[key: string]: CacheItem[]}} cache
  * @returns {boolean}
  */
-export function deepContains(el, targetEl) {
+export function deepContains(el, targetEl, cache = {}) {
+  /**
+   * @description A `Typescript` `type guard` for `HTMLElement`
+   * @param {Element|ShadowRoot} htmlElement
+   * @returns {htmlElement is HTMLElement}
+   */
+  function isHTMLElement(htmlElement) {
+    return 'getAttribute' in htmlElement;
+  }
+
+  /**
+   * @description Returns a cached item for the given element or null otherwise
+   * @param {HTMLElement|ShadowRoot} element
+   * @returns {CacheItem|null}
+   */
+  function getCachedItem(element) {
+    if (!isHTMLElement(element)) {
+      return null;
+    }
+    const slotName = element.getAttribute('slot');
+    /** @type {CacheItem|null} */
+    let result = null;
+    if (slotName) {
+      const cachedItemsWithSameName = cache[slotName];
+      if (cachedItemsWithSameName) {
+        result = cachedItemsWithSameName.filter(item => item?.element === element)[0] || null;
+      }
+    }
+    return result;
+  }
+
+  const cachedItem = getCachedItem(el);
+  if (cachedItem) {
+    return cachedItem.deepContains;
+  }
+
+  /**
+   * @description Cache an html element and its `deepContains` status
+   * @param {boolean} contains The `deepContains` status for the element
+   * @returns {void}
+   */
+  function cacheItem(contains) {
+    if (!isHTMLElement(el)) {
+      return;
+    }
+    const slotName = el.getAttribute('slot');
+    if (slotName) {
+      // eslint-disable-next-line no-param-reassign
+      cache[slotName] = cache[slotName] || [];
+      cache[slotName].push({ element: el, deepContains: contains });
+    }
+  }
+
   let containsTarget = el.contains(targetEl);
   if (containsTarget) {
+    cacheItem(true);
     return true;
   }
 
+  /**
+   * A `Typescript` `type guard` for `HTMLSlotElement`
+   * @param {HTMLElement|HTMLSlotElement} htmlElement
+   * @returns {htmlElement is HTMLSlotElement}
+   */
+  function isSlot(htmlElement) {
+    return htmlElement.tagName === 'SLOT';
+  }
+
+  /**
+   * Returns a slot projection or it returns `null` if `htmlElement` is not an `HTMLSlotElement`
+   * @example
+   * Let's say this is a custom element declared as follows:
+   * ```
+   * <custom-element>
+   *   shadowRoot
+   *     <div id="dialog-wrapper">
+   *       <div id="dialog-header">Header</div>
+   *       <div id="dialog-content">
+   *         <slot id="dialog-content-slot" name="content"></slot>
+   *       </div>
+   *     </div>
+   *   <!-- Light DOM -->
+   *   <div id="my-slot-content" slot="content">my content</div>
+   * </custom-element>
+   * ```
+   * Then for `slot#dialog-content-slot` which is defined in the ShadowDom the function returns `div#my-slot-content` which is defined in the LightDom
+   * @param {HTMLElement|HTMLSlotElement} htmlElement
+   * @returns {Element[]}
+   * */
+  function getSlotProjections(htmlElement) {
+    return isSlot(htmlElement) ? /** @type {Element[]}  */ (htmlElement.assignedElements()) : [];
+  }
+
+  /**
+   * @description A `Typescript` `type guard` for `ShadowRoot`
+   * @param {Element|ShadowRoot} htmlElement
+   * @returns {htmlElement is ShadowRoot}
+   */
+  function isShadowRoot(htmlElement) {
+    return htmlElement.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
+  }
+
+  /**
+   * Check whether any element contains target
+   * @param {(Element|ShadowRoot|null)[]} elements
+   * */
+  function checkElements(elements) {
+    let contains = false;
+    for (let i = 0; i < elements.length; i += 1) {
+      const element = elements[i];
+      if (
+        element &&
+        (isHTMLElement(element) || isShadowRoot(element)) &&
+        deepContains(element, targetEl, cache)
+      ) {
+        contains = true;
+        break;
+      }
+    }
+    return contains;
+  }
+
   /** @param {HTMLElement|ShadowRoot} elem */
   function checkChildren(elem) {
     for (let i = 0; i < elem.children.length; i += 1) {
       const child = /** @type {HTMLElement}  */ (elem.children[i]);
-      if (child.shadowRoot && deepContains(child.shadowRoot, targetEl)) {
+      const cachedChild = getCachedItem(child);
+      if (cachedChild) {
+        containsTarget = cachedChild.deepContains || containsTarget;
+        break;
+      }
+      const slotProjections = getSlotProjections(child);
+      const childSubElements = [child.shadowRoot, ...slotProjections];
+      if (checkElements(childSubElements)) {
         containsTarget = true;
         break;
       }
@@ -26,11 +155,13 @@ export function deepContains(el, targetEl) {
 
   // If element is not shadowRoot itself
   if (el instanceof HTMLElement && el.shadowRoot) {
-    containsTarget = deepContains(el.shadowRoot, targetEl);
+    containsTarget = deepContains(el.shadowRoot, targetEl, cache);
     if (containsTarget) {
+      cacheItem(true);
       return true;
     }
   }
   checkChildren(el);
+  cacheItem(containsTarget);
   return containsTarget;
 }

package/components/overlays/test/OverlayController.test.js

@@ -585,6 +585,17 @@ describe('OverlayController', () => {
         expect(ctrl.isShown).to.be.false;
       });
 
+      it("doesn't hide when [escape] is pressed and hidesOnEsc is set to false", async () => {
+        const ctrl = new OverlayController({
+          ...withGlobalTestConfig(),
+          hidesOnEsc: false,
+        });
+        await ctrl.show();
+        ctrl.contentNode.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape' }));
+        await aTimeout(0);
+        expect(ctrl.isShown).to.be.true;
+      });
+
       it('stays shown when [escape] is pressed on outside element', async () => {
         const ctrl = new OverlayController({
           ...withGlobalTestConfig(),

package/components/overlays/test/utils-tests/deep-contains.test.js

@@ -124,4 +124,102 @@ describe('deepContains()', () => {
     expect(deepContains(element, elementFirstChildShadowChildShadow)).to.be.true;
     expect(deepContains(element, elementFirstChildShadowChildShadowLastChild)).to.be.true;
   });
+
+  it('returns true if the element, which is located in ShadowsRoot, contains a target element, located in the LightDom', async () => {
+    const mainElement = /** @type {HTMLElement} */ (await fixture('<div id="main"></div>'));
+    mainElement.innerHTML = `      
+      <div slot="content" id="light-el-content">
+        <input type="text" id="light-el-input-1"></input>
+      </div>
+      <div slot="content" id="light-el-content">
+        <input type="text" id="light-el-input-2"></input>
+      </div>
+    `;
+    const shadowRoot = mainElement.attachShadow({ mode: 'open' });
+    shadowRoot.innerHTML = `
+      <div id="dialog-wrapper">
+        <div id="dialog-header">
+          Header          
+        </div>  
+        <div id="dialog-content">
+          <slot name="content" id="shadow-el-content"></slot>
+        </div>  
+      </div>      
+    `;
+    const inputElement = /** @type {HTMLElement} */ (
+      mainElement.querySelector('#light-el-input-2')
+    );
+    const dialogWrapperElement = /** @type {HTMLElement} */ (
+      shadowRoot.querySelector('#dialog-wrapper')
+    );
+    expect(deepContains(dialogWrapperElement, inputElement)).to.be.true;
+  });
+
+  it(`returns true if the element, which is located in ShadowRoot, contains a target element, located in the ShadowRoot element of the LightDom element  `, async () => {
+    /**
+     * The DOM for the `main` element looks as follows:
+     *
+     * <div id="main">
+     *   #shadow-root
+     *     <div id="dialog-wrapper">                                        // dialogWrapperElement
+     *       <div id="dialog-header">
+     *         Header
+     *       </div>
+     *       <div id="dialog-content">
+     *         <slot name="content" id="shadow-el-content"></slot>
+     *       </div>
+     *     </div>
+     *   <div slot="content" id="light-el-content">
+     *     <div id="conent-wrapper">
+     *       #shadow-root
+     *         <div id="conent-wrapper-sub">
+     *           #shadow-root
+     *             <input type="type" id="content-input"></input>           //inputElement
+     *         </div>
+     *     </div>
+     *   </div>
+     * </div>
+     */
+    const mainElement = /** @type {HTMLElement} */ (await fixture('<div id="main"></div>'));
+    mainElement.innerHTML = `      
+      <div slot="content" id="light-el-content">
+        <div id="content-wrapper"></div>
+      </div>
+      <div slot="content" id="light-el-content">
+        <div id="content-wrapper"></div>
+      </div>
+    `;
+    const contentWrapper = /** @type {HTMLElement} */ (
+      mainElement.querySelector('#content-wrapper')
+    );
+    const contentWrapperShadowRoot = contentWrapper.attachShadow({ mode: 'open' });
+    contentWrapperShadowRoot.innerHTML = `
+      <div id="conent-wrapper-sub"></div>
+    `;
+    const contentWrapperSub = /** @type {HTMLElement} */ (
+      contentWrapperShadowRoot.querySelector('#conent-wrapper-sub')
+    );
+    const contentWrapperSubShadowRoot = contentWrapperSub.attachShadow({ mode: 'open' });
+    contentWrapperSubShadowRoot.innerHTML = `
+      <input type="type" id="content-input"></input>
+    `;
+    const inputElement = /** @type {HTMLElement} */ (
+      contentWrapperSubShadowRoot.querySelector('#content-input')
+    );
+    const mainElementShadowRoot = mainElement.attachShadow({ mode: 'open' });
+    mainElementShadowRoot.innerHTML = `
+      <div id="dialog-wrapper">
+        <div id="dialog-header">
+          Header          
+        </div>  
+        <div id="dialog-content">
+          <slot name="content" id="shadow-el-content"></slot>
+        </div>  
+      </div>      
+    `;
+    const dialogWrapperElement = /** @type {HTMLElement} */ (
+      mainElementShadowRoot.querySelector('#dialog-wrapper')
+    );
+    expect(deepContains(dialogWrapperElement, inputElement)).to.be.true;
+  });
 });

package/custom-elements.json

@@ -91207,6 +91207,38 @@
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
               },
+              "default": "parseNumber",
+              "privacy": "public"
+            },
+            {
+              "kind": "field",
+              "name": "formatter",
+              "parameters": [
+                {
+                  "name": "v",
+                  "description": "modelValue: can be an Object, Number, String depending on the\ninput type(date, number, email etc)",
+                  "type": {
+                    "text": "*"
+                  }
+                },
+                {
+                  "name": "opts",
+                  "type": {
+                    "text": "FormatOptions"
+                  }
+                }
+              ],
+              "description": "Converts modelValue to formattedValue (formattedValue will be synced with\n`._inputNode.value`)\nFor instance, a Date object to a localized date.",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "default": "formatNumber",
               "privacy": "public"
             },
             {
@@ -91403,36 +91435,6 @@
               },
               "privacy": "public"
             },
-            {
-              "kind": "method",
-              "name": "formatter",
-              "parameters": [
-                {
-                  "name": "v",
-                  "description": "modelValue: can be an Object, Number, String depending on the\ninput type(date, number, email etc)",
-                  "type": {
-                    "text": "*"
-                  }
-                },
-                {
-                  "name": "opts",
-                  "type": {
-                    "text": "FormatOptions"
-                  }
-                }
-              ],
-              "description": "Converts modelValue to formattedValue (formattedValue will be synced with\n`._inputNode.value`)\nFor instance, a Date object to a localized date.",
-              "return": {
-                "type": {
-                  "text": "string"
-                }
-              },
-              "inheritedFrom": {
-                "name": "LionField",
-                "module": "components/form-core/src/LionField.js"
-              },
-              "privacy": "public"
-            },
             {
               "kind": "method",
               "name": "serializer",
@@ -114681,6 +114683,17 @@
               ],
               "privacy": "public"
             },
+            {
+              "kind": "method",
+              "name": "__cancelHandler",
+              "parameters": [
+                {
+                  "name": "ev"
+                }
+              ],
+              "description": "When the overlay is a modal dialog hidesOnEsc works out of the box, so we prevent that.\n\nThere is currently a bug in chrome that makes the dialog close when pressing Esc the second time",
+              "privacy": "private"
+            },
             {
               "kind": "method",
               "name": "__escKeyHandler",
@@ -115682,6 +115695,13 @@
               "type": {
                 "text": "HTMLElement|ShadowRoot"
               }
+            },
+            {
+              "name": "cache",
+              "default": "{}",
+              "type": {
+                "text": "{[key: string]: CacheItem[]}"
+              }
             }
           ],
           "description": "Whether first element contains the second element, also goes through shadow roots",

package/dist-types/components/form/src/LionForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LionForm.d.ts","sourceRoot":"","sources":["../../../../components/form/src/LionForm.js"],"names":[],"mappings":"AAYA;;;;GAIG;AAEH;IAoCE;;;OAGG;IACH,sBAHW,KAAK,QAYf;IAUD;;;OAGG;IACH,qBAHW,KAAK,QAQf;IA3DD,0BAMC;IAOD,iCAEC;IAED,eAQC;IAiBD,cAMC;IAaD;;;OAGG;IACH,wDAHW,iBAAiB,QAa3B;IAED,eAAe;IACf,oCAGC;IAED,eAAe;IACf,oCAGC;CACF;gCAhHY,OAAO,+DAA+D,EAAE,iBAAiB"}
+{"version":3,"file":"LionForm.d.ts","sourceRoot":"","sources":["../../../../components/form/src/LionForm.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AAEH;IAoCE;;;OAGG;IACH,sBAHW,KAAK,QAYf;IAUD;;;OAGG;IACH,qBAHW,KAAK,QAQf;IA3DD,0BAMC;IAOD,iCAEC;IAED,eAQC;IAiBD,cAMC;IAaD;;;OAGG;IACH,wDAHW,iBAAiB,QAa3B;IAED,eAAe;IACf,oCAGC;IAED,eAAe;IACf,oCAGC;CACF;gCAzHY,OAAO,+DAA+D,EAAE,iBAAiB"}

package/dist-types/components/form/test/lion-form.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lion-form.test.d.ts","sourceRoot":"","sources":["../../../../components/form/test/lion-form.test.js"],"names":[],"mappings":"uBAmBa,OAAO,oBAAoB,EAAE,QAAQ;6BACrC,OAAO,KAAK,EAAE,cAAc"}
+{"version":3,"file":"lion-form.test.d.ts","sourceRoot":"","sources":["../../../../components/form/test/lion-form.test.js"],"names":[],"mappings":"uBAoBa,OAAO,oBAAoB,EAAE,QAAQ;6BACrC,OAAO,KAAK,EAAE,cAAc"}