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

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,19 +10,43 @@ 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"
+  },
+  "chevron-up": {
+    "class": "i-daikin-chevron-up",
+    color: null
+  },
+  "chevron-down": {
+    "class": "i-daikin-chevron-down",
+    color: null
+  },
+  "chevron-left": {
+    "class": "i-daikin-chevron-left",
+    color: null
+  },
+  "chevron-right": {
+    "class": "i-daikin-chevron-right",
     color: null
   }
 };

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,19 +9,43 @@ 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"
+    },
+    "chevron-up": {
+      "class": "i-daikin-chevron-up",
+      "color": null
+    },
+    "chevron-down": {
+      "class": "i-daikin-chevron-down",
+      "color": null
+    },
+    "chevron-left": {
+      "class": "i-daikin-chevron-left",
+      "color": null
+    },
+    "chevron-right": {
+      "class": "i-daikin-chevron-right",
       "color": null
     }
   }

package/dist/cjs/components/index.cjs

@@ -6,16 +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 daikinPanelSwitcher = require("./panel-switcher/daikin-panel-switcher.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 daikinTabGroup = require("./tab-group/daikin-tab-group.cjs");
-const daikinTextInput = require("./text-input/daikin-text-input.cjs");
-const daikinTextarea = require("./textarea/daikin-textarea.cjs");
+const daikinTabPanels = require("./tab-panels/daikin-tab-panels.cjs");
+const daikinTabs = require("./tabs/daikin-tabs.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", {
@@ -42,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
@@ -51,37 +66,57 @@ Object.defineProperty(exports, "DaikinInputGroup", {
   enumerable: true,
   get: () => daikinInputGroup.DaikinInputGroup
 });
-Object.defineProperty(exports, "DaikinNotification", {
+Object.defineProperty(exports, "DaikinList", {
   enumerable: true,
-  get: () => daikinNotification.DaikinNotification
+  get: () => daikinList.DaikinList
+});
+Object.defineProperty(exports, "DaikinListItem", {
+  enumerable: true,
+  get: () => daikinListItem.DaikinListItem
 });
-Object.defineProperty(exports, "DaikinPanelSwitcher", {
+Object.defineProperty(exports, "DaikinNotification", {
   enumerable: true,
-  get: () => daikinPanelSwitcher.DaikinPanelSwitcher
+  get: () => daikinNotification.DaikinNotification
 });
 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
 });
-Object.defineProperty(exports, "DaikinTabGroup", {
+Object.defineProperty(exports, "DaikinTabPanels", {
+  enumerable: true,
+  get: () => daikinTabPanels.DaikinTabPanels
+});
+Object.defineProperty(exports, "DaikinTabs", {
   enumerable: true,
-  get: () => daikinTabGroup.DaikinTabGroup
+  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,15 +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 './panel-switcher';
 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-group';
-export * from './text-input';
-export * from './textarea';
+export * from './tab-panels';
+export * from './tabs';
+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-negative 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);

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

@@ -1,65 +1,109 @@
 import { LitElement } from 'lit';
-import { DaikinTextInput } from '../text-input/daikin-text-input';
-import { DaikinTextarea } from '../textarea/daikin-textarea';
-type ControlElement = DaikinTextInput | DaikinTextarea;
 /**
- * The input group component serves as a wrapper for a `daikin-text-input` or `daikin-textarea` component, providing additional elements such as labels, helper texts, or a counter.
+ * The input group component serves as a wrapper for an input control component (full list below), providing additional elements such as label text, helper text, or a counter.
  * It enhances the user experience by associating supplementary information or functionality directly with the input field.
  * This component is particularly useful for creating complex forms where clear communication and guidance are essential.
  *
  * Hierarchies:
- * - `daikin-input-group` > `daikin-text-input`
- * - `daikin-input-group` > `daikin-textarea`
+ * - `daikin-input-group` > `daikin-select`
+ * - `daikin-input-group` > `daikin-dropdown` > `daikin-dropdown-item`
+ * - `daikin-input-group` > `daikin-text-area`
+ * - `daikin-input-group` > `daikin-text-field`
+ * - `daikin-input-group` > `daikin-radio-group` > `daikin-radio`
  *
- * @slot - A slot for a input component. Place a `daikin-text-input` or `daikin-textarea` element here.
+ * @slot - A slot for an input component. See **Hierarchies** for supported components.
  *
  * @example
  *
- * With Text Input:
+ * ```js
+ * import "@daikin-oss/design-system-web-components/components/input-group/index.js";
+ * import "@daikin-oss/design-system-web-components/components/select/index.js";
+ * import "@daikin-oss/design-system-web-components/components/text-area/index.js";
+ * import "@daikin-oss/design-system-web-components/components/text-field/index.js";
+ * ```
+ *
+ * With Dropdown:
  *
  * ```html
  * <daikin-input-group>
- *   <daikin-text-input value="Content of Text Input"></daikin-text-input>
+ *   <daikin-dropdown value="Value of Dropdown">
+ *     <daikin-dropdown-item value="Value of Dropdown Item">
+ *       Dropdown item 1
+ *     </daikin-dropdown-item>
+ *   </daikin-dropdown>
  * </daikin-input-group>
  * ```
  *
- * With Textarea:
+ * With Select:
  *
  * ```html
  * <daikin-input-group>
- *   <daikin-textarea value="Content of Textarea"></daikin-textarea>
+ *   <daikin-select>
+ *     <select name="select">
+ *       <option value="value1">Option 1</option>
+ *       <option value="value2">Option 2</option>
+ *       <option value="value3">Option 3</option>
+ *     </select>
+ *   </daikin-select>
  * </daikin-input-group>
  * ```
+ *
+ * With Text Field:
+ *
+ * ```html
+ * <daikin-input-group>
+ *   <daikin-text-field value="Content of Text Field"></daikin-text-field>
+ * </daikin-input-group>
+ * ```
+ *
+ * With TextArea:
+ *
+ * ```html
+ * <daikin-input-group>
+ *   <daikin-text-area value="Content of TextArea"></daikin-text-area>
+ * </daikin-input-group>
+ * ```
+ * ```
  */
 export declare class DaikinInputGroup extends LitElement {
     static readonly styles: import('lit').CSSResult;
     /**
-     * Label text to place at the top of the field
+     * Label text displayed at the top of the field.
      */
-    label?: string;
+    label: string | null;
     /**
-     * Helper text to place at the bottom of the field. In error conditions, this text is hidden.
+     * Helper text displayed at the top of the field.
+     * If `error` is specified and `disabled` is `false`, that takes precedence and helper text is not displayed.
      */
-    helper?: string;
+    helper: string | null;
     /**
-     * Whether the field is disabled. Reflected in the `disabled` property of the input in the slot.
+     * Text indicating that the field is required.
+     * If a non-empty string is set,
+     * - the text will be displayed in red to the right of the label, and
+     * - the `required` attribute will be set for the input control in the slot.
+     * Ignored if `disabled` is `true`.
      */
-    disabled: boolean;
+    required: string | null;
     /**
-     * Whether the field is required. An additional star mark will be added if `true`.
+     * Error text displayed at the top of the field.
+     * Ignored if `disabled` is `true`.
+     * Reflected in presence of `error` attribute of the input control in the slot.
      */
-    required: boolean;
+    error: string | null;
     /**
-     * Error text to place at the bottom of the field. If specified, sets the `error` property of the element in the slot to `true`. Ignored if the `disabled` is `true`.
+     * Whether the field is disabled.
+     * Reflected in `disabled` attribute of the input control in the slot.
      */
-    error: string;
+    disabled: boolean;
     /**
-     * Whether to display the counter in the Textarea
+     * Maximum value to display on the counter. When `null`, the counter will be hidden.
      */
-    textareaCounter: boolean;
-    _textareas: DaikinTextarea[];
-    _controls: ControlElement[];
+    textareaMaxCount: number | null;
+    private readonly _textareas;
+    private readonly _controls;
+    private _textareaCount;
     private _handleSlotChange;
+    private _handleInput;
     private _reflectSlotProperties;
     render(): import('lit-html').TemplateResult<1>;
     updated(): void;

package/dist/cjs/components/list/daikin-list.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lit = require("lit");
+const decorators_js = require("lit/decorators.js");
+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;
+};
+exports.DaikinList = class DaikinList extends lit.LitElement {
+  render() {
+    return lit.html`<div role="list">
+      <slot></slot>
+    </div>`;
+  }
+};
+exports.DaikinList = __decorateClass([
+  decorators_js.customElement("daikin-list")
+], exports.DaikinList);

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

@@ -0,0 +1,28 @@
+import { LitElement } from 'lit';
+/**
+ * The list component is used to list items using the list item component.
+ *
+ * Hierarchy:
+ * - `daikin-list` > `daikin-list-item`
+ *
+ * @slot - A slot for the list items. Place `daikin-list-item` elements here.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-list>
+ *   <daikin-list-item>List item label 1</daikin-list-item>
+ *   <daikin-list-item>List item label 2</daikin-list-item>
+ *   <daikin-list-item>List item label 3</daikin-list-item>
+ * </daikin-list>
+ * ```
+ */
+export declare class DaikinList extends LitElement {
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-list": DaikinList;
+    }
+}
+export default DaikinList;

package/dist/cjs/components/list/index.cjs

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

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

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