@lekoala/date-picker 0.5.2 → 0.6.0

package/dist/types/date-picker.d.ts

@@ -1,83 +1,5 @@
 import { DateCalendarElement } from "./date-calendar.js";
-import { DateFieldController } from "./date-field.js";
-import { DateRangeController } from "./date-range.js";
-export type PickIntent = {
-    id: number;
-    endpoint: "" | "start" | "end";
-};
-/** A grid activation intent: the generation at interaction time plus the bound
- * a drag drop targets, empty for a normal pick.
- * @typedef {{id: number, endpoint: "" | "start" | "end"}} PickIntent */
 export declare class DatePickerElement extends HTMLElement {
-    _id: string;
-    _connected: boolean;
-    _reflecting: boolean;
-    _value: string;
-    _input: HTMLInputElement | null;
-    /** @type {DateFieldController | null} */
-    _field: DateFieldController | null;
-    /** @type {DateFieldController[] | null} */
-    _fields: DateFieldController[] | null;
-    /** @type {DateRangeController | null} */
-    _range: DateRangeController | null;
-    _orderTags: Set<any>;
-    /** Native time companions, [start, end]. @type {[HTMLInputElement | null, HTMLInputElement | null]} */
-    _timeFields: [HTMLInputElement | null, HTMLInputElement | null];
-    /** Time inputs currently holding our order error. @type {Set<HTMLInputElement>} */
-    _timeOrderOwned: Set<HTMLInputElement>;
-    /** @type {"" | "start" | "end"} */
-    _lastFocusEndpoint: "" | "start" | "end";
-    /** Activation generation. A grid intent records it at interaction time
-     * and travels with its own activation (see `activationIntents`), so a late
-     * response is checked against the generation, never looked up by date. */
-    _activationId: number;
-    /** Candidate date currently projected onto the calendar band, if any. */
-    _previewDate: string;
-    /** Live endpoint drag, or null. @type {{pointerId:number, endpoint:"start"|"end", x:number, y:number, date:string, active:boolean} | null} */
-    _drag: {
-        pointerId: number;
-        endpoint: "start" | "end";
-        x: number;
-        y: number;
-        date: string;
-        active: boolean;
-    } | null;
-    /** A real drag already committed; swallow the click that follows it. */
-    _suppressGridClick: boolean;
-    /** Overlaid calendar triggers, one per field (single) or per bound (range). @type {{button: HTMLButtonElement, endpoint: "" | "start" | "end"}[]} */
-    _buttons: {
-        button: HTMLButtonElement;
-        endpoint: "" | "start" | "end";
-    }[];
-    /** Control that opened the popover, so single mode can restore focus to it.
-     * @type {HTMLElement | null} */
-    _returnFocus: HTMLElement | null;
-    _panel: HTMLDivElement | null;
-    _calendar: DateCalendarElement | null;
-    _originalDescribedBy: string;
-    _rangeOriginalDescribedBy: string[];
-    _formatHint: HTMLSpanElement | null;
-    _generatedPlaceholder: boolean;
-    _controller: AbortController | null;
-    _stopTracking: (() => void) | null;
-    _open: boolean;
-    _suppressFocusOpen: boolean;
-    /** @type {typeof import("./messages.js").DEFAULT_MESSAGES | null} */
-    _messages: typeof import("./messages.js").DEFAULT_MESSAGES | null;
-    /** @type {Partial<import("./control-classes.js").ControlClasses> | null} */
-    _controlClasses: Partial<import("./control-classes.js").ControlClasses> | null;
-    /** @type {(() => void) | null} */
-    _stopDefaultMessages: (() => void) | null;
-    /** @type {import("./date-calendar.js").DateSource | null} */
-    _source: import("./date-calendar.js").DateSource | null;
-    /** @type {import("./date-calendar.js").DateStateResolver | null} */
-    _dateState: import("./date-calendar.js").DateStateResolver | null;
-    /** @type {import("./date-calendar.js").DayRenderer | null} */
-    _renderDay: import("./date-calendar.js").DayRenderer | null;
-    /** @type {import("./date-calendar.js").DateDisabledPredicate | null} */
-    _isDateDisabled: import("./date-calendar.js").DateDisabledPredicate | null;
-    /** Public picker coordinate-space request. @type {"viewport" | "document"} */
-    _coordinateSpace: "viewport" | "document";
     static observedAttributes: string[];
     /** @public @param {Partial<import("./control-classes.js").ControlClasses>} classes */
     static setDefaultControlClasses(classes: Partial<import("./control-classes.js").ControlClasses>): void;
@@ -111,19 +33,8 @@ export declare class DatePickerElement extends HTMLElement {
         rangeOrderEnd: string;
     };
     constructor();
-    _rangeMode(): boolean;
     connectedCallback(): void;
-    _connectSingle(): void;
-    /**
-     * Find optional native time companions. They stay fully native (no hidden
-     * input, no field controller); the picker only coordinates from/to order.
-     * A bad composition never breaks the date picker: warn and leave times alone.
-     */
-    _discoverTimeFields(): void;
-    _connectRange(): void;
     disconnectedCallback(): void;
-    /** @param {DateFieldController | null} field */
-    _teardownField(field: DateFieldController | null): void;
     /** @param {string} name @param {string|null} oldValue @param {string|null} newValue */
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     /** @public */
@@ -171,7 +82,6 @@ export declare class DatePickerElement extends HTMLElement {
     get messages(): typeof import("./messages.js").DEFAULT_MESSAGES;
     /** @param {Partial<typeof import("./messages.js").DEFAULT_MESSAGES> | null} value */
     set messages(value: Partial<typeof import("./messages.js").DEFAULT_MESSAGES> | null);
-    _refreshMessages(): void;
     /** @public @returns {import("./date-calendar.js").DateSource | null} */
     get source(): import("./date-calendar.js").DateSource | null;
     set source(value: import("./date-calendar.js").DateSource | null);
@@ -187,224 +97,6 @@ export declare class DatePickerElement extends HTMLElement {
     /** @public JS-only coordinate-space policy: "viewport" by default, "document" as an explicit opt-in; a change made while open applies to the next opening only. @returns {"viewport" | "document"} */
     get coordinateSpace(): "viewport" | "document";
     set coordinateSpace(value: "viewport" | "document");
-    _adapter(): {
-        locale: string;
-        placeholder: string;
-        format(value: string): string;
-        parse(text: string): string;
-    };
-    _setupFormValue(): void;
-    _syncInputState(): void;
-    _syncRangeFields(): void;
-    _setRangeAria(): void;
-    /**
-     * Create one calendar trigger. It is a real button overlaid inside the
-     * field's own box (see the CSS): the field reserves the room, the trigger
-     * stays transparent, and the field's focus ring wraps both.
-     * @param {"" | "start" | "end"} endpoint
-     * @returns {HTMLButtonElement}
-     */
-    _createTrigger(endpoint: "" | "start" | "end"): HTMLButtonElement;
-    /**
-     * Build the popup once and one trigger per field. Each trigger is inserted
-     * immediately after its own field so DOM order follows visual/tab order
-     * (`date -> its trigger -> next control`). The hidden ISO field may sit
-     * between the two; it is not focusable.
-     */
-    _build(): void;
-    /** @param {AbortSignal} signal @param {HTMLInputElement | null | undefined} input @param {() => void} restore */
-    _bindPopup(signal: AbortSignal, input: HTMLInputElement | null | undefined, restore: () => void): void;
-    _bind(): void;
-    _bindRange(): void;
-    /**
-     * Point the shared calendar at one range bound and invalidate any pending
-     * activation, so a late response can never commit on the wrong bound.
-     * @param {"start" | "end"} endpoint
-     */
-    _activateRangeEndpoint(endpoint: "start" | "end"): void;
-    /**
-     * Range has one trigger per bound. A press on the other bound's trigger is a
-     * local switch, not a toggle: it repoints the single open popup instead of
-     * closing it. Only a press on the already-active bound toggles shut.
-     * @param {"start" | "end"} endpoint
-     * @param {MouseEvent} event
-     */
-    _onRangeTriggerClick(endpoint: "start" | "end", event: MouseEvent): void;
-    /**
-     * ArrowDown on a trigger opens the popup and drops into the grid, like the
-     * field itself (Enter/Space go through the click path). Needed because focus
-     * now returns to the trigger that opened the popover.
-     * @param {"" | "start" | "end"} endpoint
-     * @param {KeyboardEvent} event
-     */
-    _onTriggerKeyDown(endpoint: "" | "start" | "end", event: KeyboardEvent): void;
-    /** @param {"" | "start" | "end"} endpoint @param {KeyboardEvent} event */
-    _onFieldKeyDown(endpoint: "" | "start" | "end", event: KeyboardEvent): void;
-    /** @param {"" | "start" | "end"} endpoint @param {FocusEvent} event */
-    _onFieldFocus(endpoint: "" | "start" | "end", event: FocusEvent): void;
-    /** Record grid activation intent (click or keyboard) so a stale,
-     * late-confirmed dateactivate can be recognized and dropped. Each new grid
-     * activation supersedes every earlier pending one.
-     * @param {Event} event */
-    _captureGridIntent(event: Event): void;
-    /**
-     * Hand a new intent to the calendar's next activation of `date`. Taking a
-     * new generation supersedes every earlier pending activation.
-     * @param {string} date @param {"" | "start" | "end"} endpoint
-     */
-    _attachIntent(date: string, endpoint: "" | "start" | "end"): void;
-    /**
-     * Invalidate every pending grid activation: each one carries its own intent,
-     * which now fails the generation check. A programmatic
-     * `calendar.activateDate()` carries none.
-     */
-    _supersedeActivations(): void;
-    /** Whether one bound can receive a user pick right now.
-     * @param {"start" | "end"} bound */
-    _boundEditable(bound: "start" | "end"): boolean;
-    /**
-     * Single write path for a calendar-driven range change. Both fields are
-     * synchronized before anything is announced, because one transition can move
-     * both bounds at once (`10` then `5` commits `start 10 -> 5` together with
-     * `end "" -> 10`); writing bound by bound would expose an intermediate
-     * inverted pair. Synthetic `input`/`change` stay on the bounds that moved.
-     * @param {import("./date-range.js").RangeTransition} transition
-     */
-    _applyRangeTransition(transition: import("./date-range.js").RangeTransition): void;
-    /**
-     * Project a candidate date onto the calendar band. Purely visual: no
-     * `rangechange`, no field write, no validation and no source request — the
-     * projection reads the month state already loaded, and the real availability
-     * check still runs on commit.
-     * @param {string} date @param {"" | "start" | "end"} [endpoint]
-     */
-    _setPreview(date: string, endpoint?: "" | "start" | "end"): void;
-    /** Drop the projection and put the committed range back on the band. */
-    _clearPreview(): void;
-    /** @param {Event} event */
-    _onGridDateFocus(event: Event): void;
-    /**
-     * Hover candidate. `focusedDate` stays the keyboard target only: pointer
-     * hover never moves it, it just feeds the same projection.
-     * @param {Event} event
-     */
-    _onGridPointerOver(event: Event): void;
-    _onGridPointerLeave(): void;
-    /** @param {EventTarget | null} target @returns {string} */
-    _cellDate(target: EventTarget | null): string;
-    /** @param {number} x @param {number} y @returns {string} */
-    _dateAtPoint(x: number, y: number): string;
-    /**
-     * Arm an endpoint drag. Only a complete, ordered range offers two distinct
-     * handles; a one-day range carries both markers on the same cell, and
-     * guessing which one the user meant would be worse than not dragging.
-     * @param {Event} event
-     */
-    _onGridPointerDown(event: Event): void;
-    /** @param {Event} event */
-    _onGridPointerMove(event: Event): void;
-    /** @param {Event} event */
-    _onGridPointerUp(event: Event): void;
-    /** @param {Event} event */
-    _onGridPointerCancel(event: Event): void;
-    /** @param {number} pointerId */
-    _releaseDragCapture(pointerId: number): void;
-    /** Expose whether the band currently offers draggable handles, and whether
-     * one is being dragged, so the cursor can say so. */
-    _syncDragAffordance(): void;
-    /** @param {KeyboardEvent} event */
-    _onEscape(event: KeyboardEvent): void;
-    _syncCalendarOptions(): void;
-    _refreshLocale(): void;
-    _refreshButtonLabel(): void;
-    /** Each bound has its own trigger, so each needs its own accessible name: the
-     * bound label is what tells two otherwise identical triggers apart. */
-    _refreshRangeButtonLabel(): void;
-    /** @param {string} value */
-    _reflectValue(value: string): void;
-    /** @param {string} value @param {{emit?:boolean,format?:boolean,reflect?:boolean,moveDisplay?:boolean}} [options] */
-    _setValue(value: string, options?: {
-        emit?: boolean;
-        format?: boolean;
-        reflect?: boolean;
-        moveDisplay?: boolean;
-    }): void;
-    /**
-     * Calendar-backed availability gate injected into the field controllers.
-     * A cancelled or failed source load confirms nothing: do not fill the
-     * submitted ISO field nor treat the date as available.
-     * @param {string} date @param {{moveDisplay?: boolean}} [options]
-     * @returns {Promise<{ok: boolean, message?: string}>}
-     */
-    _confirmDate(date: string, options?: {
-        moveDisplay?: boolean;
-    }): Promise<{
-        ok: boolean;
-        message?: string;
-    }>;
-    /** @param {boolean} emit @param {{force?: boolean, moveDisplay?: boolean}} [options] */
-    _commitText(emit: boolean, options?: {
-        force?: boolean;
-        moveDisplay?: boolean;
-    }): Promise<boolean>;
-    /** @param {"start" | "end"} which */
-    _commitFieldText(which: "start" | "end"): Promise<boolean>;
-    /** @param {"start" | "end"} which @param {string} value
-     * @param {{emit?:boolean, format?:boolean, user?:boolean}} [options] @returns {boolean} */
-    _setBound(which: "start" | "end", value: string, options?: {
-        emit?: boolean;
-        format?: boolean;
-        user?: boolean;
-    }): boolean;
-    /** Atomic pair update: canonical + visible + hidden before one event.
-     * @param {string} start @param {string} end @param {{emit?:boolean, format?:boolean}} [options] */
-    _setRange(start: string, end: string, options?: {
-        emit?: boolean;
-        format?: boolean;
-    }): void;
-    /** @param {"start" | "end"} which */
-    _boundCanonical(which: "start" | "end"): string;
-    _emitRangeChange(): void;
-    /** Displayable projection of the business range. An inverted or start-less
-     * pair shows no misleading band. @returns {{start:string, end:string}} */
-    _displayRange(): {
-        start: string;
-        end: string;
-    };
-    /** Put the committed range back on the calendar band, dropping any
-     * projection currently shown over it. */
-    _syncHighlight(): void;
-    /**
-     * Cross-bound validity: the order error is attributed to the bound that was
-     * just modified; the other bound only loses a stale order error, never its
-     * independent parse/source validity.
-     * @param {"start" | "end"} which
-     */
-    _revalidateRange(which: "start" | "end"): void;
-    /**
-     * Single-mode from/to order on the shared date: `start <= end`.
-     * The order error is attributed to the bound that was just modified; the
-     * other bound only loses a stale order error, never its native validity.
-     * Missing, empty or disabled times fall back to no order constraint: times
-     * are never implicitly required. Equality stays valid (duration rules are
-     * application-owned).
-     * @param {"start" | "end"} which
-     */
-    _revalidateTimeOrder(which: "start" | "end"): void;
-    _clearTimeOrderValidity(): void;
-    _restoreDefault(): void;
-    _restoreRangeDefault(): void;
-    /** @param {"start" | "end"} which */
-    _focusField(which: "start" | "end"): void;
-    /**
-     * Restore focus to the control that opened the popover (single mode). focus()
-     * must not run synchronously from a keydown handler (Chromium drops focus
-     * changes there) and must not re-open the popover under the default
-     * open-on-focus. Deferring keeps _suppressFocusOpen active for the call.
-     */
-    _restoreFocus(): void;
-    /** @returns {"" | "start" | "end"} */
-    _resolveRangeEndpoint(): "" | "start" | "end";
     /** @public */
     validate(): Promise<boolean>;
     /** @public @param {{moveFocus?:boolean, endpoint?:"start"|"end", returnFocus?:HTMLElement}} [options] */
@@ -413,14 +105,6 @@ export declare class DatePickerElement extends HTMLElement {
         endpoint?: "start" | "end";
         returnFocus?: HTMLElement;
     }): void;
-    /** @param {boolean} expanded */
-    _setExpanded(expanded: boolean): void;
     /** @public @param {boolean} [restoreFocus] */
     hide(restoreFocus?: boolean): void;
-    /** The bound to restore focus to after closing a range popup: the active
-     * endpoint first (it moved after the first selection), then the next
-     * focusable bound.
-     * @returns {"" | "start" | "end"} */
-    _restoreFocusEndpoint(): "" | "start" | "end";
 }
-//# sourceMappingURL=date-picker.d.ts.map

package/dist/types/date-range.d.ts

@@ -78,10 +78,9 @@ export type RangeTransition = {
  * - activating through `start` commits `start`, moves the active endpoint to
  *   `end` and leaves the popup open for the second selection.
  *
- * Each rule exists once, as a `project*()` projection; `activate()` and
- * `moveEndpoint()` only apply one. Hover, keyboard and drag previews read the
- * same projections, so a second copy of the interaction rules cannot drift
- * into the DOM layer.
+ * Each rule exists once, as a `project()` projection; `activate()` only
+ * applies one. Keyboard and pointer previews read the same projection, so a
+ * second copy of the interaction rules cannot drift into the DOM layer.
  *
  * Text entry is deliberately outside this machine: a typed pair may be
  * temporarily inverted and report a validation error. It is the coordinator's
@@ -114,34 +113,20 @@ export declare class DateRangeController {
      * @returns {RangeTransition}
      */
     project(date: string, editable?: (bound: "start" | "end") => boolean): RangeTransition;
-    /**
-     * Project a direct move of one bound (endpoint drag), without mutating.
-     *
-     * Only a complete, ordered pair offers two handles to grab, and a handle
-     * never crosses the other one: the candidate is clamped to the opposite
-     * bound, so the previewed band is exactly what a drop commits. Equality is
-     * allowed (a one-day range).
-     * @param {string} date
-     * @param {"start" | "end"} endpoint
-     * @param {(bound: "start" | "end") => boolean} [editable]
-     * @returns {RangeTransition}
-     */
-    projectEndpoint(date: string, endpoint: "start" | "end", editable?: (bound: "start" | "end") => boolean): RangeTransition;
     /**
      * Displayable band a candidate date would produce, or `null` when there is
-     * nothing to promise. Single source of truth for hover, keyboard and drag
-     * previews: the projection rules with no mutation and no event.
+     * nothing to promise. Single source of truth for hover and keyboard previews:
+     * the projection rules with no mutation and no event.
      *
-     * Without a drag handle a preview only speaks during range creation, when
-     * exactly one bound is anchored and the other is still open. An empty range
-     * has no anchor to project from, and a complete pair is not a promise in
-     * progress — previewing it would repaint the committed band on every hover.
+     * A preview only speaks during range creation, when exactly one bound is
+     * anchored and the other is still open. An empty range has no anchor to
+     * project from, and a complete pair is not a promise in progress —
+     * previewing it would repaint the committed band on every hover.
      * @param {string} date
-     * @param {"" | "start" | "end"} [endpoint] drag handle, empty for a normal pick
      * @param {(bound: "start" | "end") => boolean} [editable]
      * @returns {DateRange | null}
      */
-    previewRange(date: string, endpoint?: "" | "start" | "end", editable?: (bound: "start" | "end") => boolean): DateRange | null;
+    previewRange(date: string, editable?: (bound: "start" | "end") => boolean): DateRange | null;
     /** @param {RangeTransition} transition @returns {RangeTransition} */
     _apply(transition: RangeTransition): RangeTransition;
     /**
@@ -151,14 +136,6 @@ export declare class DateRangeController {
      * @returns {RangeTransition}
      */
     activate(date: string, editable?: (bound: "start" | "end") => boolean): RangeTransition;
-    /**
-     * Apply a direct move of one bound (endpoint drag).
-     * @param {string} date
-     * @param {"start" | "end"} endpoint
-     * @param {(bound: "start" | "end") => boolean} [editable]
-     * @returns {RangeTransition}
-     */
-    moveEndpoint(date: string, endpoint: "start" | "end", editable?: (bound: "start" | "end") => boolean): RangeTransition;
 }
 /**
  * Link two date pickers without teaching either picker about its sibling.

package/dist/types/date-range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date-range.d.ts","sourceRoot":"","sources":["../../src/date-range.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"date-range.d.ts","sourceRoot":"","sources":["../../src/date-range.js"],"names":[],"mappings":"AAEI,YAAsC,SAAS,GAArC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,MAAM,CAAA;CAAC,CAAW;AAAnD,sDAAsD;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAHzB;IAAC,KAAK,CAAC,EAAC,MAAM,CAAC;IAAC,GAAG,CAAC,EAAC,MAAM,CAAA;CAAC,GAAC,IAAI,GAAC,SAGT,GAFvB,SAAS,CAYrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAJvB,MAIuB,EAAE,KAAK,EAH9B,SAAS,GAAC,IAAI,GAAC,SAGe,GAF5B,EAAE,GAAG,OAAO,GAAG,IAAI,GAAG,KAAK,GAAG,QAAQ,CAUlD;AAGE,YAAkB,eAAe,GACjC;IAA+C,MAAM,EAA1C,SAAS,GAAG,UAAU,GAAG,SAAS,CAC7C;;;;IAA4B,QAAQ,EAAzB,OAAO,GAAG,KAAK,CAC1B;;;;IAAgC,gBAAgB,EAArC,CAAC,OAAO,GAAG,KAAK,CAAC,EAAE,CAC9B;;;;IAAsB,KAAK,EAAhB,SAAS,CACpB;;;;IAAiC,cAAc,EAApC,EAAE,GAAG,OAAO,GAAG,KAAK,CAC/B;;;;IAAqB,KAAK,AAA1B,CACF,EADa,OAAO,CACpB;CAAA,CAAA;AARD;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,mBAAmB;IAE5B,mCAAmC;IAC9B,cAAc,EADR,EAAE,GAAG,OAAO,GAAG,KAAK;IAE1B,KAAK;IACL,GAAG;IAJV,cAKC;IAED,2BAA2B;IAC3B,IAAI,KAAK,IADK,SAAS,CAGtB;IAED,gEAAgE;IAChE,IAAI,QAAQ,YAEX;IAED,6CAA6C;IAC7C,KAAK,CAAC,QAAQ,EADF,EAAE,GAAG,OAAO,GAAG,KACb,QAEb;IAED,mEAAmE;IACnE,OAAO,CAAC,QAAQ,EADJ,OAAO,GAAG,KACN,GADgC,eAAe,CAS9D;IAED;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,IAAI,EAJD,MAIC,EAAE,QAAQ,AAHnB,CACA,EADQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,KAAK,OAGJ,GAFtB,eAAe,CAoE3B;IAED;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,IAAI,EAJN,MAIM,EAAE,QAAQ,AAHxB,CACA,EADQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,KAAK,OAGC,GAF3B,SAAS,GAAG,IAAI,CAU5B;IAED,qEAAqE;IACrE,MAAM,CAAC,UAAU,EADL,eACK,GADiC,eAAe,CAOhE;IAED;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAJF,MAIE,EAAE,QAAQ,AAHpB,CACA,EADQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,KAAK,OAGH,GAFvB,eAAe,CAI3B;CACF;AAgBD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAJxB,OAAO,kBAAkB,EAAE,iBAIH,EAAE,GAAG,EAH7B,OAAO,kBAAkB,EAAE,iBAGE,GAF3B,MAAM,IAAI,CAyBtB"}

package/dist/types/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/date.js"],"names":[],"mappings":"AAGA,2BAA2B;AAC3B,wBAAgB,UAAU,CAAC,IAAI,EADnB,MACmB,WAE9B;AAED,iDAAiD;AACjD,wBAAgB,WAAW,CAAC,IAAI,EADpB,MACoB,EAAE,KAAK,EADN,MACM,qBAGtC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAHpB,MAGoB,GAFlB;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,MAAM,CAAA;CAAC,GAAG,IAAI,CAW1D;AAED,4BAA4B;AAC5B,wBAAgB,MAAM,CAAC,KAAK,EADhB,MACgB,WAE3B;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAHnB,MAGmB,GAFjB,MAAM,CAYlB;AAED,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,IAAI,EADlB,MACkB,EAAE,KAAK,EADJ,MACI,EAAE,GAAG,EADa,MACb,UAIzC;AAeD,4BAA4B;AAC5B,wBAAgB,UAAU,CAAC,KAAK,EADpB,MACoB,QAI/B;AAED,0CAA0C;AAC1C,wBAAgB,YAAY,CAAC,CAAC,EADlB,MACkB,EAAE,CAAC,EADH,MACG,cAGhC;AAED,mDAAmD;AACnD,wBAAgB,OAAO,CAAC,KAAK,EADjB,MACiB,EAAE,MAAM,EADH,MACG,UAOpC;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,KAAK,EADnB,MACmB,EAAE,MAAM,EADL,MACK,UAUtC;AAED,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,KAAK,EADlB,MACkB,EAAE,MAAM,EADJ,MACI,UAOrC;AAED,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,KAAK,EADpB,MACoB,EAAE,MAAM,EADN,MACM,UAGvC;AAED,4BAA4B;AAC5B,wBAAgB,YAAY,CAAC,KAAK,EADtB,MACsB,UAEjC;AAED,4BAA4B;AAC5B,wBAAgB,UAAU,CAAC,KAAK,EADpB,MACoB,UAI/B;AAED,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,KAAK,EADM,MACN,UAI9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAF/B,MAE+B,UAKzC;AAED,qDAAqD;AACrD,wBAAgB,WAAW,CAAC,KAAK,EADrB,MACqB,EAAE,QAAQ,GADT,MACa,UAG9C;AAED,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,KAAK,EADnB,MACmB,EAAE,QAAQ,GADP,MACW,UAE5C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAHxB,MAGwB,EAAE,OAAO,AAFzC,CAA4D,EAApD;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAEF,cAsBhD;AAaD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAJ5B,MAI4B,EAAE,QAAQ,AAH9C,CACA,EADQ,MAG0C,GAFxC,MAAM,CAyBlB;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,KAAK,EADnB,MACmB,EAAE,GAAG,AADV,CAAsB,EAAd,MACO,EAAE,GAAG,AADE,CAAqB,EAAb,MACL,UAKlD;AAED,2EAA2E;AAC3E,wBAAgB,QAAQ,WAGvB;AAED,kDAAkD;AAClD,wBAAgB,aAAa,CAAC,KAAK,EADD,MACC,UAUlC"}
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/date.js"],"names":[],"mappings":"AAGA,2BAA2B;AAC3B,wBAAgB,UAAU,CAAC,IAAI,EADnB,MACmB,WAE9B;AAED,iDAAiD;AACjD,wBAAgB,WAAW,CAAC,IAAI,EADpB,MACoB,EAAE,KAAK,EADN,MACM,qBAGtC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAHpB,MAGoB,GAFlB;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,MAAM,CAAA;CAAC,GAAG,IAAI,CAW1D;AAED,4BAA4B;AAC5B,wBAAgB,MAAM,CAAC,KAAK,EADhB,MACgB,WAE3B;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAHnB,MAGmB,GAFjB,MAAM,CAelB;AAED,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,IAAI,EADlB,MACkB,EAAE,KAAK,EADJ,MACI,EAAE,GAAG,EADa,MACb,UAIzC;AAeD,4BAA4B;AAC5B,wBAAgB,UAAU,CAAC,KAAK,EADpB,MACoB,QAI/B;AAED,0CAA0C;AAC1C,wBAAgB,YAAY,CAAC,CAAC,EADlB,MACkB,EAAE,CAAC,EADH,MACG,cAGhC;AAED,mDAAmD;AACnD,wBAAgB,OAAO,CAAC,KAAK,EADjB,MACiB,EAAE,MAAM,EADH,MACG,UAOpC;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,KAAK,EADnB,MACmB,EAAE,MAAM,EADL,MACK,UAUtC;AAED,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,KAAK,EADlB,MACkB,EAAE,MAAM,EADJ,MACI,UAOrC;AAED,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,KAAK,EADpB,MACoB,EAAE,MAAM,EADN,MACM,UAGvC;AAED,4BAA4B;AAC5B,wBAAgB,YAAY,CAAC,KAAK,EADtB,MACsB,UAEjC;AAED,4BAA4B;AAC5B,wBAAgB,UAAU,CAAC,KAAK,EADpB,MACoB,UAI/B;AAED,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,KAAK,EADM,MACN,UAI9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAF/B,MAE+B,UAKzC;AAED,qDAAqD;AACrD,wBAAgB,WAAW,CAAC,KAAK,EADrB,MACqB,EAAE,QAAQ,GADT,MACa,UAG9C;AAED,qDAAqD;AACrD,wBAAgB,SAAS,CAAC,KAAK,EADnB,MACmB,EAAE,QAAQ,GADP,MACW,UAE5C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAHxB,MAGwB,EAAE,OAAO,AAFzC,CAA4D,EAApD;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAEF,cAsBhD;AAaD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAJ5B,MAI4B,EAAE,QAAQ,AAH9C,CACA,EADQ,MAG0C,GAFxC,MAAM,CAyBlB;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,KAAK,EADnB,MACmB,EAAE,GAAG,AADV,CAAsB,EAAd,MACO,EAAE,GAAG,AADE,CAAqB,EAAb,MACL,UAKlD;AAED,2EAA2E;AAC3E,wBAAgB,QAAQ,WAGvB;AAED,kDAAkD;AAClD,wBAAgB,aAAa,CAAC,KAAK,EADD,MACC,UAUlC"}

package/dist/types/session.d.ts

@@ -0,0 +1,17 @@
+/**
+ * One lifetime: a picker connection, a calendar connection or a field
+ * controller. The returned controller is the token an operation captures
+ * before it suspends.
+ * @returns {AbortController}
+ */
+export declare function createSession(): AbortController;
+/**
+ * Protect a callback with the signal captured now. The caller keeps the
+ * scheduling choice (`queueMicrotask` vs `setTimeout`), because focus behavior
+ * in Chromium depends on it.
+ * @param {AbortSignal} signal
+ * @param {() => void} callback
+ * @returns {() => void}
+ */
+export declare function guard(signal: AbortSignal, callback: () => void): () => void;
+//# sourceMappingURL=session.d.ts.map

package/dist/types/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,aAAa,IAFhB,eAAe,CAI3B;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAJjB,WAIiB,EAAE,QAAQ,EAH3B,MAAM,IAGqB,GAFzB,MAAM,IAAI,CAMtB"}

package/docs/ACCESSIBILITY.md

@@ -42,7 +42,7 @@ Moving focus never changes selection. Each cell that actually receives focus dis
 
 A range preview projected onto the band is visual only: it never contributes a range start/end to a day's accessible name, so a proposal is never announced as a committed selection.
 
-Endpoint dragging is a pointer enhancement. Every adjustment it offers is also reachable from the keyboard: activating before or after a complete range moves the corresponding bound.
+An application-owned pointer gesture that moves a range bound must end in the same `activateDate()` + `dateactivate` path as the keyboard: availability is checked and the activation is cancellable, so a pointer gesture cannot bypass the keyboard contract.
 
 ## Month/year controls
 

package/docs/API.md

@@ -27,6 +27,16 @@ The public surface — flat event names, `selection` values, `--dp-*` styling to
 
 Presentation-only range band. It never changes `value`, `selection` or `focusedDate`. It accepts an ordered `{ start, end }` pair of `YYYY-MM-DD` values; `end` may be empty (range in progress), and a `start === end` range renders both endpoints with a dedicated label. `null` and `{ start: "", end: "" }` reset the band. Inverted ranges and `{ start: "", end: "…" }` throw a `TypeError` — the property never reorders or guesses. Styled spans render `data-range-start="true"`, `data-in-range="true"`, `data-range-end="true"` and extend each day's `aria-label` accordingly.
 
+### Day cell data attributes
+
+Day cells stay component-owned DOM (D3): `.dp-*` classes are not a styling API and the cell cannot be replaced. These read-only data attributes are stable hooks for application-owned interactions:
+
+- `data-date="YYYY-MM-DD"` — canonical date of the cell;
+- `data-range-start` / `data-in-range` / `data-range-end` — band position painted from `highlightedRange` (a one-day range carries both start and end);
+- `data-range-preview` — on the calendar, not the cell: the band is a proposal, so cells stop contributing a range start/end to their accessible name while it is set.
+
+Applications may read them (for example to hit-test a pointer gesture, see [CALENDAR-INTEGRATION](CALENDAR-INTEGRATION.md)); they must not write them.
+
 ### Callback properties
 
 ```js
@@ -149,7 +159,7 @@ Markup:
 </date-picker>
 ```
 
-The direct child text input is required. On enhancement its original `name` moves to an internal hidden input that submits the canonical ISO value.
+The direct child text input is required. On enhancement its original `name` moves to an internal hidden input that submits the canonical ISO value. Dynamic `name`/`form`/`disabled` changes are synchronized by a `MutationObserver`; code that reads `FormData` in the same task as such a mutation must wait for the next microtask. Removing `name` from the visible enhanced input does not unregister the canonical field because that input no longer owns the submitted name; disable the field to omit it from submission.
 
 ### Attributes / properties
 
@@ -211,6 +221,8 @@ picker.hide();
 await picker.validate();
 ```
 
+When disconnected, `validate()` cannot run source availability checks and returns the current native validity of the authored date/time inputs.
+
 ### Events
 
 - `valuechange` — canonical value changed;
@@ -303,7 +315,7 @@ The business range may be temporarily incomplete or inverted; `calendar.highligh
 - **Calendar interaction never produces an inverted range.** While a range is being created, a second pick before the anchor is sorted rather than refused: `10` then `15` gives `10 -> 15`, `10` then `5` gives `5 -> 10`, and `10` then `10` a one-day range. That transition moves **both** bounds at once and is applied in a single write — one `rangechange`, with synthetic `input`/`change` on each bound that moved, and no intermediate inverted pair ever observable. Typed text keeps the opposite contract and may be temporarily inverted (see [DECISIONS D6](DECISIONS.md)).
 - Changing one bound of an already complete pair keeps that bound's identity: moving `end` before `start` is refused (`dateinvalid`, nothing changes) instead of rewriting the other field.
 - **Preview.** While a range is being created, hovering a day or moving the keyboard focus projects the range the next pick would commit onto `calendar.highlightedRange`, and the pick commits exactly what was projected. The projection is visual only: no `rangechange`, no field write, no validation and no source request. It reads the month already loaded, so a day known to be unavailable promises nothing; the real availability check still runs on commit. Pointer hover never moves `focusedDate`, which stays the keyboard target. Leaving the grid, Escape and closing the popup restore the committed band.
-- **Endpoint drag.** On a complete, ordered range whose two ends sit on different days, each endpoint can be dragged with a mouse or pen (pointer events plus capture, armed only once the pointer travels). A handle never crosses the other one — the candidate is clamped to it, equality allowed — an unavailable cell is not a drop target, and `pointercancel` restores the committed band. The drop runs the same projection and the same `ensureDate` + cancelable `dateactivate` path as a click, emits one `rangechange`, and keeps the popup open: a drag adjusts a range, it does not validate it. A press without travel stays a plain click. Touch keeps native scrolling and stays a plain tap.
+- Adjusting an existing bound by pointer (dragging an endpoint) is application-owned: see [DECISIONS D9](DECISIONS.md) and the recipe in [CALENDAR-INTEGRATION.md](CALENDAR-INTEGRATION.md). The picker itself only moves a bound through a calendar activation (`activateDate()` / `dateactivate`).
 - Each bound owns its trigger (`input[data-range-start]` then its trigger, `input[data-range-end]` then its trigger); the two triggers share **one** popup, calendar, source and state. Pressing the other bound's trigger while the popup is open switches the active bound and keeps it open instead of toggling it shut. A trigger never opens a `readonly`/`disabled` bound.
 - Typing stays independent per field. Moving `start` past `end` keeps both values and flags the *modified* bound with `rangeOrderStart`; fixing either side revalidates both. Parse/source errors are never cleared by cross-bound revalidation.
 - A stale availability response resolving after the active endpoint changed (or after a newer selection) never commits; a field focus that switches the endpoint invalidates in-flight activations.
@@ -328,29 +340,6 @@ rangePosition("2026-09-12", range); // "start" | "in" | "end" | "single" | ""
 
 `normalizeRange` validates an ordered displayable range and never reorders: an inversion or an `end` without a `start` throws. `rangePosition` classifies one day within a displayable range (see [`highlightedRange`](#highlightedrange)).
 
-## `DateRangeController`
-
-The pure two-bound state machine behind `date-picker[range]`. It owns the
-selection rules and knows nothing about DOM, popups or async availability.
-
-```js
-const model = new DateRangeController();
-model.focus("start");
-model.activate("2026-09-10"); // { status: "pending", endpoint: "start", … }
-model.previewRange("2026-09-05"); // { start: "2026-09-05", end: "2026-09-10" }
-model.activate("2026-09-05"); // changedEndpoints: ["start", "end"]
-```
-
-- `project(date, editable?)` / `projectEndpoint(date, endpoint, editable?)` describe a transition without applying it;
-- `activate(date, editable?)` / `moveEndpoint(date, endpoint, editable?)` apply one;
-- `previewRange(date, endpoint?, editable?)` returns the displayable band a candidate would produce, or `null` when there is nothing to promise.
-
-A transition is `{ status, endpoint, changedEndpoints, range, activeEndpoint, close? }`.
-`range` is the whole resulting pair, because one interaction can move both
-bounds; `changedEndpoints` names the ones that actually move. Every rule exists
-once, as a projection, and the previews read the same projections the commit
-applies.
-
 ## `createDateAdapter(locale)`
 
 Locale-aware editable numeric adapter:

package/docs/ARCHITECTURE.md

@@ -126,6 +126,8 @@ Supported response shapes:
 
 No server URL, query parameter names or backend schema are hard-coded into the core. `createFetchSource()` is only a convenience adapter.
 
+A commit belongs to the field controller and connection that started it. Disconnect tears controllers down: pending validation is invalidated, and neither the controller nor the picker may apply a result produced before the rebuild. A reconnected picker re-derives its state from the live DOM instead of resuming pending work.
+
 ## 7. Picker composition
 
 `<date-picker>` enhances a direct child text input.
@@ -195,3 +197,75 @@ Expected homes:
 - start/end relationship → `date-range.js`.
 
 Do not add a plugin system to solve a one-off rendering need.
+
+## 11. Lifecycle and supported mutations
+
+### 11.1 One session token
+
+Every lifetime owns one `AbortController`: a picker connection, a calendar connection, a `DateFieldController`. Listeners are attached with its `signal`, and teardown aborts it.
+
+Any write that follows a suspension (`await`, timer, microtask) is checked against **the session captured when the operation started**, never against the current one:
+
+```js
+const session = this._session;
+const result = await field.commit();
+if (session.signal.aborted) return;
+```
+
+A reconnected component has a new, live session. Testing `this._session` after the await would let a stale continuation through — that is the exact failure `1977785` fixed locally. This rule replaces per-path guards; it is not one more guard.
+
+Scheduling stays at the call site (`queueMicrotask` vs `setTimeout`) because Chromium focus behavior depends on it. Only the guard is shared.
+
+### 11.2 Three distinct questions, three mechanisms
+
+| Question | Mechanism | Scope |
+|---|---|---|
+| Is the session I started in still alive? | captured `AbortSignal` | per connection / controller |
+| Is my operation still the newest intent? | monotonic generation (`commitId`, activation id) | per field / per activation |
+| Is the action still allowed now? | native state + interaction state (`isEditable()`, `:disabled`, `_open`, active bound) | read at apply time |
+
+Do not merge them. The signal says nothing about a newer intent, and neither says whether a `<fieldset>` was disabled or the popup closed.
+
+### 11.3 Supported mutations
+
+| Element | Policy |
+|---|---|
+| single/range mode | read at connect; changing it requires reconnecting |
+| identity of `[data-range-start]` / `[data-range-end]` inputs | fixed at connect |
+| presence and role of `[data-time-start]` / `[data-time-end]` | fixed at connect |
+| initial values (`input.value`, `defaultValue`) | read at connect |
+| public API (`value`, `range`, `min`, `max`, `locale`, `source`, `dateState`, `renderDay`, `isDateDisabled`, `messages`, `controlClasses`, `monthFormat`, `openOnFocus`, `coordinateSpace`) | live; each setter documents whether it invalidates pending work |
+| `name`, `form`, `disabled`, `readonly`, disabled fieldset, form reset, `defaultValue` | followed: this is the browser contract, not an arbitrary mutation |
+| visible input text | draft, read at commit (blur/change/validate) |
+| replacing child inputs | unsupported without reconnecting |
+
+Undocumented structural mutations carry no guarantee:
+
+> Undocumented structural mutations provide no resynchronization guarantee and no guarantee that interaction state is preserved. The component supports only the structure captured at connect time and the mutations listed above. To change the structure, disconnect and reconnect the component.
+
+A security or native-data-integrity defect is still acceptable **inside a supported usage**, with a reproducible scenario. It is not required to be robust against arbitrary combinations of DOM mutations.
+
+The initial `name` is captured for restoration; the current `name` stays dynamic.
+
+### 11.4 Reconnect is a new session
+
+Moving an element in the DOM disconnects and reconnects it. That rebuilds the controllers and calendar and abandons in-flight interaction without emitting an event. Native values and public configuration survive; popup, focus and active-bound state do not. This is the contract, not an edge case to patch.
+
+### 11.5 State authorities
+
+Name the authority before touching sync code; everything else is a projection recomputed from it.
+
+| Mode | Authority | Projections |
+|---|---|---|
+| single | `DatePickerElement._value` | field canonical, hidden ISO, formatted text, `calendar.value`, `value` attribute |
+| range | `DateRangeController.start/end` | each field canonical, hidden ISO, texts, `calendar.highlightedRange` (only when displayable) |
+| calendar | `CalendarModel` | DOM, `_renderedStates` (paint cache) |
+| draft | input text | re-read at commit; `_dirty` says whether it differs from the authority |
+| native default | `input.defaultValue` | restored by reset; `_generatedDefault` separates a generated default from an application one |
+
+Priority rules:
+
+- assigning `value`/`range` invalidates pending activations and commits;
+- a form reset wins and resynchronizes everything;
+- a direct native write to the input is read at commit, not watched;
+- a commit result is applied only if the captured session is alive **and** its `commitId` is current.