@cruglobal/cornerstone-components 0.1.0

package/dist/bundled/internal/get-text.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Like textContent, but better:
+ * - Uses assignedNodes to get text content from slots (and falls back to content if nothing is slotted)
+ * - Ignores script and style elements
+ * @param root - One or more nodes to get text content from.
+ * @param depth - By default, will just return element.textContent for any child elements instead of calling the function recursively.
+ *                Set to a positive integer to recurse that many levels. Generally a tradeoff between performance and accuracy.
+ * @returns
+ */
+export default function getText(root: Node | Iterable<Node>, depth?: number): string;

package/dist/bundled/internal/live-announcer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A shared, light-DOM live region for announcing dynamic updates to screen readers.
+ *
+ * Live regions rendered inside a shadow root are not reliably announced — notably, JAWS + Firefox ignores them
+ * entirely. To work around this, we maintain a single visually-hidden live region appended to `document.body` (light
+ * DOM) and update its contents imperatively. This mirrors the approach used by Adobe's React Aria `LiveAnnouncer` and is
+ * the most robust way to ensure announcements are picked up across screen readers.
+ *
+ * The region is created lazily and persists for the lifetime of the page. Each announcement appends a fresh node (so
+ * repeating the same message still announces) and removes it shortly after, preventing stale text from accumulating or
+ * being re-read when focus returns.
+ */
+type Politeness = 'polite' | 'assertive';
+/**
+ * Announces a message to assistive technology via a shared light-DOM live region.
+ *
+ * @param message - The text to announce. Empty strings are ignored.
+ * @param politeness - Whether to announce politely (default) or assertively.
+ */
+export declare function announce(message: string, politeness?: Politeness): void;
+export {};

package/dist/bundled/internal/math.d.ts

@@ -0,0 +1,3 @@
+/** Ensures a number stays within a minimum and maximum value */
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function uniqueId(prefix?: string): string;

package/dist/bundled/internal/offset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns an element's offset relative to its parent. Similar to element.offsetTop and element.offsetLeft, except the
+ * parent doesn't have to be positioned relative or absolute.
+ *
+ * NOTE: This was created to work around what appears to be a bug in Chrome where a slotted element's offsetParent seems
+ * to ignore elements inside the surrounding shadow DOM: https://bugs.chromium.org/p/chromium/issues/detail?id=920069
+ */
+export declare function getOffset(element: HTMLElement, parent: HTMLElement): {
+    top: number;
+    left: number;
+};

package/dist/bundled/internal/parse.d.ts

@@ -0,0 +1,2 @@
+/** Parses a space-delimited set of tokens and returns an array with all whitespace removed. */
+export declare function parseSpaceDelimitedTokens(input: string): string[];

package/dist/bundled/internal/rendered-watcher.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Watches an element and reports when it stops or starts generating layout boxes, e.g. when third-party CSS applies
+ * "display: none" to it or an ancestor. A ResizeObserver signals changes and getClientRects() determines the state,
+ * since it distinguishes "not rendered" from "rendered at zero size". Visibility and opacity never count as hidden.
+ */
+export declare class RenderedWatcher {
+    private readonly element;
+    private readonly callback;
+    private observer;
+    private initialCheckHandle;
+    constructor(element: HTMLElement, callback: (isRendered: boolean) => void);
+    /**
+     * Starts watching and reports the current state on the next frame. Additional targets also act as change signals,
+     * e.g. an internal element that always has a non-zero box when rendered.
+     */
+    start(...additionalTargets: Element[]): void;
+    /** Stops watching. */
+    stop(): void;
+    private check;
+}

package/dist/bundled/internal/scroll.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Prevents body scrolling. Keeps track of which elements requested a lock so multiple levels of locking are possible
+ * without premature unlocking.
+ */
+export declare function lockBodyScrolling(lockingEl: HTMLElement): void;
+/**
+ * Unlocks body scrolling. Scrolling will only be unlocked once all elements that requested a lock call this method.
+ */
+export declare function unlockBodyScrolling(lockingEl: HTMLElement): void;
+/** Scrolls an element into view of its container. If the element is already in view, nothing will happen. */
+export declare function scrollIntoView(element: HTMLElement, container: HTMLElement, direction?: 'horizontal' | 'vertical' | 'both', behavior?: 'smooth' | 'auto'): void;

package/dist/bundled/internal/scrollend-polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bundled/internal/segmented-field/segmented-field-controller.d.ts

