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

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

@@ -0,0 +1,116 @@
+"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 cvaLinkSlot = classVarianceAuthority.cva(
+  [
+    "slotted:h-8",
+    "slotted:font-normal",
+    "slotted:not-italic",
+    "slotted:leading-8",
+    "slotted:text-sm",
+    "slotted:text-daikinBlue-500",
+    "slotted:outline-none",
+    "slotted:font-daikinSerif"
+  ],
+  {
+    variants: {
+      variant: {
+        normal: [
+          "slotted:hover:text-daikinBlue-300",
+          "slotted:active:text-daikinNeutral-800",
+          "slotted-[*:focus-visible]:text-daikinBlue-700"
+        ],
+        ellipsis: ["slotted:hover:text-daikinBlue-300"]
+      },
+      disabled: {
+        true: [
+          "slotted:!text-daikinNeutral-800",
+          "slotted:pointer-events-none",
+          "slotted:cursor-default",
+          "slotted-[*:focus-visible]:!text-daikinNeutral-800"
+        ],
+        false: []
+      }
+    }
+  }
+);
+exports.DaikinBreadcrumbItem = class DaikinBreadcrumbItem extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.href = "";
+    this.variant = "normal";
+    this.disabled = false;
+    this.target = null;
+    this.trailingSlash = false;
+    this.hidden = false;
+  }
+  render() {
+    const slash = this.trailingSlash ? lit.html`<span class="text-daikinNeutral-800 font-daikinSerif">/</span>` : null;
+    return lit.html`
+      ${this.variant === "normal" ? lit.html`<slot name="link" class=${cvaLinkSlot(this)}>
+            <a
+              href=${ifDefined_js.ifDefined(this.href)}
+              target=${// eslint-disable-next-line @typescript-eslint/no-explicit-any -- workaround lit-analyzer checking
+    ifDefined_js.ifDefined(this.target)}
+            >
+              <slot></slot>
+            </a>
+          </slot>` : (
+      // Though `cvaLinkSlot` is designed for slots, it contains "& > *" selector for fallback content so it can be used here.
+      lit.html`<span class=${cvaLinkSlot(this)} aria-label="…">
+            <span>. . .</span>
+          </span> `
+    )}
+      ${slash}
+    `;
+  }
+};
+exports.DaikinBreadcrumbItem.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      flex-shrink: 0;
+    }
+
+    :host([hidden]) {
+      display: none;
+    }
+  `;
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinBreadcrumbItem.prototype, "href", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinBreadcrumbItem.prototype, "variant", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinBreadcrumbItem.prototype, "disabled", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinBreadcrumbItem.prototype, "target", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true, attribute: "trailing-slash" })
+], exports.DaikinBreadcrumbItem.prototype, "trailingSlash", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinBreadcrumbItem.prototype, "hidden", 2);
+exports.DaikinBreadcrumbItem = __decorateClass([
+  decorators_js.customElement("daikin-breadcrumb-item")
+], exports.DaikinBreadcrumbItem);

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

@@ -0,0 +1,62 @@
+import { LitElement } from 'lit';
+import { MergeVariantProps } from '../../type-utils';
+declare const cvaLinkSlot: (props?: ({
+    variant?: "normal" | "ellipsis" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type LinkVariantProps = MergeVariantProps<typeof cvaLinkSlot>;
+/**
+ * The `daikin-breadcrumb-item` is a component used to represent each item of the breadcrumb list, and is used as a child element of the `daikin-breadcrumb` component.
+ *
+ * Hierarchy:
+ * - `daikin-breadcrumb` > `daikin-breadcrumb-item`
+ *
+ * @slot - A slot for the breadcrumb item content.
+ *
+ * @example
+ *
+ * ```html
+ * <!-- See `daikin-breadcrumb` component for complete example. -->
+ * <daikin-breadcrumb-item href="#">
+ *   Breadcrumb Item 1
+ * </daikin-breadcrumb-item>
+ * ```
+ */
+export declare class DaikinBreadcrumbItem extends LitElement {
+    static styles: import('lit').CSSResult;
+    /**
+     * Specify link href
+     */
+    href: string;
+    /**
+     * Specifies the display content.
+     * If `ellipsis`, the "..." will be displayed instead of the link.
+     * Set automatically by `daikin-breadcrumb`.
+     */
+    variant: LinkVariantProps["variant"];
+    /**
+     * Specify whether the link should be disabled
+     */
+    disabled: boolean;
+    /**
+     * Specify the link target
+     */
+    target: string | null;
+    /**
+     * Whether the slash after the link should shown.
+     * Set automatically by `daikin-breadcrumb`.
+     */
+    trailingSlash: boolean;
+    /**
+     * Whether the link should be hidden when ellipsis mode.
+     * Set automatically by `daikin-breadcrumb`.
+     */
+    hidden: boolean;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-breadcrumb-item": DaikinBreadcrumbItem;
+    }
+}
+export {};

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

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

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

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

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

@@ -5,6 +5,7 @@ const classVarianceAuthority = require("class-variance-authority");
 const lit = require("lit");
 const decorators_js = require("lit/decorators.js");
 const tailwind = require("../../tailwind.css.cjs");
+require("../icon/daikin-icon.cjs");
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -15,16 +16,21 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+const BUTTON_ICON_SIZE_MAP = {
+  default: "m",
+  condensed: "s"
+};
 const cvaButton = classVarianceAuthority.cva(
   [
     "inline-flex",
     "justify-center",
     "items-center",
+    "gap-2",
     "font-daikinSerif",
     "font-bold",
     "rounded-lg",
     "tracking-wide",
-    "text-wrap",
+    "text-nowrap",
     "disabled:cursor-default",
     "w-full",
     "h-full"
@@ -92,8 +98,8 @@ exports.DaikinButton = class DaikinButton extends lit.LitElement {
     super(...arguments);
     this.variant = "primary";
     this.disabled = false;
-    this.rightIcon = "";
-    this.leftIcon = "";
+    this.rightIcon = null;
+    this.leftIcon = null;
     this.href = "";
     this.size = "default";
     this.type = "button";
@@ -106,12 +112,20 @@ exports.DaikinButton = class DaikinButton extends lit.LitElement {
       size: this.size
     });
     const content = lit.html`
