@nanisoft/prism-ui 0.10.1 → 0.13.0

package/dist/components/ui/aspect-ratio.d.ts

@@ -0,0 +1,60 @@
+import type { ComponentProps } from 'react';
+/** The props the AspectRatio accepts. */
+export interface AspectRatioProps extends ComponentProps<'div'> {
+    /**
+     * The ratio to hold, as CSS's `aspect-ratio` value: width over height.
+     *
+     * A number rather than a pair, and not a keyword. `16 / 9` is the shape the
+     * CSS property takes and the shape a designer writes, and the keyword set
+     * (`square`, `video`) is closed and short of every ratio a caller actually has.
+     */
+    ratio?: number;
+    /** Layout only. */
+    className?: string;
+}
+/**
+ * A box whose height follows its width at a stated ratio.
+ *
+ * **Why this is a Component and not a class.** The instinct is `className="aspect-video"`
+ * and a caller who has run out of keywords writes `className="aspect-[4/3]"`. Neither
+ * reaches a consumer's browser. Prism's stylesheet scans Prism's own source and
+ * nothing else, because Tailwind is an internal build dependency of this package
+ * and never the consumer's, so a utility that appears in no Prism source file is
+ * a utility no consumer's stylesheet contains. An arbitrary value typed by a
+ * consumer is therefore not a layout decision, it is a silently missing rule and
+ * a box at whatever ratio its content happens to have. `ratio` is a prop so the
+ * ratio is a number this package reads and applies, not a name this package
+ * cannot see.
+ *
+ * **It is not the Diagram's canvas, and the two do not overlap.** The Diagram
+ * draws nodes and the relations between them into a fixed 640 by 400 coordinate
+ * space, fitting whatever coordinates a caller gives it into that space with their
+ * aspect ratio kept, and its own ratio is a consequence of the canvas it draws
+ * into rather than a thing the caller chooses. It is also `role="img"`: the whole
+ * subtree is presentational, and the caller's sentence is what a screen reader
+ * gets. This Component holds arbitrary content at a caller's ratio and keeps that
+ * content in the accessibility tree, so a video, a screenshot, a map or a
+ * placeholder that has not loaded can sit in one without being turned into a
+ * picture of itself. A Diagram cannot be used for any of those, and this cannot
+ * draw a relation.
+ *
+ * **The content is clipped.** A ratio that is only a ratio leaves the content free
+ * to overflow it, and a box whose height is fixed by its width with content
+ * spilling out of the bottom is a box that has failed at the one job it has. A
+ * caller whose content should escape passes `overflow-visible` through
+ * `className`, which is the only override the Component has and which is a
+ * decision a caller makes about their own content rather than about the ratio.
+ *
+ * **A ratio that cannot be drawn falls back rather than collapsing.** A caller
+ * computing a ratio from data that has not arrived passes `NaN` or `0`, and
+ * `aspect-ratio: 0` is a box with no height at all, which looks like a failed
+ * image rather than a missing number. The default ratio is drawn instead and the
+ * value the caller passed is carried on the element as `data-ratio`, so the
+ * substitution is visible in the markup rather than only in the screenshot.
+ *
+ * It is a server Component. It holds no state and reads nothing, so a hundred
+ * media placeholders cost no JavaScript.
+ */
+declare function AspectRatio({ ratio, className, style, ...props }: AspectRatioProps): import("react").JSX.Element;
+export { AspectRatio };
+//# sourceMappingURL=aspect-ratio.d.ts.map