@@ -0,0 +1,198 @@
+/**
+ * `SegmentedFieldController` — a reactive controller that wires the **keystroke and focus mechanics** for a segmented
+ * input. It is the generic skeleton used by `<cs-date-input>` and `<cs-time-input>`, and is intentionally agnostic
+ * about what the segments represent.
+ *
+ * What it owns:
+ *  - Per-segment digit buffer (the raw chars the user is typing before commit).
+ *  - Roving tabindex and the "active segment" pointer used by host render and focus restore.
+ *  - Arrow Up/Down stepping, Arrow Left/Right navigation (with RTL inversion), Home/End, Backspace/Delete,
+ *    separator-advance, Tab flush.
+ *
+ * What it does NOT own (the host plugs these in via `SegmentRules`):
+ *  - The meaning of the segments (date fields, time fields, anything else).
+ *  - Per-field digit typing semantics (when to commit, when to advance, when to overflow-replace).
+ *  - Per-field bounds and stepping rules (wraparound, leap years, AM/PM, …).
+ *  - Layout derivation (the host builds a `SegmentLayout` from the locale and passes it in each render).
+ *  - The popup, validation, hidden form input, or any DOM beyond the segment elements themselves.
+ *
+ * The controller is **DOM-aware** (it reads `[data-group]`/`[data-segment]` attrs from the host's shadow root and
+ * dispatches focus on them), but it has no knowledge of the host's render tree — the host renders segments however it
+ * likes as long as those two data attributes are present.
+ *
+ * Why a controller instead of a class mixin: Cornerstone form controls already extend
+ * `CornerstoneFormAssociatedElement`, and date/time pickers need different validators on top of that base. A
+ * ReactiveController composes cleanly without forcing inheritance and can be tested in isolation against a synthetic
+ * host.
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** A field identifier — opaque to the controller. The host defines the strings (e.g. `'month'`, `'hour'`). */
+export type SegmentField = string;
+/** A group identifier — opaque to the controller. Single-group hosts can use a fixed string like `'single'`. */
+export type SegmentGroup = string;
+/** One editable segment in the layout. */
+export interface SegmentToken {
+    kind: 'segment';
+    field: SegmentField;
+}
+/** Inert text rendered between segments (separator, suffix, …). The host renders this verbatim. */
+export interface LiteralToken {
+    kind: 'literal';
+    text: string;
+}
+export type LayoutToken = SegmentToken | LiteralToken;
+/** The ordered list of layout tokens for the current locale. */
+export interface SegmentLayout {
+    tokens: LayoutToken[];
+    /** Just the segment fields, in order — convenience for focus/advance logic. */
+    order: SegmentField[];
+}
+/** Result of typing a digit into a segment. */
+export interface TypeDigitResult {
+    /** The segment's new value (host-defined type), or `null` if still effectively empty. */
+    value: unknown;
+    /** The raw digit buffer still being accumulated. Empty once committed. */
+    buffer: string;
+    /** When true, the controller advances focus to the next segment. */
+    advance: boolean;
+}
+/** Result of stepping a segment (Arrow Up / Down). */
+export interface StepResult {
+    /** The new value for the stepped segment. */
+    value: unknown;
+}
+/** Inclusive numeric bounds for a segment, used for `aria-valuemin`/`aria-valuemax`. */
+export interface SegmentBounds {
+    min: number;
+    max: number;
+}
+/**
+ * Host-provided per-field rules. The controller calls these to apply user actions; the host owns the meaning.
+ */
+export interface SegmentRules {
+    /**
+     * Apply a digit to the current buffer of `field` in `group`. The host knows the field's value semantics; the
+     * controller blindly forwards the result.
+     */
+    typeDigit(group: SegmentGroup, field: SegmentField, buffer: string, digit: string): TypeDigitResult;
+    /**
+     * Step a field by `delta` (always ±1 — Page Up/Down can be wired by the host via a custom shortcut if needed).
+     * The host may return `null` to indicate the step was a no-op (e.g., past a hard bound).
+     */
+    step(group: SegmentGroup, field: SegmentField, delta: -1 | 1): StepResult | null;
+    /** Bounds for the field's spinbutton ARIA values. */
+    bounds(group: SegmentGroup, field: SegmentField): SegmentBounds;
+    /**
+     * Commit a non-empty buffer as the field's value when the user navigates away. Returns the value to store, or `null`
+     * to leave the segment empty.
+     */
+    commitBuffer(group: SegmentGroup, field: SegmentField, buffer: string): unknown;
+    /**
+     * Clear the field — used by Backspace/Delete on a committed value. Returns `true` if a value was actually cleared,
+     * `false` if the field was already empty. The controller uses this to decide whether Backspace should additionally
+     * jump focus to the previous segment.
+     */
+    clear(group: SegmentGroup, field: SegmentField): boolean;
+}
+/** Host-supplied side-effect hook fired when a segment's value changes. The host updates its model and re-renders. */
+export type SegmentCommitListener = (group: SegmentGroup, field: SegmentField, value: unknown) => void;
+/** Optional config for the controller. */
+export interface SegmentedFieldControllerConfig {
+    /**
+     * Returns the layout for the current render. The host typically derives this from its current locale; we read it on
+     * demand so locale changes reflect on the next interaction without controller surgery.
+     */
+    getLayout: (group: SegmentGroup) => SegmentLayout;
+    /** True if the field is currently RTL. The controller flips logical left/right when computing nav direction. */
+    isRtl: () => boolean;
+    /** Per-field rules — required. */
+    rules: SegmentRules;
+    /** Fired after a segment's value changes (digit type, step, clear, buffer-flush). */
+    onCommit?: SegmentCommitListener;
+    /**
+     * Characters that advance to the next segment without changing the current one. Defaults match common date/time
+     * separators: `/`, `.`, `-`, `:`, `,`, and space. The host can override (e.g. add `'+'` for sign segments).
+     */
+    separatorKeys?: string[];
+    /** Read-only mode — disables typing/stepping but still allows focus traversal. */
+    isReadonly?: () => boolean;
+    /** Disabled mode — disables everything (focus included; tab indices go to -1). */
+    isDisabled?: () => boolean;
+}
+/**
+ * Wires segment behavior into a Lit host. Construct one per host element.
+ *
+ * The host renders each segment with `data-group="<group>"` and `data-segment="<field>"` and binds the keyboard/focus
+ * events returned by `eventHandlers()`. Everything else flows through the controller.
+ */
+export declare class SegmentedFieldController implements ReactiveController {
+    private host;
+    private config;
+    /** Per-segment digit buffers keyed by `${group}:${field}`. */
+    private buffers;
+    /** Which segment currently owns the roving tabindex / was most recently focused. */
+    private active;
+    constructor(host: ReactiveControllerHost & Element, config: SegmentedFieldControllerConfig);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /** Get the buffer for a segment. Empty string when nothing is pending. */
+    getBuffer(group: SegmentGroup, field: SegmentField): string;
+    /** Replace the buffer for a segment. Pass `''` to clear. */
+    setBuffer(group: SegmentGroup, field: SegmentField, buffer: string): void;
+    /** Drop every pending buffer. Used by the host when the canonical value is replaced wholesale. */
+    clearBuffers(): void;
+    /** The active segment, or `null` if focus has never landed on one. */
+    getActiveSegment(): {
+        group: SegmentGroup;
+        field: SegmentField;
+    } | null;
+    /** Sets the active segment (does not move DOM focus). Used by hosts that programmatically restore focus. */
+    setActiveSegment(group: SegmentGroup, field: SegmentField): void;
+    /** All segment elements in the host's shadow root, in DOM (logical) order. */
+    segmentElements(): HTMLElement[];
+    /** The segment element for a given (group, field), or `null` if not in the DOM. */
+    segmentElementFor(group: SegmentGroup, field: SegmentField): HTMLElement | null;
+    /**
+     * Returns the segment that should receive initial focus: the first empty segment (no value AND no buffer) per
+     * `isEmpty`, otherwise the first segment in the layout. The host supplies the emptiness predicate since the
+     * controller doesn't know the field's stored value.
+     */
+    findFocusableSegment(isEmpty: (group: SegmentGroup, field: SegmentField) => boolean): HTMLElement | null;
+    /** Restore focus to the most recently active segment (or the first segment if none has been active). */
+    focusActiveSegment(options?: FocusOptions): void;
+    /** Move focus to the neighbor segment in logical (DOM) order. */
+    moveFocus(from: HTMLElement, direction: -1 | 1, options?: FocusOptions): void;
+    /**
+     * Commit a pending buffer to its committed value via `rules.commitBuffer`. Notifies the host via `onCommit`. Does
+     * nothing if no buffer is pending.
+     */
+    flushBuffer(group: SegmentGroup, field: SegmentField): boolean;
+    /**
+     * Flush every pending buffer across all groups. Used when the host needs to read a final value (e.g., on form
+     * submission outside of a focus change).
+     */
+    flushAllBuffers(): void;
+    /**
+     * Returns the event handlers a segment element should bind. Hosts wire these via `@keydown=${handlers.keydown}` etc.
+     * The returned functions are stable references safe to pass to Lit's directive cache.
+     *
+     * Hosts that need host-level shortcuts (e.g. `Alt+ArrowDown` to open a popup) should call `handleKeyDown` themselves
+     * after handling their own keys. The controller's `keydown` handler is safe to invoke when the host has not consumed
+     * the event — it ignores keys it doesn't recognize.
+     */
+    eventHandlers(): {
+        keydown: (event: KeyboardEvent) => void;
+        focus: (event: FocusEvent) => void;
+        blur: (event: FocusEvent) => void;
+    };
+    /**
+     * Direct entry point for hosts that wrap the controller's keydown with their own pre-handler (e.g. for popup
+     * shortcuts). Returns `true` if the controller consumed the event (called `preventDefault`), `false` otherwise.
+     */
+    handleKeyDownEvent(event: KeyboardEvent): boolean;
+    private handleFocus;
+    private handleBlur;
+    private handleKeyDown;
+    private key;
+    private isReadonlyOrDisabled;
+}

