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

package/dist/cjs-dev/components/select/daikin-select.cjs

@@ -0,0 +1,160 @@
+"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 cvaSelect = classVarianceAuthority.cva(
+  [
+    "block",
+    "w-full",
+    "h-full",
+    "relative",
+    "after:i-daikin-dropdown-chevron-down",
+    "after:w-6",
+    "after:h-6",
+    "after:m-auto",
+    "after:absolute",
+    "after:top-0",
+    "after:bottom-0",
+    "after:right-3",
+    "after:pointer-events-none",
+    "slotted-[select]:!appearance-none",
+    "slotted-[select]:!flex",
+    "slotted-[select]:!items-center",
+    "slotted-[select]:!gap-2",
+    "slotted-[select]:!w-full",
+    "slotted-[select]:!h-full",
+    "slotted-[select]:!min-h-12",
+    "slotted-[select]:!pl-4",
+    "slotted-[select]:!pr-12",
+    "slotted-[select]:!text-base",
+    "slotted-[select]:!font-daikinSerif",
+    "slotted-[select]:!border",
+    "slotted-[select]:!border-[--color-base]",
+    "slotted-[select]:!rounded-md",
+    "slotted-[select]:!font-daikinSerif",
+    "slotted-[select]:!leading-5",
+    "slotted-[select]:!outline",
+    "slotted-[select]:!outline-0",
+    "slotted-[select]:!-outline-offset-2",
+    "slotted-[select:focus-visible]:!outline-2",
+    "slotted-[select:focus-visible]:!outline-[--color-focus]",
+    "slotted-[select:enabled]:!cursor-pointer",
+    "slotted-[select:enabled]:!text-daikinNeutral-800",
+    "slotted-[select:enabled:hover]:!bg-[#f2f2f2]",
+    "slotted-[select:enabled:active]:!bg-daikinNeutral-100",
+    "slotted-[select:disabled]:!text-daikinNeutral-200",
+    "slotted-[select:disabled]:!border-daikinNeutral-200"
+  ],
+  {
+    variants: {
+      disabled: {
+        false: ["after:text-daikinNeutral-900"],
+        true: ["after:text-daikinNeutral-200"]
+      },
+      error: {
+        false: [
+          "var-color-daikinNeutral-600/color-base",
+          "var-color-daikinBlue-700/color-focus"
+        ],
+        true: [
+          "var-color-daikinRed-500/color-base",
+          "var-color-daikinRed-500/color-focus"
+        ]
+      }
+    }
+  }
+);
+exports.DaikinSelect = class DaikinSelect extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.error = false;
+    this.required = false;
+    this.disabled = false;
+  }
+  get _select() {
+    return this._selects[0] ?? null;
+  }
+  _updateSelect() {
+    const select = this._select;
+    if (select) {
+      select.disabled = this.disabled;
+    }
+  }
+  _handleSlotChange() {
+    this._updateSelect();
+  }
+  render() {
+    return lit.html`<slot
+      class=${cvaSelect({ disabled: this.disabled, error: this.error })}
+      @slotchange=${this._handleSlotChange}
+    ></slot>`;
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("disabled")) {
+      this._updateSelect();
+    }
+  }
+  reflectInputGroup(inputGroup) {
+    const isError = !inputGroup.disabled && !!inputGroup.error;
+    this.disabled = !!inputGroup.disabled;
+    this.required = !!inputGroup.required;
+    this.error = isError;
+  }
+  /**
+   * Focuses on the `<select>` element in the slot.
+   * @param options focus options
+   */
+  focus(options) {
+    var _a;
+    (_a = this._select) == null ? void 0 : _a.focus(options);
+  }
+};
+exports.DaikinSelect.styles = lit.css`
+    ::slotted(select) {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+      border: 0 solid;
+
+      font: inherit;
+      font-feature-settings: inherit;
+      font-variation-settings: inherit;
+      letter-spacing: inherit;
+      color: inherit;
+      background: transparent;
+    }
+
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: block;
+      width: 100%;
+    }
+  `;
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinSelect.prototype, "error", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinSelect.prototype, "required", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinSelect.prototype, "disabled", 2);
+__decorateClass([
+  decorators_js.queryAssignedElements({ selector: "select" })
+], exports.DaikinSelect.prototype, "_selects", 2);
+exports.DaikinSelect = __decorateClass([
+  decorators_js.customElement("daikin-select")
+], exports.DaikinSelect);