package/dist/components/ui/aspect-ratio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aspect-ratio.d.ts","sourceRoot":"","sources":["../../../src/components/ui/aspect-ratio.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAgB3C,yCAAyC;AACzC,MAAM,WAAW,gBAAiB,SAAQ,cAAc,CAAC,KAAK,CAAC;IAC7D;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,mBAAmB;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iBAAS,WAAW,CAAC,EAAE,KAAsB,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,EAAE,gBAAgB,+BAc5F;AAED,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/components/ui/aspect-ratio.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../lib/utils.js';
+/**
+ * The ratio Prism falls back to when a caller passes one that cannot be drawn.
+ *
+ * A number that is not finite, or is zero or negative, is not a ratio: it is the
+ * result of a division that has not happened yet, and it is a state a caller
+ * reaches by computing a ratio from data that has not loaded. Handing it to CSS
+ * collapses the box to nothing, which reads as "the image failed" rather than as
+ * "the ratio was not known", so the default is drawn instead and the value the
+ * caller passed is reported on the element for a caller to debug.
+ */
+const FALLBACK_RATIO = 16 / 9;
+/**
+ * A box whose height follows its width at a stated ratio.
+ *
+ * **Why this is a Component and not a class.** The instinct is `className="aspect-video"`
+ * and a caller who has run out of keywords writes `className="aspect-[4/3]"`. Neither
+ * reaches a consumer's browser. Prism's stylesheet scans Prism's own source and
+ * nothing else, because Tailwind is an internal build dependency of this package
+ * and never the consumer's, so a utility that appears in no Prism source file is
+ * a utility no consumer's stylesheet contains. An arbitrary value typed by a
+ * consumer is therefore not a layout decision, it is a silently missing rule and
+ * a box at whatever ratio its content happens to have. `ratio` is a prop so the
+ * ratio is a number this package reads and applies, not a name this package
+ * cannot see.
+ *
+ * **It is not the Diagram's canvas, and the two do not overlap.** The Diagram
+ * draws nodes and the relations between them into a fixed 640 by 400 coordinate
+ * space, fitting whatever coordinates a caller gives it into that space with their
+ * aspect ratio kept, and its own ratio is a consequence of the canvas it draws
+ * into rather than a thing the caller chooses. It is also `role="img"`: the whole
+ * subtree is presentational, and the caller's sentence is what a screen reader
+ * gets. This Component holds arbitrary content at a caller's ratio and keeps that
+ * content in the accessibility tree, so a video, a screenshot, a map or a
+ * placeholder that has not loaded can sit in one without being turned into a
+ * picture of itself. A Diagram cannot be used for any of those, and this cannot
+ * draw a relation.
+ *
+ * **The content is clipped.** A ratio that is only a ratio leaves the content free
+ * to overflow it, and a box whose height is fixed by its width with content
+ * spilling out of the bottom is a box that has failed at the one job it has. A
+ * caller whose content should escape passes `overflow-visible` through
+ * `className`, which is the only override the Component has and which is a
+ * decision a caller makes about their own content rather than about the ratio.
+ *
+ * **A ratio that cannot be drawn falls back rather than collapsing.** A caller
+ * computing a ratio from data that has not arrived passes `NaN` or `0`, and
+ * `aspect-ratio: 0` is a box with no height at all, which looks like a failed
+ * image rather than a missing number. The default ratio is drawn instead and the
+ * value the caller passed is carried on the element as `data-ratio`, so the
+ * substitution is visible in the markup rather than only in the screenshot.
+ *
+ * It is a server Component. It holds no state and reads nothing, so a hundred
+ * media placeholders cost no JavaScript.
+ */
+function AspectRatio({ ratio = FALLBACK_RATIO, className, style, ...props }) {
+    const drawable = typeof ratio === 'number' && Number.isFinite(ratio) && ratio > 0;
+    return (_jsx("div", { "data-slot": "aspect-ratio", "data-ratio": drawable ? ratio : String(ratio), style: { aspectRatio: drawable ? ratio : FALLBACK_RATIO, ...style }, className: cn('relative w-full overflow-hidden', className), ...props }));
+}
+export { AspectRatio };