package/dist/bundled/internal/slot.d.ts

@@ -0,0 +1,24 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** A reactive controller that determines when slots exist. */
+export declare class HasSlotController implements ReactiveController {
+    host: ReactiveControllerHost & HTMLElement;
+    slotNames: string[];
+    constructor(host: typeof this.host, ...slotNames: string[]);
+    private hasDefaultSlot;
+    private hasNamedSlot;
+    /**
+     * @param slotName     - Name of the slot to look for
+     * @param propertyName - Generally we infer via the matching `ssr*` property on the host, but in cases where its different, you can specify a manual property name.
+     */
+    test(slotName: string, propertyName?: null | string): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private handleSlotChange;
+}
+/**
+ * Given a list of nodes, this function iterates over all of them and returns the concatenated
+ * HTML as a string. This is useful for getting the HTML that corresponds to a slot’s assigned nodes (since we can't use slot.innerHTML as an alternative).
+ * @param nodes - The list of nodes to iterate over.
+ * @param callback - A function that can be used to customize the HTML output for specific types of nodes. If the function returns undefined, the default HTML output will be used.
+ */
+export declare function getInnerHTML(nodes: Iterable<Node>, callback?: (node: Node) => string | undefined): string;

package/dist/bundled/internal/submit-on-enter.d.ts

