@duskmoon-dev/components 0.1.2

package/dist/components/dm-auxiliary/DmAuxiliary.types.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentProps, ReactNode } from "react";
+export interface DmAuxiliaryAction {
+    label: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+}
+export interface DmAuxiliaryProps extends Omit<ComponentProps<"div">, "content" | "children"> {
+    content?: string;
+    children?: ReactNode;
+    hideClose?: boolean;
+    icon?: ReactNode;
+    actions?: DmAuxiliaryAction[];
+    extra?: ReactNode;
+    onClose?: () => void;
+}

package/dist/components/dm-auxiliary/index.d.ts

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

package/dist/components/dm-auxiliary/index.js

@@ -0,0 +1,127 @@
+"use client";
+
+// src/components/dm-auxiliary/DmAuxiliary.tsx
+import { forwardRef, useEffect, 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/dm-auxiliary.ts
+var dmAuxiliaryBaseClass = "dm-auxiliary";
+var dmAuxiliaryContainerClass = "dm-auxiliary-container";
+var dmAuxiliaryIconClass = "dm-auxiliary-prompt-icon";
+var dmAuxiliaryContentClass = "dm-auxiliary-content";
+var dmAuxiliaryActionsClass = "dm-auxiliary-actions";
+var dmAuxiliaryActionClass = "dm-auxiliary-action";
+var dmAuxiliaryCloseClass = "dm-auxiliary-close";
+function getDmAuxiliaryClasses({
+  closed,
+  className
+}) {
+  return cn(dmAuxiliaryBaseClass, closed && "dm-auxiliary-closed", className);
+}
+
+// src/components/dm-auxiliary/DmAuxiliary.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var defaultIcon = /* @__PURE__ */ jsx("svg", {
+  "aria-hidden": "true",
+  focusable: "false",
+  width: "21",
+  height: "21",
+  viewBox: "0 0 21 21",
+  children: /* @__PURE__ */ jsx("path", {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    clipRule: "evenodd",
+    d: "M10.5 2.167a8.333 8.333 0 1 1 0 16.666 8.333 8.333 0 0 1 0-16.666Zm0 1.666a6.667 6.667 0 1 0 0 13.334 6.667 6.667 0 0 0 0-13.334Zm0 5c.46 0 .833.374.833.834v4.166a.833.833 0 1 1-1.666 0V9.667c0-.46.373-.834.833-.834Zm0-2.5h.833V8H9.667V6.333h.833Z"
+  })
+});
+function hasRenderableContent(content, children) {
+  return Boolean(content || children);
+}
+var DmAuxiliary = forwardRef(({
+  content = "",
+  children,
+  hideClose = false,
+  icon = defaultIcon,
+  actions,
+  extra,
+  onClose,
+  className,
+  ...props
+}, ref) => {
+  const [closed, setClosed] = useState(!hasRenderableContent(content, children));
+  useEffect(() => {
+    setClosed(!hasRenderableContent(content, children));
+  }, [children, content]);
+  if (closed)
+    return null;
+  function handleClose() {
+    setClosed(true);
+    onClose?.();
+  }
+  return /* @__PURE__ */ jsx("div", {
+    ...props,
+    ref,
+    className: getDmAuxiliaryClasses({ closed, className }),
+    children: /* @__PURE__ */ jsxs("div", {
+      className: dmAuxiliaryContainerClass,
+      children: [
+        icon ? /* @__PURE__ */ jsx("span", {
+          className: dmAuxiliaryIconClass,
+          children: icon
+        }) : null,
+        /* @__PURE__ */ jsx("div", {
+          className: dmAuxiliaryContentClass,
+          children: children ?? /* @__PURE__ */ jsx("span", {
+            dangerouslySetInnerHTML: { __html: content }
+          })
+        }),
+        actions?.length ? /* @__PURE__ */ jsx("div", {
+          className: dmAuxiliaryActionsClass,
+          children: actions.map((action, index) => /* @__PURE__ */ jsx("button", {
+            type: "button",
+            className: dmAuxiliaryActionClass,
+            disabled: action.disabled,
+            onClick: action.onClick,
+            children: action.label
+          }, index))
+        }) : null,
+        extra,
+        !hideClose ? /* @__PURE__ */ jsx("button", {
+          type: "button",
+          className: dmAuxiliaryCloseClass,
+          "aria-label": "Close auxiliary",
+          onClick: handleClose,
+          children: "x"
+        }) : null
+      ]
+    })
+  });
+});
+DmAuxiliary.displayName = "DmAuxiliary";
+export {
+  DmAuxiliary
+};

