@duskmoon-dev/components 0.1.2

package/dist/classes/table.d.ts

@@ -0,0 +1,36 @@
+export declare const tableWrapperClass = "table-wrapper";
+export declare const tableBaseClass = "table";
+export declare const tableBorderedClass = "table-bordered";
+export declare const tableLoadingClass = "table-loading";
+export declare const tableSmallClass = "table-sm";
+export declare const tableLargeClass = "table-lg";
+export declare const tableHeaderCellClass = "table-header-cell";
+export declare const tableCellClass = "table-cell";
+export declare const tableRowClass = "table-row";
+export declare const tableRowSelectedClass = "table-row-selected";
+export declare const tableRowExpandedClass = "table-row-expanded";
+export declare const tableEmptyClass = "table-empty";
+export declare const tableLoadingIndicatorClass = "table-loading-indicator";
+export declare const tableSorterClass = "table-sorter";
+export declare const tableSorterActiveClass = "table-sorter-active";
+export declare const tableFilterClass = "table-filter";
+export declare const tableSelectionCellClass = "table-selection-cell";
+export declare const tableExpandCellClass = "table-expand-cell";
+export declare const tableExpandButtonClass = "table-expand-button";
+export declare const tablePaginationClass = "table-pagination";
+export declare const tablePaginationButtonClass = "table-pagination-button";
+export declare const tablePaginationInfoClass = "table-pagination-info";
+export declare function getTableWrapperClasses({ loading, className, }: {
+    loading?: boolean;
+    className?: string;
+}): string;
+export declare function getTableClasses({ bordered, size, }: {
+    bordered?: boolean;
+    size?: "small" | "middle" | "large";
+}): string;
+export declare function getTableRowClasses({ selected, expanded, className, }: {
+    selected?: boolean;
+    expanded?: boolean;
+    className?: string;
+}): string;
+export declare function getTableSorterClasses(active?: boolean): string;

package/dist/classes/tabs.d.ts

@@ -0,0 +1,42 @@
+import type { TabsPosition, TabsSize, TabsType } from "../components/tabs/Tabs.types";
+export declare const tabsRootClass = "tabs-root";
+export declare const tabsRootVerticalClass = "tabs-root-vertical";
+export declare const tabsRootBottomClass = "tabs-root-bottom";
+export declare const tabsRootRightClass = "tabs-root-right";
+export declare const tabsBarClass = "tabs-bar";
+export declare const tabsBaseClass = "tabs";
+export declare const tabsVerticalClass = "tabs-vertical";
+export declare const tabsScrollableClass = "tabs-scrollable";
+export declare const tabsCenteredClass = "tabs-center";
+export declare const tabsBoxedClass = "tabs-boxed";
+export declare const tabBaseClass = "tab";
+export declare const tabActiveClass = "tab-active";
+export declare const tabDisabledClass = "tab-disabled";
+export declare const tabIconClass = "tab-icon";
+export declare const tabIconOnlyClass = "tab-icon-only";
+export declare const tabPanelClass = "tab-panel";
+export declare const tabPanelShowClass = "tab-panel-show";
+export declare const tabsAddClass = "tab tab-add";
+export declare const tabsCloseClass = "tab-icon tab-close";
+export declare const tabsSizeClasses: Record<TabsSize, string>;
+export declare const tabsTypeClasses: Record<TabsType, string>;
+export declare function getTabsRootClasses({ tabPosition, className, }: {
+    tabPosition?: TabsPosition;
+    className?: string;
+}): string;
+export declare function getTabsListClasses({ tabPosition, type, size, centered, }: {
+    tabPosition?: TabsPosition;
+    type?: TabsType;
+    size?: TabsSize;
+    centered?: boolean;
+}): string;
+export declare function getTabClasses({ active, disabled, iconOnly, className, }: {
+    active?: boolean;
+    disabled?: boolean;
+    iconOnly?: boolean;
+    className?: string;
+}): string;
+export declare function getTabPanelClasses({ active, className, }: {
+    active?: boolean;
+    className?: string;
+}): string;

package/dist/classes/tag.d.ts