@@ -0,0 +1,3 @@
+import type { CornerstoneFormAssociatedElement } from './cornerstone-form-associated-element.js';
+export declare function submitOnEnter<T extends HTMLElement>(event: KeyboardEvent, el: T): void;
+export declare function submitForm(el: HTMLElement | CornerstoneFormAssociatedElement): void;

package/dist/bundled/internal/test/data-testid-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Allows you to find a DOM element based on the value of its `data-testid` attribute.
+ * This attribute can be used to decouple identifying dom elements for testing from
+ * styling (which is typically done via class selectors) or other ids which serve
+ * different purposes.
+ * See also https://kentcdodds.com/blog/making-your-ui-tests-resilient-to-change
+ * Inspired by https://testing-library.com/docs/queries/bytestid/
+ * @param {HTMLElement} container - A parent element of the DOM element to find
+ * @param {string} testId - The value of the `data-testid` attribute of the component to find.
+ * @returns The found element or null if there was no such element
+ */
+export declare const queryByTestId: <T extends Element>(container: HTMLElement, testId: string) => T | null;

package/dist/bundled/internal/test/element-visible-overflow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Given a parent element featuring `overflow: hidden` and a child element inside the parent, this
+ * function determines whether the child will be visible taking only the overflow of the parent into account
+ * Id does NOT check whether it is hidden or overlapped by another element
+ * It basically checks whether the bounding rects of the parent and the child overlap
+ *
+ * @param {HTMLElement} outerElement - The parent element
+ * @param {HTMLElement} innerElement - the child element
+ * @returns {Boolean} whether the two elements overlap
+ */
+export declare const isElementVisibleFromOverflow: (outerElement: Element, innerElement: Element) => boolean;