package/dist/cjs-dev/components/select/daikin-select.d.ts

@@ -0,0 +1,60 @@
+import { LitElement, PropertyValues } from 'lit';
+import { DaikinInputGroup } from '../input-group';
+/**
+ * A select component.
+ * This component accepts an HTML `<select>` element in the slot and applies styles to it.
+ * The `disabled` property of the component is also reflected in the `<select>` element in the slot.
+ *
+ * Hierarchy:
+ * - `daikin-input-group` > `daikin-select`
+ *
+ * @slot - A slot for an HTML `<select>` element which may contain `<option>` and `<optgroup>`.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-select>
+ *   <select name="select">
+ *     <option value="value1">Option 1</option>
+ *     <option value="value2">Option 2</option>
+ *     <optgroup label="Group">
+ *       <option value="value3">Option 3</option>
+ *       <option value="value4">Option 4</option>
+ *     </optgroup>
+ *   </select>
+ * </daikin-select>
+ * ```
+ */
+export declare class DaikinSelect extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    /**
+     * Whether the select component is in an error state.
+     */
+    error: boolean;
+    /**
+     * Whether the select component is required.
+     */
+    required: boolean;
+    /**
+     * Whether the select component is disabled.
+     * This value will also be applied to the `disabled` property of the `<select>` element in the slot.
+     */
+    disabled: boolean;
+    private readonly _selects;
+    private get _select();
+    private _updateSelect;
+    private _handleSlotChange;
+    render(): import('lit-html').TemplateResult<1>;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    reflectInputGroup(inputGroup: DaikinInputGroup): void;
+    /**
+     * Focuses on the `<select>` element in the slot.
+     * @param options focus options
+     */
+    focus(options?: FocusOptions): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-select": DaikinSelect;
+    }
+}

package/dist/cjs-dev/components/select/index.cjs

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

package/dist/cjs-dev/components/select/index.d.ts

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

package/dist/cjs-dev/components/tab/daikin-tab.cjs

