@daikin-oss/design-system-web-components 0.4.0 → 0.5.0

package/dist/cjs/components/dropdown/daikin-dropdown.d.ts

@@ -0,0 +1,100 @@
+import { LitElement, PropertyValues } from 'lit';
+import { DaikinInputGroup } from '../input-group';
+/**
+ * A dropdown list component.
+ *
+ * Hierarchy:
+ * - `daikin-dropdown` > `daikin-dropdown-item`
+ * - `daikin-input-group` > `daikin-dropdown` > `daikin-dropdown-item`
+ *
+ * @fires change - A custom event emitted when a user selects a dropdown item.
+ *
+ * @slot - Dropdown item list slot. Place `daikin-dropdown-item` elements here.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-dropdown label="Dropdown label">
+ *   <daikin-dropdown-item value="value1">Dropdown item 1</daikin-dropdown-item>
+ *   <daikin-dropdown-item value="value2">Dropdown item 2</daikin-dropdown-item>
+ *   <daikin-dropdown-item value="value3" disabled>Dropdown item 3</daikin-dropdown-item>
+ * </daikin-dropdown>
+ * ```
+ */
+export declare class DaikinDropdown extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    static readonly formAssociated = true;
+    private _internals;
+    /**
+     * Label of the dropdown.
+     */
+    label: string | null;
+    /**
+     * Form value of the dropdown.
+     * `null` if not selected.
+     */
+    value: string | null;
+    /**
+     * Placeholder text of the dropdown.
+     */
+    placeholder: string;
+    /**
+     * Whether the dropdown is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Whether the dropdown is required.
+     */
+    required: boolean;
+    /**
+     * Whether the dropdown is in an error state.
+     */
+    error: boolean;
+    /**
+     * Whether the dropdown menu is opened.
+     */
+    open: boolean;
+    private readonly _items;
+    private _button;
+    private _popover;
+    private _hasSelectedItem;
+    private _selectedItemLabel;
+    private _autoUpdateController;
+    private _clickOutsideController;
+    /**
+     * Last focused dropdown item.
+     * The next time the dropdown opens, the focus will be moved to this element.
+     */
+    private _lastFocusedItem;
+    private _updateFormValue;
+    private _onClickOutside;
+    private _reflectItemsAndLabel;
+    private _handleClick;
+    private _searchItem;
+    private _handleKeyDownEscape;
+    private _moveFocus;
+    private _handleKeyDown;
+    /**
+     * Handle `select` event from `daikin-dropdown-item`.
+     */
+    private _handleSelect;
+    /**
+     * Handle `focusin` event to remember last focused item.
+     */
+    private _handleFocusIn;
+    /**
+     * Handle `floating-ready` event dispatched by `FloatingUIAutoUpdateController`.
+     * The dropdown menu opens after the Floating UI has finished calculating its position, so there is a slight time lag between the change to `this.open` and the actual display.
+     * Since the focus cannot be moved until the element is displayed on the screen, the focus is moved to the item after receiving the completion of the Floating UI position calculation here.
+     */
+    private _handleFloatingReady;
+    render(): import('lit-html').TemplateResult<1>;
+    focus(options?: FocusOptions): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    reflectInputGroup(inputGroup: DaikinInputGroup): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-dropdown": DaikinDropdown;
+    }
+}

package/dist/cjs/components/dropdown/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const daikinDropdown = require("./daikin-dropdown.cjs");
+Object.defineProperty(exports, "DaikinDropdown", {
+  enumerable: true,
+  get: () => daikinDropdown.DaikinDropdown
+});

package/dist/cjs/components/dropdown/index.d.ts

@@ -0,0 +1 @@
+export * from './daikin-dropdown';