package/dist/bundled/internal/test/expect-event.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Verifies that the specified events fire on an element during an action.
+ *
+ * Usage:
+ *   await expectEvent(el, ['input', 'cs-input'], () => clickOnElement(el));
+ *   const events = await expectEvent(el, 'cs-change', () => el.click());
+ *
+ * Options:
+ *   - timeout: max ms to wait for events (default 1000)
+ *   - count: expected number of times each event fires (default 1)
+ */
+export declare function expectEvent(el: Element, events: string | string[], action: () => void | Promise<void>, options?: {
+    timeout?: number;
+    count?: number;
+}): Promise<Event[]>;

package/dist/bundled/internal/test/fixture.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This is the intended way of using fixtures since it has some nice ways of catching hydration errors.
+ * These fixtures will also auto-load all of our components.
+ */
+import type { TemplateResult } from 'lit';
+declare global {
+    interface Window {
+        clientComponents: string[];
+        serverComponents: string[];
+        SSR_ONLY: boolean;
+        CSR_ONLY: boolean;
+    }
+}
+/**
+ * Loads up a fixture and loads all client components
+ */
+export declare function clientFixture<T extends HTMLElement = HTMLElement>(template: TemplateResult | string): Promise<T>;
+export declare namespace clientFixture {
+    var type: "client-only";
+}
+/**
+ * Loads up a fixture with SSR, using all unbundled modules, then when it finishes, calls hydration scripts, and then when hydration completes, returns the element.
+ */
+export declare function hydratedFixture<T extends HTMLElement = HTMLElement>(template: TemplateResult): Promise<T>;
+export declare namespace hydratedFixture {
+    var type: "ssr-client-hydrated";
+}
+export declare const fixtures: (typeof clientFixture | typeof hydratedFixture)[];

package/dist/bundled/internal/test/form-control-base-tests.d.ts

@@ -0,0 +1,22 @@
+import type { CornerstoneFormControl } from '../cornerstone-form-associated-element.js';
+/** Runs a set of generic tests for Cornerstone form controls */
+export declare function runFormControlBaseTests<T extends CornerstoneFormControl = CornerstoneFormControl>(tagNameOrConfig: string | {
+    tagName: string;
+    init?: (control: T) => void;
+    /** Distinguishes several configurations of one tag. Omit when there is only one. */
+    variantName?: string;
+    formValue?: FormValueConfig;
+}): void;
+/**
+ * How a control's restorable value is exercised. Reset is otherwise untestable generically: the suite has to
+ * know a value that differs from the control's default, and only the control knows what is valid for it.
+ */
+export interface FormValueConfig {
+    /** The property carrying the restorable value. `checked` for boolean controls. Defaults to `value`. */
+    property?: 'value' | 'checked';
+    /**
+     * A value different from the control's default, assigned to dirty it before reset. Optional when
+     * `property` is `checked`, where the opposite of the default is the only other option.
+     */
+    dirtyValue?: unknown;
+}

package/dist/bundled/internal/test/pointer-utilities.d.ts

@@ -0,0 +1,36 @@
+/**
+ * True on WebKit. Every Chromium UA string also contains "Safari", so both Chrome spellings have to be
+ * excluded — the previous check only excluded `HeadlessChrome`, which made this true on headed Chromium.
+ */
+export declare const isWebkit: boolean;
+/** A testing utility that measures an element's position and clicks on it. */
+export declare function clickOnElement(
+/** The element to click */
+el: Element, 
+/** The location of the element to click */
+position?: 'top' | 'right' | 'bottom' | 'left' | 'center', 
+/** The horizontal offset to apply to the position when clicking */
+offsetX?: number, 
+/** The vertical offset to apply to the position when clicking */
+offsetY?: number): Promise<void>;
+/** A testing utility that moves the mouse onto an element. */
+export declare function moveMouseOnElement(
+/** The element to click */
+el: Element, 
+/** The location of the element to click */
+position?: 'top' | 'right' | 'bottom' | 'left' | 'center', 
+/** The horizontal offset to apply to the position when clicking */
+offsetX?: number, 
+/** The vertical offset to apply to the position when clicking */
+offsetY?: number): Promise<void>;
+/** A testing utility that drags an element with the mouse. */
+export declare function dragElement(
+/** The element to drag */
+el: Element, 
+/** The horizontal distance to drag in pixels */
+deltaX?: number, 
+/** The vertical distance to drag in pixels */
+deltaY?: number, callbacks?: {
+    afterMouseDown?: () => void | Promise<void>;
+    afterMouseMove?: () => void | Promise<void>;
+}): Promise<void>;

