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

package/dist/cjs-dev/components/accordion-item/daikin-accordion-item.d.ts

@@ -0,0 +1,55 @@
+import { LitElement, PropertyValues } from 'lit';
+/**
+ * The accordion item component is a child element within the `daikin-accordion` component.
+ * It functions similarly to the HTML `<details>` and `<summary>` tag, allowing users to expand or collapse the associated content by clicking on the header.
+ * This component is responsible for displaying the specific content within the accordion and allowing users to interact with each section independently.
+ *
+ * Hierarchy:
+ * - `daikin-accordion` > `daikin-accordion-item`
+ *
+ * @slot - A slot for the accordion item content.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-accordion-item title="The first accordion item">
+ *   Accordion 1 content.
+ * </daikin-accordion-item>
+ * ```
+ */
+export declare class DaikinAccordionItem extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    private _contentRef;
+    /**
+     * Heading of accordion
+     */
+    title: string;
+    /**
+     * Whether the accordion is open
+     */
+    open: boolean;
+    /**
+     * Whether the accordion is disabled
+     */
+    disabled: boolean;
+    /**
+     * Open attribute of the actual details element
+     *
+     * The default `open` attribute of the default details element does not allow the display of content to have transitions.
+     * To solve this, the `open` property that `daikin-accordion-item` receives manages the opening and closing of items independently of the open attribute.
+     *
+     * The `open` attribute, which should be present, is taken over by `_detailsOpen`.
+     */
+    private _detailsOpen;
+    private _contentAnimate;
+    private _handleSummaryClick;
+    render(): import('lit-html').TemplateResult<1>;
+    protected firstUpdated(): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-accordion-item": DaikinAccordionItem;
+    }
+}
+export default DaikinAccordionItem;

package/dist/cjs-dev/components/accordion-item/index.cjs

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