package/dist/cjs/components/dropdown-item/daikin-dropdown-item.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const classVarianceAuthority = require("class-variance-authority");
+const lit = require("lit");
+const decorators_js = require("lit/decorators.js");
+const tailwind = require("../../tailwind.css.cjs");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+const cvaOption = classVarianceAuthority.cva(
+  [
+    "flex",
+    "items-center",
+    "justify-between",
+    "w-full",
+    "min-h-12",
+    "text-system-element-text-primary",
+    "bg-system-element-text-inverse",
+    "p-3",
+    "font-daikinSerif",
+    "leading-5",
+    "text-left",
+    "focus-visible:outline",
+    "focus-visible:outline-2",
+    "focus-visible:-outline-offset-2",
+    "focus-visible:outline-system-state-focus",
+    "disabled:text-system-state-disabled"
+  ],
+  {
+    variants: {
+      selected: {
+        false: [
+          "enabled:hover:bg-system-background-surface-hover",
+          "enabled:active:bg-system-background-surface-press"
+        ],
+        true: [
+          "enabled:bg-system-background-surface-selected",
+          "enabled:hover:bg-system-background-surface-selectedHover",
+          "enabled:active:bg-system-background-surface-selectedActive",
+          "after:i-daikin-dropdown-check",
+          "after:size-6"
+        ]
+      }
+    }
+  }
+);
+exports.DaikinDropdownItem = class DaikinDropdownItem extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.value = "";
+    this.disabled = false;
+    this.selected = false;
+  }
+  _handleClick() {
+    if (this.disabled) {
+      return;
+    }
+    this.dispatchEvent(
+      new Event("select", {
+        bubbles: true
+      })
+    );
+  }
+  render() {
+    return lit.html`<button
+      type="button"
+      class=${cvaOption({ selected: this.selected })}
+      data-value=${this.value}
+      role="option"
+      aria-selected=${this.selected}
+      tabindex="-1"
+      ?disabled=${this.disabled}
+      @click=${this._handleClick}
+    >
+      <slot></slot>
+    </button>`;
+  }
+  focus(options) {
+    var _a;
+    (_a = this._button) == null ? void 0 : _a.focus(options);
+  }
+};
+exports.DaikinDropdownItem.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: block;
+      width: 100%;
+    }
+  `;
+__decorateClass([
+  decorators_js.property({ type: String })
+], exports.DaikinDropdownItem.prototype, "value", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinDropdownItem.prototype, "disabled", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinDropdownItem.prototype, "selected", 2);
+__decorateClass([
+  decorators_js.query("button")
+], exports.DaikinDropdownItem.prototype, "_button", 2);
+exports.DaikinDropdownItem = __decorateClass([
+  decorators_js.customElement("daikin-dropdown-item")
+], exports.DaikinDropdownItem);

package/dist/cjs/components/dropdown-item/daikin-dropdown-item.d.ts

@@ -0,0 +1,42 @@
+import { LitElement } from 'lit';
+/**
+ * The dropdown item (option) component that can be used within `daikin-dropdown` component.
+ *
+ * Hierarchy:
+ * - `daikin-dropdown` > `daikin-dropdown-item`
+ *
+ * @fires select - A custom event emitted when a user clicks the item. For internal use (`daikin-dropdown`).
+ *
+ * @slot - A slot for the item content.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-dropdown-item value="value">Dropdown item</daikin-dropdown-item>
+ * ```
+ */
+export declare class DaikinDropdownItem extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    /**
+     * Form value of the dropdown item.
+     */
+    value: string;
+    /**
+     * Whether the dropdown item is disabled
+     */
+    disabled: boolean;
+    /**
+     * Whether the dropdown item is selected.
+     * Set automatically by `daikin-dropdown` component.
+     */
+    selected: boolean;
+    private _button;
+    private _handleClick;
+    render(): import('lit-html').TemplateResult<1>;
+    focus(options?: FocusOptions): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-dropdown-item": DaikinDropdownItem;
+    }
+}

package/dist/cjs/components/dropdown-item/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const daikinDropdownItem = require("./daikin-dropdown-item.cjs");
+Object.defineProperty(exports, "DaikinDropdownItem", {
+  enumerable: true,
+  get: () => daikinDropdownItem.DaikinDropdownItem
+});