package/dist/bundled/internal/test/wait-for-scrolling.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wait until an element has stopped scrolling
+ * This considers the element to have stopped scrolling, as soon as it did not change its
+ * scroll position for 20 successive animation frames
+ * @param {HTMLElement} element - The element which is scrolled
+ * @param {numeric} timeoutInMs - A timeout in ms. If the timeout has elapsed, the promise rejects
+ * @returns A promise which resolves after the scrolling has stopped
+ */
+export declare const waitForScrollingToEnd: (element: Element, timeoutInMs?: number) => Promise<void>;

package/dist/bundled/internal/validators/custom-error-validator.d.ts

@@ -0,0 +1,6 @@
+import type { Validator } from '../cornerstone-form-associated-element.js';
+/**
+ * This validator is for if you have an exact copy of your element in the shadow DOM. Rather than needing
+ * custom translations and error messages, you can simply rely on the element "formControl" in your shadow dom.
+ */
+export declare const CustomErrorValidator: () => Validator;

package/dist/bundled/internal/validators/mirror-validator.d.ts

@@ -0,0 +1,6 @@
+import type { Validator } from '../cornerstone-form-associated-element.js';
+/**
+ * This validator is for if you have an exact copy of your element in the shadow DOM. Rather than needing
+ * custom translations and error messages, you can simply rely on the element "formControl" in your shadow dom.
+ */
+export declare const MirrorValidator: () => Validator;

package/dist/bundled/internal/validators/required-validator.d.ts

@@ -0,0 +1,19 @@
+import type { Validator } from '../cornerstone-form-associated-element.js';
+type ValidationElement = HTMLSelectElement | HTMLInputElement;
+export interface RequiredValidatorOptions {
+    /**
+     * This is a cheap way for us to get translation strings for the user without having proper translations.
+     *
+     * Prefer a factory over an element. A component's `static get validators()` also runs during server render,
+     * so a caller that builds an element eagerly has to guard `document` itself; passing a factory keeps that
+     * obligation here, in the one place that already guards it.
+     */
+    validationElement?: ValidationElement | (() => ValidationElement);
+    /**
+     * The property to check if its not null-ish. For most elements this will be "value".
+     * For "checkbox" for example it will be "checked"
+     */
+    validationProperty?: string;
+}
+export declare const RequiredValidator: (options?: RequiredValidatorOptions) => Validator;
+export {};

package/dist/bundled/internal/validators/slider-validator.d.ts

@@ -0,0 +1,6 @@
+import type CsSlider from '../../components/slider/slider.js';
+import type { Validator } from '../cornerstone-form-associated-element.js';
+/**
+ * Comprehensive validator for sliders that handles range and step validation
+ */
+export declare const SliderValidator: () => Validator<CsSlider>;

package/dist/bundled/internal/watch.d.ts

@@ -0,0 +1,26 @@
+import type { LitElement } from 'lit';
+type UpdateHandler = (prev?: unknown, next?: unknown) => void;
+type NonUndefined<A> = A extends undefined ? never : A;
+type UpdateHandlerFunctionKeys<T extends object> = {
+    [K in keyof T]-?: NonUndefined<T[K]> extends UpdateHandler ? K : never;
+}[keyof T];
+interface WatchOptions {
+    /**
+     * If true, will only start watching after the initial update/render
+     */
+    waitUntilFirstUpdate?: boolean;
+}
+/**
+ * Runs when observed properties change, e.g. @property or @state, but before the component updates. To wait for an
+ * update to complete after a change occurs, use `await this.updateComplete` in the handler. To start watching after the
+ * initial update/render, use `{ waitUntilFirstUpdate: true }` or `this.hasUpdated` in the handler.
+ *
+ * Usage:
+ *
+ * @watch('propName')
+ * handlePropChange(oldValue, newValue) {
+ *   ...
+ * }
+ */
+export declare function watch(propertyName: string | string[], options?: WatchOptions): <ElemClass extends LitElement>(proto: ElemClass, decoratedFnName: UpdateHandlerFunctionKeys<ElemClass>) => void;
+export {};