@@ -0,0 +1,20 @@
+import type { TagColor } from "../components/tag/Tag.types";
+export declare const tagBaseClass = "chip";
+export declare const tagIconClass = "chip-icon";
+export declare const tagCloseClass = "chip-remove";
+export declare const tagCheckableClass = "chip-selectable";
+export declare const tagCheckedClass = "chip-selected";
+export declare const tagDisabledClass = "chip-disabled";
+export declare const tagBorderlessClass = "chip-borderless";
+export declare const tagCustomColorClass = "chip-custom-color";
+export declare const tagColorClasses: Record<TagColor, string>;
+export declare function getTagClasses({ color, bordered, className, }: {
+    color?: string;
+    bordered?: boolean;
+    className?: string;
+}): string;
+export declare function getCheckableTagClasses({ checked, disabled, className, }: {
+    checked?: boolean;
+    disabled?: boolean;
+    className?: string;
+}): string;

package/dist/classes/time-picker.d.ts

@@ -0,0 +1,24 @@
+import type { TimePickerSize, TimePickerStatus } from "../components/time-picker/TimePicker.types";
+export declare const timePickerBaseClass = "time-input time-picker";
+export declare const timePickerInputClass = "time-picker-input";
+export declare const timePickerIconClass = "time-picker-icon";
+export declare const timePickerClearClass = "time-picker-clear";
+export declare const timePickerPanelClass = "time-input-picker time-picker-panel";
+export declare const timePickerFooterClass = "time-picker-footer";
+export declare const timePickerNowClass = "time-picker-now";
+export declare const timePickerRangeClass = "time-picker-range";
+export declare const timePickerSeparatorClass = "time-picker-range-separator";
+export declare const timePickerSizeClasses: Record<TimePickerSize, string>;
+export declare const timePickerStatusClasses: Record<TimePickerStatus, string>;
+export declare function getTimePickerClasses({ size, status, disabled, open, range, className, }: {
+    size?: TimePickerSize;
+    status?: TimePickerStatus;
+    disabled?: boolean;
+    open?: boolean;
+    range?: boolean;
+    className?: string;
+}): string;
+export declare function getTimePickerPanelClasses({ open, className, }: {
+    open?: boolean;
+    className?: string;
+}): string;

package/dist/classes/timeline.d.ts

@@ -0,0 +1,20 @@
+import type { TimelineColor, TimelineMode, TimelineSize } from "../components/timeline/Timeline.types";
+export declare const timelineBaseClass = "timeline";
+export declare const timelineItemClass = "timeline-item";
+export declare const timelineMarkerBaseClass = "timeline-marker";
+export declare const timelineMarkerIconClass = "timeline-marker-icon";
+export declare const timelineContentClass = "timeline-content";
+export declare const timelineTimeClass = "timeline-time";
+export declare const timelinePendingClass = "timeline-item-pending";
+export declare const timelineModeClasses: Record<TimelineMode, string>;
+export declare const timelineSizeClasses: Record<TimelineSize, string>;
+export declare const timelineMarkerColorClasses: Record<TimelineColor, string>;
+export declare function getTimelineClasses({ mode, size, className, }: {
+    mode?: TimelineMode;
+    size?: TimelineSize;
+    className?: string;
+}): string;
+export declare function getTimelineMarkerClasses({ color, hasIcon, }: {
+    color?: TimelineColor;
+    hasIcon?: boolean;
+}): string;

package/dist/classes/tooltip.d.ts

@@ -0,0 +1,15 @@
+import type { TooltipPlacement, TooltipSize } from "../components/tooltip/Tooltip.types";
+export declare const tooltipWrapperClass = "tooltip-wrapper";
+export declare const tooltipBaseClass = "tooltip";
+export declare const tooltipShowClass = "tooltip-show";
+export declare const tooltipArrowClass = "tooltip-arrow";
+export declare const tooltipNoArrowClass = "tooltip-no-arrow";
+export declare const tooltipPlacementClasses: Record<TooltipPlacement, string>;
+export declare const tooltipSizeClasses: Record<TooltipSize, string>;
+export declare function getTooltipClasses({ placement, size, open, arrow, className, }: {
+    placement?: TooltipPlacement;
+    size?: TooltipSize;
+    open?: boolean;
+    arrow?: boolean;
+    className?: string;
+}): string;

package/dist/classes/tour.d.ts