package/dist/cjs-dev/components/accordion-item/index.d.ts

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

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lit = require("lit");
+const decorators_js = require("lit/decorators.js");
+const ref_js = require("lit/directives/ref.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;
+};
+exports.DaikinBreadcrumb = class DaikinBreadcrumb extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.resizeObserver = new ResizeObserver(() => {
+      this._omit();
+    });
+    this._divWrapRef = ref_js.createRef();
+    this.trailingSlash = false;
+    this.overflow = "visible";
+    this._expandedContentWidth = 0;
+    this.omitted = false;
+  }
+  get _isEllipsis() {
+    return this.overflow === "ellipsis";
+  }
+  _omit() {
+    const shouldOmit = this._isEllipsis && this.offsetWidth < this._expandedContentWidth;
+    if (this.omitted === shouldOmit) {
+      return;
+    }
+    this.omitted = shouldOmit;
+    const daikinBreadCrumbItems = this._slottedDaikinBreadCrumbItems;
+    for (const [index, item] of daikinBreadCrumbItems.entries()) {
+      let mode = "normal";
+      if (shouldOmit) {
+        if (index === 0 || index >= daikinBreadCrumbItems.length - 2) {
+          continue;
+        } else if (index === 1) {
+          mode = "ellipsis";
+        } else {
+          mode = "hidden";
+        }
+      }
+      item.hidden = mode === "hidden";
+      item.variant = mode === "ellipsis" ? "ellipsis" : "normal";
+    }
+  }
+  _updateBreadcrumbs() {
+    const daikinBreadCrumbItems = this._slottedDaikinBreadCrumbItems;
+    for (const [index, item] of daikinBreadCrumbItems.entries()) {
+      if (index === daikinBreadCrumbItems.length - 1) {
+        item.trailingSlash = this.trailingSlash;
+        item.disabled = true;
+        continue;
+      }
+      item.trailingSlash = true;
+    }
+  }
+  _handleChange() {
+    this._updateBreadcrumbs();
+  }
+  _handleResizeObserver() {
+    if (this._isEllipsis) {
+      this.resizeObserver.observe(this);
+    } else {
+      this.resizeObserver.disconnect();
+    }
+  }
+  render() {
+    return lit.html`
+      <div class="flex gap-2" ${ref_js.ref(this._divWrapRef)}>
+        <slot @slotchange=${this._handleChange}></slot>
+      </div>
+    `;
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("trailingSlash")) {
+      this._updateBreadcrumbs();
+    }
+    if (changedProperties.has("overflow")) {
+      this._omit();
+      this._handleResizeObserver();
+    }
+  }
+  firstUpdated() {
+    this._updateBreadcrumbs();
+    this._omit();
+    this._handleResizeObserver();
+    this.updateComplete.then(() => {
+      const divElement = this._divWrapRef.value;
+      if (!divElement) {
+        return;
+      }
+      this._expandedContentWidth = divElement.offsetWidth;
+    }).catch(() => {
+    });
+  }
+};
+exports.DaikinBreadcrumb.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      display: flex;
+      align-items: center;
+    }
+  `;
+__decorateClass([
+  decorators_js.queryAssignedElements()
+], exports.DaikinBreadcrumb.prototype, "_slottedDaikinBreadCrumbItems", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true, attribute: "trailing-slash" })
+], exports.DaikinBreadcrumb.prototype, "trailingSlash", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinBreadcrumb.prototype, "overflow", 2);
+exports.DaikinBreadcrumb = __decorateClass([
+  decorators_js.customElement("daikin-breadcrumb")
+], exports.DaikinBreadcrumb);

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

@@ -0,0 +1,52 @@
+import { LitElement, PropertyValues } from 'lit';
+/**
+ * `daikin-breadcrumb` is a component for representing a breadcrumb list, and is used together with the `daikin-breadcrumb-item` component.
+ *
+ * Hierarchy:
+ * - `daikin-breadcrumb` > `daikin-breadcrumb-item`
+ *
+ * @slot - A slot for breadcrumb items. Place `breadcrumb-item` elements here.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-breadcrumb>
+ *  <daikin-breadcrumb-item href="#">
+ *   Breadcrumb Item 1
+ *  </daikin-breadcrumb-item>
+ *  <daikin-breadcrumb-item href="#">
+ *   Breadcrumb Item 2
+ *  </daikin-breadcrumb-item>
+ * </daikin-breadcrumb>
+ * ```
+ */
+export declare class DaikinBreadcrumb extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    private resizeObserver;
+    private _slottedDaikinBreadCrumbItems;
+    private _divWrapRef;
+    /**
+     * Whether the last breadcrumb item should have trailing slash.
+     */
+    trailingSlash: boolean;
+    /**
+     * Specifies overflow.
+     * If `ellipsis`, some breadcrumb items will be omitted when the total width exceeds the container width.
+     */
+    overflow: "visible" | "ellipsis";
+    private _expandedContentWidth;
+    private omitted;
+    get _isEllipsis(): boolean;
+    private _omit;
+    private _updateBreadcrumbs;
+    private _handleChange;
+    private _handleResizeObserver;
+    render(): import('lit-html').TemplateResult<1>;
+    updated(changedProperties: PropertyValues<this>): void;
+    firstUpdated(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-breadcrumb": DaikinBreadcrumb;
+    }
+}

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

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

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

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

package/dist/cjs-dev/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-dev/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-dev/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-dev/components/breadcrumb-item/index.d.ts

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

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

