@bluevolt-tech/lumen 2.1.0 → 2.3.0

package/dist/components/_shared/date-range-validator.d.ts

@@ -15,9 +15,14 @@
  *   4. Feature limit (V6) — last, only when both fields are individually
  *      valid AND the cross-field check passes.
  *
+ * Per BTN-10312 each rule has a **severity** (`error` / `warning` / `primary` /
+ * `success`). Only `error` blocks Apply. Default severity is `error` for every
+ * rule so the behavior of consumers not opting in is preserved.
+ *
  * The consumer decides how to render each error — this module has no strings
  * and no DOM.
  */
+export type ErrorSeverity = 'error' | 'warning' | 'primary' | 'success';
 export interface DateRangeConfig {
     /** ISO date string (YYYY-MM-DD). Enables V1/V2 (lower bound) when set. */
     min?: string;
@@ -29,6 +34,16 @@ export interface DateRangeConfig {
     validateOrder?: boolean;
     /** Opt-in to V8 (format guard — non-parseable strings become field errors). */
     validateFormat?: boolean;
+    /** Severity of `min` field error. Default `'error'` (blocks Apply). */
+    minSeverity?: ErrorSeverity;
+    /** Severity of `max` field error. Default `'error'` (blocks Apply). */
+    maxSeverity?: ErrorSeverity;
+    /** Severity of `format` field error. Default `'error'` (blocks Apply). */
+    formatSeverity?: ErrorSeverity;
+    /** Severity of `order` form error. Default `'error'` (blocks Apply). */
+    orderSeverity?: ErrorSeverity;
+    /** Severity of `range-limit` form error. Default `'error'` (blocks Apply). */
+    rangeLimitSeverity?: ErrorSeverity;
 }
 export interface DateRangeInput {
     /** Raw ISO string (YYYY-MM-DD) or empty. Non-empty non-parseable strings become format errors when V8 is on. */
@@ -46,13 +61,23 @@ export type FormError = 'order' | 'range-limit';
 export interface DateRangeValidity {
     /** True when NO rule fires (field-level or form-level). Does not consider whether both dates are set. */
     valid: boolean;
-    /** True when `valid` AND both `start` and `end` parse to real dates. Consumer disables Apply when this is false. */
+    /**
+     * True when no *blocking* error is active AND both `start` and `end` parse to real dates.
+     * An error is blocking iff its resolved severity is `'error'`. Consumer disables Apply
+     * when this is false.
+     */
     applyEnabled: boolean;
     startError?: FieldError;
     endError?: FieldError;
     formError?: FormError;
 }
+/** Coerce an unknown value to a valid severity, defaulting to `'error'`. */
+export declare function normalizeSeverity(value: string | ErrorSeverity | undefined | null): ErrorSeverity;
 export declare function validateDateRange(input: DateRangeInput, config?: DateRangeConfig): DateRangeValidity;
+/** Resolve the configured severity for a field error kind. */
+export declare function severityOfFieldError(err: FieldError, config: DateRangeConfig): ErrorSeverity;
+/** Resolve the configured severity for a form error kind. */
+export declare function severityOfFormError(err: FormError, config: DateRangeConfig): ErrorSeverity;
 /**
  * Strict ISO parser. Accepts `YYYY-MM-DD` where every field is a real calendar
  * date. Rejects `2026-02-30` (JS Date would auto-correct it to 2026-03-02).

package/dist/components/_shared/dropdown-controller.d.ts

@@ -1,8 +1,37 @@
+/**
+ * Why the dropdown is closing:
+ * - `'escape'` — user pressed Escape.
+ * - `'outside-click'` — user clicked outside the host.
+ * - `'programmatic'` — consumer called `close()` or `toggle()`, or the user
+ *   clicked the trigger to close it (also routed through `toggle()`). This
+ *   also covers the Apply / Cancel path in `bv-date-range-input`, which
+ *   listens for `bv-change` / `bv-cancel` from the internal picker and
+ *   calls `close()` on the controller.
+ *
+ * Consumers use `reason` in their `canClose` gate to distinguish implicit
+ * dismissals (Escape / outside-click) from explicit user actions
+ * (Cancel button, Apply, trigger toggle). A validity gate typically wants
+ * to block only implicit dismissals so the user can always intentionally
+ * back out of an invalid state.
+ */
+export type CloseReason = 'escape' | 'outside-click' | 'programmatic';
 export interface DropdownControllerOptions {
     /** Element whose `aria-expanded` should mirror the open state — usually the trigger. */
     trigger?: HTMLElement | null;
     /** Called just before opening. Use for lazy state seeding (e.g. syncing an internal picker). */
     onBeforeOpen?: () => void;
+    /**
+     * Called just before closing. Return `false` to prevent the close.
+     * `reason` (BTN-10312 refinement) lets the consumer gate only implicit
+     * dismissals (Escape / outside-click) while still allowing explicit user
+     * actions (Cancel / Apply / trigger toggle) to close.
+     */
+    canClose?: (reason: CloseReason) => boolean;
+    /**
+     * Called immediately after a successful close. Use for cleanup that should run
+     * on every close path (e.g. resetting an internal draft state).
+     */
+    onAfterClose?: () => void;
 }
 export interface DropdownController {
     open: () => void;
@@ -21,6 +50,22 @@ export interface DropdownController {
  *   the state. The controller is the single source of truth; consuming
  *   components must NOT duplicate this sync in their own attributeChangedCallback.
  * - `bv-open` is dispatched from the host when opening via `open()`/`toggle()`.
+ * - `bv-dropdown-close` is dispatched from the host on every successful close,
+ *   with `detail: { reason }` matching the `CloseReason` union — consumers can
+ *   use it to close sibling dropdowns or release focus/scroll locks. The name
+ *   is prefixed to avoid colliding with `bv-modal` / `bv-course-detail-modal`,
+ *   which dispatch a bare `bv-close` on dismissal — a plain `bv-close` here
+ *   would bubble into ancestor `bv-close` listeners (e.g. a modal that
+ *   contains a dropdown) and fire spuriously on every dropdown dismissal.
+ *
+ * **Consumers MUST NOT call `e.stopPropagation()` on the trigger click**
+ * (BTN-10408). The outside-click listener attached here on `document` uses
+ * `composedPath().includes(host)` to skip clicks that originated inside its
+ * own host — so it already ignores the trigger click without needing the
+ * event to be swallowed. Stopping propagation on the trigger prevents the
+ * `document`-level listeners attached by *sibling* controllers from
+ * receiving the click at all, which is why opening one dropdown while
+ * another is open used to leave both visible.
  *
  * The controller mutates the `open` attribute on the host. Consumers should
  * drive their visual state (`.panel` visibility, focus management) from that

package/dist/components/bv-date-range-input/bv-date-range-input.d.ts

@@ -1,12 +1,18 @@
 import '../bv-date-range-picker/bv-date-range-picker.ts';
 export declare class BvDateRangeInput extends HTMLElement {
-    static readonly observedAttributes: readonly ["label", "start", "end", "placeholder", "required", "min", "max", "max-range-years", "validate-order", "validate-format", "show-range-limit-banner", "error-min", "error-max", "error-order", "error-format", "range-limit-message", "range-limit-heading"];
+    static readonly observedAttributes: readonly ["label", "start", "end", "placeholder", "required", "keep-open-while-invalid", "min", "max", "max-range-years", "validate-order", "validate-format", "show-range-limit-banner", "error-min", "error-max", "error-order", "error-format", "range-limit-message", "range-limit-heading", "error-min-severity", "error-max-severity", "error-format-severity", "error-order-severity", "range-limit-severity"];
     private _rendered;
     private _labelEl;
     private _displayEl;
     private _triggerEl;
     private _pickerEl;
     private _dropdown;
+    /**
+     * BTN-10312 — cached validity from the internal picker. `canClose` on the
+     * dropdown controller consults this to gate popup close when
+     * `keep-open-while-invalid` is set.
+     */
+    private _pickerValidity;
     constructor();
     get start(): string;
     set start(v: string);