@@ -0,0 +1,34 @@
+import type { TourPlacement } from "../components/tour/Tour.types";
+export declare const tourRootClass = "tour-root";
+export declare const tourOpenClass = "tour-open";
+export declare const tourMaskClass = "tour-mask";
+export declare const tourMaskHiddenClass = "tour-mask-hidden";
+export declare const tourTargetClass = "tour-target";
+export declare const tourPanelClass = "tour-panel popover";
+export declare const tourArrowClass = "tour-arrow popover-arrow";
+export declare const tourHeaderClass = "tour-header";
+export declare const tourTitleClass = "tour-title";
+export declare const tourCloseClass = "tour-close";
+export declare const tourBodyClass = "tour-body";
+export declare const tourCoverClass = "tour-cover";
+export declare const tourFooterClass = "tour-footer";
+export declare const tourIndicatorsClass = "tour-indicators";
+export declare const tourIndicatorClass = "tour-indicator";
+export declare const tourIndicatorActiveClass = "tour-indicator-active";
+export declare const tourActionsClass = "tour-actions";
+export declare const tourPlacementClasses: Record<TourPlacement, string>;
+export declare function getTourRootClasses({ open, className, }: {
+    open?: boolean;
+    className?: string;
+}): string;
+export declare function getTourMaskClasses({ visible, className, }: {
+    visible?: boolean;
+    className?: string;
+}): string;
+export declare function getTourPanelClasses({ placement, className, }: {
+    placement?: TourPlacement;
+    className?: string;
+}): string;
+export declare function getTourIndicatorClasses({ active }: {
+    active?: boolean;
+}): string;

package/dist/classes/transfer.d.ts

@@ -0,0 +1,30 @@
+export declare const transferBaseClass = "transfer";
+export declare const transferDisabledClass = "transfer-disabled";
+export declare const transferListClass = "transfer-list";
+export declare const transferListHeaderClass = "transfer-list-header";
+export declare const transferListBodyClass = "transfer-list-body";
+export declare const transferListItemClass = "transfer-list-item";
+export declare const transferListItemSelectedClass = "transfer-list-item-selected";
+export declare const transferListItemDisabledClass = "transfer-list-item-disabled";
+export declare const transferListItemContentClass = "transfer-list-item-content";
+export declare const transferListItemDescriptionClass = "transfer-list-item-description";
+export declare const transferListEmptyClass = "transfer-list-empty";
+export declare const transferSearchClass = "transfer-search";
+export declare const transferOperationClass = "transfer-operation";
+export declare const transferOperationButtonClass = "transfer-operation-button";
+export declare const transferPaginationClass = "transfer-pagination";
+export declare const transferPaginationButtonClass = "transfer-pagination-button";
+export declare function getTransferClasses({ disabled, oneWay, className, }: {
+    disabled?: boolean;
+    oneWay?: boolean;
+    className?: string;
+}): string;
+export declare function getTransferListClasses({ direction, className, }: {
+    direction: "left" | "right";
+    className?: string;
+}): string;
+export declare function getTransferListItemClasses({ selected, disabled, className, }: {
+    selected?: boolean;
+    disabled?: boolean;
+    className?: string;
+}): string;

package/dist/classes/tree-select.d.ts

@@ -0,0 +1,39 @@
+export declare const treeSelectContainerClass = "tree-select-container";
+export declare const treeSelectBaseClass = "tree-select";
+export declare const treeSelectOpenClass = "tree-select-open";
+export declare const treeSelectDisabledClass = "tree-select-disabled";
+export declare const treeSelectMultipleClass = "tree-select-multiple";
+export declare const treeSelectSelectionClass = "tree-select-selection";
+export declare const treeSelectPlaceholderClass = "tree-select-placeholder";
+export declare const treeSelectTagClass = "tree-select-tag";
+export declare const treeSelectClearClass = "tree-select-clear";
+export declare const treeSelectIconClass = "tree-select-icon";
+export declare const treeSelectDropdownClass = "tree-select-dropdown";
+export declare const treeSelectSearchClass = "tree-select-search";
+export declare const treeSelectListClass = "tree-select-list";
+export declare const treeSelectEmptyClass = "tree-select-empty";
+export declare const treeSelectNodeClass = "tree-select-node";
+export declare const treeSelectNodeSelectedClass = "tree-select-node-selected";
+export declare const treeSelectNodeCheckedClass = "tree-select-node-checked";
+export declare const treeSelectNodeExpandedClass = "tree-select-node-expanded";
+export declare const treeSelectNodeDisabledClass = "tree-select-node-disabled";
+export declare const treeSelectSwitcherClass = "tree-select-switcher";
+export declare const treeSelectCheckboxClass = "tree-select-checkbox";
+export declare const treeSelectTitleClass = "tree-select-title";
+export declare function getTreeSelectContainerClasses({ open, disabled, multiple, className, }: {
+    open?: boolean;
+    disabled?: boolean;
+    multiple?: boolean;
+    className?: string;
+}): string;
+export declare function getTreeSelectClasses({ disabled, className, }: {
+    disabled?: boolean;
+    className?: string;
+}): string;
+export declare function getTreeSelectNodeClasses({ selected, checked, expanded, disabled, className, }: {
+    selected?: boolean;
+    checked?: boolean;
+    expanded?: boolean;
+    disabled?: boolean;
+    className?: string;
+}): string;