package/dist/components/dm-breadcrumb/DmBreadcrumb.d.ts

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

package/dist/components/dm-breadcrumb/DmBreadcrumb.types.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentProps, MouseEventHandler, ReactNode } from "react";
+import type { BreadcrumbMenuProps, BreadcrumbProps } from "../breadcrumb/Breadcrumb.types";
+export interface DmBreadcrumbHistoryItem {
+    pathname: string;
+    search?: string;
+}
+export interface DmBreadcrumbItem {
+    title: ReactNode;
+    url?: string;
+    href?: string;
+    value?: ReactNode;
+    onClick?: (url: string) => void;
+    itemRender?: (item: DmBreadcrumbItem) => ReactNode;
+    menu?: BreadcrumbMenuProps;
+}
+export interface DmBreadcrumbProps extends Omit<ComponentProps<"nav">, "children" | "onClick">, Omit<BreadcrumbProps, "items" | "routes" | "onClick"> {
+    items: DmBreadcrumbItem[];
+    isStoragePath?: boolean;
+    storageKey?: string;
+    maxHistoryLength?: number;
+    compact?: boolean;
+    maxVisibleItems?: number;
+    history?: DmBreadcrumbHistoryItem[];
+    onClick?: MouseEventHandler<HTMLElement>;
+}

package/dist/components/dm-breadcrumb/index.d.ts

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

package/dist/components/dm-breadcrumb/index.js