package/dist/components/ui/avatar.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Avatar as AvatarPrimitive } from '@base-ui/react/avatar';
-import { cn } from '../../lib/utils';
+import { cn } from '../../lib/utils.js';
 /**
  * A person or entity's image, with initials as the fallback.
  *

package/dist/components/ui/badge.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { cva } from 'class-variance-authority';
-import { cn } from '../../lib/utils';
+import { cn } from '../../lib/utils.js';
 const badgeVariants = cva('inline-flex w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-md border px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-colors', {
     variants: {
         variant: {

package/dist/components/ui/breadcrumb.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ChevronRight } from 'lucide-react';
-import { cn } from '../../lib/utils';
+import { cn } from '../../lib/utils.js';
 /**
  * The trail of ancestor links that shows where the current page sits.
  *

package/dist/components/ui/button-group.d.ts

@@ -0,0 +1,68 @@
+import type { ComponentProps, ReactNode } from 'react';
+/** The props the ButtonGroup accepts. */
+export interface ButtonGroupProps extends Omit<ComponentProps<'div'>, 'children'> {
+    /**
+     * The buttons, or the controls, in the order a reader meets them.
+     *
+     * Children rather than an array of entries, because a ButtonGroup's whole claim
+     * is that it arranges whatever the caller composed. It does not decide what a
+     * button says, which variant it wears, or what it does; it draws the frame
+     * around them and removes the frames they would otherwise each draw.
+     */
+    children?: ReactNode;
+    /**
+     * The accessible name of the group.
+     *
+     * Required rather than defaulted, and it is the one prop a caller cannot skip.
+     * A row of three buttons is announced as three buttons and nothing else, so a
+     * reader who tabs into a toolbar of alignment controls cannot tell which of the
+     * four toolbars on the page they are in. Prism does not know what the caller's
+     * buttons are for, so the name is the caller's word.
+     */
+    label: string;
+    /** The direction the group runs in. @defaultValue 'horizontal' */
+    orientation?: 'horizontal' | 'vertical';
+    /** Layout only. */
+    className?: string;
+}
+/**
+ * Related controls joined as one, with the focus ring drawn once around them.
+ *
+ * **The ring is the reason this is a Component and not a flex row.** Three
+ * buttons side by side each draw their own focus ring, so a reader tabbing along
+ * the row sees three separate rings marching across a control that reads as one
+ * thing, and the reader has to work out each time whether the thing they are in
+ * has changed. Here the group takes the ring: the buttons suppress their own, and
+ * the group draws a single ring around its whole bounds when focus is inside it.
+ * The reader sees one indicator around one control, and it moves as a unit.
+ *
+ * The cost is stated rather than hidden: a ring drawn around a group is on the
+ * group, so it is visible whether the focus arrived from the keyboard or from a
+ * click. That is a real trade, and it is the right one here, because a group of
+ * mutually exclusive or sequential actions is nearly always operated from the
+ * keyboard and the ambiguity of a ring on a click is much cheaper than three rings
+ * marching. A caller who needs the per-button indicator back puts the buttons in a
+ * `Toolbar` instead, which is a different Component with a different claim.
+ *
+ * **The frame is drawn by the group and the inner frames are removed.** A
+ * ButtonGroup carries the border and the radius; each button inside drops its own
+ * border and its own corner radius, and the first and last keep the outer corners.
+ * The alternative, letting each button keep its own border, gives a row with a
+ * double rule between every pair and a gap at both ends, which is the reason
+ * grouped toolbars so often look like a row of separate buttons that happen to be
+ * near each other.
+ *
+ * **It is a `group` with a name, not a `toolbar`.** A toolbar is a set of controls
+ * that operates on a document, with its own arrow-key model, and a ButtonGroup is
+ * usually a set of related actions rather than an editing surface. The `group`
+ * role says "these belong together" and stops there, which is the claim being
+ * made. A caller whose buttons operate on a document and want the arrow keys
+ * composes Prism's `Toolbar` and does not use this.
+ *
+ * It is a server Component. It holds no state, reads no context and attaches no
+ * handler, so a row of controls in a static page costs no JavaScript, and the
+ * focus behaviour is two descendant variants of the group's own class string.
+ */
+declare function ButtonGroup({ className, children, label, orientation, ...props }: ButtonGroupProps): import("react").JSX.Element;
+export { ButtonGroup };
+//# sourceMappingURL=button-group.d.ts.map