@@ -18,46 +18,50 @@ const cvaTab = classVarianceAuthority.cva(
   [
     "flex",
     "w-full",
-    "h-full",
+    "min-w-14",
+    "h-10",
     "items-center",
     "justify-center",
     "px-4",
     "pt-2",
     "pb-3",
-    "text-base",
-    "font-bold",
     "text-center",
     "font-daikinSerif",
-    "relative",
     "tracking-wide",
     "whitespace-nowrap",
-    "contain-paint",
+    "relative",
     "focus-visible:outline-none",
-    "focus-visible:before:w-full",
-    "focus-visible:before:h-[calc(100%_-_4px)]",
-    "focus-visible:before:border",
-    "focus-visible:before:border-daikinBlue-700",
     "focus-visible:before:absolute",
-    "focus-visible:before:top-0",
-    "disabled:text-daikinNeutral-200"
+    "focus-visible:before:-inset-[3px]",
+    "focus-visible:before:z-[1]",
+    "focus-visible:before:border",
+    "focus-visible:before:border-2",
+    "focus-visible:before:border-system-state-focus",
+    "disabled:text-system-state-disabled",
+    "after:absolute",
+    "after:inset-0",
+    "after:top-auto"
   ],
   {
     variants: {
       active: {
         false: [
-          "hover:text-daikinNeutral-500",
-          "active:text-daikinNeutral-700"
+          "enabled:text-system-state-neutral-active",
+          "enabled:hover:text-system-state-neutral-hover",
+          "enabled:hover:bg-system-background-surface-hover",
+          "enabled:active:text-system-state-neutral-press",
+          "enabled:active:bg-system-background-surface-press",
+          "after:h-[1px]",
+          "after:bg-system-element-divider-secondary"
         ],
         true: [
-          "text-daikinBlue-500",
-          "hover:text-daikinBlue-300",
-          "active:text-daikinBlue-600",
-          "after:w-full",
+          "font-bold",
+          "enabled:text-system-state-primary-active",
+          "enabled:hover:bg-system-state-primary-surface-hover",
+          "enabled:active:bg-system-state-primary-surface-press",
           "after:h-1",
-          "after:absolute",
-          "after:bottom-0",
-          "enabled:after:bg-daikinBlue-500",
-          "disabled:after:bg-daikinNeutral-200"
+          "enabled:after:bg-system-state-primary-active",
+          "disabled:after:bg-system-state-disabled"
         ]
       }
     }
@@ -101,7 +105,8 @@ exports.DaikinTab.styles = lit.css`
     ${lit.unsafeCSS(tailwind.default)}
 
     :host {
-      display: inline-block;
+      display: block;
+      width: 100%;
     }
   `;
 __decorateClass([

package/dist/cjs-dev/components/tab-panels/daikin-tab-panels.d.ts

@@ -1,8 +1,8 @@
 import { LitElement } from 'lit';
 import { ARIARole } from '../../lit-analyzer-types';
 /**
- * The panel switcher component is a child element within the `daikin-tabs` that controls the display of the content panels associated with each tab.
- * When a user selects a tab, the panel switcher component ensures the corresponding content panel is shown while hiding the others.
+ * The tab panels component is a child element within the `daikin-tabs` that controls the display of the content panels associated with each tab.
+ * When a user selects a tab, the tab panels component ensures the corresponding content panel is shown while hiding the others.
  *
  * Hierarchy:
  * - `daikin-tabs` > `daikin-tab-panels` ("panels" slot)
@@ -12,7 +12,7 @@ import { ARIARole } from '../../lit-analyzer-types';
  * @example
  *
  * ```js
- * import "@daikin-oss/design-system-web-components/components/panel-switcher/index.js";
+ * import "@daikin-oss/design-system-web-components/components/tab-panels/index.js";
  * ```
  *
  * ```html

package/dist/cjs-dev/components/tabs/daikin-tabs.cjs

@@ -180,7 +180,7 @@ exports.DaikinTabs = class DaikinTabs extends lit.LitElement {
   render() {
     return lit.html`
       <div
-        part="tablist"
+        class="flex flex-nowrap w-full p-[3px] overflow-auto relative before:absolute before:h-[1px] before:inset-[3px] before:top-auto before:bg-system-element-divider-secondary"
         role="tablist"
         @click=${this._handleTabClick}
         @keydown=${this._handleKeyDown}
@@ -200,6 +200,11 @@ exports.DaikinTabs = class DaikinTabs extends lit.LitElement {
 };
 exports.DaikinTabs.styles = lit.css`
     ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: block;
+      width: 100%;
+    }
   `;
 __decorateClass([
   decorators_js.property({ type: String, reflect: true })

package/dist/cjs-dev/components/tabs/daikin-tabs.d.ts

@@ -2,7 +2,6 @@ import { LitElement, PropertyValues } from 'lit';
 /**
  * The tab group component manages a group of tabs and switches the content displayed using the panel switcher component.
  * It allows users to navigate between different sections of content by clicking on individual tabs.
- * Tab groups do not provide styles; developers must apply styles to the wrapper of the tabs (`tablist` part) and to the panel switcher(s).
  *
  * > [!WARNING]
  * > At least one tab must be available (that means, the tab must be present and enabled).
@@ -18,18 +17,15 @@ import { LitElement, PropertyValues } from 'lit';
  * @slot - A slot for tab buttons. Place `daikin-tab` elements here.
  * @slot panels - A slot for tab panels component. Place a `daikin-tab-panels` element here.
  *
- * @csspart tablist - The container element for the default (tab list) slot. Has "tablist" role.
- *
  * @example
  *
  * ```js
  * import "@daikin-oss/design-system-web-components/components/tab/index.js";
  * import "@daikin-oss/design-system-web-components/components/tab-group/index.js";
- * import "@daikin-oss/design-system-web-components/components/panel-switcher/index.js";
+ * import "@daikin-oss/design-system-web-components/components/tab-panels/index.js";
  * ```
  *
  * ```html
- * <!-- See storybook for styling tab group. You'll need `::part(tablist)` to style the tab container. -->
  * <daikin-tabs value="foo">
  *   <daikin-tab value="foo">Foo tab</daikin-tab>
  *   <daikin-tab value="bar">Bar tab</daikin-tab>

package/dist/cjs-dev/components/text-area/daikin-text-area.cjs

@@ -0,0 +1,164 @@
+"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 ifDefined_js = require("lit/directives/if-defined.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 cvaTextArea = classVarianceAuthority.cva(
+  [
+    "w-full",
+    "h-full",
+    "px-4",
+    "py-3",
+    "rounded-md",
+    "font-daikinSerif",
+    "outline",
+    "outline-[--color-border]",
+    "outline-0",
+    "-outline-offset-2",
+    "placeholder:text-system-element-text-secondary",
+    // Define `--color-border` as a CSS variable that references `--color-state-focus` and `--color-base` in that order.
+    // `--color-base` indicates the color of the border when the element is normal, hovered, or disabled.
+    "define-[--color-state-active,--color-state-focus,--color-base]/color-border",
+    "border",
+    "border-[--color-border]",
+    // Update `--color-base` depending on the state.
+    // The default `--color-base` and `--color-state-focus` values are defined in `variants.error` because they differ depending on whether or not the input has an error state.
+    "enabled:text-system-element-text-primary",
+    "enabled:hover:bg-system-background-surface-hover",
+    "enabled:active:bg-system-background-surface-press",
+    "focus-visible:outline-2",
+    "disabled:var-color-system-state-disabled/color-base",
+    "disabled:text-system-state-disabled",
+    "disabled:bg-white",
+    "disabled:placeholder:text-system-state-disabled"
+  ],
+  {
+    variants: {
+      error: {
+        false: [
+          "enabled:var-color-system-state-neutral-hover/color-base",
+          "focus-visible:var-color-system-state-focus/color-state-focus"
+        ],
+        true: ["enabled:var-color-system-state-error-active/color-base"]
+      },
+      resize: {
+        false: ["resize-none"],
+        true: ["resize-vertical"]
+      }
+    }
+  }
+);
+exports.DaikinTextArea = class DaikinTextArea extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this._internals = this.attachInternals();
+    this.value = "";
+    this.name = "";
+    this.placeholder = null;
+    this.disabled = false;
+    this.readonly = false;
+    this.required = false;
+    this.error = false;
+    this.resizable = false;
+    this._label = null;
+  }
+  get count() {
+    return this.value.length;
+  }
+  _updateValue(value) {
+    this._internals.setFormValue(value);
+  }
+  _handleInput(e) {
+    this.value = e.target.value;
+    this._updateValue(this.value);
+  }
+  render() {
+    return lit.html`<textarea
+      class=${cvaTextArea({
+      error: !this.disabled && this.error,
+      resize: this.resizable
+    })}
+      .value=${this.value}
+      placeholder=${ifDefined_js.ifDefined(this.placeholder ?? void 0)}
+      name=${this.name}
+      autocomplete=${// eslint-disable-next-line @typescript-eslint/no-explicit-any -- workaround lit-analyzer checking
+    ifDefined_js.ifDefined(this.autocomplete)}
+      aria-label=${// eslint-disable-next-line @typescript-eslint/no-explicit-any -- workaround lit-analyzer checking
+    ifDefined_js.ifDefined(this._label)}
+      ?disabled=${this.disabled}
+      ?readonly=${this.readonly}
+      ?required=${this.required}
+      @change=${(e) => this.dispatchEvent(new Event("change", e))}
+      @input=${this._handleInput}
+      @keydown=${this._handleInput}
+    ></textarea>`;
+  }
+  updated(changedProperties) {
+    if (!changedProperties.has("value")) {
+      return;
+    }
+    this._updateValue(this.value);
+  }
+  reflectInputGroup(inputGroup) {
+    const isError = !inputGroup.disabled && !!inputGroup.error;
+    this.disabled = !!inputGroup.disabled;
+    this.required = !!inputGroup.required;
+    this.error = isError;
+    this._label = inputGroup.label;
+  }
+};
+exports.DaikinTextArea.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: block;
+      height: 87px;
+      position: relative;
+    }
+  `;
+exports.DaikinTextArea.formAssociated = true;
+__decorateClass([
+  decorators_js.property({ type: String })
+], exports.DaikinTextArea.prototype, "value", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinTextArea.prototype, "name", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinTextArea.prototype, "placeholder", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextArea.prototype, "disabled", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextArea.prototype, "readonly", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextArea.prototype, "required", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextArea.prototype, "error", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinTextArea.prototype, "autocomplete", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinTextArea.prototype, "resizable", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.DaikinTextArea.prototype, "_label", 2);
+exports.DaikinTextArea = __decorateClass([
+  decorators_js.customElement("daikin-text-area")
+], exports.DaikinTextArea);

package/dist/{es-dev/components/textarea/daikin-textarea.d.ts → cjs-dev/components/text-area/daikin-text-area.d.ts}

@@ -1,12 +1,13 @@
 import { LitElement, PropertyValues } from 'lit';
+import { DaikinInputGroup } from '../input-group';
 /**
- * The textarea component is designed for multiline text input, similar to the HTML `<textarea>` tag.
+ * The text area component is designed for multiline text input, similar to the HTML `<textarea>` tag.
  * It is ideal for situations where users need to enter longer pieces of text, such as comments, descriptions, or messages.
  * Can be used within `daikin-input-group` component.
  *
  * Hierarchies:
- * - `daikin-textarea` (can be used solely)
- * - `daikin-input-group` > `daikin-textarea`
+ * - `daikin-text-area` (can be used solely)
+ * - `daikin-input-group` > `daikin-text-area`
  *
  * @fires change - A cloned event of a [change event](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event) emitted from the inner `<textarea>` element.
  * @fires input - A retargeted event of a [input event](https://developer.mozilla.org/en-US/docs/Web/API/Element/input_event).
@@ -14,62 +15,68 @@ import { LitElement, PropertyValues } from 'lit';
  * @example
  *
  * ```js
- * import "@daikin-oss/design-system-web-components/components/textarea/index.js";
+ * import "@daikin-oss/design-system-web-components/components/text-area/index.js";
  * ```
  *
  * ```html
  * <!-- See `daikin-input-group` component for complete example. -->
- * <daikin-textarea name="name"></daikin-textarea>
+ * <daikin-text-area name="name"></daikin-text-area>
  * ```
  */
-export declare class DaikinTextarea extends LitElement {
+export declare class DaikinTextArea extends LitElement {
     static readonly styles: import('lit').CSSResult;
     static readonly formAssociated = true;
     private _internals;
     /**
-     * Field value
+     * Value of the text area.
      */
     value: string;
     /**
-     * Placeholder text
+     * Form name of the text area.
      */
-    placeholder: string;
+    name: string;
     /**
-     * Whether the field is disabled
+     * Placeholder text.
      */
-    disabled: boolean;
+    placeholder: string | null;
     /**
-     * Whether the field is required
+     * Whether the text area is disabled.
      */
-    required: boolean;
+    disabled: boolean;
     /**
-     * Whether the field is readonly
+     * Whether the text area is readonly.
      */
     readonly: boolean;
     /**
-     * Maximum length in field values
+     * Whether the text area is required.
+     */
+    required: boolean;
+    /**
+     * Error state. Ignored if the `disabled` is `true`.
      */
-    maxlength: number;
+    error: boolean;
     /**
-     * Specify auto-completion values
+     * Value of `autocomplete` attribute of the internal `<textarea>`.
      */
     autocomplete?: HTMLInputElement["autocomplete"];
     /**
-     * Error state. Ignored if the `disabled` is `true`.
+     * Whether to allow resizing of the text area.
      */
-    error: boolean;
+    resizable: boolean;
     /**
-     * Whether to display a counter at the top of the text area
+     * The label text used as the value of aria-label.
+     * Set automatically by `reflectInputGroup` method.
      */
-    counter: boolean;
-    protected _textareaCounter: number;
-    private _updateValueAndCounter;
+    private _label;
+    get count(): number;
+    private _updateValue;
     private _handleInput;
     render(): import('lit-html').TemplateResult<1>;
     updated(changedProperties: PropertyValues<this>): void;
+    reflectInputGroup(inputGroup: DaikinInputGroup): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        "daikin-textarea": DaikinTextarea;
+        "daikin-text-area": DaikinTextArea;
     }
 }

package/dist/cjs-dev/components/text-area/index.cjs

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

package/dist/cjs-dev/components/text-area/index.d.ts

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