@@ -0,0 +1,215 @@
+"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");
+require("../icon/daikin-icon.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 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-nowrap",
+    "disabled:cursor-default",
+    "w-full",
+    "h-full"
+  ],
+  {
+    variants: {
+      intent: {
+        primary: [
+          "text-white",
+          "bg-[--buttonColorBackgroundPrimaryActive]",
+          "enabled:focus-visible:bg-[--buttonColorBackgroundPrimaryFocus]",
+          "enabled:hover:bg-[--buttonColorBackgroundPrimaryHover]",
+          "enabled:active:bg-[--buttonColorBackgroundPrimaryPress]",
+          "disabled:bg-[--buttonColorBackgroundPrimaryDisabled]",
+          "focus-visible:outline-none"
+        ],
+        secondary: [
+          "border-2",
+          "bg-white",
+          "text-daikinBlue-500",
+          "border-daikinBlue-500",
+          "enabled:hover:text-daikinBlue-300",
+          "enabled:hover:border-daikinBlue-300",
+          "enabled:active:text-daikinBlue-600",
+          "enabled:active:border-daikinBlue-600",
+          "enabled:focus-visible:text-daikinBlue-700",
+          "enabled:focus-visible:border-daikinBlue-700",
+          "disabled:border-daikinNeutral-300",
+          "disabled:text-daikinNeutral-400",
+          "disabled:border",
+          "focus-visible:outline-none"
+        ],
+        tertiary: [
+          "text-daikinBlue-400",
+          "bg-none",
+          "border-none",
+          "shadow-none",
+          "enabled:hover:bg-daikinNeutral-100",
+          "disabled:bg-transparent",
+          "disabled:text-daikinNeutral-400"
+        ],
+        primaryDanger: [
+          "bg-daikinRed",
+          "text-white",
+          "enabled:hover:bg-daikinRed-400",
+          "enabled:focus-visible:bg-daikinRed-700",
+          "enabled:active:bg-daikinRed-700",
+          "disabled:bg-daikinNeutral-300",
+          "focus-visible:outline-none"
+        ]
+      },
+      size: {
+        default: ["px-4", "text-[14px]"],
+        condensed: ["px-[10px]", "text-[12px]"]
+      }
+    },
+    defaultVariants: {
+      intent: "primary",
+      size: "condensed"
+    }
+  }
+);
+exports.DaikinButton = class DaikinButton extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.variant = "primary";
+    this.disabled = false;
+    this.rightIcon = null;
+    this.leftIcon = null;
+    this.href = "";
+    this.size = "default";
+    this.type = "button";
+    this.role = "button";
+    this.isLoading = false;
+  }
+  render() {
+    const buttonClassName = cvaButton({
+      intent: this.variant,
+      size: this.size
+    });
+    const content = lit.html`
+      ${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
+        href="${this.href}"
+        class="${buttonClassName}"
+        role="${this.role}"
+      >
+        ${content}
+      </a>`;
+    }
+    return lit.html`
+      <button
+        class="${buttonClassName}"
+        ?disabled="${this.disabled}"
+        type="${this.type}"
+        role="${this.role}"
+      >
+        ${content}
+      </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);
+  }
+};
+exports.DaikinButton.styles = lit.css`
+    ${lit.unsafeCSS(tailwind.default)}
+
+    :host {
+      --buttonColorBackgroundPrimaryActive: ${lit.unsafeCSS(
+  variables_js.buttonColorBackgroundPrimaryActive
+)};
+      --buttonColorBackgroundPrimaryFocus: ${lit.unsafeCSS(
+  variables_js.buttonColorBackgroundPrimaryFocus
+)};
+      --buttonColorBackgroundPrimaryHover: ${lit.unsafeCSS(
+  variables_js.buttonColorBackgroundPrimaryHover
+)};
+      --buttonColorBackgroundPrimaryPress: ${lit.unsafeCSS(
+  variables_js.buttonColorBackgroundPrimaryPress
+)};
+      --buttonColorBackgroundPrimaryDisabled: ${lit.unsafeCSS(
+  variables_js.buttonColorBackgroundPrimaryDisabled
+)};
+
+      display: inline-block;
+      width: fit-content;
+      min-height: 42px;
+      height: 1px;
+    }
+
+    :host([size="condensed"]) {
+      min-height: 32px;
+    }
+  `;
+__decorateClass([
+  decorators_js.property({ type: String })
+], exports.DaikinButton.prototype, "variant", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean, reflect: true })
+], exports.DaikinButton.prototype, "disabled", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinButton.prototype, "rightIcon", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinButton.prototype, "leftIcon", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinButton.prototype, "href", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinButton.prototype, "size", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinButton.prototype, "type", 2);
+__decorateClass([
+  decorators_js.property({ type: String, reflect: true })
+], exports.DaikinButton.prototype, "role", 2);
+__decorateClass([
+  decorators_js.property({ type: Boolean })
+], exports.DaikinButton.prototype, "isLoading", 2);
+exports.DaikinButton = __decorateClass([
+  decorators_js.customElement("daikin-button")
+], exports.DaikinButton);