package/dist/components/ui/button-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button-group.d.ts","sourceRoot":"","sources":["../../../src/components/ui/button-group.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAItD,yCAAyC;AACzC,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC/E;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,WAAW,CAAC,EAAE,YAAY,GAAG,UAAU,CAAA;IACvC,mBAAmB;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,QAAQ,EACR,KAAK,EACL,WAA0B,EAC1B,GAAG,KAAK,EACT,EAAE,gBAAgB,+BA8ClB;AAED,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/components/ui/button-group.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../lib/utils.js';
+/**
+ * Related controls joined as one, with the focus ring drawn once around them.
+ *
+ * **The ring is the reason this is a Component and not a flex row.** Three
+ * buttons side by side each draw their own focus ring, so a reader tabbing along
+ * the row sees three separate rings marching across a control that reads as one
+ * thing, and the reader has to work out each time whether the thing they are in
+ * has changed. Here the group takes the ring: the buttons suppress their own, and
+ * the group draws a single ring around its whole bounds when focus is inside it.
+ * The reader sees one indicator around one control, and it moves as a unit.
+ *
+ * The cost is stated rather than hidden: a ring drawn around a group is on the
+ * group, so it is visible whether the focus arrived from the keyboard or from a
+ * click. That is a real trade, and it is the right one here, because a group of
+ * mutually exclusive or sequential actions is nearly always operated from the
+ * keyboard and the ambiguity of a ring on a click is much cheaper than three rings
+ * marching. A caller who needs the per-button indicator back puts the buttons in a
+ * `Toolbar` instead, which is a different Component with a different claim.
+ *
+ * **The frame is drawn by the group and the inner frames are removed.** A
+ * ButtonGroup carries the border and the radius; each button inside drops its own
+ * border and its own corner radius, and the first and last keep the outer corners.
+ * The alternative, letting each button keep its own border, gives a row with a
+ * double rule between every pair and a gap at both ends, which is the reason
+ * grouped toolbars so often look like a row of separate buttons that happen to be
+ * near each other.
+ *
+ * **It is a `group` with a name, not a `toolbar`.** A toolbar is a set of controls
+ * that operates on a document, with its own arrow-key model, and a ButtonGroup is
+ * usually a set of related actions rather than an editing surface. The `group`
+ * role says "these belong together" and stops there, which is the claim being
+ * made. A caller whose buttons operate on a document and want the arrow keys
+ * composes Prism's `Toolbar` and does not use this.
+ *
+ * It is a server Component. It holds no state, reads no context and attaches no
+ * handler, so a row of controls in a static page costs no JavaScript, and the
+ * focus behaviour is two descendant variants of the group's own class string.
+ */
+function ButtonGroup({ className, children, label, orientation = 'horizontal', ...props }) {
+    return (_jsx("div", { "data-slot": "button-group", "data-orientation": orientation, role: "group", "aria-label": label, className: cn('inline-flex items-center', orientation === 'vertical' ? 'flex-col' : 'flex-row', 
+        // The ring belongs to the group, at full strength, and it is drawn when
+        // focus is anywhere inside it. This is the whole Component: without this
+        // the buttons beside it draw their own and the reader sees three rings
+        // crossing one control.
+        'focus-within:ring-ring focus-within:ring-[3px]', 'rounded-md', className), ...props, children: _jsx("div", { "data-slot": "button-group-inner", className: cn('flex items-stretch', orientation === 'vertical' ? 'flex-col' : 'flex-row', '[&>*]:rounded-none', orientation === 'vertical'
+                ? '[&>*+*]:-mt-px [&>*:first-child]:rounded-t-md [&>*:last-child]:rounded-b-md'
+                : '[&>*+*]:-ms-px [&>*:first-child]:rounded-s-md [&>*:last-child]:rounded-e-md', 
+            // The ring is the group's, and only the group's. A button that drew its
+            // own as well would put a second indicator on the same control.
+            '[&>*]:focus-visible:outline-none'), children: children }) }));
+}
+export { ButtonGroup };