-      <slot name="leftIcon"></slot>
-      <span><slot></slot></span>
-      <slot name="rightIcon"></slot>
+      ${this.leftIcon ? lit.html`<daikin-icon
+            icon=${this.leftIcon}
+            size=${BUTTON_ICON_SIZE_MAP[this.size]}
+            color="current"
+          ></daikin-icon>` : null}
+      <slot></slot>
+      ${this.rightIcon ? lit.html`<daikin-icon
+            icon=${this.rightIcon}
+            size=${BUTTON_ICON_SIZE_MAP[this.size]}
+            color="current"
+          ></daikin-icon>` : null}
     `;
     if (this.href) {
-      return lit.html` <a
+      return lit.html`<a
         href="${this.href}"
         class="${buttonClassName}"
         role="${this.role}"
@@ -130,6 +144,10 @@ exports.DaikinButton = class DaikinButton extends lit.LitElement {
       </button>
     `;
   }
+  /**
+   * Focuses on the inner button.
+   * @param options focus options
+   */
   focus(options) {
     var _a, _b;
     (_b = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector("button")) == null ? void 0 : _b.focus(options);

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

@@ -1,14 +1,27 @@
 import { LitElement } from 'lit';
 import { ARIARole } from '../../lit-analyzer-types';
 import { MergeVariantProps } from '../../type-utils';
-
+import { IconType } from '../icon/daikin-icon';
 declare const cvaButton: (props?: ({
     intent?: "primary" | "secondary" | "tertiary" | "primaryDanger" | null | undefined;
     size?: "default" | "condensed" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type ButtonVariantProps = MergeVariantProps<typeof cvaButton>;
 /**
- * Primary UI component for user interaction
+ * The button component is a versatile UI element that triggers actions or submits forms when clicked.
+ * It functions similarly to the HTML `<button>` tag, allowing users to initiate various operations such as submitting data, opening dialogs, or navigating to different sections of an application.
+ *
+ * @fires click - A retargeted event of a [click event](https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event) emitted from the inner `<button>` element. Suppressed if `disabled` is true,
+ *
+ * @slot - A slot for the button content.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-button>
+ *   Button label
+ * </daikin-button>
+ * ```
  */
 export declare class DaikinButton extends LitElement {
     static readonly styles: import('lit').CSSResult;
@@ -23,11 +36,11 @@ export declare class DaikinButton extends LitElement {
     /**
      * Set a icon in the right of button label.
      */
-    rightIcon: string;
+    rightIcon: IconType | null;
     /**
      * Set a icon in the left of button label.
      */
-    leftIcon: string;
+    leftIcon: IconType | null;
     /**
      * Link `href`. If present, this button is rendered as `<a>`.
      */
@@ -49,6 +62,10 @@ export declare class DaikinButton extends LitElement {
      */
     isLoading: boolean;
     render(): import('lit-html').TemplateResult<1>;
+    /**
+     * Focuses on the inner button.
+     * @param options focus options
+     */
     focus(options?: FocusOptions | undefined): void;
 }
 declare global {

package/dist/cjs/components/button/index.cjs

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

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

@@ -1,6 +1,5 @@
 import { LitElement, PropertyValues } from 'lit';
 import { MergeVariantProps } from '../../type-utils';
-
 declare const cvaCheckbox: (props?: ({
     size?: "small" | "large" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
@@ -9,7 +8,17 @@ declare const cvaLabel: (props?: ({
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type CheckboxVariantProps = MergeVariantProps<typeof cvaCheckbox | typeof cvaLabel>;
 /**
- * Primary UI component for user interaction
+ * The checkbox component is a UI element that allows users to select one or more options from a list of choices.
+ * It functions similarly to the HTML `<input type="checkbox">` tag, enabling users to toggle the selection of each option independently.
+ * This component is ideal for cases where multiple selections are allowed or required.
+ *
+ * @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 `<input type="checkbox">` element.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-checkbox label="Checkbox label" name="name" value="value"></daikin-checkbox>
+ * ```
  */
 export declare class DaikinCheckbox extends LitElement {
     static readonly styles: import('lit').CSSResult;

package/dist/cjs/components/checkbox/index.cjs

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

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const variables_js = require("@daikin-oss/dds-tokens/js/daikin/Light/variables.js");
+const classVarianceAuthority = require("class-variance-authority");
+const lit = require("lit");
+const decorators_js = require("lit/decorators.js");
+const tailwind = require("../../tailwind.css.cjs");
+const icons = require("./icons.json.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 iconList = Object.keys(icons.icons);
+const iconClassMap = Object.fromEntries(
+  Object.entries(icons.icons).map(([name, object]) => [name, object.class])
+);
+const cvaIcon = classVarianceAuthority.cva(["block"], {
+  variants: {
+    icon: iconClassMap,
+    size: {
+      s: [`w-[--size-s]`, `h-[--size-s]`],
+      m: [`w-[--size-m]`, `h-[--size-m]`],
+      l: [`w-[--size-l]`, `h-[--size-l]`],
+      xl: [`w-[--size-xl]`, `h-[--size-xl]`]
+    },
+    color: {
+      black: ["text-black"],
+      white: ["text-white"],
+      default: ["text-[--default-color]"],
+      current: []
+      // uses `currentColor`
+    }
+  }
+});
+exports.DaikinIcon = class DaikinIcon extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.icon = null;
+    this.color = "default";
+    this.size = "m";
+  }
+  render() {
+    var _a;
+    const defaultColor = (_a = icons.icons[this.icon ?? ""]) == null ? void 0 : _a.color;
+    return lit.html`<span
+      class=${cvaIcon({
+      icon: this.icon,
+      color: this.color,
+      size: this.size
+    })}
+      style=${`--default-color:${defaultColor ?? "#000000"}`}
+      role="presentation"
+    ></span>`;
+  }
+};
+exports.DaikinIcon.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      --size-s: ${lit.unsafeCSS(variables_js.space12)};
+      --size-m: ${lit.unsafeCSS(variables_js.space16)};
+      --size-l: ${lit.unsafeCSS(variables_js.space20)};
+      --size-xl: ${lit.unsafeCSS(variables_js.space24)};
+
+      display: block;
+      width: max-content;
+    }
+  `;
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinIcon.prototype, "icon", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinIcon.prototype, "color", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinIcon.prototype, "size", 2);
+exports.DaikinIcon = __decorateClass([
+  decorators_js.customElement("daikin-icon")
+], exports.DaikinIcon);
+exports.iconList = iconList;

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

@@ -0,0 +1,48 @@
+import { LitElement } from 'lit';
+import { MergeVariantProps } from '../../type-utils';
+import { icons } from './icons.json';
+export declare const iconList: string[];
+export type IconType = keyof typeof icons;
+declare const cvaIcon: (props?: ({
+    icon?: string | number | null | undefined;
+    size?: "s" | "m" | "l" | "xl" | null | undefined;
+    color?: "black" | "white" | "default" | "current" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type IconVariantProps = MergeVariantProps<typeof cvaIcon>;
+/**
+ * The icon component is a versatile UI element used to display small graphical symbols or images that represent actions, objects, or concepts within an application.
+ * The icon set is provided by DDS.
+ *
+ * To use an arbitrary color, specify `"current"` for the `color` property and set the `color` CSS property to the color you want to use.
+ *
+ * If you try to use an icon that does not exist, a blank space will be displayed.
+ * In the development build, warnings will be displayed in the console, so please check there if you encounter any unexpected behavior.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-icon icon="information" color="black" size="m"></daikin-icon>
+ * ```
+ */
+export declare class DaikinIcon extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    /**
+     * Specify the name of the icon
+     */
+    icon: IconType | null;
+    /**
+     * Specify icon color
+     */
+    color: IconVariantProps["color"];
+    /**
+     * Specify the height and width of the icon
+     */
+    size: IconVariantProps["size"];
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-icon": DaikinIcon;
+    }
+}
+export default DaikinIcon;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const icons = {
+  alarm: {
+    "class": "i-daikin-notification-status-alarm",
+    color: null
+  },
+  close: {
+    "class": "i-daikin-notification-close",
+    color: "#a0a0a0"
+  },
+  information: {
+    "class": "i-daikin-notification-status-information",
+    color: null
+  },
+  negative: {
+    "class": "i-daikin-notification-status-negative",
+    color: null
+  },
+  positive: {
+    "class": "i-daikin-notification-status-positive",
+    color: null
+  },
+  warning: {
+    "class": "i-daikin-notification-status-warning",
+    color: null
+  }
+};
+exports.icons = icons;

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

@@ -0,0 +1,31 @@
+declare const _default: {
+  "icons": {
+    "alarm": {
+      "class": "i-daikin-notification-status-alarm",
+      "color": null
+    },
+    "close": {
+      "class": "i-daikin-notification-close",
+      "color": "#a0a0a0"
+    },
+    "information": {
+      "class": "i-daikin-notification-status-information",
+      "color": null
+    },
+    "negative": {
+      "class": "i-daikin-notification-status-negative",
+      "color": null
+    },
+    "positive": {
+      "class": "i-daikin-notification-status-positive",
+      "color": null
+    },
+    "warning": {
+      "class": "i-daikin-notification-status-warning",
+      "color": null
+    }
+  }
+}
+;
+
+export default _default;

package/dist/cjs/components/icon/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const daikinIcon = require("./daikin-icon.cjs");
+Object.defineProperty(exports, "DaikinIcon", {
+  enumerable: true,
+  get: () => daikinIcon.DaikinIcon
+});
+exports.iconList = daikinIcon.iconList;

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

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

package/dist/cjs/components/index.cjs

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const daikinAccordion = require("./accordion/daikin-accordion.cjs");
+const daikinAccordionItem = require("./accordion-item/daikin-accordion-item.cjs");
+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 daikinIcon = require("./icon/daikin-icon.cjs");
+const daikinInputGroup = require("./input-group/daikin-input-group.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 daikinRadio = require("./radio/daikin-radio.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 daikinToggle = require("./toggle/daikin-toggle.cjs");
+const daikinTooltip = require("./tooltip/daikin-tooltip.cjs");
+Object.defineProperty(exports, "DaikinAccordion", {
+  enumerable: true,
+  get: () => daikinAccordion.DaikinAccordion
+});
+Object.defineProperty(exports, "DaikinAccordionItem", {
+  enumerable: true,
+  get: () => daikinAccordionItem.DaikinAccordionItem
+});
+Object.defineProperty(exports, "DaikinBreadcrumb", {
+  enumerable: true,
+  get: () => daikinBreadcrumb.DaikinBreadcrumb
+});
+Object.defineProperty(exports, "DaikinBreadcrumbItem", {
+  enumerable: true,
+  get: () => daikinBreadcrumbItem.DaikinBreadcrumbItem
+});
+Object.defineProperty(exports, "DaikinButton", {
+  enumerable: true,
+  get: () => daikinButton.DaikinButton
+});
+Object.defineProperty(exports, "DaikinCheckbox", {
+  enumerable: true,
+  get: () => daikinCheckbox.DaikinCheckbox
+});
+Object.defineProperty(exports, "DaikinIcon", {
+  enumerable: true,
+  get: () => daikinIcon.DaikinIcon
+});
+exports.iconList = daikinIcon.iconList;
+Object.defineProperty(exports, "DaikinInputGroup", {
+  enumerable: true,
+  get: () => daikinInputGroup.DaikinInputGroup
+});
+Object.defineProperty(exports, "DaikinNotification", {
+  enumerable: true,
+  get: () => daikinNotification.DaikinNotification
+});
+Object.defineProperty(exports, "DaikinPanelSwitcher", {
+  enumerable: true,
+  get: () => daikinPanelSwitcher.DaikinPanelSwitcher
+});
+Object.defineProperty(exports, "DaikinProgressBar", {
+  enumerable: true,
+  get: () => daikinProgressBar.DaikinProgressBar
+});
+Object.defineProperty(exports, "DaikinRadio", {
+  enumerable: true,
+  get: () => daikinRadio.DaikinRadio
+});
+Object.defineProperty(exports, "DaikinTab", {
+  enumerable: true,
+  get: () => daikinTab.DaikinTab
+});
+Object.defineProperty(exports, "DaikinTabGroup", {
+  enumerable: true,
+  get: () => daikinTabGroup.DaikinTabGroup
+});
+Object.defineProperty(exports, "DaikinTextInput", {
+  enumerable: true,
+  get: () => daikinTextInput.DaikinTextInput
+});
+Object.defineProperty(exports, "DaikinTextarea", {
+  enumerable: true,
+  get: () => daikinTextarea.DaikinTextarea
+});
+Object.defineProperty(exports, "DaikinToggle", {
+  enumerable: true,
+  get: () => daikinToggle.DaikinToggle
+});
+Object.defineProperty(exports, "DaikinTooltip", {
+  enumerable: true,
+  get: () => daikinTooltip.DaikinTooltip
+});