@ixfx/components 0.4.2 → 0.4.4

package/dist/{tree-component-BaCSPWg1.d.ts → tree-component-DCmmKZ4j.d.ts}

@@ -1,123 +1,4 @@
-//#region src/common/data-provider.d.ts
-/**
- * Shared data-provider contract used by components that render a list of items.
- *
- * A provider is a simple callable — the consuming component (via DataController)
- * manages the request lifecycle, cancellation, and reactive state.
- */
-/**
- * One batch of items within a streaming provider response.
- *
- * For sync and async one-shot providers, the DataController synthesises a single
- * DataBatch internally — you only need this type when writing a streaming provider.
- */
-type DataBatch<T> = {
-  /** Items delivered in this batch. */readonly items: readonly T[];
-  /**
-   * When true, replace all previously accumulated items with this batch instead
-   * of appending. Useful for re-ranked or filtered results mid-stream.
-   * Default: false (append).
-   */
-  replace?: boolean;
-  /**
-   * Provider's current estimate of the total number of items that will be
-   * delivered across all batches. Enables progress percentage in the consumer.
-   * May be refined in subsequent batches as the estimate improves.
-   * Omit when the total is unknown.
-   */
-  total?: number;
-};
-/**
- * The three return modes a provider may use.
- * DataController normalises all three — callers can mix modes freely.
- *
- * - `readonly T[]`                  — sync, items available immediately
- * - `Promise<readonly T[]>`         — async one-shot, resolves to the full result
- * - `AsyncIterable<DataBatch<T>>`   — streaming, batches arrive over time
- */
-type DataProviderResult<T> = readonly T[] | Promise<readonly T[]> | AsyncIterable<DataBatch<T>>;
-/**
- * A data provider callable.
- *
- * @typeParam TQuery - The input that scopes the request (e.g. `string` for
- *   autocomplete, `{ node, depth }` for a tree branch, `void` for a plain list).
- * @typeParam TItem  - The item type produced.
- *
- * The AbortSignal is cancelled when the consumer supersedes the request (e.g.
- * a new query arrives before the previous one completes). Streaming providers
- * should check `signal.aborted` between yields or pass the signal to their
- * underlying fetch calls.
- */
-type IDataProvider<TQuery, TItem> = (query: TQuery, signal: AbortSignal) => DataProviderResult<TItem>;
-/**
- * Collects all items from any DataProviderResult into a flat array.
- * Useful for components that need a complete list before rendering (e.g. tree branches).
- * Respects the AbortSignal — stops accumulating if cancelled mid-stream.
- */
-declare function collectDataResult<T>(result: DataProviderResult<T>, signal: AbortSignal): Promise<readonly T[]>;
-//#endregion
-//#region src/common/types.d.ts
-type TreeItem = {
-  /** Unique identifier within the tree. */key: string; /** Visible label text. */
-  label: string; /** When true the node cannot have children and will not show an expand affordance. */
-  isLeaf?: boolean; /** Arbitrary application data associated with this node. */
-  data?: unknown; /** Icon name passed to an icon component, if icons are enabled. */
-  icon?: string; /** Tooltip text shown on hover. */
-  tooltip?: string; /** Optional string value, e.g. for use as a command/route. */
-  value?: string;
-};
-/** A node in the tree, potentially containing lazily-loaded children. */
-type TreeNode = {
-  item: TreeItem;
-  /**
-   * Child nodes.
-   * - `undefined` = children not yet loaded (component will call loadChildren if set)
-   * - `[]` = confirmed leaf / empty branch
-   * - non-empty array = loaded children
-   */
-  children?: TreeNode[];
-};
-/**
- * Callback invoked when a node's children need to be loaded.
- * The AbortSignal is cancelled if the request is superseded (e.g. node collapsed before load completes).
- * May return children synchronously, as a promise, or as a streaming async iterable of batches.
- */
-type LoadChildrenCallback = IDataProvider<{
-  node: TreeNode;
-  depth: number;
-}, TreeNode>;
-/**
- * Predicate used by search/filter controllers to determine whether a node should be visible.
- * Receives depth so column-scoped filtering (e.g. in ixfx-miller-list) is possible.
- * Tree implementations that do not need depth can simply ignore the parameter.
- */
-type TreeFilterPredicate = (node: TreeNode, depth: number) => boolean;
-/**
- * Controls how expanding a node affects its siblings.
- * - `'none'`   — no constraint; any number of nodes may be expanded simultaneously
- * - `'depth'`  — only one sibling at the same depth may be expanded at a time (accordion)
- * - `'global'` — only one node anywhere in the tree may be expanded at a time
- */
-type TreeExclusivity = `none` | `depth` | `global`;
-/**
- * Restricts which kinds of nodes may enter the selection.
- * Applied as a guard in all interaction modes.
- * - `'none'`   — no node can be selected (read-only / display-only)
- * - `'leaf'`   — only leaf nodes are selectable
- * - `'branch'` — only branch nodes (nodes with children) are selectable
- * - `'all'`    — both leaf and branch nodes are selectable
- */
-type TreeSelectionFilter = `none` | `leaf` | `branch` | `all`;
-/**
- * Controls how pointer and keyboard gestures map to selection changes.
- * - `'implicit'`  — single selection that follows the click; clicking always selects + toggles expand
- * - `'standard'`  — single click selects+toggles; Ctrl/Cmd+click toggles item; Shift+click range-selects
- * - `'manual'`    — component never auto-selects; use `select()`/`deselect()`/`clearSelection()` to drive state
- * - `'checked'`   — checkboxes on every item; checkbox click toggles selection recursively; row click only expands/collapses
- * - `'vscode'`    — like `standard` for clicks; Shift+arrow uses snapshot-based toggle-range
- */
-type TreeInteractionMode = `implicit` | `standard` | `manual` | `checked` | `vscode`;
-//#endregion
+import { a as TreeItem, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-DO3gt5vg.js";
 //#region src/common/tree-data-model.d.ts
 type InvalidateEvent = {
   type: `invalidate`;
@@ -130,7 +11,8 @@ type RootEvent = {
 type ModelEvent = InvalidateEvent | RootEvent;
 type ModelSubscriber = (event: ModelEvent) => void;
 type TreeDataModelOptions = {
-  /** The initial root node. Required. */root: TreeNode;
+  /** The initial root node. Required. */
+  root: TreeNode;
   /**
    * Optional callback for lazily loading children.
    * If omitted, nodes with `children === undefined` are treated as empty branches.
@@ -222,7 +104,9 @@ declare class TreeDataModel {
  * Event name: `select`
  */
 type TreeSelectDetail = {
-  /** The new selection set. */readonly selected: ReadonlySet<TreeNode>; /** The previous selection set (empty set if there was no prior selection). */
+  /** The new selection set. */
+  readonly selected: ReadonlySet<TreeNode>;
+  /** The previous selection set (empty set if there was no prior selection). */
   readonly previous: ReadonlySet<TreeNode>;
 };
 /**
@@ -379,5 +263,5 @@ interface TreeSearchHost extends TreeComponent {
   readonly updateComplete: Promise<boolean>;
 }
 //#endregion
-export { TreeNode as C, IDataProvider as D, DataProviderResult as E, collectDataResult as O, TreeItem as S, DataBatch as T, TreeDataModelOptions as _, TreeComponent as a, TreeFilterPredicate as b, TreeExpandEvent as c, TreeSearchHost as d, TreeSelectDetail as f, TreeDataModel as g, TreeTickleEvent as h, TreeCollapseEvent as i, TreeItemClickDetail as l, TreeTickleDetail as m, TreeActivateEvent as n, TreeComponentEventMap as o, TreeSelectEvent as p, TreeCollapseDetail as r, TreeExpandDetail as s, TreeActivateDetail as t, TreeItemClickEvent as u, LoadChildrenCallback as v, TreeSelectionFilter as w, TreeInteractionMode as x, TreeExclusivity as y };
-//# sourceMappingURL=tree-component-BaCSPWg1.d.ts.map
+export { TreeDataModelOptions as _, TreeComponent as a, TreeExpandEvent as c, TreeSearchHost as d, TreeSelectDetail as f, TreeDataModel as g, TreeTickleEvent as h, TreeCollapseEvent as i, TreeItemClickDetail as l, TreeTickleDetail as m, TreeActivateEvent as n, TreeComponentEventMap as o, TreeSelectEvent as p, TreeCollapseDetail as r, TreeExpandDetail as s, TreeActivateDetail as t, TreeItemClickEvent as u };
+//# sourceMappingURL=tree-component-DCmmKZ4j.d.ts.map

package/dist/tree-component-DCmmKZ4j.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-component-DCmmKZ4j.d.ts","names":[],"sources":["../src/common/tree-data-model.ts","../src/common/tree-component.ts"],"mappings":";;KAOK;EAAoB;EAAoB;;KACxC;EAAc;EAAc,MAAM;;KAClC,aAAa,kBAAkB;KAE/B,mBAAmB,OAAO;KAmEnB;;EAEV,MAAM;;;;;EAKN,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCJ;;EAMC,YAAA,SAAS;;MAUjB,QAAQ;;;;;EAQZ,QAAQ,MAAM;;;;;;;;;EAkBR,YAAY,MAAM,UAAU,eAAe,QAAQ,cAAc,QAAQ;;;;;;EAyB/E,WAAW;;;;;EAaX,QAAQ,mBAAmB,MAAM,WAAW;;;;;EAU5C,WAAW,cAAc;;;;;EAWzB,WAAW,aAAa,OAAO,QAAQ,YAAY;;;;;EAanD,SAAS,aAAa,uBAAuB;;;;;;;EAgB7C,WAAW,UAAU;;;;;;;;KC/NX;;WAED,UAAU,YAAY;;WAEtB,UAAU,YAAY;;;;;;;KAQrB;WACD,MAAM;WACN;;;;;;KAOC;WACD,MAAM;WACN;;;;;;KAOC;WACD,MAAM;WACN;;;;;;KAOC;WACD,MAAM;WACN;;;;;;KAOC;WACD,MAAM;WACN;;KAIC,kBAAkB,YAAY;KAC9B,kBAAkB,YAAY;KAC9B,oBAAoB,YAAY;KAChC,qBAAqB,YAAY;KACjC,kBAAkB,YAAY;KAC9B,oBAAoB,YAAY;UAM3B;EACf,UAAU;EACV,UAAU;EACV,YAAY;EACZ,cAAc;EACd,UAAU;EACV,YAAY;;;;;;;;;;;;;;;UAoBG,sBAAsB;;;;;;EAQrC,MAAM;;;;;;;EAQN,OAAO;;;;;;EAOP,cAAc;;;;;EAQd,cAAc;;;;;WAML,eAAe,YAAY;;;;;;EASpC,iBAAiB;;;;;;EASjB,iBAAiB;;;;;;EASjB,aAAa;;EAKb,SAAS,MAAM;;EAEf,WAAW,MAAM;;EAEjB;;;;;EAQA,aAAa;;;;;EAMb,iBAAiB,YAAY,MAAM;;;;;EAQnC,gBAAgB;IAAgB,MAAM;IAAU;;;;;;;;;;;UAejC,uBAAuB;WAC7B,YAAY;WACZ,gBAAgB"}

package/dist/tree.d.ts

@@ -1,8 +1,14 @@
-import { n as TraversableTree, t as TickledController } from "./tickled-controller-BjYCzGrU.js";
-import { C as TreeNode, S as TreeItem, _ as TreeDataModelOptions, a as TreeComponent, b as TreeFilterPredicate, c as TreeExpandEvent, d as TreeSearchHost, f as TreeSelectDetail, g as TreeDataModel, h as TreeTickleEvent, i as TreeCollapseEvent, l as TreeItemClickDetail, m as TreeTickleDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeSelectEvent, r as TreeCollapseDetail, s as TreeExpandDetail, t as TreeActivateDetail, u as TreeItemClickEvent, v as LoadChildrenCallback, w as TreeSelectionFilter, x as TreeInteractionMode, y as TreeExclusivity } from "./tree-component-BaCSPWg1.js";
-import { t as TreeConfig } from "./types-DSfbtHs3.js";
+import { a as TreeItem, i as TreeInteractionMode, n as TreeExclusivity, o as TreeNode, r as TreeFilterPredicate, s as TreeSelectionFilter, t as LoadChildrenCallback } from "./types-DO3gt5vg.js";
+import { _ as TreeDataModelOptions, a as TreeComponent, c as TreeExpandEvent, d as TreeSearchHost, f as TreeSelectDetail, g as TreeDataModel, h as TreeTickleEvent, i as TreeCollapseEvent, l as TreeItemClickDetail, m as TreeTickleDetail, n as TreeActivateEvent, o as TreeComponentEventMap, p as TreeSelectEvent, r as TreeCollapseDetail, s as TreeExpandDetail, t as TreeActivateDetail, u as TreeItemClickEvent } from "./tree-component-DCmmKZ4j.js";
+import { t as TickledController } from "./tickled-controller-BF2Ea0DE.js";
 import { LitElement, PropertyValues, TemplateResult, nothing } from "lit";
-
+import { TraversableTree } from "@ixfx/collections";
+//#region src/tree/types.d.ts
+/** Tree layout/display configuration (tree-specific, not shared). */
+type TreeConfig = {
+  indent: number;
+};
+//#endregion
 //#region src/tree/tree-base.d.ts
 declare class TreeBaseElement extends LitElement implements TreeComponent, TreeSearchHost {
   #private;

package/dist/tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree.d.ts","names":[],"sources":["../src/tree/tree-base.ts","../src/tree/tree-list.ts","../src/tree/tree-controller.ts"],"mappings":"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"}
+{"version":3,"file":"tree.d.ts","names":[],"sources":["../src/tree/types.ts","../src/tree/tree-base.ts","../src/tree/tree-list.ts","../src/tree/tree-controller.ts"],"mappings":";;;;;;;KAqCY;EACV;;;;cCAW,wBAAwB,sBAAsB,eAAe;;EAExE,MAAM;EAGN,OAAO;;EAIP,cAAc;EAGd,aAAa;EAGb,iBAAiB;;EAIjB,iBAAiB;EAGjB,cAAc;YAGJ,gBAAc,IAAA;MAEpB,iBAAiB,YAAY;EAKjC,iBAAiB;EAGjB;YAGU,eAAa;YAEb,SAAO;YAWP;EAYD,QAAQ,cAAc;EA4CtB;EAKA;EAMT,aAAa;EAIb,UAAU,QAAQ,QAAQ;EAO1B,OAAO,MAAM;EAWb,SAAS,MAAM;EAYf;EAWA,WAAW;EAoCX,eAAe,YAAY,MAAM;EASjC,YAAY;IAAgB,MAAM;IAAU;;YA6DlC,kBAAkB,MAAM,UAAU,iBAAiB,wBAAwB;YAW3E,iBAAiB,MAAM,UAAU,eAAe,QAAQ;YAuJxD,qBAAqB,OAAO,YAAY,MAAM,UAAU;YAsJxD,YAAY,MAAM;YAIlB,WAAW,MAAM;YAIjB,YAAY,MAAM;gBAiBd,gBAAgB;YAgRpB,0BAA0B,wBAAwB;YAIzC,UAAM;YAoDf,YAAY,MAAM,UAAU,gBAAgB;SAiCtC,sBAAM;;QA4GhB;YACI;IACR,kBAAkB;;;UAIL,gCAAgC;EAC/C,cAAc;EACd,UAAU;EACV,YAAY;EACZ,UAAU;EACV,UAAU;EACV,YAAY;;UAGG;EACf,oBAAoB,gBAAgB,yBAClC,MAAM,GACN,WAAW,MAAM,iBAAiB,OAAO,wBAAwB,aACjE,oBAAoB,sCAEpB,cACA,UAAU,oCACV,oBAAoB;EAEtB,uBAAuB,gBAAgB,yBACrC,MAAM,GACN,WAAW,MAAM,iBAAiB,OAAO,wBAAwB,aACjE,oBAAoB,mCAEpB,cACA,UAAU,oCACV,oBAAoB;;;;cC/lCX,wBAAwB;;YAGhB,UAAM;YAsBN,kBAAkB,MAAM,UAAU,gBAAgB;YAiClD,YAAY,MAAM,UAAU,gBAAgB;SA0B/C,sBAAM;;QA0EhB;YACI;IACR,kBAAkB;;;UAIL;EACf,oBAAoB,gBAAgB,yBAClC,MAAM,GACN,WAAW,MAAM,iBAAiB,OAAO,wBAAwB,aACjE,oBAAoB,sCAEpB,cACA,UAAU,oCACV,oBAAoB;;;;KClMZ,sBAAsB;EAChC,cAAc,OAAO,GAAG,MAAM,gBAAgB,OAAO;;cAG1C,eAAe;;EAWxB,YAAA,MAAM,gBAAgB,IACtB,SAAS,iBACT,SAAS,sBAAsB;EAOjC;EAwBA;EAKA,gBAAgB,YAAY,OAAO"}

package/dist/tree.js

@@ -1,2 +1,2 @@
-import { i as TreeDataModel, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-D84RUgFC.js";
+import { i as TreeDataModel, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-BnvzhsAw.js";
 export { TreeBaseElement, TreeController, TreeDataModel, TreeListElement };

package/dist/types-DO3gt5vg.d.ts

@@ -0,0 +1,130 @@
+//#region src/common/data-provider.d.ts
+/**
+ * Shared data-provider contract used by components that render a list of items.
+ *
+ * A provider is a simple callable — the consuming component (via DataController)
+ * manages the request lifecycle, cancellation, and reactive state.
+ */
+/**
+ * One batch of items within a streaming provider response.
+ *
+ * For sync and async one-shot providers, the DataController synthesises a single
+ * DataBatch internally — you only need this type when writing a streaming provider.
+ */
+type DataBatch<T> = {
+  /** Items delivered in this batch. */
+  readonly items: readonly T[];
+  /**
+   * When true, replace all previously accumulated items with this batch instead
+   * of appending. Useful for re-ranked or filtered results mid-stream.
+   * Default: false (append).
+   */
+  replace?: boolean;
+  /**
+   * Provider's current estimate of the total number of items that will be
+   * delivered across all batches. Enables progress percentage in the consumer.
+   * May be refined in subsequent batches as the estimate improves.
+   * Omit when the total is unknown.
+   */
+  total?: number;
+};
+/**
+ * The three return modes a provider may use.
+ * DataController normalises all three — callers can mix modes freely.
+ *
+ * - `readonly T[]`                  — sync, items available immediately
+ * - `Promise<readonly T[]>`         — async one-shot, resolves to the full result
+ * - `AsyncIterable<DataBatch<T>>`   — streaming, batches arrive over time
+ */
+type DataProviderResult<T> = readonly T[] | Promise<readonly T[]> | AsyncIterable<DataBatch<T>>;
+/**
+ * A data provider callable.
+ *
+ * @typeParam TQuery - The input that scopes the request (e.g. `string` for
+ *   autocomplete, `{ node, depth }` for a tree branch, `void` for a plain list).
+ * @typeParam TItem  - The item type produced.
+ *
+ * The AbortSignal is cancelled when the consumer supersedes the request (e.g.
+ * a new query arrives before the previous one completes). Streaming providers
+ * should check `signal.aborted` between yields or pass the signal to their
+ * underlying fetch calls.
+ */
+type IDataProvider<TQuery, TItem> = (query: TQuery, signal: AbortSignal) => DataProviderResult<TItem>;
+/**
+ * Collects all items from any DataProviderResult into a flat array.
+ * Useful for components that need a complete list before rendering (e.g. tree branches).
+ * Respects the AbortSignal — stops accumulating if cancelled mid-stream.
+ */
+declare function collectDataResult<T>(result: DataProviderResult<T>, signal: AbortSignal): Promise<readonly T[]>;
+//#endregion
+//#region src/common/types.d.ts
+type TreeItem = {
+  /** Unique identifier within the tree. */
+  key: string;
+  /** Visible label text. */
+  label: string;
+  /** When true the node cannot have children and will not show an expand affordance. */
+  isLeaf?: boolean;
+  /** Arbitrary application data associated with this node. */
+  data?: unknown;
+  /** Icon name passed to an icon component, if icons are enabled. */
+  icon?: string;
+  /** Tooltip text shown on hover. */
+  tooltip?: string;
+  /** Optional string value, e.g. for use as a command/route. */
+  value?: string;
+};
+/** A node in the tree, potentially containing lazily-loaded children. */
+type TreeNode = {
+  item: TreeItem;
+  /**
+   * Child nodes.
+   * - `undefined` = children not yet loaded (component will call loadChildren if set)
+   * - `[]` = confirmed leaf / empty branch
+   * - non-empty array = loaded children
+   */
+  children?: TreeNode[];
+};
+/**
+ * Callback invoked when a node's children need to be loaded.
+ * The AbortSignal is cancelled if the request is superseded (e.g. node collapsed before load completes).
+ * May return children synchronously, as a promise, or as a streaming async iterable of batches.
+ */
+type LoadChildrenCallback = IDataProvider<{
+  node: TreeNode;
+  depth: number;
+}, TreeNode>;
+/**
+ * Predicate used by search/filter controllers to determine whether a node should be visible.
+ * Receives depth so column-scoped filtering (e.g. in ixfx-miller-list) is possible.
+ * Tree implementations that do not need depth can simply ignore the parameter.
+ */
+type TreeFilterPredicate = (node: TreeNode, depth: number) => boolean;
+/**
+ * Controls how expanding a node affects its siblings.
+ * - `'none'`   — no constraint; any number of nodes may be expanded simultaneously
+ * - `'depth'`  — only one sibling at the same depth may be expanded at a time (accordion)
+ * - `'global'` — only one node anywhere in the tree may be expanded at a time
+ */
+type TreeExclusivity = `none` | `depth` | `global`;
+/**
+ * Restricts which kinds of nodes may enter the selection.
+ * Applied as a guard in all interaction modes.
+ * - `'none'`   — no node can be selected (read-only / display-only)
+ * - `'leaf'`   — only leaf nodes are selectable
+ * - `'branch'` — only branch nodes (nodes with children) are selectable
+ * - `'all'`    — both leaf and branch nodes are selectable
+ */
+type TreeSelectionFilter = `none` | `leaf` | `branch` | `all`;
+/**
+ * Controls how pointer and keyboard gestures map to selection changes.
+ * - `'implicit'`  — single selection that follows the click; clicking always selects + toggles expand
+ * - `'standard'`  — single click selects+toggles; Ctrl/Cmd+click toggles item; Shift+click range-selects
+ * - `'manual'`    — component never auto-selects; use `select()`/`deselect()`/`clearSelection()` to drive state
+ * - `'checked'`   — checkboxes on every item; checkbox click toggles selection recursively; row click only expands/collapses
+ * - `'vscode'`    — like `standard` for clicks; Shift+arrow uses snapshot-based toggle-range
+ */
+type TreeInteractionMode = `implicit` | `standard` | `manual` | `checked` | `vscode`;
+//#endregion
+export { TreeItem as a, DataBatch as c, collectDataResult as d, TreeInteractionMode as i, DataProviderResult as l, TreeExclusivity as n, TreeNode as o, TreeFilterPredicate as r, TreeSelectionFilter as s, LoadChildrenCallback as t, IDataProvider as u };
+//# sourceMappingURL=types-DO3gt5vg.d.ts.map

package/dist/types-DO3gt5vg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DO3gt5vg.d.ts","names":[],"sources":["../src/common/data-provider.ts","../src/common/types.ts"],"mappings":";;;;;;;;;;;;;KAaY,UAAU;;WAEX,gBAAgB;;;;;;EAMzB;;;;;;;EAOA;;;;;;;;;;KAWU,mBAAmB,cAChB,MACT,iBAAiB,OACjB,cAAc,UAAU;;;;;;;;;;;;;KAclB,cAAc,QAAQ,UAChC,OAAO,QACP,QAAQ,gBACL,mBAAmB;;;;;;iBAOF,kBAAkB,GACtC,QAAQ,mBAAmB,IAC3B,QAAQ,cACP,iBAAiB;;;KC7DR;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;KAIU;EACV,MAAM;;;;;;;EAON,WAAW;;;;;;;KAQD,uBAAuB;EAAgB,MAAM;EAAU;GAAiB;;;;;;KAOxE,uBAAuB,MAAM,UAAU;;;;;;;KAQvC;;;;;;;;;KAUA;;;;;;;;;KAUA"}

package/dist/wheel-nudge-BlSCe_hD.js

@@ -0,0 +1,86 @@
+import { t as __decorate } from "./decorate-VRK8rslU.js";
+import { property } from "lit/decorators.js";
+//#region src/mixins/wheel-nudge.ts
+/**
+* Mixin that adds mousewheel support with an optional `lighttouch` hover mode.
+*
+* Activation rule:
+*   - If the host's `disabled` property is truthy → ignore.
+*   - Otherwise, handle if EITHER:
+*       • `lighttouch` is true AND the pointer is currently over the host, OR
+*       • the host (or anything in its shadow tree) currently has focus.
+*
+* Direction convention: `deltaY < 0` (wheel up/away) → +1 step; `deltaY > 0` → -1 step.
+*
+* Consumers must implement `_applyWheelDelta(direction, event)` (see
+* {@link WheelNudgeConsumer}). The mixin calls `event.preventDefault()` only when
+* the activation rule accepts the event, so page scroll is suppressed during
+* interaction without blocking wheel events over empty space.
+*
+* Usage:
+*
+* ```ts
+* class MyInput extends WheelNudgeMixin(LitElement) {
+*   protected _applyWheelDelta(direction, event) {
+*     const step = resolveAxisStep(this.range, this.stops, this.step, event.shiftKey);
+*     this._stepByDelta(direction, step);
+*   }
+* }
+* ```
+*/
+function WheelNudgeMixin(superClass) {
+	class WheelNudgeMixinClass extends superClass {
+		constructor(..._args) {
+			super(..._args);
+			this.lighttouch = false;
+			this._isHovering = false;
+			this._onPointerEnter = () => {
+				this._isHovering = true;
+			};
+			this._onPointerLeave = () => {
+				this._isHovering = false;
+			};
+			this._onWheel = (event) => {
+				if (!this._shouldHandleWheel()) return;
+				event.preventDefault();
+				const direction = (event.deltaY !== 0 ? event.deltaY : event.deltaX) < 0 ? 1 : -1;
+				this._applyWheelDelta(direction, event);
+			};
+		}
+		connectedCallback() {
+			super.connectedCallback();
+			this.addEventListener(`pointerenter`, this._onPointerEnter);
+			this.addEventListener(`pointerleave`, this._onPointerLeave);
+			this.addEventListener(`wheel`, this._onWheel, { passive: false });
+		}
+		disconnectedCallback() {
+			super.disconnectedCallback();
+			this.removeEventListener(`pointerenter`, this._onPointerEnter);
+			this.removeEventListener(`pointerleave`, this._onPointerLeave);
+			this.removeEventListener(`wheel`, this._onWheel);
+			this._isHovering = false;
+		}
+		/**
+		* Override to restrict when wheel is handled (e.g. editable-number rejects
+		* while the user is typing). Default: respect `disabled`, then apply the
+		* focus-or-lighttouch rule described on the mixin.
+		*/
+		_shouldHandleWheel() {
+			if (this.disabled) return false;
+			if (this.lighttouch && this._isHovering) return true;
+			if (this.matches?.(`:focus, :focus-within`)) return true;
+			const root = this.renderRoot;
+			if (root && root.activeElement !== null) return true;
+			return false;
+		}
+	}
+	__decorate([property({
+		type: Boolean,
+		reflect: true
+	})], WheelNudgeMixinClass.prototype, "lighttouch", void 0);
+	return WheelNudgeMixinClass;
+}
+//#endregion
+export { WheelNudgeMixin as t };
+
+//# sourceMappingURL=wheel-nudge-BlSCe_hD.js.map

package/dist/wheel-nudge-BlSCe_hD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wheel-nudge-BlSCe_hD.js","names":[],"sources":["../src/mixins/wheel-nudge.ts"],"sourcesContent":["import type { LitElement } from 'lit';\nimport { property } from 'lit/decorators.js';\n\ntype Constructor<T = object> = new (...args: any[]) => T;\n\n/**\n * Direction of a wheel tick. `+1` for `deltaY < 0` (wheel up/away), `-1` for\n * `deltaY > 0` (wheel down/toward).\n */\nexport type WheelDirection = 1 | -1;\n\n/**\n * Abstract surface a consumer of {@link WheelNudgeMixin} must implement.\n *\n * `_applyWheelDelta` is called once per handled wheel tick. The consumer is\n * expected to reuse its existing arrow-key step math (typically a shared\n * `_stepByDelta(direction, effectiveStep)` private method) and call it here.\n *\n * `_shouldHandleWheel` may be overridden to restrict when the wheel acts\n * (e.g. editable-number rejects while the user is typing).\n */\nexport interface WheelNudgeConsumer {\n  _applyWheelDelta: (direction: WheelDirection, event: WheelEvent) => void;\n  _shouldHandleWheel: () => boolean;\n}\n\n/**\n * Internal: the surface a {@link WheelNudgeMixin}-decorated class exposes to\n * TypeScript — its own members plus the consumer contract.\n */\nexport type WheelNudgeConsumerType<TBase> = TBase & WheelNudgeConsumer;\ntype WheelNudgeMixinBase<T> = T extends Constructor<infer U> ? U : never;\ntype WheelNudgeMixinResult<T extends Constructor<LitElement>>\n  = Constructor<WheelNudgeConsumerType<WheelNudgeMixinBase<T>>> & T;\n\n/**\n * Mixin that adds mousewheel support with an optional `lighttouch` hover mode.\n *\n * Activation rule:\n *   - If the host's `disabled` property is truthy → ignore.\n *   - Otherwise, handle if EITHER:\n *       • `lighttouch` is true AND the pointer is currently over the host, OR\n *       • the host (or anything in its shadow tree) currently has focus.\n *\n * Direction convention: `deltaY < 0` (wheel up/away) → +1 step; `deltaY > 0` → -1 step.\n *\n * Consumers must implement `_applyWheelDelta(direction, event)` (see\n * {@link WheelNudgeConsumer}). The mixin calls `event.preventDefault()` only when\n * the activation rule accepts the event, so page scroll is suppressed during\n * interaction without blocking wheel events over empty space.\n *\n * Usage:\n *\n * ```ts\n * class MyInput extends WheelNudgeMixin(LitElement) {\n *   protected _applyWheelDelta(direction, event) {\n *     const step = resolveAxisStep(this.range, this.stops, this.step, event.shiftKey);\n *     this._stepByDelta(direction, step);\n *   }\n * }\n * ```\n */\nexport function WheelNudgeMixin<T extends Constructor<LitElement>>(superClass: T): WheelNudgeMixinResult<T> {\n  class WheelNudgeMixinClass extends superClass {\n    /**\n     * When true, the wheel adjusts the value simply when the pointer is hovering\n     * over the host (no focus required). When false (default), the host must\n     * have focus for the wheel to act.\n     */\n    @property({ type: Boolean, reflect: true })\n    lighttouch = false;\n\n    /**\n     * Imperative hover flag — not Lit-reactive (avoids update churn for what\n     * is purely an interaction-time predicate).\n     */\n    _isHovering = false;\n\n    override connectedCallback(): void {\n      super.connectedCallback();\n      this.addEventListener(`pointerenter`, this._onPointerEnter);\n      this.addEventListener(`pointerleave`, this._onPointerLeave);\n      this.addEventListener(`wheel`, this._onWheel, { passive: false });\n    }\n\n    override disconnectedCallback(): void {\n      super.disconnectedCallback();\n      this.removeEventListener(`pointerenter`, this._onPointerEnter);\n      this.removeEventListener(`pointerleave`, this._onPointerLeave);\n      this.removeEventListener(`wheel`, this._onWheel);\n      this._isHovering = false;\n    }\n\n    _onPointerEnter = (): void => {\n      this._isHovering = true;\n    };\n\n    _onPointerLeave = (): void => {\n      this._isHovering = false;\n    };\n\n    /**\n     * Override to restrict when wheel is handled (e.g. editable-number rejects\n     * while the user is typing). Default: respect `disabled`, then apply the\n     * focus-or-lighttouch rule described on the mixin.\n     */\n    _shouldHandleWheel(): boolean {\n      const anyThis = this as unknown as { disabled?: boolean };\n      if (anyThis.disabled)\n        return false;\n      if (this.lighttouch && this._isHovering)\n        return true;\n      if (this.matches?.(`:focus, :focus-within`))\n        return true;\n      const root = this.renderRoot;\n      if (root && (root as ShadowRoot).activeElement !== null)\n        return true;\n      return false;\n    }\n\n    _onWheel = (event: WheelEvent): void => {\n      if (!this._shouldHandleWheel())\n        return;\n      event.preventDefault();\n      // Some browsers (notably when the user holds Shift) send `deltaY=0`\n      // and route the scroll into `deltaX` instead. Use whichever axis\n      // actually moved so the direction sign matches the user's intent.\n      const delta = event.deltaY !== 0 ? event.deltaY : event.deltaX;\n      const direction: WheelDirection = delta < 0 ? 1 : -1;\n      (this as unknown as WheelNudgeConsumer)._applyWheelDelta(direction, event);\n    };\n  }\n  return WheelNudgeMixinClass as unknown as WheelNudgeMixinResult<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,gBAAmD,YAAyC;CAC1G,MAAM,6BAA6B,WAAW;;;GAO/B,KAAA,aAAA;GAMC,KAAA,cAAA;GAiBgB,KAAA,wBAAA;IAC5B,KAAK,cAAc;GACrB;GAE8B,KAAA,wBAAA;IAC5B,KAAK,cAAc;GACrB;GAqBY,KAAA,YAAA,UAA4B;IACtC,IAAI,CAAC,KAAK,mBAAmB,GAC3B;IACF,MAAM,eAAe;IAKrB,MAAM,aADQ,MAAM,WAAW,IAAI,MAAM,SAAS,MAAM,UACd,IAAI,IAAI;IAClD,KAAwC,iBAAiB,WAAW,KAAK;GAC3E;;EApDA,oBAAmC;GACjC,MAAM,kBAAkB;GACxB,KAAK,iBAAiB,gBAAgB,KAAK,eAAe;GAC1D,KAAK,iBAAiB,gBAAgB,KAAK,eAAe;GAC1D,KAAK,iBAAiB,SAAS,KAAK,UAAU,EAAE,SAAS,MAAM,CAAC;EAClE;EAEA,uBAAsC;GACpC,MAAM,qBAAqB;GAC3B,KAAK,oBAAoB,gBAAgB,KAAK,eAAe;GAC7D,KAAK,oBAAoB,gBAAgB,KAAK,eAAe;GAC7D,KAAK,oBAAoB,SAAS,KAAK,QAAQ;GAC/C,KAAK,cAAc;EACrB;;;;;;EAeA,qBAA8B;GAE5B,IAAI,KAAQ,UACV,OAAO;GACT,IAAI,KAAK,cAAc,KAAK,aAC1B,OAAO;GACT,IAAI,KAAK,UAAU,uBAAuB,GACxC,OAAO;GACT,MAAM,OAAO,KAAK;GAClB,IAAI,QAAS,KAAoB,kBAAkB,MACjD,OAAO;GACT,OAAO;EACT;CAaF;CA9DG,WAAA,CAAA,SAAS;EAAE,MAAM;EAAS,SAAS;CAAK,CAAC,CAAA,GAAA,qBAAA,WAAA,cAAA,KAAA,CAAA;CA+D5C,OAAO;AACT"}

package/dist/wheel-nudge-DGrNzWuE.d.ts

@@ -0,0 +1,29 @@
+import { LitElement } from "lit";
+//#region src/mixins/wheel-nudge.d.ts
+/**
+ * Direction of a wheel tick. `+1` for `deltaY < 0` (wheel up/away), `-1` for
+ * `deltaY > 0` (wheel down/toward).
+ */
+type WheelDirection = 1 | -1;
+/**
+ * Abstract surface a consumer of {@link WheelNudgeMixin} must implement.
+ *
+ * `_applyWheelDelta` is called once per handled wheel tick. The consumer is
+ * expected to reuse its existing arrow-key step math (typically a shared
+ * `_stepByDelta(direction, effectiveStep)` private method) and call it here.
+ *
+ * `_shouldHandleWheel` may be overridden to restrict when the wheel acts
+ * (e.g. editable-number rejects while the user is typing).
+ */
+interface WheelNudgeConsumer {
+  _applyWheelDelta: (direction: WheelDirection, event: WheelEvent) => void;
+  _shouldHandleWheel: () => boolean;
+}
+/**
+ * Internal: the surface a {@link WheelNudgeMixin}-decorated class exposes to
+ * TypeScript — its own members plus the consumer contract.
+ */
+type WheelNudgeConsumerType<TBase> = TBase & WheelNudgeConsumer;
+//#endregion
+export { WheelNudgeConsumerType as n, WheelDirection as t };
+//# sourceMappingURL=wheel-nudge-DGrNzWuE.d.ts.map

package/dist/wheel-nudge-DGrNzWuE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wheel-nudge-DGrNzWuE.d.ts","names":[],"sources":["../src/mixins/wheel-nudge.ts"],"mappings":";;;;;;KASY;;;;;;;;;;;UAYK;EACf,mBAAmB,WAAW,gBAAgB,OAAO;EACrD;;;;;;KAOU,uBAAuB,SAAS,QAAQ"}