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

package/dist/es-dev/components/breadcrumb/daikin-breadcrumb.js

@@ -0,0 +1,125 @@
+import { css, unsafeCSS, LitElement, html } from "lit";
+import { queryAssignedElements, property, customElement } from "lit/decorators.js";
+import { createRef, ref } from "lit/directives/ref.js";
+import tailwindStyles from "../../tailwind.css.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;
+};
+let DaikinBreadcrumb = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.resizeObserver = new ResizeObserver(() => {
+      this._omit();
+    });
+    this._divWrapRef = 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 html`
+      <div class="flex gap-2" ${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(() => {
+    });
+  }
+};
+DaikinBreadcrumb.styles = css`
+    ${unsafeCSS(tailwindStyles)}
+
+    :host {
+      display: flex;
+      align-items: center;
+    }
+  `;
+__decorateClass([
+  queryAssignedElements()
+], DaikinBreadcrumb.prototype, "_slottedDaikinBreadCrumbItems", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true, attribute: "trailing-slash" })
+], DaikinBreadcrumb.prototype, "trailingSlash", 2);
+__decorateClass([
+  property({ type: String, reflect: true })
+], DaikinBreadcrumb.prototype, "overflow", 2);
+DaikinBreadcrumb = __decorateClass([
+  customElement("daikin-breadcrumb")
+], DaikinBreadcrumb);
+export {
+  DaikinBreadcrumb
+};

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

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

package/dist/es-dev/components/breadcrumb/index.js

@@ -0,0 +1,4 @@
+import { DaikinBreadcrumb } from "./daikin-breadcrumb.js";
+export {
+  DaikinBreadcrumb
+};

package/dist/es-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/es-dev/components/breadcrumb-item/daikin-breadcrumb-item.js

@@ -0,0 +1,117 @@
+import { cva } from "class-variance-authority";
+import { css, unsafeCSS, LitElement, html } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import { ifDefined } from "lit/directives/if-defined.js";
+import tailwindStyles from "../../tailwind.css.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;
+};
+const cvaLinkSlot = 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: []
+      }
+    }
+  }
+);
+let DaikinBreadcrumbItem = class extends 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 ? html`<span class="text-daikinNeutral-800 font-daikinSerif">/</span>` : null;
+    return html`
+      ${this.variant === "normal" ? html`<slot name="link" class=${cvaLinkSlot(this)}>
+            <a
+              href=${ifDefined(this.href)}
+              target=${// eslint-disable-next-line @typescript-eslint/no-explicit-any -- workaround lit-analyzer checking
+    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.
+      html`<span class=${cvaLinkSlot(this)} aria-label="…">
+            <span>. . .</span>
+          </span> `
+    )}
+      ${slash}
+    `;
+  }
+};
+DaikinBreadcrumbItem.styles = css`
+    ${unsafeCSS(tailwindStyles)}
+
+    :host {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      flex-shrink: 0;
+    }
+
+    :host([hidden]) {
+      display: none;
+    }
+  `;
+__decorateClass([
+  property({ type: String, reflect: true })
+], DaikinBreadcrumbItem.prototype, "href", 2);
+__decorateClass([
+  property({ type: String, reflect: true })
+], DaikinBreadcrumbItem.prototype, "variant", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DaikinBreadcrumbItem.prototype, "disabled", 2);
+__decorateClass([
+  property({ type: String, reflect: true })
+], DaikinBreadcrumbItem.prototype, "target", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true, attribute: "trailing-slash" })
+], DaikinBreadcrumbItem.prototype, "trailingSlash", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DaikinBreadcrumbItem.prototype, "hidden", 2);
+DaikinBreadcrumbItem = __decorateClass([
+  customElement("daikin-breadcrumb-item")
+], DaikinBreadcrumbItem);
+export {
+  DaikinBreadcrumbItem
+};

package/dist/es-dev/components/breadcrumb-item/index.d.ts

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

package/dist/es-dev/components/breadcrumb-item/index.js