package/dist/cjs/components/dropdown-item/index.d.ts

@@ -0,0 +1 @@
+export * from './daikin-dropdown-item';

package/dist/cjs/components/icon/icons.json.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const icons = {
   alarm: {
-    "class": "i-daikin-notification-status-alarm",
+    "class": "i-daikin-status-alarm",
     color: null
   },
   close: {
@@ -10,24 +10,28 @@ const icons = {
     color: "#a0a0a0"
   },
   information: {
-    "class": "i-daikin-notification-status-information",
+    "class": "i-daikin-status-information",
     color: null
   },
   negative: {
-    "class": "i-daikin-notification-status-negative",
+    "class": "i-daikin-status-negative",
     color: null
   },
   positive: {
-    "class": "i-daikin-notification-status-positive",
+    "class": "i-daikin-status-positive",
     color: null
   },
   warning: {
-    "class": "i-daikin-notification-status-warning",
+    "class": "i-daikin-status-warning",
     color: null
   },
+  success: {
+    "class": "i-daikin-status-success",
+    color: "#0097E0"
+  },
   error: {
     "class": "i-daikin-status-error",
-    color: "#ff4949"
+    color: "#FF4949"
   },
   "chevron-up": {
     "class": "i-daikin-chevron-up",

package/dist/cjs/components/icon/icons.json.d.ts

@@ -1,7 +1,7 @@
 declare const _default: {
   "icons": {
     "alarm": {
-      "class": "i-daikin-notification-status-alarm",
+      "class": "i-daikin-status-alarm",
       "color": null
     },
     "close": {
@@ -9,24 +9,28 @@ declare const _default: {
       "color": "#a0a0a0"
     },
     "information": {
-      "class": "i-daikin-notification-status-information",
+      "class": "i-daikin-status-information",
       "color": null
     },
     "negative": {
-      "class": "i-daikin-notification-status-negative",
+      "class": "i-daikin-status-negative",
       "color": null
     },
     "positive": {
-      "class": "i-daikin-notification-status-positive",
+      "class": "i-daikin-status-positive",
       "color": null
     },
     "warning": {
-      "class": "i-daikin-notification-status-warning",
+      "class": "i-daikin-status-warning",
       "color": null
     },
+    "success": {
+      "class": "i-daikin-status-success",
+      "color": "#0097E0"
+    },
     "error": {
       "class": "i-daikin-status-error",
-      "color": "#ff4949"
+      "color": "#FF4949"
     },
     "chevron-up": {
       "class": "i-daikin-chevron-up",

package/dist/cjs/components/index.cjs

@@ -6,18 +6,23 @@ const daikinBreadcrumb = require("./breadcrumb/daikin-breadcrumb.cjs");
 const daikinBreadcrumbItem = require("./breadcrumb-item/daikin-breadcrumb-item.cjs");
 const daikinButton = require("./button/daikin-button.cjs");
 const daikinCheckbox = require("./checkbox/daikin-checkbox.cjs");
+const daikinDropdown = require("./dropdown/daikin-dropdown.cjs");
+const daikinDropdownItem = require("./dropdown-item/daikin-dropdown-item.cjs");
 const daikinIcon = require("./icon/daikin-icon.cjs");
 const daikinInputGroup = require("./input-group/daikin-input-group.cjs");
 const daikinList = require("./list/daikin-list.cjs");
 const daikinListItem = require("./list-item/daikin-list-item.cjs");
 const daikinNotification = require("./notification/daikin-notification.cjs");
 const daikinProgressBar = require("./progress-bar/daikin-progress-bar.cjs");
+const daikinProgressIndicator = require("./progress-indicator/daikin-progress-indicator.cjs");
+const daikinProgressIndicatorItem = require("./progress-indicator-item/daikin-progress-indicator-item.cjs");
 const daikinRadio = require("./radio/daikin-radio.cjs");
+const daikinSelect = require("./select/daikin-select.cjs");
 const daikinTab = require("./tab/daikin-tab.cjs");
 const daikinTabPanels = require("./tab-panels/daikin-tab-panels.cjs");
 const daikinTabs = require("./tabs/daikin-tabs.cjs");
-const daikinTextInput = require("./text-input/daikin-text-input.cjs");
-const daikinTextarea = require("./textarea/daikin-textarea.cjs");
+const daikinTextArea = require("./text-area/daikin-text-area.cjs");
+const daikinTextField = require("./text-field/daikin-text-field.cjs");
 const daikinToggle = require("./toggle/daikin-toggle.cjs");
 const daikinTooltip = require("./tooltip/daikin-tooltip.cjs");
 Object.defineProperty(exports, "DaikinAccordion", {
@@ -44,6 +49,14 @@ Object.defineProperty(exports, "DaikinCheckbox", {
   enumerable: true,
   get: () => daikinCheckbox.DaikinCheckbox
 });
+Object.defineProperty(exports, "DaikinDropdown", {
+  enumerable: true,
+  get: () => daikinDropdown.DaikinDropdown
+});
+Object.defineProperty(exports, "DaikinDropdownItem", {
+  enumerable: true,
+  get: () => daikinDropdownItem.DaikinDropdownItem
+});
 Object.defineProperty(exports, "DaikinIcon", {
   enumerable: true,
   get: () => daikinIcon.DaikinIcon
@@ -69,10 +82,22 @@ Object.defineProperty(exports, "DaikinProgressBar", {
   enumerable: true,
   get: () => daikinProgressBar.DaikinProgressBar
 });
+Object.defineProperty(exports, "DaikinProgressIndicator", {
+  enumerable: true,
+  get: () => daikinProgressIndicator.DaikinProgressIndicator
+});
+Object.defineProperty(exports, "DaikinProgressIndicatorItem", {
+  enumerable: true,
+  get: () => daikinProgressIndicatorItem.DaikinProgressIndicatorItem
+});
 Object.defineProperty(exports, "DaikinRadio", {
   enumerable: true,
   get: () => daikinRadio.DaikinRadio
 });
+Object.defineProperty(exports, "DaikinSelect", {
+  enumerable: true,
+  get: () => daikinSelect.DaikinSelect
+});
 Object.defineProperty(exports, "DaikinTab", {
   enumerable: true,
   get: () => daikinTab.DaikinTab
@@ -85,13 +110,13 @@ Object.defineProperty(exports, "DaikinTabs", {
   enumerable: true,
   get: () => daikinTabs.DaikinTabs
 });
-Object.defineProperty(exports, "DaikinTextInput", {
+Object.defineProperty(exports, "DaikinTextArea", {
   enumerable: true,
-  get: () => daikinTextInput.DaikinTextInput
+  get: () => daikinTextArea.DaikinTextArea
 });
-Object.defineProperty(exports, "DaikinTextarea", {
+Object.defineProperty(exports, "DaikinTextField", {
   enumerable: true,
-  get: () => daikinTextarea.DaikinTextarea
+  get: () => daikinTextField.DaikinTextField
 });
 Object.defineProperty(exports, "DaikinToggle", {
   enumerable: true,

package/dist/cjs/components/index.d.ts

@@ -4,17 +4,22 @@ export * from './breadcrumb';
 export * from './breadcrumb-item';
 export * from './button';
 export * from './checkbox';
+export * from './dropdown';
+export * from './dropdown-item';
 export * from './icon';
 export * from './input-group';
 export * from './list';
 export * from './list-item';
 export * from './notification';
 export * from './progress-bar';
+export * from './progress-indicator';
+export * from './progress-indicator-item';
 export * from './radio';
+export * from './select';
 export * from './tab';
 export * from './tab-panels';
 export * from './tabs';
-export * from './text-input';
-export * from './textarea';
+export * from './text-area';
+export * from './text-field';
 export * from './toggle';
 export * from './tooltip';

package/dist/cjs/components/input-group/daikin-input-group.cjs

@@ -15,64 +15,116 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
-const cvaLabel = classVarianceAuthority.cva(["text-base", "font-bold"], {
+const cvaLabel = classVarianceAuthority.cva(["flex", "items-center", "font-bold", "leading-5"], {
   variants: {
-    variant: {
-      enabled: ["text-daikinNeutral-800"],
-      disabled: ["text-daikinNeutral-200"]
-    },
-    required: {
-      optional: [],
-      required: ["after:content-['*']", "after:ml-[2px]"]
+    disabled: {
+      false: [],
+      true: ["text-system-state-disabled"]
     }
   }
 });
-const cvaHelper = classVarianceAuthority.cva(["h-[22px]", "text-xs"], {
+const cvaHelper = classVarianceAuthority.cva(
+  ["flex", "gap-1", "items-center", "leading-5", "text-sm"],
+  {
+    variants: {
+      type: {
+        helper: [],
+        helperDisabled: ["text-system-state-disabled"],
+        error: [
+          "text-system-state-error-active",
+          "font-bold",
+          "before:size-4",
+          "before:i-daikin-status-error"
+        ],
+        none: ["hidden"]
+      }
+    }
+  }
+);
+const cvaCounter = classVarianceAuthority.cva(["text-sm", "font-bold"], {
+  variants: {
+    disabled: {
+      false: ["text-system-element-text-secondary"],
+      true: ["text-system-state-disabled"]
+    }
+  }
+});
+const cvaCounterValueLength = classVarianceAuthority.cva([], {
   variants: {
-    variant: {
-      enabled: ["text-daikinNeutral-800"],
-      disabled: ["text-daikinNeutral-200"]
+    error: {
+      false: [],
+      true: ["text-system-state-error-active"]
     }
   }
 });
 exports.DaikinInputGroup = class DaikinInputGroup extends lit.LitElement {
   constructor() {
     super(...arguments);
+    this.label = null;
+    this.helper = null;
+    this.required = null;
+    this.error = null;
     this.disabled = false;
-    this.required = false;
-    this.error = "";
-    this.textareaCounter = false;
+    this.textareaMaxCount = null;
+    this._textareaCount = null;
   }
   _handleSlotChange() {
     this._reflectSlotProperties();
+    const textarea = this._textareas[0];
+    this._textareaCount = (textarea == null ? void 0 : textarea.count) ?? null;
+  }
+  _handleInput(event) {
+    if (event.target.tagName === "DAIKIN-TEXT-AREA") {
+      this._textareaCount = event.target.count;
+    }
   }
   _reflectSlotProperties() {
-    const isError = !this.disabled && !!this.error;
     for (const control of this._controls) {
-      control.disabled = !!this.disabled;
-      control.error = isError;
-    }
-    for (const item of this._textareas) {
-      item.counter = this.textareaCounter;
+      control.reflectInputGroup(this);
     }
   }
   render() {
-    const inputGroupLabelClassName = cvaLabel({
-      variant: this.disabled ? "disabled" : "enabled",
-      required: this.required ? "required" : "optional"
-    });
-    const inputGroupHelperClassName = cvaHelper({
-      variant: this.disabled ? "disabled" : "enabled"
-    });
+    const helperType = this.error && !this.disabled ? "error" : this.helper ? this.disabled ? "helperDisabled" : "helper" : "none";
+    const helperText = {
+      error: this.error,
+      helper: this.helper,
+      helperDisabled: this.helper,
+      none: ""
+    }[helperType];
     return lit.html`<fieldset class="content" ?disabled=${this.disabled}>
-      <label class="flex flex-col justify-center w-max gap-1 font-daikinSerif">
-        ${this.label ? lit.html`<span class=${inputGroupLabelClassName}>${this.label}</span>` : null}
-        <slot @slotchange=${this._handleSlotChange}></slot>
-        ${this.helper && !this.error ? lit.html`<span class=${inputGroupHelperClassName}>${this.helper}</span>` : null}
-        ${!this.disabled && !!this.error ? lit.html`<span
-              class="flex gap-2 text-[--input-group-border-color-error] leading-[22px] before:i-daikin-status-error before:block before:w-[16px] before:h-[22px]"
-              >${this.error}</span
-            >` : null}
+      <label
+        class="flex flex-col justify-center gap-2 w-full text-system-element-text-primary font-daikinSerif"
+      >
+        <div class="flex justify-between items-center gap-2">
+          <div class="flex items-center gap-1 font-bold">
+            ${this.label ? lit.html`<span class=${cvaLabel({ disabled: this.disabled })}>
+                  ${this.label}
+                </span>` : lit.nothing}
+            ${this.required && !this.disabled ? lit.html`<span class="text-system-state-error-active text-xs">
+                  ${this.required}
+                </span>` : lit.nothing}
+          </div>
+          ${this.textareaMaxCount != null && this._textareaCount != null ? lit.html`
+                <span class=${cvaCounter({ disabled: this.disabled })}>
+                  <span
+                    class=${cvaCounterValueLength({
+      error: this.textareaMaxCount < this._textareaCount
+    })}
+                    >${this._textareaCount}</span
+                  ><span>/</span><span>${this.textareaMaxCount}</span>
+                </span>
+              ` : lit.nothing}
+        </div>
+        <span
+          class=${cvaHelper({ type: helperType })}
+          aria-live=${helperType === "error" ? "polite" : "off"}
+        >
+          ${helperText}
+        </span>
+        <slot
+          @slotchange=${this._handleSlotChange}
+          @input=${this._handleInput}
+        ></slot>
       </label>
     </fieldset>`;
   }
@@ -87,33 +139,38 @@ exports.DaikinInputGroup.styles = lit.css`
       --input-group-border-color-error: ${lit.unsafeCSS(variables_js.colorFeedbackNegative)};
 
       display: block;
-      width: max-content;
+      width: 100%;
     }
   `;
 __decorateClass([
-  decorators_js.property({ type: String })
+  decorators_js.property({ type: String, reflect: true })
 ], exports.DaikinInputGroup.prototype, "label", 2);
 __decorateClass([
-  decorators_js.property({ type: String })
+  decorators_js.property({ type: String, reflect: true })
 ], exports.DaikinInputGroup.prototype, "helper", 2);
 __decorateClass([
-  decorators_js.property({ type: Boolean, reflect: true })
-], exports.DaikinInputGroup.prototype, "disabled", 2);
-__decorateClass([
-  decorators_js.property({ type: Boolean, reflect: true })
+  decorators_js.property({ type: String, reflect: true })
 ], exports.DaikinInputGroup.prototype, "required", 2);
 __decorateClass([
   decorators_js.property({ type: String, reflect: true })
 ], exports.DaikinInputGroup.prototype, "error", 2);
 __decorateClass([
   decorators_js.property({ type: Boolean, reflect: true })
-], exports.DaikinInputGroup.prototype, "textareaCounter", 2);
+], exports.DaikinInputGroup.prototype, "disabled", 2);
 __decorateClass([
-  decorators_js.queryAssignedElements({ selector: "daikin-textarea" })
+  decorators_js.property({ type: Number, reflect: true, attribute: "textarea-max-count" })
+], exports.DaikinInputGroup.prototype, "textareaMaxCount", 2);
+__decorateClass([
+  decorators_js.queryAssignedElements({ selector: "daikin-text-area" })
 ], exports.DaikinInputGroup.prototype, "_textareas", 2);
 __decorateClass([
-  decorators_js.queryAssignedElements({ selector: "daikin-text-input,daikin-textarea" })
+  decorators_js.queryAssignedElements({
+    selector: "daikin-dropdown,daikin-select,daikin-text-field,daikin-text-area,daikin-radio-group"
+  })
 ], exports.DaikinInputGroup.prototype, "_controls", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.DaikinInputGroup.prototype, "_textareaCount", 2);
 exports.DaikinInputGroup = __decorateClass([
   decorators_js.customElement("daikin-input-group")
 ], exports.DaikinInputGroup);