package/dist/classes/tree.d.ts

@@ -0,0 +1,34 @@
+export declare const treeBaseClass = "tree";
+export declare const treeDirectoryClass = "tree-directory";
+export declare const treeDisabledClass = "tree-disabled";
+export declare const treeShowLineClass = "tree-show-line";
+export declare const treeCheckableClass = "tree-checkable";
+export declare const treeMultipleClass = "tree-multiple";
+export declare const treeListClass = "tree-list";
+export declare const treeNodeClass = "tree-node";
+export declare const treeNodeSelectedClass = "tree-node-selected";
+export declare const treeNodeCheckedClass = "tree-node-checked";
+export declare const treeNodeDisabledClass = "tree-node-disabled";
+export declare const treeNodeExpandedClass = "tree-node-expanded";
+export declare const treeNodeDraggableClass = "tree-node-draggable";
+export declare const treeNodeSwitcherClass = "tree-node-switcher";
+export declare const treeNodeCheckboxClass = "tree-node-checkbox";
+export declare const treeNodeIconClass = "tree-node-icon";
+export declare const treeNodeTitleClass = "tree-node-title";
+export declare const treeNodeChildrenClass = "tree-node-children";
+export declare function getTreeClasses({ disabled, checkable, multiple, showLine, directory, className, }: {
+    disabled?: boolean;
+    checkable?: boolean;
+    multiple?: boolean;
+    showLine?: boolean;
+    directory?: boolean;
+    className?: string;
+}): string;
+export declare function getTreeNodeClasses({ selected, checked, disabled, expanded, draggable, className, }: {
+    selected?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    expanded?: boolean;
+    draggable?: boolean;
+    className?: string;
+}): string;

package/dist/classes/typography.d.ts

@@ -0,0 +1,48 @@
+import type { TypographySize, TypographyStatus } from "../components/typography/Typography.types";
+export declare const typographyBaseClass = "typography markdown-body";
+export declare const typographyTextClass = "typography-text";
+export declare const typographyTitleClass = "typography-title";
+export declare const typographyParagraphClass = "typography-paragraph";
+export declare const typographyLinkClass = "typography-link";
+export declare const typographyDisabledClass = "typography-disabled";
+export declare const typographyEditableClass = "typography-editable";
+export declare const typographyEditingClass = "typography-editing";
+export declare const typographyCopyableClass = "typography-copyable";
+export declare const typographyEllipsisClass = "typography-ellipsis";
+export declare const typographyExpandClass = "typography-expand";
+export declare const typographyActionClass = "typography-action btn btn-text btn-sm";
+export declare const typographyEditInputClass = "typography-edit-input input";
+export declare const typographyStatusClasses: Record<TypographyStatus, string>;
+export declare const typographySizeClasses: Record<TypographySize, string>;
+export declare function getTypographyClasses(className?: string): string;
+export declare function getTypographyTextClasses({ status, disabled, editable, copyable, ellipsis, size, className, }: {
+    status?: TypographyStatus;
+    disabled?: boolean;
+    editable?: boolean;
+    copyable?: boolean;
+    ellipsis?: boolean;
+    size?: TypographySize;
+    className?: string;
+}): string;
+export declare function getTypographyTitleClasses({ status, disabled, editable, copyable, ellipsis, className, }: {
+    status?: TypographyStatus;
+    disabled?: boolean;
+    editable?: boolean;
+    copyable?: boolean;
+    ellipsis?: boolean;
+    className?: string;
+}): string;
+export declare function getTypographyParagraphClasses({ status, disabled, editable, copyable, ellipsis, className, }: {
+    status?: TypographyStatus;
+    disabled?: boolean;
+    editable?: boolean;
+    copyable?: boolean;
+    ellipsis?: boolean;
+    className?: string;
+}): string;
+export declare function getTypographyLinkClasses({ status, disabled, ellipsis, className, }: {
+    status?: TypographyStatus;
+    disabled?: boolean;
+    ellipsis?: boolean;
+    className?: string;
+}): string;

package/dist/classes/upload.d.ts

