@blueprintui/cli 0.11.0 → 0.11.2

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/input/element.d.ts

@@ -0,0 +1,51 @@
+import { TemplateResult } from 'lit';
+import { FormControl } from '@blueprintui/components/forms';
+import { BpTypeControl } from '@blueprintui/components/internals';
+export declare const inputStyles: CSSStyleSheet;
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/input.js';
+ * ```
+ *
+ * ```html
+ * <bp-control>
+ *   <label>input</label>
+ *   <bp-input></bp-input>
+ *   <bp-field-message>message text</bp-field-message>
+ * </bp-control>
+ * ```
+ *
+ * @summary The text input component is used to allow users to input and edit text. The text input should have a clear, descriptive label that explains what the user should enter as well as a placeholder text that gives an example of the expected input format.
+ * @element bp-input
+ * @since 1.0.0
+ * @slot prefix - slot for prefix text or icons
+ * @slot suffix - slot for suffic text or icons
+ * @cssprop --background-size
+ * @cssprop --color
+ * @cssprop --background
+ * @cssprop --border
+ * @cssprop --border-radius
+ * @cssprop --outline
+ * @cssprop --outline-offset
+ * @cssprop --padding
+ * @cssprop --font-size
+ * @cssprop --line-height
+ * @cssprop --height
+ * @cssprop --min-width
+ * @cssprop --width
+ * @cssprop --transition
+ * @cssprop --text-align
+ * @cssprop --cursor
+ * @event {InputEvent} input - occurs when the value changes
+ * @event {InputEvent} change - occurs when the value changes
+ */
+export declare class BpInput extends FormControl implements Pick<BpTypeControl, keyof BpInput> {
+    accessor type: string;
+    accessor value: string | FormData;
+    static styles: CSSStyleSheet[];
+    protected get prefixTemplate(): TemplateResult | null;
+    protected get suffixTemplate(): TemplateResult | null;
+    protected get input(): HTMLInputElement;
+    render(): TemplateResult<1>;
+    protected showPicker(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/input/element.js

@@ -0,0 +1,93 @@
+import { html } from 'lit';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { FormControl } from '@blueprintui/components/forms';
+import { baseStyles } from '@blueprintui/components/internals';
+import styles from './element.css' with { type: 'css' };
+export const inputStyles = styles;
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/input.js';
+ * ```
+ *
+ * ```html
+ * <bp-control>
+ *   <label>input</label>
+ *   <bp-input></bp-input>
+ *   <bp-field-message>message text</bp-field-message>
+ * </bp-control>
+ * ```
+ *
+ * @summary The text input component is used to allow users to input and edit text. The text input should have a clear, descriptive label that explains what the user should enter as well as a placeholder text that gives an example of the expected input format.
+ * @element bp-input
+ * @since 1.0.0
+ * @slot prefix - slot for prefix text or icons
+ * @slot suffix - slot for suffic text or icons
+ * @cssprop --background-size
+ * @cssprop --color
+ * @cssprop --background
+ * @cssprop --border
+ * @cssprop --border-radius
+ * @cssprop --outline
+ * @cssprop --outline-offset
+ * @cssprop --padding
+ * @cssprop --font-size
+ * @cssprop --line-height
+ * @cssprop --height
+ * @cssprop --min-width
+ * @cssprop --width
+ * @cssprop --transition
+ * @cssprop --text-align
+ * @cssprop --cursor
+ * @event {InputEvent} input - occurs when the value changes
+ * @event {InputEvent} change - occurs when the value changes
+ */
+export class BpInput extends FormControl {
+    constructor() {
+        super();
+        this.type = 'text';
+        this.value = '';
+    }
+    static { this.properties = {
+        type: { type: String },
+        value: { type: String }
+    }; }
+    static { this.styles = [baseStyles, styles]; }
+    get prefixTemplate() {
+        return null;
+    }
+    get suffixTemplate() {
+        return null;
+    }
+    get input() {
+        return this.shadowRoot.querySelector('input');
+    }
+    render() {
+        return html `
+      <div role="presentation" part="internal">
+        ${this.prefixTemplate}
+        <slot name="prefix"></slot>
+        <input
+          input
+          placeholder=${this.placeholder}
+          size=${ifDefined(this.size)}
+          .autocomplete=${ifDefined(this.autocomplete)}
+          ?required=${this.required}
+          min=${ifDefined(this.min)}
+          max=${ifDefined(this.max)}
+          minlength=${ifDefined(this.minLength)}
+          maxlength=${ifDefined(this.maxLength)}
+          .ariaLabel=${this.composedLabel}
+          .type=${this.type}
+          .value=${this.value}
+          .disabled=${this.disabled || this.readonly}
+          @change=${this.onChange}
+          @input=${this.onInput} />
+        <slot name="suffix"></slot>
+        ${this.suffixTemplate}
+      </div>
+    `;
+    }
+    showPicker() {
+        this.input.showPicker();
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/input/index.d.ts

@@ -0,0 +1 @@
+export * from './element.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/input/index.js

@@ -0,0 +1,2 @@
+export * from './element.js';
+// export { default as styles } from './element.css';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/components/button.d.ts

@@ -0,0 +1,62 @@
+import { LitElement } from 'lit';
+import { BpTypeButton } from '../types/index.js';
+export declare class BaseButton extends LitElement implements Pick<BpTypeButton, keyof BaseButton> {
+    /** turns the button into a toggle button */
+    accessor pressed: boolean;
+    /** indicate the current "selected" state of various widgets */
+    accessor selected: boolean;
+    /** indicate if a control is expanded or collapsed */
+    accessor expanded: boolean;
+    /** makes the element not mutable, meaning the user can not interact with button */
+    accessor readonly: boolean;
+    /** determines if element is mutable or focusable */
+    accessor disabled: boolean;
+    /** default behavior of the button */
+    accessor type: 'button' | 'submit';
+    /** represents the name of the current <form> element as a string. */
+    accessor name: string;
+    /** determines the current value  */
+    accessor value: string;
+    /**
+     * The target element for the popover
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button#popovertarget
+     */
+    accessor popoverTargetElement: HTMLElement;
+    /**
+     * The action to perform on the target popover element
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button#popovertargetaction
+     */
+    accessor popoverTargetAction: 'toggle' | 'show' | 'hide';
+    /**
+     * The target popover id
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button#popovertarget
+     */
+    accessor popovertarget: string;
+    /**
+     * The command property of the HTMLButtonElement interface gets and sets the action to be performed on an element being controlled by this button. For this to have an effect, commandfor must be set.
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button#command
+     */
+    accessor command: string;
+    /**
+     * The command for property of the HTMLButtonElement interface gets and sets the id of the element being controlled by this button. For this to have an effect, command must be set.
+     * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/button#command
+     */
+    accessor commandFor: string;
+    readonly form: HTMLFormElement;
+    readonly formAction: string;
+    readonly formEnctype: string;
+    readonly formMethod: string;
+    readonly formNoValidate: boolean;
+    readonly formTarget: string;
+    readonly labels: NodeListOf<HTMLLabelElement>;
+    readonly validationMessage: string;
+    readonly validity: ValidityState;
+    readonly willValidate: boolean;
+    readonly checkValidity: any;
+    readonly reportValidity: any;
+    readonly setCustomValidity: any;
+    /** @private */
+    readonly _internals: ElementInternals;
+    static formAssociated: boolean;
+    render(): import("lit").TemplateResult<1>;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/components/button.js

@@ -0,0 +1,53 @@
+import { __decorate } from "tslib";
+import { html, LitElement } from 'lit';
+import { typeAnchor } from '../controllers/type-anchor.controller.js';
+import { typeButton } from '../controllers/type-button.controller.js';
+import { stateActive } from '../controllers/state-active.controller.js';
+import { stateDisabled } from '../controllers/state-disabled.controller.js';
+import { statePressed } from '../controllers/state-pressed.controller.js';
+import { stateSelected } from '../controllers/state-selected.controller.js';
+import { stateExpanded } from '../controllers/state-expanded.controller.js';
+import { stateReadonly } from '../controllers/state-readonly.controller.js';
+import { interactionClick } from '../controllers/interaction-click.controller.js';
+import { typePopoverTrigger } from '../controllers/type-popover-trigger.controller.js';
+import { typeCommandTrigger } from '../controllers/type-command-trigger.controller.js';
+let BaseButton = class BaseButton extends LitElement {
+    static { this.properties = {
+        pressed: { type: Boolean },
+        selected: { type: Boolean },
+        expanded: { type: Boolean },
+        readonly: { type: Boolean },
+        disabled: { type: Boolean },
+        type: { type: String, reflect: true },
+        name: { type: String, reflect: true },
+        value: { type: String },
+        popoverTargetElement: { type: Object },
+        popoverTargetAction: { type: String, attribute: 'popovertargetaction', reflect: true },
+        popovertarget: { type: String, attribute: 'popovertarget', reflect: true },
+        command: { type: String },
+        commandFor: { type: String }
+    }; }
+    constructor() {
+        super(...arguments);
+        /** determines if element is mutable or focusable */
+        this.disabled = false;
+    }
+    static { this.formAssociated = true; }
+    render() {
+        return html `<div interaction part="internal"><slot></slot></div>`;
+    }
+};
+BaseButton = __decorate([
+    typeButton(),
+    typeAnchor(),
+    typePopoverTrigger(),
+    typeCommandTrigger(),
+    stateActive(),
+    statePressed(),
+    stateSelected(),
+    stateExpanded(),
+    stateDisabled(),
+    stateReadonly(),
+    interactionClick()
+], BaseButton);
+export { BaseButton };

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/dynamic-controllers.controller.d.ts

@@ -0,0 +1,13 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export declare function dynamicControllers<T extends ReactiveElement>(): ClassDecorator;
+/**
+ * Responsible for dynamically initializing controllers that are added to the static _controllers property of a given element
+ */
+export declare class DynamicControllers<T extends ReactiveElement> implements ReactiveController {
+    #private;
+    private host;
+    constructor(host: T);
+    hostConnected(): Promise<void>;
+    sync(): void;
+    static add(hostClass: any, Controller: any): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/dynamic-controllers.controller.js

@@ -0,0 +1,38 @@
+export function dynamicControllers() {
+    return (target, _context) => target.addInitializer((instance) => new DynamicControllers(instance));
+}
+/**
+ * Responsible for dynamically initializing controllers that are added to the static _controllers property of a given element
+ */
+export class DynamicControllers {
+    #instances = new Set();
+    get #hostConstructor() {
+        return this.host.constructor;
+    }
+    get #hostControllers() {
+        return Array.from(this.#hostConstructor._controllers);
+    }
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    async hostConnected() {
+        await this.host.updateComplete;
+        this.#hostConstructor._controllers ??= new Set();
+        this.sync();
+    }
+    sync() {
+        this.#hostControllers
+            .filter(C => !this.#instances.has(C))
+            .forEach(C => {
+            this.#instances.add(C);
+            new C(this.host);
+        });
+    }
+    static add(hostClass, Controller) {
+        hostClass._controllers ??= new Set();
+        if (!hostClass._controllers.has(Controller)) {
+            hostClass._controllers.add(Controller);
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/i18n.controller.d.ts

@@ -0,0 +1,22 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+import { I18nStrings } from '../services/i18n.service.js';
+export declare function i18n<T extends ReactiveElement & {
+    i18n: any;
+}>(config: {
+    key: keyof I18nStrings;
+}): ClassDecorator;
+/**
+ * Responsible for managing the internationalization (i18n) of a LitElement
+ */
+export declare class I18nController<T extends ReactiveElement & {
+    i18n: any;
+}> implements ReactiveController {
+    #private;
+    private host;
+    private config;
+    constructor(host: T, config: {
+        key: keyof I18nStrings;
+    });
+    hostConnected(): void;
+    hostUpdated(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/i18n.controller.js

@@ -0,0 +1,41 @@
+import { GlobalStateService } from '../services/global.service.js';
+import { I18nService } from '../services/i18n.service.js';
+import { mergeObjects } from '../utils/traversal.js';
+import { matchInterpolate } from '../utils/i18n.js';
+export function i18n(config) {
+    return (target, _context) => target.addInitializer((instance) => new I18nController(instance, config));
+}
+/**
+ * Responsible for managing the internationalization (i18n) of a LitElement
+ */
+export class I18nController {
+    #i18n = {};
+    constructor(host, config) {
+        this.host = host;
+        this.config = config;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        GlobalStateService.stateUpdate.subscribe(update => {
+            if (update.type === 'i18nRegistry') {
+                this.#updateProp();
+            }
+        });
+    }
+    hostUpdated() {
+        if (this.#firstUpdated && !this.host.i18n?.__set) {
+            this.#i18n = this.host.i18n;
+            this.#updateProp();
+        }
+    }
+    #updateProp() {
+        const i18nObj = mergeObjects(I18nService.keys[this.config.key], this.#i18n);
+        this.host.i18n = { ...JSON.parse(matchInterpolate(JSON.stringify(i18nObj), this.host)), __set: true };
+        this.host.requestUpdate('i18n');
+    }
+    #updates = 0;
+    get #firstUpdated() {
+        this.#updates++;
+        return this.#updates > 1;
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-click.controller.d.ts

@@ -0,0 +1,22 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export type InteractionClick = ReactiveElement & {
+    disabled: boolean;
+    readonly?: boolean;
+    _internals?: ElementInternals;
+};
+export declare function interactionClick<T extends InteractionClick>(): ClassDecorator;
+/**
+ * Responsible for managing the click interaction of a LitElement
+ * - click event
+ * - space/enter keyup event
+ * - disabled state
+ * - readonly state
+ * - tabindex state
+ */
+export declare class InteractionClickController<T extends InteractionClick> implements ReactiveController {
+    #private;
+    private host;
+    constructor(host: T);
+    hostConnected(): void;
+    hostUpdated(): Promise<void>;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-click.controller.js

@@ -0,0 +1,61 @@
+import { attachInternals } from '../utils/a11y.js';
+import { onKeys, stopEvent } from '../utils/events.js';
+export function interactionClick() {
+    return (target, _context) => target.addInitializer((instance) => new InteractionClickController(instance));
+}
+/**
+ * Responsible for managing the click interaction of a LitElement
+ * - click event
+ * - space/enter keyup event
+ * - disabled state
+ * - readonly state
+ * - tabindex state
+ */
+export class InteractionClickController {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        this.host.tabIndex = 0; // element can be focused synchronously
+        attachInternals(this.host);
+    }
+    async hostUpdated() {
+        await this.host.updateComplete;
+        this.#updateFocus();
+        this.#updateReadonly();
+        this.#updateEventListeners();
+    }
+    #clickFn = this.#click.bind(this);
+    #keyUpFn = this.#keyup.bind(this);
+    #updateEventListeners() {
+        this.host.removeEventListener('click', this.#clickFn);
+        this.host.removeEventListener('keyup', this.#keyUpFn);
+        if (!this.host.readonly && !this.host.disabled) {
+            this.host.addEventListener('click', this.#clickFn);
+            this.host.addEventListener('keyup', this.#keyUpFn);
+        }
+    }
+    #updateFocus() {
+        this.host.tabIndex = !this.host.disabled ? 0 : -1;
+    }
+    #updateReadonly() {
+        if (this.host.readonly) {
+            this.host.tabIndex = null;
+            this.host.removeAttribute('tabindex');
+        }
+    }
+    #click(event) {
+        if (this.host.disabled) {
+            stopEvent(event);
+        }
+    }
+    #keyup(event) {
+        onKeys(['Enter', 'Space'], event, () => {
+            stopEvent(event);
+            if (!this.host.disabled) {
+                this.host.click();
+            }
+        });
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-close.controller.d.ts

@@ -0,0 +1,14 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export type InteractionClose = ReactiveElement & {
+    closable: boolean;
+};
+export declare function interactionClose<T extends InteractionClose>(): ClassDecorator;
+/**
+ * responsible for managing the closable behavior of an element
+ */
+export declare class InteractionCloseController<T extends InteractionClose> implements ReactiveController {
+    private host;
+    constructor(host: T);
+    hostConnected(): void;
+    close(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-close.controller.js

@@ -0,0 +1,30 @@
+import { attachInternals } from '../utils/a11y.js';
+import { createCustomEvent } from '../utils/events.js';
+export function interactionClose() {
+    return (target, _context) => target.addInitializer((instance) => {
+        if (!instance.interactionCloseController) {
+            Object.defineProperty(instance, 'interactionCloseController', {
+                value: new InteractionCloseController(instance),
+                writable: false
+            });
+        }
+        return instance.interactionCloseController;
+    });
+}
+/**
+ * responsible for managing the closable behavior of an element
+ */
+export class InteractionCloseController {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        attachInternals(this.host);
+    }
+    close() {
+        if (this.host.closable) {
+            this.host.dispatchEvent(createCustomEvent('close'));
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-expand.controller.d.ts

@@ -0,0 +1,24 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export type InteractionExpand = ReactiveElement & {
+    interactionExpandControllerConfig?: InteractionExpandConfig;
+    interaction?: 'auto';
+    expanded: boolean;
+};
+export interface InteractionExpandConfig {
+    keynav?: 'inline' | 'block';
+}
+export declare function interactionExpand<T extends InteractionExpand>(fn?: (host: T) => InteractionExpandConfig): ClassDecorator;
+/**
+ * @event open
+ * @event close
+ * responsible for managing the closable behavior of an element
+ */
+export declare class InteractionExpandController<T extends InteractionExpand> implements ReactiveController {
+    #private;
+    private host;
+    constructor(host: T);
+    hostConnected(): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-expand.controller.js

@@ -0,0 +1,69 @@
+import { attachInternals } from '../utils/a11y.js';
+import { createCustomEvent } from '../utils/events.js';
+export function interactionExpand(fn) {
+    return (target, _context) => target.addInitializer((instance) => {
+        if (!instance.interactionExpandController) {
+            Object.defineProperty(instance, 'interactionExpandController', {
+                value: new InteractionExpandController(instance),
+                writable: false
+            });
+        }
+        if (!instance.interactionExpandControllerConfig) {
+            Object.defineProperty(instance, 'interactionExpandControllerConfig', {
+                get() {
+                    return fn ? fn(instance) : {};
+                }
+            });
+        }
+        return instance.interactionExpandController;
+    });
+}
+/**
+ * @event open
+ * @event close
+ * responsible for managing the closable behavior of an element
+ */
+export class InteractionExpandController {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        attachInternals(this.host);
+        this.#setupKeynav();
+    }
+    toggle() {
+        if (this.host.expanded) {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    open() {
+        if (this.host.interaction === 'auto') {
+            this.host.expanded = true;
+        }
+        this.host.dispatchEvent(createCustomEvent('open'));
+    }
+    close() {
+        if (this.host.interaction === 'auto') {
+            this.host.expanded = false;
+        }
+        this.host.dispatchEvent(createCustomEvent('close'));
+    }
+    #setupKeynav() {
+        if (this.host.interactionExpandControllerConfig.keynav === 'inline') {
+            this.host.addEventListener('keyup', e => {
+                if (e.target === this.host) {
+                    if (e.code === 'ArrowRight') {
+                        this.open();
+                    }
+                    if (e.code === 'ArrowLeft') {
+                        this.close();
+                    }
+                }
+            });
+        }
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-open.controller.d.ts

@@ -0,0 +1,12 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+export type InteractionOpen = ReactiveElement;
+export declare function interactionOpen<T extends InteractionOpen>(): ClassDecorator;
+/**
+ * responsible for managing the closable behavior of an element
+ */
+export declare class InteractionOpenController<T extends InteractionOpen> implements ReactiveController {
+    private host;
+    constructor(host: T);
+    hostConnected(): void;
+    open(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-open.controller.js

@@ -0,0 +1,28 @@
+import { attachInternals } from '../utils/a11y.js';
+import { createCustomEvent } from '../utils/events.js';
+export function interactionOpen() {
+    return (target, _context) => target.addInitializer((instance) => {
+        if (!instance.interactionOpenController) {
+            Object.defineProperty(instance, 'interactionOpenController', {
+                value: new InteractionOpenController(instance),
+                writable: false
+            });
+        }
+        return instance.interactionOpenController;
+    });
+}
+/**
+ * responsible for managing the closable behavior of an element
+ */
+export class InteractionOpenController {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+    hostConnected() {
+        attachInternals(this.host);
+    }
+    open() {
+        this.host.dispatchEvent(createCustomEvent('open'));
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprintui/packages/components/dist/internals/controllers/interaction-range-selection.controller.d.ts

@@ -0,0 +1,17 @@
+import { ReactiveController, ReactiveElement } from 'lit';
+type InteractionRangeSelectionConfig = {
+    grid: HTMLElement[][];
+    rangeSelection?: boolean;
+};
+export declare function interactionRangeSelection<T extends ReactiveElement>(fn?: (host: T) => InteractionRangeSelectionConfig): ClassDecorator;
+/**
+ * Responsible for handling range selection in a grid of elements
+ */
+export declare class InteractionRangeSelectionController<T extends ReactiveElement> implements ReactiveController {
+    #private;
+    private host;
+    private fn;
+    constructor(host: T, fn: (host: T) => InteractionRangeSelectionConfig);
+    hostConnected(): Promise<void>;
+}
+export {};