package/dist/components/ui/button.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { cva } from 'class-variance-authority';
-import { cn } from '../../lib/utils';
+import { cn } from '../../lib/utils.js';
 const buttonVariants = cva(
 // The focus ring is `ring-ring` at full strength, not shadcn's stock
 // `focus-visible:ring-ring/50`. The token build pins `--ring` to a step that

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,158 @@
+/**
+ * The seven weekday headings, in the order the reader's week begins.
+ *
+ * A tuple rather than an array of strings, so the compiler refuses a caller who
+ * passed six. A grid whose header is one column short is a grid whose first and
+ * last rows are shifted by a day, and nothing on the screen shows it.
+ */
+export type CalendarWeekdays = readonly [
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string
+];
+/** The props the Calendar accepts. */
+export interface CalendarProps {
+    /**
+     * The accessible name of the grid.
+     *
+     * Required. A grid with no name is a table of numbers, and a reader who cannot
+     * tell a delivery date from a return date is being asked to guess.
+     */
+    label: string;
+    /**
+     * The caption over the grid, for the month on show.
+     *
+     * A prop, and the reason it is a prop is the reason every word in this
+     * Component is one: a month name is reader-facing text in the reader's language
+     * and the reader's calendar convention, and a Component that carried a table of
+     * them would ship English and a Western year into every consumer's product.
+     * Format it with the same `Intl` call the rest of the product uses.
+     */
+    monthLabel: string;
+    /** The seven weekday headings, starting from `firstWeekday`. */
+    weekdayLabels: CalendarWeekdays;
+    /**
+     * Which day the reader's week starts on, as `Date.prototype.getDay()` numbers
+     * it, so `0` is Sunday.
+     *
+     * Defaults to Sunday because that is what `getDay` returns and a default a
+     * caller may override is the honest one. Pass it for a Monday-first locale, and
+     * order `weekdayLabels` to match: the two are the same fact and the Component
+     * cannot infer either half of it.
+     */
+    firstWeekday?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** The accessible name of the control that steps back one month. */
+    previousLabel: string;
+    /** The accessible name of the control that steps forward one month. */
+    nextLabel: string;
+    /**
+     * The month on show.
+     *
+     * Controlled, and required to be, because the first month a calendar may open
+     * on is a rule about the reader's situation rather than about the calendar: a
+     * booking form opens on next month, an archive opens on the month the record is
+     * in. A calendar that kept that state would have to be told the rule twice.
+     */
+    month: Date;
+    /** Called with the first day of the month when the reader moves between months. */
+    onMonthChange: (month: Date) => void;
+    /**
+     * The chosen date, or `null` for nothing chosen.
+     *
+     * The grid marks the chosen date with `aria-selected`, so this is also what the
+     * month opens on when the reader has already answered.
+     */
+    value?: Date | null;
+    /** Called with the date the reader chooses. Never called with a disabled date. */
+    onValueChange?: (date: Date) => void;
+    /**
+     * Whether a date cannot be chosen.
+     *
+     * A disabled date stays in the grid and stays reachable by the arrow keys,
+     * announced as unavailable and refusing to be chosen. A date that is simply
+     * absent is indistinguishable from a grid that failed to draw that week, and a
+     * reader who cannot land on it cannot tell a sold-out day from a bug. Say why
+     * it is unavailable in text beside the field.
+     */
+    isDateDisabled?: (date: Date) => boolean;
+    /**
+     * The full accessible name of a day cell.
+     *
+     * A date is a phrase in the reader's language and their date convention, so it
+     * is the caller's. Without it the cell is named by its day number and its column
+     * heading, which is what grid navigation already conveys.
+     */
+    dayLabel?: (date: Date) => string;
+    /**
+     * The date to mark as today, when the reader's clock is not the renderer's.
+     *
+     * The mark is drawn and announced by `aria-current="date"`, which is a machine
+     * value, so no word is spent on it.
+     */
+    today?: Date;
+    /** Whether the reader may not change the month or choose a date. */
+    disabled?: boolean;
+    /**
+     * The form field name. The chosen date is submitted as `YYYY-MM-DD`.
+     *
+     * The field is a plain hidden input rather than a date input, so the value is
+     * one format the caller can parse without reading the reader's display
+     * convention out of the string.
+     */
+    name?: string;
+    /** Identifies the form that owns the hidden input. */
+    form?: string;
+    /** Layout only. */
+    className?: string;
+}
+/**
+ * A month grid for picking one date.
+ *
+ * **It is built here because Base UI does not ship one.** The package at 1.8.0
+ * has a combobox, a number field, an OTP field and a field, and no calendar, so
+ * there is nothing to compose and everything here is the Component's own. That is
+ * stated rather than implied because "the docs show one" is not evidence, and a
+ * wrapper around a module that is not in the installed package is the failure this
+ * Component could have shipped.
+ *
+ * **The grid is always six weeks tall.** A month that needs five rows and a month
+ * that needs six would otherwise resize as the reader pages through, which moves
+ * the dates under the pointer and under the highlight: a reader who aims at the
+ * 24th after reading its position in a five-row month clicks the 31st in a
+ * six-row one. The empty cells at the edges are marked `aria-hidden` rather than
+ * filled with the neighbouring month's dates, because a date from another month in
+ * this grid is a date the reader did not come for.
+ *
+ * **Every date, weekday name and month name is the caller's.** The caption, the
+ * seven column headings and the month the reader moves to are all reader-facing
+ * text in the reader's language, and the Component has no business carrying a
+ * table of them. What it does carry is the geometry: which column a date falls in
+ * and which day it sits on.
+ *
+ * **One cell is in the tab order, and the arrows move it.** The roving tab stop
+ * sits on the chosen date, or on today, or on the first of the month, so a reader
+ * who tabs in lands on the date they care about rather than on the 1st. The arrows
+ * step a day and a week, Home and End step to the ends of the week, and PageUp and
+ * PageDown step a month, with Shift for a year. Moving past the end of a month
+ * changes the month on show and carries the focus with it, so paging never leaves
+ * the highlight on a cell that is no longer drawn.
+ *
+ * **A disabled date is drawn, reachable and refused.** It stays in the grid and
+ * stays in the arrow path, because a date that is simply missing is
+ * indistinguishable from a grid that failed to render that week, and a reader who
+ * cannot reach it cannot tell a fully booked day from a bug. Enter, Space and a
+ * click on it do nothing, and it announces as unavailable. Explain the reason in
+ * text beside the field; a greyed cell on its own says only that it is not
+ * available.
+ *
+ * **The caption is a live region.** Paging a month changes the month with no other
+ * visible change for a reader who is on the grid, so the caption announces itself
+ * when it changes.
+ */
+declare function Calendar({ label, monthLabel, weekdayLabels, firstWeekday, previousLabel, nextLabel, month, onMonthChange, value, onValueChange, isDateDisabled, dayLabel, today, disabled, name, form, className, }: CalendarProps): import("react").JSX.Element;
+export { Calendar };
+//# sourceMappingURL=calendar.d.ts.map

package/dist/components/ui/calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../../src/components/ui/calendar.tsx"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS;IACtC,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAA;AAED,sCAAsC;AACtC,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;;OAQG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB,gEAAgE;IAChE,aAAa,EAAE,gBAAgB,CAAA;IAC/B;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACxC,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAA;IACrB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;;;OAOG;IACH,KAAK,EAAE,IAAI,CAAA;IACX,mFAAmF;IACnF,aAAa,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAA;IACpC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,IAAI,GAAG,IAAI,CAAA;IACnB,kFAAkF;IAClF,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IACpC;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAA;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAA;IACjC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,IAAI,CAAA;IACZ,oEAAoE;IACpE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mBAAmB;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAmDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,iBAAS,QAAQ,CAAC,EAChB,KAAK,EACL,UAAU,EACV,aAAa,EACb,YAAgB,EAChB,aAAa,EACb,SAAS,EACT,KAAK,EACL,aAAa,EACb,KAAY,EACZ,aAAa,EACb,cAAc,EACd,QAAQ,EACR,KAAK,EACL,QAAgB,EAChB,IAAI,EACJ,IAAI,EACJ,SAAS,GACV,EAAE,aAAa,+BA2Pf;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}