@@ -0,0 +1,31 @@
+import type { UploadListType } from "../components/upload/Upload.types";
+export declare const uploadBaseClass = "file-upload";
+export declare const uploadTriggerClass = "file-upload-trigger";
+export declare const uploadInputClass = "file-upload-input";
+export declare const uploadDropzoneClass = "file-upload-dropzone";
+export declare const uploadDropzoneDragoverClass = "file-upload-dropzone-dragover";
+export declare const uploadListClass = "file-upload-list";
+export declare const uploadItemClass = "file-upload-item";
+export declare const uploadItemInfoClass = "file-upload-item-info";
+export declare const uploadItemNameClass = "file-upload-item-name";
+export declare const uploadItemSizeClass = "file-upload-item-size";
+export declare const uploadItemActionsClass = "file-upload-item-actions";
+export declare const uploadPreviewClass = "file-upload-item-preview";
+export declare const uploadRemoveClass = "file-upload-item-remove";
+export declare const uploadProgressClass = "file-upload-progress";
+export declare const uploadProgressBarClass = "file-upload-progress-bar";
+export declare const uploadListTypeClasses: Record<UploadListType, string>;
+export declare function getUploadClasses({ disabled, dragger, dragover, className, }: {
+    disabled?: boolean;
+    dragger?: boolean;
+    dragover?: boolean;
+    className?: string;
+}): string;
+export declare function getUploadListClasses({ listType, className, }: {
+    listType?: UploadListType;
+    className?: string;
+}): string;
+export declare function getUploadItemClasses({ status, className, }: {
+    status?: string;
+    className?: string;
+}): string;

package/dist/classes/watermark.d.ts

@@ -0,0 +1,5 @@
+export declare const watermarkBaseClass = "watermark";
+export declare const watermarkContentClass = "watermark-content";
+export declare function getWatermarkClasses({ className }: {
+    className?: string;
+}): string;

package/dist/components/affix/Affix.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { AffixProps } from "./Affix.types";
+export declare const Affix: React.ForwardRefExoticComponent<Omit<AffixProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/affix/Affix.types.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps, ReactNode } from "react";
+export interface AffixProps extends Omit<ComponentProps<"div">, "children" | "onChange"> {
+    offsetTop?: number;
+    offsetBottom?: number;
+    target?: () => Window | HTMLElement | null;
+    onChange?: (affixed?: boolean) => void;
+    children?: ReactNode;
+}

package/dist/components/affix/index.d.ts

@@ -0,0 +1,2 @@
+export { Affix } from "./Affix";
+export type { AffixProps } from "./Affix.types";

package/dist/components/affix/index.js

@@ -0,0 +1,103 @@
+"use client";
+
+// src/components/affix/Affix.tsx
+import { forwardRef, useEffect, useRef, useState } from "react";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/affix.ts
+var affixBaseClass = "affix";
+var affixFixedClass = "affix-fixed";
+function getAffixClasses({
+  fixed,
+  className
+}) {
+  return cn(affixBaseClass, fixed && affixFixedClass, className);
+}
+
+// src/components/affix/Affix.tsx
+import { jsx } from "react/jsx-runtime";
+function getScrollTarget(target) {
+  if (typeof window === "undefined")
+    return null;
+  return target?.() ?? window;
+}
+function getScrollTop(target) {
+  if (!target)
+    return 0;
+  return target instanceof Window ? target.scrollY : target.scrollTop;
+}
+var Affix = forwardRef(({
+  offsetTop,
+  offsetBottom,
+  target,
+  onChange,
+  className,
+  style,
+  children,
+  ...props
+}, ref) => {
+  const [fixed, setFixed] = useState(false);
+  const fixedRef = useRef(fixed);
+  fixedRef.current = fixed;
+  useEffect(() => {
+    const scrollTarget = getScrollTarget(target);
+    if (!scrollTarget)
+      return;
+    function updateFixed() {
+      const scrollTop = getScrollTop(scrollTarget);
+      const nextFixed = offsetBottom !== undefined ? scrollTop > offsetBottom : scrollTop > (offsetTop ?? 0);
+      if (nextFixed !== fixedRef.current) {
+        fixedRef.current = nextFixed;
+        setFixed(nextFixed);
+        onChange?.(nextFixed);
+      }
+    }
+    updateFixed();
+    scrollTarget.addEventListener("scroll", updateFixed);
+    window.addEventListener("resize", updateFixed);
+    return () => {
+      scrollTarget.removeEventListener("scroll", updateFixed);
+      window.removeEventListener("resize", updateFixed);
+    };
+  }, [offsetBottom, offsetTop, onChange, target]);
+  return /* @__PURE__ */ jsx("div", {
+    ...props,
+    ref,
+    className: getAffixClasses({ fixed, className }),
+    style: {
+      position: fixed ? "fixed" : undefined,
+      top: fixed && offsetBottom === undefined ? offsetTop ?? 0 : undefined,
+      bottom: fixed && offsetBottom !== undefined ? offsetBottom : undefined,
+      ...style
+    },
+    children
+  });
+});
+Affix.displayName = "Affix";
+export {
+  Affix
+};