@@ -0,0 +1,4 @@
+import { DaikinBreadcrumbItem } from "./daikin-breadcrumb-item.js";
+export {
+  DaikinBreadcrumbItem
+};

package/dist/es-dev/components/button/daikin-button.d.ts

@@ -2,7 +2,6 @@ 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;

package/dist/es-dev/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;

package/dist/es-dev/components/icon/daikin-icon.d.ts

@@ -1,7 +1,6 @@
 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?: ({

package/dist/es-dev/components/index.d.ts

@@ -1,14 +1,18 @@
 export * from './accordion';
 export * from './accordion-item';
+export * from './breadcrumb';
+export * from './breadcrumb-item';
 export * from './button';
 export * from './checkbox';
 export * from './icon';
 export * from './input-group';
 export * from './notification';
 export * from './panel-switcher';
+export * from './progress-bar';
 export * from './radio';
 export * from './tab';
 export * from './tab-group';
 export * from './text-input';
 export * from './textarea';
 export * from './toggle';
+export * from './tooltip';

package/dist/es-dev/components/index.js

@@ -1,31 +1,39 @@
 import { DaikinAccordion } from "./accordion/daikin-accordion.js";
 import { DaikinAccordionItem } from "./accordion-item/daikin-accordion-item.js";
+import { DaikinBreadcrumb } from "./breadcrumb/daikin-breadcrumb.js";
+import { DaikinBreadcrumbItem } from "./breadcrumb-item/daikin-breadcrumb-item.js";
 import { DaikinButton } from "./button/daikin-button.js";
 import { DaikinCheckbox } from "./checkbox/daikin-checkbox.js";
 import { DaikinIcon, iconList } from "./icon/daikin-icon.js";
 import { DaikinInputGroup } from "./input-group/daikin-input-group.js";
 import { DaikinNotification } from "./notification/daikin-notification.js";
 import { DaikinPanelSwitcher } from "./panel-switcher/daikin-panel-switcher.js";
+import { DaikinProgressBar } from "./progress-bar/daikin-progress-bar.js";
 import { DaikinRadio } from "./radio/daikin-radio.js";
 import { DaikinTab } from "./tab/daikin-tab.js";
 import { DaikinTabGroup } from "./tab-group/daikin-tab-group.js";
 import { DaikinTextInput } from "./text-input/daikin-text-input.js";
 import { DaikinTextarea } from "./textarea/daikin-textarea.js";
 import { DaikinToggle } from "./toggle/daikin-toggle.js";
+import { DaikinTooltip } from "./tooltip/daikin-tooltip.js";
 export {
   DaikinAccordion,
   DaikinAccordionItem,
+  DaikinBreadcrumb,
+  DaikinBreadcrumbItem,
   DaikinButton,
   DaikinCheckbox,
   DaikinIcon,
   DaikinInputGroup,
   DaikinNotification,
   DaikinPanelSwitcher,
+  DaikinProgressBar,
   DaikinRadio,
   DaikinTab,
   DaikinTabGroup,
   DaikinTextInput,
   DaikinTextarea,
   DaikinToggle,
+  DaikinTooltip,
   iconList
 };

package/dist/es-dev/components/input-group/daikin-input-group.d.ts

@@ -1,7 +1,6 @@
 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.

package/dist/es-dev/components/input-group/daikin-input-group.js

@@ -68,7 +68,7 @@ let DaikinInputGroup = class extends LitElement {
         <slot @slotchange=${this._handleSlotChange}></slot>
         ${this.helper && !this.error ? html`<span class=${inputGroupHelperClassName}>${this.helper}</span>` : null}
         ${!this.disabled && !!this.error ? html`<span
-              class="flex gap-2 text-[--input-group-border-color-error] leading-[22px] before:i-daikin-input-group-error before:block before:w-[16px] before:h-[22px]"
+              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>

package/dist/es-dev/components/notification/daikin-notification.d.ts

@@ -1,6 +1,5 @@
 import { LitElement } from 'lit';
 import { MergeVariantProps } from '../../type-utils';
-
 declare const cvaContainer: (props?: ({
     variant?: "toast" | "inline" | null | undefined;
     status?: "alarm" | "information" | "negative" | "positive" | "warning" | null | undefined;

package/dist/es-dev/components/panel-switcher/daikin-panel-switcher.d.ts

@@ -1,6 +1,5 @@
 import { LitElement } from 'lit';
 import { ARIARole } from '../../lit-analyzer-types';
-
 /**
  * The panel switcher component is a child element within the `daikin-tab-group` 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.

package/dist/es-dev/components/progress-bar/daikin-progress-bar.d.ts

@@ -0,0 +1,47 @@
+import { LitElement, PropertyValues } from 'lit';
+/**
+ * The progress bar component is used to visually convey the progress to the user.
+ *
+ * There are four variants of the progress bar:
+ *
+ * - "inprogress": The default variant. Use this when you know the exact progress. The length of the bar is the ratio of `value` to `max`.
+ * - "indeterminate": Use this variant when you don't know the exact progress. In this variant, the `value` is ignored and the bar always animates from left to right with a constant length.
+ * - "completed": In addition to "inprogress", a completed icon is added. In this variant, the `value` is ignored and the bar always expands to the full width.
+ * - "error": In addition to "inprogress", an error icon is added and the color becomes red. In this variant, the `value` is ignored and the bar always expands to the full width.
+ *
+ * @example
+ *
+ * ```html
+ * <daikin-progress-bar value="40" helper="Progress bar helper">
+ *   Progress bar label
+ * </daikin-progress-bar>
+ * ```
+ */
+export declare class DaikinProgressBar extends LitElement {
+    static readonly styles: import('lit').CSSResult;
+    /**
+     * Value of the progress bar
+     */
+    value: number;
+    /**
+     * Variant of the progress bar
+     */
+    variant: "inprogress" | "completed" | "indeterminate" | "error";
+    /**
+     * The max value of the progress bar
+     */
+    max: number;
+    /**
+     * Helper text
+     */
+    helper: string;
+    private _validateProperties;
+    render(): import('lit-html').TemplateResult<1>;
+    protected updated(changedProperties: PropertyValues): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "daikin-progress-bar": DaikinProgressBar;
+    }
+}
+export default DaikinProgressBar;

package/dist/es-dev/components/progress-bar/daikin-progress-bar.js

@@ -0,0 +1,153 @@
+import { colorFeedbackPositive, colorFeedbackNegative } from "@daikin-oss/dds-tokens/js/daikin/Light/variables.js";
+import { cva } from "class-variance-authority";
+import { css, unsafeCSS, LitElement, html } from "lit";
+import { property, customElement } from "lit/decorators.js";
+import tailwindStyles from "../../tailwind.css.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;
+};
+const cvaBar = cva(
+  [
+    "w-full",
+    "h-1",
+    "bg-daikinNeutral-200",
+    "overflow-hidden",
+    "relative",
+    "after:block",
+    "after:h-full",
+    "after:absolute",
+    "after:left-0"
+  ],
+  {
+    variants: {
+      variant: {
+        inprogress: ["after:w-[--bar-width]", "after:bg-daikinBlue-500"],
+        completed: ["after:w-full", "after:bg-[--colorFeedbackPositive]"],
+        indeterminate: [
+          "after:w-1/2",
+          "after:bg-daikinBlue-500",
+          "after:animate-[progress-bar-indeterminate_1200ms_linear_infinite]"
+        ],
+        error: ["after:w-full", "after:bg-[--colorFeedbackNegative]"]
+      }
+    }
+  }
+);
+const cvaIcon = cva(["size-4"], {
+  variants: {
+    variant: {
+      inprogress: ["none"],
+      completed: ["i-daikin-status-positive"],
+      indeterminate: [],
+      error: ["i-daikin-status-negative"]
+    }
+  }
+});
+const cvaHelper = cva(["text-xs", "mt-2"], {
+  variants: {
+    variant: {
+      inprogress: [],
+      completed: [],
+      indeterminate: [],
+      error: ["text-[--colorFeedbackNegative]"]
+    }
+  }
+});
+let DaikinProgressBar = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.value = 0;
+    this.variant = "inprogress";
+    this.max = 100;
+    this.helper = "";
+  }
+  // Validate the 'value' and 'max' properties to ensure they are valid
+  _validateProperties() {
+    if (typeof this.value !== "number" || this.value < 0) {
+      {
+        console.warn(
+          `Invalid 'value' property: ${this.value}. Falling back to 0.`
+        );
+      }
+      this.value = 0;
+    }
+    if (typeof this.max !== "number" || this.max <= 0) {
+      {
+        console.warn(
+          `Invalid 'max' property: ${this.max}. Falling back to 100.`
+        );
+      }
+      this.max = 100;
+    }
+    if (this.value > this.max) {
+      {
+        console.warn(
+          `'value' property: ${this.value} exceeds 'max' property: ${this.max}. Clamping value to max.`
+        );
+      }
+      this.value = this.max;
+    }
+  }
+  render() {
+    const progressRatio = Math.min(Math.max(this.value / this.max, 0), 1);
+    return html`<div class="flex flex-col w-full font-daikinSerif">
+      <div class="flex justify-between items-center mb-2.5">
+        <span class="text-sm leading-[22px] font-medium"><slot></slot></span>
+        <span class=${cvaIcon({ variant: this.variant })}></span>
+      </div>
+      <div
+        class=${cvaBar({ variant: this.variant })}
+        role="progressbar"
+        aria-label=${this.textContent ?? ""}
+        aria-valuenow=${this.value}
+        aria-valuemin="0"
+        aria-valuemax=${this.max}
+        style=${`--bar-width:${progressRatio * 100}%`}
+      ></div>
+      ${this.helper ? html`<span class=${cvaHelper({ variant: this.variant })}
+            >${this.helper}</span
+          >` : null}
+    </div>`;
+  }
+  updated(changedProperties) {
+    if (changedProperties.has("value") || changedProperties.has("max")) {
+      this._validateProperties();
+    }
+  }
+};
+DaikinProgressBar.styles = css`
+    ${unsafeCSS(tailwindStyles)}
+
+    :host {
+      --colorFeedbackPositive: ${unsafeCSS(colorFeedbackPositive)};
+      --colorFeedbackNegative: ${unsafeCSS(colorFeedbackNegative)};
+
+      display: block;
+      width: 100%;
+    }
+  `;
+__decorateClass([
+  property({ type: Number })
+], DaikinProgressBar.prototype, "value", 2);
+__decorateClass([
+  property({ type: String })
+], DaikinProgressBar.prototype, "variant", 2);
+__decorateClass([
+  property({ type: Number })
+], DaikinProgressBar.prototype, "max", 2);
+__decorateClass([
+  property({ type: String })
+], DaikinProgressBar.prototype, "helper", 2);
+DaikinProgressBar = __decorateClass([
+  customElement("daikin-progress-bar")
+], DaikinProgressBar);
+export {
+  DaikinProgressBar
+};

package/dist/es-dev/components/progress-bar/index.d.ts

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

package/dist/es-dev/components/progress-bar/index.js

@@ -0,0 +1,4 @@
+import { DaikinProgressBar } from "./daikin-progress-bar.js";
+export {
+  DaikinProgressBar
+};

package/dist/es-dev/components/radio/daikin-radio.d.ts

@@ -1,6 +1,5 @@
 import { LitElement } from 'lit';
 import { MergeVariantProps } from '../../type-utils';
-
 declare const cvaRadio: (props?: ({
     size?: "small" | "large" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/es-dev/components/tab/daikin-tab.d.ts

@@ -1,5 +1,4 @@
 import { LitElement } from 'lit';
-
 /**
  * The tab component is a child element within the `daikin-tab-group` component, representing a clickable button or label that users interact with to switch between different panels of content.
  * Each tab corresponds to a specific panel and is typically labeled to indicate the content it reveals.

package/dist/es-dev/components/tab-group/daikin-tab-group.d.ts

@@ -1,5 +1,4 @@
 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.