@@ -0,0 +1,460 @@
+"use client";
+
+// src/components/breadcrumb/Breadcrumb.tsx
+import React, { 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/breadcrumb.ts
+var breadcrumbBaseClass = "breadcrumbs";
+var breadcrumbItemClass = "breadcrumb-item";
+var breadcrumbItemActiveClass = "breadcrumb-item-active";
+var breadcrumbItemDisabledClass = "breadcrumb-item-disabled";
+var breadcrumbLinkClass = "breadcrumb-link";
+var breadcrumbSeparatorClass = "breadcrumb-separator";
+var breadcrumbIconClass = "breadcrumb-icon";
+var breadcrumbMenuClass = "breadcrumb-menu";
+var breadcrumbMenuListClass = "breadcrumb-menu-list";
+var breadcrumbMenuItemClass = "breadcrumb-menu-item";
+function getBreadcrumbClasses({ className }) {
+  return cn(breadcrumbBaseClass, className);
+}
+function getBreadcrumbItemClasses({
+  active,
+  disabled,
+  className
+}) {
+  return cn(breadcrumbItemClass, active && breadcrumbItemActiveClass, disabled && breadcrumbItemDisabledClass, className);
+}
+function getBreadcrumbLinkClasses({
+  disabled,
+  className
+}) {
+  return cn(breadcrumbLinkClass, disabled && breadcrumbItemDisabledClass, className);
+}
+
+// src/components/breadcrumb/Breadcrumb.tsx
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var defaultSeparator = "/";
+function isSeparatorItem(item) {
+  return "type" in item && item.type === "separator";
+}
+function hasNode(node) {
+  return node !== undefined && node !== null && node !== false;
+}
+function getItemTitle(item) {
+  if ("breadcrumbName" in item && hasNode(item.breadcrumbName)) {
+    return item.breadcrumbName;
+  }
+  return item.title ?? item.label;
+}
+function replacePathParams(path, params) {
+  return path.replace(/:([^/]+)/g, (token, key) => {
+    const value = params?.[key];
+    return value === undefined ? token : encodeURIComponent(String(value));
+  });
+}
+function normalizePathSegment(path) {
+  return path.replace(/^\/+|\/+$/g, "");
+}
+function buildPaths(routes, routeIndex, params) {
+  return routes.slice(0, routeIndex + 1).reduce((paths, route) => {
+    if (!route.path) {
+      return paths;
+    }
+    const path = normalizePathSegment(replacePathParams(route.path, params));
+    if (path) {
+      paths.push(path);
+    }
+    return paths;
+  }, []);
+}
+function getHref(item, paths) {
+  if (item.href) {
+    return item.href;
+  }
+  if (!item.path || paths.length === 0) {
+    return;
+  }
+  return `/${paths.join("/")}`;
+}
+function activateOnKeyboard(event) {
+  if (event.key !== "Enter" && event.key !== " ") {
+    return;
+  }
+  event.preventDefault();
+  event.currentTarget.click();
+}
+function renderItemBody(item) {
+  const title = getItemTitle(item);
+  return /* @__PURE__ */ jsxs(Fragment, {
+    children: [
+      item.icon ? /* @__PURE__ */ jsx("span", {
+        className: breadcrumbIconClass,
+        "aria-hidden": "true",
+        children: item.icon
+      }) : null,
+      hasNode(title) ? title : null
+    ]
+  });
+}
+function routeChildrenToMenu(children) {
+  if (!children?.length) {
+    return;
+  }
+  return {
+    items: children.map((child, index) => ({
+      key: child.key ?? child.path ?? index,
+      label: getItemTitle(child),
+      href: child.href,
+      path: child.path,
+      icon: child.icon,
+      disabled: child.disabled,
+      onClick: child.onClick,
+      children: child.children?.map((nested, nestedIndex) => ({
+        key: nested.key ?? nested.path ?? nestedIndex,
+        label: getItemTitle(nested),
+        href: nested.href,
+        path: nested.path,
+        icon: nested.icon,
+        disabled: nested.disabled,
+        onClick: nested.onClick
+      }))
+    }))
+  };
+}
+function renderMenuItems(menu, items = []) {
+  return items.map((item, index) => {
+    const key = item.key ?? item.path ?? index;
+    const href = item.href ?? item.path;
+    const label = renderItemBody(item);
+    function handleClick(event) {
+      if (item.disabled) {
+        event.preventDefault();
+        return;
+      }
+      item.onClick?.(event);
+      menu.onClick?.({ key, item, domEvent: event });
+    }
+    const content = item.disabled ? /* @__PURE__ */ jsx("span", {
+      role: "menuitem",
+      "aria-disabled": "true",
+      className: getBreadcrumbLinkClasses({
+        disabled: true,
+        className: breadcrumbMenuItemClass
+      }),
+      children: label
+    }) : href ? /* @__PURE__ */ jsx("a", {
+      role: "menuitem",
+      className: cn(breadcrumbMenuItemClass, getBreadcrumbLinkClasses({})),
+      href,
+      onClick: handleClick,
+      children: label
+    }) : /* @__PURE__ */ jsx("button", {
+      type: "button",
+      role: "menuitem",
+      className: cn(breadcrumbMenuItemClass, getBreadcrumbLinkClasses({})),
+      onClick: handleClick,
+      children: label
+    });
+    return /* @__PURE__ */ jsxs("li", {
+      children: [
+        content,
+        item.children?.length ? /* @__PURE__ */ jsx("ul", {
+          className: breadcrumbMenuListClass,
+          role: "menu",
+          children: renderMenuItems(menu, item.children)
+        }) : null
+      ]
+    }, key);
+  });
+}
+function renderDefaultItemContent(item, paths, active) {
+  const body = renderItemBody(item);
+  if (item.disabled) {
+    return body;
+  }
+  const href = item.href ?? (!active ? getHref(item, paths) : undefined);
+  if (href) {
+    return /* @__PURE__ */ jsx("a", {
+      className: getBreadcrumbLinkClasses({}),
+      href,
+      onClick: item.onClick,
+      children: body
+    });
+  }
+  if (item.onClick) {
+    return /* @__PURE__ */ jsx("span", {
+      role: "button",
+      tabIndex: 0,
+      className: getBreadcrumbLinkClasses({}),
+      onClick: item.onClick,
+      onKeyDown: activateOnKeyboard,
+      children: body
+    });
+  }
+  return body;
+}
+function renderMenuItem(item, menu, children, disabled) {
+  return /* @__PURE__ */ jsxs("details", {
+    className: getBreadcrumbItemClasses({
+      disabled,
+      className: cn(breadcrumbMenuClass, item.className)
+    }),
+    "aria-disabled": disabled || undefined,
+    children: [
+      /* @__PURE__ */ jsx("summary", {
+        className: getBreadcrumbLinkClasses({ disabled }),
+        children
+      }),
+      /* @__PURE__ */ jsx("ul", {
+        className: breadcrumbMenuListClass,
+        role: "menu",
+        children: renderMenuItems(menu, menu.items)
+      })
+    ]
+  });
+}
+var Breadcrumb = forwardRef(({
+  items,
+  routes,
+  params = {},
+  separator = defaultSeparator,
+  itemRender,
+  className,
+  children,
+  "aria-label": ariaLabel = "Breadcrumb",
+  ...props
+}, ref) => {
+  const entries = items ?? routes;
+  if (!entries?.length) {
+    return /* @__PURE__ */ jsx("nav", {
+      ...props,
+      ref,
+      "aria-label": ariaLabel,
+      className: getBreadcrumbClasses({ className }),
+      children
+    });
+  }
+  const routeEntries = entries.filter((item) => !isSeparatorItem(item));
+  let routeIndex = -1;
+  let previousRenderedItemWasSeparator = true;
+  return /* @__PURE__ */ jsx("nav", {
+    ...props,
+    ref,
+    "aria-label": ariaLabel,
+    className: getBreadcrumbClasses({ className }),
+    children: entries.map((entry, index) => {
+      if (isSeparatorItem(entry)) {
+        previousRenderedItemWasSeparator = true;
+        return /* @__PURE__ */ jsx("span", {
+          className: cn(breadcrumbSeparatorClass, entry.className),
+          "aria-hidden": "true",
+          children: entry.separator ?? separator
+        }, entry.key ?? `separator-${index}`);
+      }
+      routeIndex += 1;
+      const currentRouteIndex = routeIndex;
+      const paths = buildPaths(routeEntries, currentRouteIndex, params);
+      const active = currentRouteIndex === routeEntries.length - 1;
+      const menu = entry.menu ?? routeChildrenToMenu(entry.children);
+      const content = itemRender?.(entry, params, routeEntries, paths) ?? renderDefaultItemContent(entry, paths, active);
+      const applyActiveClass = active && !itemRender && !entry.href && !entry.onClick;
+      const insertSeparator = !previousRenderedItemWasSeparator;
+      previousRenderedItemWasSeparator = false;
+      return /* @__PURE__ */ jsxs(React.Fragment, {
+        children: [
+          insertSeparator ? /* @__PURE__ */ jsx("span", {
+            className: breadcrumbSeparatorClass,
+            "aria-hidden": "true",
+            children: separator
+          }) : null,
+          menu?.items?.length ? renderMenuItem(entry, menu, content, entry.disabled) : /* @__PURE__ */ jsx("span", {
+            className: getBreadcrumbItemClasses({
+              active: applyActiveClass,
+              disabled: entry.disabled,
+              className: entry.className
+            }),
+            "aria-current": active ? "page" : undefined,
+            "aria-disabled": entry.disabled || undefined,
+            children: content
+          })
+        ]
+      }, entry.key ?? entry.href ?? entry.path ?? currentRouteIndex);
+    })
+  });
+});
+Breadcrumb.displayName = "Breadcrumb";
+// src/components/dm-breadcrumb/DmBreadcrumb.tsx
+import { forwardRef as forwardRef2, useEffect, useMemo, useState } from "react";
+
+// src/classes/dm-breadcrumb.ts
+var dmBreadcrumbClass = "dm-breadcrumb";
+var dmBreadcrumbCompactClass = "dm-breadcrumb-compact";
+var dmBreadcrumbRecentClass = "dm-breadcrumb-recent";
+var dmBreadcrumbValueClass = "dm-breadcrumb-value";
+function getDmBreadcrumbClasses({
+  compact,
+  recent,
+  className
+}) {
+  return cn(dmBreadcrumbClass, compact && dmBreadcrumbCompactClass, recent && dmBreadcrumbRecentClass, className);
+}
+
+// src/components/dm-breadcrumb/DmBreadcrumb.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var defaultStorageKey = "dm-breadcrumb-history-list";
+var defaultMaxHistoryLength = 10;
+function canUseSessionStorage() {
+  return typeof window !== "undefined" && typeof window.sessionStorage !== "undefined";
+}
+function readHistory(storageKey) {
+  if (!canUseSessionStorage())
+    return [];
+  try {
+    const raw = window.sessionStorage.getItem(storageKey);
+    const parsed = raw ? JSON.parse(raw) : [];
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeHistory(storageKey, history) {
+  if (!canUseSessionStorage())
+    return;
+  window.sessionStorage.setItem(storageKey, JSON.stringify(history));
+}
+function currentLocation() {
+  if (typeof window === "undefined")
+    return;
+  return {
+    pathname: window.location.pathname,
+    search: window.location.search
+  };
+}
+function upsertHistory(history, item, maxLength) {
+  const nextHistory = history.filter((entry) => entry.pathname !== item.pathname);
+  return [...nextHistory, item].slice(-maxLength);
+}
+function resolveRecentUrl(item, history, isStoragePath) {
+  const baseUrl = item.url ?? item.href ?? "";
+  if (!isStoragePath || !item.url)
+    return baseUrl;
+  const recent = history.find((entry) => entry.pathname === item.url);
+  return recent ? `${recent.pathname}${recent.search ?? ""}` : baseUrl;
+}
+function renderTitle(item, index) {
+  if (item.itemRender)
+    return item.itemRender(item);
+  return /* @__PURE__ */ jsxs2("span", {
+    title: typeof item.title === "string" ? item.title : undefined,
+    children: [
+      item.title,
+      item.value !== undefined && index > 0 ? /* @__PURE__ */ jsxs2("span", {
+        className: dmBreadcrumbValueClass,
+        children: [
+          "(",
+          item.value,
+          ")"
+        ]
+      }) : null
+    ]
+  });
+}
+function collapseItems(items, maxVisibleItems) {
+  if (!maxVisibleItems || items.length <= maxVisibleItems || maxVisibleItems < 3) {
+    return items;
+  }
+  const headCount = 2;
+  const tailCount = Math.max(1, maxVisibleItems - headCount - 1);
+  return [
+    ...items.slice(0, headCount),
+    { type: "separator", key: "__dm-breadcrumb-ellipsis", separator: "..." },
+    ...items.slice(-tailCount)
+  ];
+}
+var DmBreadcrumb = forwardRef2(({
+  items,
+  isStoragePath = true,
+  storageKey = defaultStorageKey,
+  maxHistoryLength = defaultMaxHistoryLength,
+  maxVisibleItems,
+  compact,
+  history,
+  className,
+  separator,
+  ...props
+}, ref) => {
+  const [currentHistory, setCurrentHistory] = useState(() => history ?? readHistory(storageKey));
+  useEffect(() => {
+    if (history) {
+      setCurrentHistory(history);
+    }
+  }, [history]);
+  useEffect(() => {
+    if (!isStoragePath || history)
+      return;
+    const locationItem = currentLocation();
+    if (!locationItem)
+      return;
+    setCurrentHistory((prevHistory) => {
+      const nextHistory = upsertHistory(prevHistory, locationItem, maxHistoryLength);
+      writeHistory(storageKey, nextHistory);
+      return nextHistory;
+    });
+  }, [history, isStoragePath, maxHistoryLength, storageKey]);
+  const breadcrumbItems = useMemo(() => {
+    const mappedItems = items.map((item, index) => {
+      const url = resolveRecentUrl(item, currentHistory, isStoragePath);
+      return {
+        key: item.url ?? item.href ?? index,
+        title: renderTitle(item, index),
+        href: item.onClick ? undefined : url || undefined,
+        menu: item.menu,
+        onClick: item.onClick ? (event) => {
+          event.preventDefault();
+          item.onClick?.(url);
+        } : undefined
+      };
+    });
+    return collapseItems(mappedItems, maxVisibleItems);
+  }, [currentHistory, isStoragePath, items, maxVisibleItems]);
+  return /* @__PURE__ */ jsx2(Breadcrumb, {
+    ...props,
+    ref,
+    items: breadcrumbItems,
+    separator,
+    className: getDmBreadcrumbClasses({
+      compact,
+      recent: isStoragePath,
+      className
+    })
+  });
+});
+DmBreadcrumb.displayName = "DmBreadcrumb";
+export {
+  DmBreadcrumb
+};

package/dist/components/dm-date-picker/DmDatePicker.d.ts

@@ -0,0 +1,4 @@
+import { setDmDatePickerLocale } from "../../infrastructure";
+import type { DmDatePickerComponent } from "./DmDatePicker.types";
+export declare const DmDatePicker: DmDatePickerComponent;
+export { setDmDatePickerLocale };

package/dist/components/dm-date-picker/DmDatePicker.types.d.ts

@@ -0,0 +1,11 @@
+import type { ForwardRefExoticComponent, RefAttributes } from "react";
+import type { DatePickerProps, RangePickerProps } from "../date-picker";
+export type DmDatePickerProps = DatePickerProps;
+export type DmRangePickerProps = RangePickerProps;
+export interface DmDatePickerComponent extends ForwardRefExoticComponent<DmDatePickerProps & RefAttributes<HTMLDivElement>> {
+    RangePicker: ForwardRefExoticComponent<DmRangePickerProps & RefAttributes<HTMLDivElement>>;
+    WeekPicker: ForwardRefExoticComponent<DmDatePickerProps & RefAttributes<HTMLDivElement>>;
+    MonthPicker: ForwardRefExoticComponent<DmDatePickerProps & RefAttributes<HTMLDivElement>>;
+    QuarterPicker: ForwardRefExoticComponent<DmDatePickerProps & RefAttributes<HTMLDivElement>>;
+    YearPicker: ForwardRefExoticComponent<DmDatePickerProps & RefAttributes<HTMLDivElement>>;
+}

package/dist/components/dm-date-picker/index.d.ts

@@ -0,0 +1,2 @@
+export { DmDatePicker, setDmDatePickerLocale } from "./DmDatePicker";
+export type { DmDatePickerComponent, DmDatePickerProps, DmRangePickerProps, } from "./DmDatePicker.types";