@blueprintui/cli 0.12.0 → 0.13.0

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/types/index.d.ts

@@ -0,0 +1,98 @@
+import { LitElement, TemplateResult } from 'lit';
+export type Permutations<T extends string, U extends string = T> = T extends any ? T | `${T} ${Permutations<Exclude<U, T>>}` : never;
+export type ConstructorTypeOf<T> = new (...args: any[]) => T;
+export interface BpTypeElement extends Partial<LitElement> {
+    base?: null;
+    active?: boolean;
+    checked?: boolean;
+    closable?: boolean;
+    disabled?: boolean;
+    expanded?: boolean;
+    pressed?: boolean;
+    readonly?: boolean;
+    selected?: boolean;
+    indeterminate?: boolean;
+    value?: string | number | FormData | File;
+    type?: string;
+    name?: string;
+    selectable?: 'multi' | 'single';
+    expandable?: boolean;
+    interaction?: 'auto';
+    size?: 'sm' | 'md' | 'lg';
+    layer?: 'container' | 'flat' | 'inline';
+    action?: 'primary' | 'secondary' | 'flat' | 'inline';
+    dir?: 'ltr' | 'rtl' | 'auto' | string;
+    orientation?: 'horizontal' | 'vertical';
+    layout?: 'horizontal' | 'vertical';
+    sort?: 'ascending' | 'descending' | 'none';
+    direction?: 'up' | 'down' | 'left' | 'right';
+    status?: 'accent' | 'success' | 'warning' | 'danger';
+    color?: 'blue' | 'green' | 'red' | 'yellow' | 'purple';
+    i18n?: any;
+    _internals?: ElementInternals;
+    render(): TemplateResult;
+    updated?: any;
+    firstUpdated?: any;
+}
+export interface BpTypeControl extends Omit<BpTypeElement, 'size'> {
+    value?: string | number | FormData | File;
+    valueAsNumber?: number;
+    valueAsDate?: Date;
+    size?: number;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    required?: boolean;
+    multiple?: boolean;
+    autocomplete?: string;
+    pattern?: string;
+    placeholder?: string;
+    reset?: any;
+    formAssociated: boolean;
+    form: HTMLFormElement;
+    formAction: string;
+    formEnctype: string;
+    formMethod: string;
+    formNoValidate: boolean;
+    formTarget: string;
+    labels: NodeListOf<HTMLLabelElement>;
+    validationMessage: string;
+    validity: ValidityState;
+    willValidate: boolean;
+    checkValidity: any;
+    reportValidity: any;
+    setCustomValidity: any;
+    composedLabel: string;
+    _internals?: ElementInternals;
+}
+export interface BpTypeButton extends BpTypeControl {
+    popoverTargetElement: HTMLElement;
+    popoverTargetAction: 'toggle' | 'show' | 'hide';
+    interestForElement: HTMLElement;
+    commandForElement: HTMLElement;
+    command: string;
+}
+export interface BpTypePopover extends BpTypeElement {
+    position: string;
+    trigger: HTMLElement | string;
+    anchor: HTMLElement | string;
+    open: boolean;
+    modal?: boolean;
+    static?: boolean;
+}
+export declare type Alignment = 'start' | 'end';
+export declare type Side = 'top' | 'right' | 'bottom' | 'left';
+export declare type AlignedPosition = `${Side}-${Alignment}`;
+export declare type Position = Side | AlignedPosition | 'center';
+export declare type CommandExpandable = '--open' | '--close' | '--toggle';
+export declare type CommandClosable = '--open' | '--close' | '--toggle';
+export declare type CommandSelectable = '--select' | '--deselect' | '--toggle';
+export declare type CommandPopover = 'toggle-popover' | 'show-popover' | 'hide-popover';
+export declare type Command = CommandExpandable | CommandClosable | CommandSelectable;
+export declare type EventExpandable = 'open' | 'close';
+export declare type EventClosable = 'open' | 'close';
+export declare type EventSelectable = 'select' | 'deselect';
+export declare type EventPopover = 'hide' | 'show' | 'toggle';
+export declare type Event = EventExpandable | EventClosable | EventSelectable | EventPopover;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/types/index.js

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

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/a11y.d.ts