package/dist/components/alert/Alert.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { AlertProps } from "./Alert.types";
+export declare const Alert: React.ForwardRefExoticComponent<Omit<AlertProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/alert/Alert.types.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from "react";
+export type AlertColor = "info" | "success" | "warning" | "error";
+export type AlertAppearance = "filled" | "outline" | "tonal";
+export interface AlertProps extends ComponentProps<"div"> {
+    color?: AlertColor;
+    appearance?: AlertAppearance;
+}

package/dist/components/alert/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Alert";
+export * from "./Alert.types";

package/dist/components/alert/index.js

@@ -0,0 +1,65 @@
+"use client";
+
+// src/components/alert/Alert.tsx
+import { forwardRef } from "react";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/alert.ts
+var alertBaseClass = "alert";
+var alertColorClasses = {
+  info: "alert-info",
+  success: "alert-success",
+  warning: "alert-warning",
+  error: "alert-error"
+};
+var alertAppearanceClasses = {
+  filled: "",
+  outline: "alert-outline",
+  tonal: "alert-tonal"
+};
+function getAlertClasses({
+  color = "info",
+  appearance = "filled",
+  className
+}) {
+  return cn(alertBaseClass, alertColorClasses[color], alertAppearanceClasses[appearance], className);
+}
+
+// src/components/alert/Alert.tsx
+import { jsx } from "react/jsx-runtime";
+var Alert = forwardRef(({ className, color = "info", appearance = "filled", ...props }, ref) => {
+  return /* @__PURE__ */ jsx("div", {
+    ref,
+    role: "alert",
+    className: getAlertClasses({ color, appearance, className }),
+    ...props
+  });
+});
+Alert.displayName = "Alert";
+export {
+  Alert
+};

package/dist/components/anchor/Anchor.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { AnchorComponent, AnchorLinkProps } from "./Anchor.types";
+export declare const AnchorLink: React.ForwardRefExoticComponent<Omit<AnchorLinkProps, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+export declare const Anchor: AnchorComponent;

package/dist/components/anchor/Anchor.types.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentProps, ForwardRefExoticComponent, MouseEvent, ReactNode, RefAttributes } from "react";
+export interface AnchorItem {
+    key?: string;
+    href: string;
+    title: ReactNode;
+    target?: string;
+    children?: AnchorItem[];
+}
+export interface AnchorLinkProps extends Omit<ComponentProps<"a">, "children" | "href" | "onClick" | "title"> {
+    href: string;
+    title: ReactNode;
+    target?: string;
+    children?: ReactNode;
+    onClick?: ComponentProps<"a">["onClick"];
+}
+export interface AnchorProps extends Omit<ComponentProps<"nav">, "onChange" | "onClick"> {
+    items?: AnchorItem[];
+    targetOffset?: number;
+    bounds?: number;
+    offsetTop?: number;
+    getContainer?: () => Window | HTMLElement;
+    getCurrentAnchor?: (activeLink: string) => string;
+    affix?: boolean;
+    showInkInFixed?: boolean;
+    onClick?: (event: MouseEvent<HTMLElement>, link: {
+        title: ReactNode;
+        href: string;
+    }) => void;
+    onChange?: (currentActiveLink: string) => void;
+}
+export type AnchorLinkComponent = ForwardRefExoticComponent<AnchorLinkProps & RefAttributes<HTMLAnchorElement>>;
+export type AnchorComponent = ForwardRefExoticComponent<AnchorProps & RefAttributes<HTMLElement>> & {
+    Link: AnchorLinkComponent;
+};

package/dist/components/anchor/index.d.ts

@@ -0,0 +1,2 @@
+export { Anchor, AnchorLink } from "./Anchor";
+export type { AnchorComponent, AnchorItem, AnchorLinkComponent, AnchorLinkProps, AnchorProps, } from "./Anchor.types";