@@ -0,0 +1,8 @@
+export declare function attachInternals(element: HTMLElement & {
+    _internals?: ElementInternals;
+}): void;
+export declare function associateAriaDescribedBy(element: HTMLElement, descriptions: HTMLElement[]): void;
+export declare function associateInputAndLabel(input: HTMLInputElement, label: HTMLLabelElement): void;
+export declare function associateInputToDatalist(input: HTMLInputElement, datalist: HTMLDataListElement): void;
+export declare function associateAriaLabel(label: HTMLElement, element: HTMLElement): void;
+export declare function associateFieldNames(inputs: HTMLInputElement[]): void;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/a11y.js

@@ -0,0 +1,41 @@
+import { createId } from './string.js';
+export function attachInternals(element) {
+    try {
+        element._internals = element.attachInternals();
+    }
+    catch {
+        return;
+    }
+}
+export function associateAriaDescribedBy(element, descriptions) {
+    element.setAttribute('aria-describedby', descriptions
+        .map(d => {
+        d.id = d.id?.length ? d.id : createId();
+        return d.id;
+    })
+        .join(' '));
+}
+export function associateInputAndLabel(input, label) {
+    if (input && label) {
+        input.id = input.id?.length ? input.id : createId();
+        label.setAttribute('for', input.id);
+        label.addEventListener('click', () => input.focus());
+    }
+}
+export function associateInputToDatalist(input, datalist) {
+    if (datalist) {
+        input.id = input.id?.length ? input.id : createId();
+        datalist.id = `${input.id}-datalist`;
+        input.setAttribute('list', datalist.id);
+    }
+}
+export function associateAriaLabel(label, element) {
+    if (label) {
+        label.id = label.id?.length ? label.id : createId();
+        element?.setAttribute('aria-labelledby', label.id);
+    }
+}
+export function associateFieldNames(inputs) {
+    const name = createId();
+    inputs.filter(i => !i.name && !i.getAttribute('name')).forEach(i => i.setAttribute('name', name));
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/array.d.ts

@@ -0,0 +1,8 @@
+export declare function group(array: any[], n: number): any[][];
+export declare function selectionStates(items: {
+    selected: boolean;
+}[]): {
+    allSelected: boolean;
+    anySelected: boolean;
+    noneSelected: boolean;
+};

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/array.js

@@ -0,0 +1,10 @@
+export function group(array, n) {
+    return [...Array(Math.ceil(array.length / n))].map((_e, i) => array.slice(i * n, (i + 1) * n));
+}
+export function selectionStates(items) {
+    return {
+        allSelected: items.every(i => i.selected),
+        anySelected: items.some(i => i.selected),
+        noneSelected: items.every(i => !i.selected)
+    };
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/define.d.ts

@@ -0,0 +1,8 @@
+export declare const version = "0.0.0";
+export interface ElementMetadata {
+    name: string;
+    version: string;
+}
+export declare function defineElement(name: string, element: typeof HTMLElement & {
+    __meta?: ElementMetadata;
+}): void;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/define.js

@@ -0,0 +1,10 @@
+import { GlobalStateService } from '../services/global.service.js';
+export const version = '0.0.0';
+export function defineElement(name, element) {
+    if (!customElements.get(name)) {
+        customElements.define(name, element);
+        const meta = { name, version: '0.0.0' };
+        element.__meta = meta;
+        GlobalStateService.dispatch('defineElement', { elementRegistry: [meta] });
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/dom.d.ts

@@ -0,0 +1,12 @@
+export declare function attachRootNodeStyles(host: HTMLElement | Element | ParentNode, styles: CSSStyleSheet[]): void;
+export declare function toggleState(internals: ElementInternals, state: string, value: boolean): void;
+/** Get host render root for a given element. This may be the document or the nearest shadow root. */
+export declare function getRenderRoot(element: HTMLElement): HTMLElement | ShadowRoot;
+export declare function querySelectorByIdRef(element: HTMLElement, idRef: string): HTMLElement;
+export declare function queryCommandTriggerRef(element: HTMLElement): HTMLElement;
+export declare function sameRenderRoot(elementOne: HTMLElement, elementTwo: HTMLElement): boolean;
+export declare function getOffesetDifference(min: number, end: number): number;
+export declare function assignedElements<T extends HTMLElement>(element: HTMLElement, config?: {
+    name?: string;
+    flatten?: boolean;
+}): T[];

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/dom.js

@@ -0,0 +1,50 @@
+import { getFlattenedDOMTree } from './traversal.js';
+export function attachRootNodeStyles(host, styles) {
+    const root = host.getRootNode();
+    const hasStyles = root.adoptedStyleSheets.some(styleSheet => styles.some(s => styleSheetToString(s) === styleSheetToString(styleSheet)));
+    if (!hasStyles) {
+        root.adoptedStyleSheets = [...root.adoptedStyleSheets, ...styles];
+    }
+}
+function styleSheetToString(styleSheet) {
+    return Array.from(styleSheet.cssRules)
+        .map(rule => rule.cssText)
+        .join('');
+}
+export function toggleState(internals, state, value) {
+    if (value) {
+        internals.states.add(state);
+    }
+    else {
+        internals.states.delete(state);
+    }
+}
+/** Get host render root for a given element. This may be the document or the nearest shadow root. */
+export function getRenderRoot(element) {
+    const root = element.parentNode;
+    return root.shadowRoot ? root.shadowRoot : document.body;
+}
+export function querySelectorByIdRef(element, idRef) {
+    return getFlattenedDOMTree(element.getRootNode()).find(e => e?.id !== '' && e.id === idRef);
+}
+export function queryCommandTriggerRef(element) {
+    return element.id
+        ? getFlattenedDOMTree(element.getRootNode()).find(e => e.getAttribute('commandfor') === element.id)
+        : null;
+}
+export function sameRenderRoot(elementOne, elementTwo) {
+    const rootOne = elementOne.getRootNode();
+    const rootTwo = elementTwo.getRootNode();
+    const sameShadowRoot = rootOne instanceof ShadowRoot && rootTwo instanceof ShadowRoot && rootOne.host === rootTwo.host;
+    const sameDocument = rootOne instanceof Document && rootTwo instanceof Document && rootOne === rootTwo;
+    return sameShadowRoot || sameDocument;
+}
+export function getOffesetDifference(min, end) {
+    return Math.sign(end - min) * Math.abs(min - end);
+}
+export function assignedElements(element, config = { flatten: false }) {
+    const items = element.shadowRoot
+        .querySelector(config.name ? `slot[name="${config.name}"]` : 'slot')
+        ?.assignedElements({ flatten: config.flatten });
+    return items ? Array.from(items) : [];
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/event-subject.d.ts

@@ -0,0 +1,15 @@
+export declare class BroadcastSubscription {
+    #private;
+    fn: (value: any) => void;
+    constructor(fn: (value: any) => void, channelId: string);
+    unsubscribe(): void;
+}
+export declare class BroadcastSubject<T> {
+    #private;
+    constructor();
+    subscribe(fn: (value: T) => void): BroadcastSubscription;
+    emit(value: T): void;
+    toEventObservable(): BroadcastObservable<T>;
+}
+export interface BroadcastObservable<T> extends Pick<BroadcastSubject<T>, 'subscribe'> {
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/event-subject.js

@@ -0,0 +1,28 @@
+import { createId } from './string.js';
+export class BroadcastSubscription {
+    #channel;
+    constructor(fn, channelId) {
+        this.fn = fn;
+        this.#channel = new BroadcastChannel(channelId);
+        this.#channel.addEventListener('message', e => fn(e.data));
+    }
+    unsubscribe() {
+        this.#channel.close();
+    }
+}
+export class BroadcastSubject {
+    #id = createId();
+    #channel;
+    constructor() {
+        this.#channel = new BroadcastChannel(this.#id);
+    }
+    subscribe(fn) {
+        return new BroadcastSubscription(fn, this.#id);
+    }
+    emit(value) {
+        this.#channel.postMessage(value);
+    }
+    toEventObservable() {
+        return this;
+    }
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/events.d.ts

@@ -0,0 +1,11 @@
+export declare function createCustomEvent<T>(name: string, options?: CustomEventInit): CustomEvent<T>;
+export declare function eventWasDefaultPrevented(event: Event): Promise<boolean>;
+export declare function stopEvent(event: any): void;
+export declare function onKeys(events: string[], event: KeyboardEvent, fn: () => any): void;
+export declare const getElementUpdates: (element: HTMLElement, propertyKey: string, fn: (value: any) => void) => MutationObserver;
+export declare function listenForAttributeChange(element: HTMLElement, attrName: string, fn: (attrValue: string | null) => void): MutationObserver;
+export declare function listenForAttributeListChange(element: HTMLElement, attrNames: string[], fn: (mutation: MutationRecord) => void): MutationObserver;
+export type TouchedElement = HTMLElement & {
+    __bpTouched?: boolean;
+};
+export declare function onFirstInteraction(element: HTMLElement): Promise<null>;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/events.js

@@ -0,0 +1,74 @@
+export function createCustomEvent(name, options = {}) {
+    return new CustomEvent(name, { bubbles: true, composed: true, ...options });
+}
+export async function eventWasDefaultPrevented(event) {
+    await Promise.resolve();
+    return event?.defaultPrevented;
+}
+export function stopEvent(event) {
+    event?.preventDefault();
+    event?.stopPropagation();
+}
+export function onKeys(events, event, fn) {
+    if (events.find(e => e === event.code)) {
+        fn();
+    }
+}
+export const getElementUpdates = (element, propertyKey, fn) => {
+    if (element.hasAttribute(propertyKey)) {
+        fn(element.getAttribute(propertyKey));
+    }
+    else if (element[propertyKey] !== undefined) {
+        fn(element[propertyKey]);
+    }
+    const updatedProp = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(element), propertyKey);
+    if (updatedProp) {
+        try {
+            Object.defineProperty(element, propertyKey, {
+                get: updatedProp.get,
+                set: val => {
+                    fn(val);
+                    updatedProp.set.call(element, val);
+                }
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    return listenForAttributeChange(element, propertyKey, val => fn(val));
+};
+export function listenForAttributeChange(element, attrName, fn) {
+    const observer = new MutationObserver(mutations => {
+        if (mutations.find(m => m.attributeName === attrName)) {
+            fn(element.getAttribute(attrName));
+        }
+    });
+    observer.observe(element, { attributes: true });
+    return observer;
+}
+export function listenForAttributeListChange(element, attrNames, fn) {
+    const observer = new MutationObserver(mutations => {
+        const mutation = mutations.find(m => attrNames.find(i => m.attributeName === i));
+        if (mutation) {
+            fn(mutation);
+        }
+    });
+    observer.observe(element, { attributes: true, attributeFilter: attrNames, subtree: true });
+    return observer;
+}
+export function onFirstInteraction(element) {
+    return new Promise(resolve => {
+        const update = () => {
+            resolve(null);
+            element.__bpTouched = true;
+        };
+        if (element.__bpTouched) {
+            resolve(null);
+        }
+        element.addEventListener('pointerdown', update, { once: true, passive: true }); // prevent SRs like NVDA from anouncing "clickable" https://github.com/nvaccess/nvda/issues/5830
+        element.addEventListener('mouseover', update, { once: true, passive: true });
+        element.addEventListener('keydown', update, { once: true, passive: true });
+        element.addEventListener('focus', update, { once: true, passive: true });
+    });
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/focus.d.ts

@@ -0,0 +1,3 @@
+export declare function createFocusTrap(element: HTMLElement): void;
+export declare function getFlattenedFocusableItems(element: Node, depth?: number): HTMLElement[];
+export declare function focusable(element: Element): boolean;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/focus.js

@@ -0,0 +1,37 @@
+import { getFlattenedDOMTree } from './traversal.js';
+export function createFocusTrap(element) {
+    element.addEventListener('keydown', e => {
+        if (e.code === 'Tab' && !element.hidden) {
+            const focusableItems = getFlattenedFocusableItems(element);
+            const first = focusableItems[0];
+            const last = focusableItems[focusableItems.length - 1];
+            if (e.shiftKey && (document.activeElement === first || document.activeElement === element)) {
+                e.preventDefault();
+                last.focus();
+            }
+            else if (!e.shiftKey && document.activeElement === last) {
+                e.preventDefault();
+                first.focus();
+            }
+        }
+    });
+}
+export function getFlattenedFocusableItems(element, depth = 10) {
+    return getFlattenedDOMTree(element, depth).filter((e) => focusable(e));
+}
+export function focusable(element) {
+    return element.matches([
+        'a[href]',
+        'area[href]',
+        'input:not([disabled])',
+        'button:not([disabled])',
+        'select:not([disabled])',
+        'textarea:not([disabled])',
+        'iframe',
+        'object',
+        'embed',
+        '*[tabindex]', // -1 tabindex is a focusable element and needed for keyboard navigation
+        '*[contenteditable=true]',
+        '[role=button]:not([disabled])'
+    ].join(','));
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/i18n.d.ts

@@ -0,0 +1,2 @@
+export declare function matchInterpolate(template: string, obj?: any): string;
+export declare function getElementLanguageDirection(element: HTMLElement): string;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/i18n.js

@@ -0,0 +1,7 @@
+import { getFromObjectPath } from './string.js';
+export function matchInterpolate(template, obj = {}) {
+    return template.replace(/\$\{.+?\}/g, match => getFromObjectPath(match.substring(2, match.length - 1).trim(), obj));
+}
+export function getElementLanguageDirection(element) {
+    return getComputedStyle(element).getPropertyValue('direction').trim();
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/responsive.d.ts

@@ -0,0 +1,17 @@
+import { LitElement } from 'lit';
+export declare function elementVisible(element: HTMLElement, fn: () => void): IntersectionObserver;
+export declare function elementResize(element: HTMLElement, fn: () => void, async?: boolean): ResizeObserver;
+export type ResponsiveComponent = LitElement & {
+    layout: string;
+    responsive: boolean;
+    layoutStable: boolean;
+};
+export interface LayoutConfig {
+    layouts: string[];
+    initialLayout: string;
+}
+/**
+ * This function loops through a list of layout options and changes the layout
+ * of ResponsiveComponent until the component layout condition is met.
+ */
+export declare function calculateOptimalLayout(component: ResponsiveComponent, layoutConfig: LayoutConfig): Promise<boolean>;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/responsive.js

@@ -0,0 +1,48 @@
+export function elementVisible(element, fn) {
+    const observer = new IntersectionObserver(entries => {
+        if (entries[0].isIntersecting === true) {
+            fn();
+        }
+    }, { threshold: [0] });
+    observer.observe(element);
+    return observer;
+}
+export function elementResize(element, fn, async = true) {
+    const observer = new ResizeObserver(() => {
+        if (async) {
+            window.requestAnimationFrame(() => fn()); // prevents "ResizeObserver loop limit exceeded" error
+        }
+        else {
+            fn();
+        }
+    });
+    observer.observe(element);
+    return observer;
+}
+/**
+ * This function loops through a list of layout options and changes the layout
+ * of ResponsiveComponent until the component layout condition is met.
+ */
+export function calculateOptimalLayout(component, layoutConfig) {
+    return component.updateComplete.then(() => {
+        const currentLayout = component.layout;
+        component.layout = layoutConfig.layouts[0];
+        return component.responsive
+            ? layoutConfig.layouts
+                .reduce((prev, next) => prev.then(() => {
+                if (component.layout === layoutConfig.initialLayout) {
+                    return next;
+                }
+                else {
+                    const prev = component.layout;
+                    component.layout = next;
+                    return component.updateComplete.then(() => {
+                        component.layout = component.layoutStable ? component.layout : prev;
+                        return next;
+                    });
+                }
+            }), Promise.resolve(layoutConfig.layouts[0]))
+                .then(() => currentLayout !== component.layout)
+            : true;
+    });
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/string.d.ts

@@ -0,0 +1,6 @@
+export declare function camelCaseToKebabCase(value: string): string;
+export declare function isNumericString(val: string): boolean;
+export declare function createId(prefix?: string): string;
+export declare function getFromObjectPath(path: string, dataObj: any, fallback?: string): any;
+export declare function rgbToHex(red: number, green: number, blue: number): string;
+export declare function parseMinimumTouchWidth(width: string): number;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/string.js

@@ -0,0 +1,43 @@
+export function camelCaseToKebabCase(value) {
+    return value.replace(/[A-Z]/g, l => `-${l.toLowerCase()}`);
+}
+export function isNumericString(val) {
+    return typeof val === 'string' && val.trim() !== '' && +val === +val;
+}
+export function createId(prefix = '_') {
+    return `${prefix}${Math.random().toString(36).substring(2, 9)}`;
+}
+export function getFromObjectPath(path, dataObj, fallback = `$\{${path}}`) {
+    return path.split('.').reduce((res, key) => {
+        try {
+            const value = res[key];
+            if (value === null || value === false || value === '' || value === 0) {
+                return value;
+            }
+            else {
+                return value || fallback;
+            }
+        }
+        catch {
+            return fallback;
+        }
+    }, dataObj);
+}
+export function rgbToHex(red, green, blue) {
+    let r = red.toString(16);
+    let g = green.toString(16);
+    let b = blue.toString(16);
+    if (r.length === 1) {
+        r = '0' + r;
+    }
+    if (g.length === 1) {
+        g = '0' + g;
+    }
+    if (b.length === 1) {
+        b = '0' + b;
+    }
+    return `#${r}${g}${b}`;
+}
+export function parseMinimumTouchWidth(width) {
+    return isNumericString(width) || width?.includes('px') ? parseInt(width) : 36;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/time.d.ts

@@ -0,0 +1,3 @@
+export declare function getMonths(format?: 'long' | 'numeric' | '2-digit' | 'short' | 'narrow'): string[];
+/** returns next decade of the given year */
+export declare function getYearSelection(year: number): number[];

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/time.js

@@ -0,0 +1,13 @@
+export function getMonths(format = 'long') {
+    return Array.from(Array(12).keys()).map((_i, i) => {
+        const date = new Date();
+        date.setDate(1);
+        date.setMonth(i);
+        return date.toLocaleString('en-us', { month: format });
+    });
+}
+/** returns next decade of the given year */
+export function getYearSelection(year) {
+    let y = year;
+    return [year - 1, ...Array.from(Array(9).keys()).map(() => y++)];
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/traversal.d.ts

@@ -0,0 +1,5 @@
+export declare function getParents(node: Node): HTMLElement[];
+export declare function getFlattenedDOMTree(node: Node, depth?: number): HTMLElement[];
+export declare function getChildren(node: any): any;
+export declare function isObject(val: any): boolean;
+export declare function mergeObjects(...objs: object[]): object;

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/main/projects/components/dist/internals/utils/traversal.js

@@ -0,0 +1,60 @@
+export function getParents(node) {
+    const parents = [];
+    let parent = node?.parentNode || node.getRootNode().host;
+    while (parent && parent !== document) {
+        if (parent instanceof HTMLElement) {
+            parents.push(parent);
+        }
+        else if (parent instanceof ShadowRoot) {
+            parents.push(parent.getRootNode().host);
+        }
+        parent = parent.getRootNode()?.host || parent?.parentNode;
+    }
+    return parents;
+}
+export function getFlattenedDOMTree(node, depth = 10) {
+    return Array.from(getChildren(node))
+        .reduce((prev, next) => {
+        return [...prev, [next, [...Array.from(getChildren(next)).map((i) => [i, getFlattenedDOMTree(i, depth)])]]];
+    }, [])
+        .flat(depth);
+}
+export function getChildren(node) {
+    if (node.documentElement) {
+        return node.documentElement.children;
+    }
+    else if (node.shadowRoot) {
+        return node.shadowRoot.children;
+    }
+    else if (node.assignedElements) {
+        const slotted = node.assignedElements(); // slotted elements
+        return slotted.length ? slotted : node.children; // else slot fallback
+    }
+    else {
+        return node.children;
+    }
+}
+export function isObject(val) {
+    return val?.constructor === Object;
+}
+export function mergeObjects(...objs) {
+    const clone = {};
+    objs
+        .map(o => (isObject(o) ? { ...o } : {}))
+        .forEach((obj) => {
+        Object.keys(obj).forEach(prop => {
+            const propVal = obj[prop];
+            if (Array.isArray(propVal)) {
+                const initial = Array.isArray(clone[prop]) ? clone[prop] : [];
+                clone[prop] = [...initial, ...Array.from(propVal)];
+            }
+            else if (isObject(propVal)) {
+                clone[prop] = mergeObjects(clone[prop] || {}, propVal);
+            }
+            else {
+                clone[prop] = propVal;
+            }
+        });
+    });
+    return clone;
+}