@aquera/nile-elements 1.3.3-beta-1.4 → 1.3.3-beta-1.6

package/dist/dist/types/src/nile-rich-text-editor/nile-rte-mentions-item.d.ts

@@ -0,0 +1,18 @@
+import { LitElement } from 'lit';
+export type MentionItem = {
+    key: string;
+    label: string;
+};
+export declare class NileRteMentionsItem extends LitElement {
+    protected createRenderRoot(): this;
+    mentionsCharacter: string;
+    mentionsColor: string;
+    mentionsPrefix: string;
+    mentionsSuffix: string;
+    mentionsData: MentionItem[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-rte-mentions-item': NileRteMentionsItem;
+    }
+}

package/dist/dist/types/src/nile-rich-text-editor/nile-rte-mentions.d.ts

@@ -0,0 +1,63 @@
+import { LitElement } from 'lit';
+import type { MentionItem } from './nile-rte-mentions-item';
+type MentionsConfig = Record<string, MentionItem[]>;
+export declare class NileRteMentions extends LitElement {
+    protected createRenderRoot(): this;
+    displayFormat: boolean;
+    mentions: MentionsConfig;
+    mentionFormat: Record<string, {
+        prefix?: string;
+        suffix?: string;
+    }>;
+    private itemsFormats;
+    private getTriggerFormat;
+    private formatLabel;
+    mentionColors: Record<string, string>;
+    private externalConfig;
+    private itemsConfig;
+    private mentionActiveIndex;
+    private itemsColors;
+    private get config();
+    private editorEl;
+    private hostEl;
+    private dropdownEl;
+    private menuEl;
+    private lastRange;
+    private mentionOpen;
+    private mentionTrigger;
+    private mentionQuery;
+    private mentionSuggestions;
+    private mentionFiltered;
+    private mentionX;
+    private mentionY;
+    private triggerBtn;
+    private mo;
+    attach(editorEl: HTMLElement, hostEl: HTMLElement): void;
+    detach(): void;
+    setExternalConfig(cfg: MentionsConfig): void;
+    disconnectedCallback(): void;
+    private rebuildConfigFromChildren;
+    private injectStyles;
+    private getTriggerColor;
+    private ensureMentionDropdown;
+    private onSelectionChange;
+    private saveSelection;
+    private restoreSelection;
+    private getCaretClientRect;
+    private onEditorInput;
+    private onEditorKeyUp;
+    private onEditorKeyDown;
+    private openMention;
+    private closeMention;
+    private handleMention;
+    private updateMentionFiltered;
+    private renderMentionList;
+    private repositionMention;
+    private selectMention;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-rte-mentions': NileRteMentions;
+    }
+}
+export {};

package/dist/dist/types/src/nile-rich-text-editor/nile-rte-preview.d.ts

@@ -0,0 +1,10 @@
+import { LitElement } from 'lit';
+export declare class NileRtePreview extends LitElement {
+    protected createRenderRoot(): this;
+    protected shouldUpdate(): boolean;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-rte-preview': NileRtePreview;
+    }
+}

package/dist/dist/types/src/nile-rich-text-editor/nile-rte-select.d.ts

@@ -0,0 +1,33 @@
+import { LitElement } from 'lit';
+type HeadingTag = 'p' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+type GenericOption = {
+    value: string;
+    label?: string;
+    icon?: string;
+};
+type HeadingOption = {
+    value: HeadingTag;
+    label?: string;
+    icon?: string;
+};
+export declare class NileRteSelect extends LitElement {
+    protected createRenderRoot(): this;
+    type: string;
+    options: string;
+    optionsObj?: Array<GenericOption | HeadingOption>;
+    label: string;
+    private selectedValue;
+    private mapAlignIcon;
+    private get parsedOptions();
+    private ensureDefault;
+    private onSelect;
+    connectedCallback(): void;
+    private injectLocalStyles;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-rte-select': NileRteSelect;
+    }
+}
+export {};

package/dist/dist/types/src/nile-rich-text-editor/nile-rte-toolbar-item.d.ts

@@ -0,0 +1,12 @@
+import { LitElement } from 'lit';
+export declare class NileRteToolbarItem extends LitElement {
+    protected createRenderRoot(): this;
+    protected shouldUpdate(): boolean;
+    name: string;
+    label: string;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-rte-toolbar-item': NileRteToolbarItem;
+    }
+}

package/dist/dist/types/src/nile-rich-text-editor/nile-rte-toolbar.d.ts

@@ -0,0 +1,10 @@
+import { LitElement } from 'lit';
+export declare class NileRteToolbar extends LitElement {
+    protected createRenderRoot(): this;
+    protected shouldUpdate(): boolean;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-rte-toolbar': NileRteToolbar;
+    }
+}

package/dist/dist/types/src/nile-rich-text-editor/utils/block-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function closestBlock(node: Node | null, root: HTMLElement): HTMLElement | null;
+export declare function setBlockTag(root: HTMLElement, tag: 'p' | 'h1' | 'h2' | 'h3'): void;
+export declare function setAlignment(root: HTMLElement, alignment: string): void;
+export declare function nearestElement(n: Node | null): HTMLElement | null;

package/dist/dist/types/src/nile-rich-text-editor/utils/color-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function setForeColor(editor: HTMLElement, hex: string): void;
+export declare function setBackColor(editor: HTMLElement, hex: string): void;

package/dist/dist/types/src/nile-rich-text-editor/utils/inline-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function toggleInlineTag(root: HTMLElement, tag: 'strong' | 'em' | 'u' | 'span', attrs?: Record<string, string>): void;
+export declare function surroundInline(range: Range, tag: string, attrs?: Record<string, string>): void;
+export declare function unwrap(node: HTMLElement): void;
+export declare function rgbToHex(rgb: string): string;
+export declare function setFontFamily(root: HTMLElement, family: string): void;

package/dist/dist/types/src/nile-rich-text-editor/utils/link-utils.d.ts

@@ -0,0 +1 @@
+export declare function insertOrEditLink(root: HTMLElement, href?: string): void;

package/dist/dist/types/src/nile-rich-text-editor/utils/list-utils.d.ts

@@ -0,0 +1 @@
+export declare function toggleList(root: HTMLElement, kind: 'ul' | 'ol'): void;

package/dist/dist/types/src/nile-section-message/index.d.ts

@@ -0,0 +1 @@
+export { NileSectionMessage } from './nile-section-message';

package/dist/dist/types/src/nile-section-message/nile-section-message.css.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * SectionMessage CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;

package/dist/dist/types/src/nile-section-message/nile-section-message.d.ts

@@ -0,0 +1,26 @@
+import { CSSResultArray, TemplateResult } from 'lit';
+import NileElement from '../internal/nile-element';
+export declare class NileSectionMessage extends NileElement {
+    static get styles(): CSSResultArray;
+    private readonly hasSlotController;
+    heading: string;
+    description: string;
+    iconSize: number;
+    /** The section message theme variant. */
+    variant: 'primary' | 'success' | 'warning' | 'error';
+    iconMap: {
+        primary: string;
+        success: string;
+        warning: string;
+        error: string;
+    };
+    connectedCallback(): void;
+    private addActionSeparators;
+    render(): TemplateResult;
+}
+export default NileSectionMessage;
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-section-message': NileSectionMessage;
+    }
+}

package/dist/dist/types/src/nile-select/nile-select.css.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Select_2 CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;

package/dist/dist/types/src/nile-select/nile-select.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Copyright Aquera Inc 2023
+ *
+ * This source code is licensed under the BSD-3-Clause license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import '../nile-icon';
+import '../nile-popup/nile-popup';
+import '../nile-tag/nile-tag';
+import NileElement from '../internal/nile-element';
+import type { CSSResultGroup, PropertyValues } from 'lit';
+import type { NileFormControl } from '../internal/nile-element';
+import type NileOption from '../nile-option/nile-option';
+import type NilePopup from '../nile-popup/nile-popup';
+import type { RenderItemConfig } from '../nile-virtual-select/types.js';
+import '../nile-virtual-select/nile-virtual-select';
+/**
+ * Nile icon component.
+ *
+ * @tag nile-select
+ *
+ */
+/**
+ * @summary Selects allow you to choose items from a menu of predefined options.
+ * @status stable
+ * @since 2.0
+ *
+ * @dependency nile-icon
+ * @dependency nile-popup
+ * @dependency nile-tag
+ * @dependency nile-virtual-select
+ *
+ * @slot - The listbox options. Must be `<nile-option>` elements. You can use `<nile-divider>` to group items visually.
+ * @slot label - The input's label. Alternatively, you can use the `label` attribute.
+ * @slot prefix - Used to prepend a presentational icon or similar element to the combobox.
+ * @slot clear-icon - An icon to use in lieu of the default clear icon.
+ * @slot expand-icon - The icon to show when the control is expanded and collapsed. Rotates on open and close.
+ * @slot help-text - Text that describes how to use the input. Alternatively, you can use the `help-text` attribute.
+ *
+ * @event nile-change - Emitted when the control's value changes.
+ * @event nile-clear - Emitted when the control's value is cleared.
+ * @event nile-input - Emitted when the control receives input.
+ * @event nile-focus - Emitted when the control gains focus.
+ * @event nile-blur - Emitted when the control loses focus.
+ * @event nile-show - Emitted when the select's menu opens.
+ * @event nile-after-show - Emitted after the select's menu opens and all animations are complete.
+ * @event nile-hide - Emitted when the select's menu closes.
+ * @event nile-after-hide - Emitted after the select's menu closes and all animations are complete.
+ * @event nile-invalid - Emitted when the form control has been checked for validity and its constraints aren't satisfied.
+ * @event nile-search - Emitted when the user types in the search input. The event payload includes the search query for backend search functionality.
+ * @event nile-scroll - Emitted when the user scrolls within the listbox. The event payload includes scroll position information.
+ * @event nile-scroll-start - Emitted when the user starts scrolling within the listbox.
+ * @event nile-scroll-end - Emitted when the user stops scrolling and reaches the bottom of the listbox (debounced).
+ *
+ * @csspart form-control - The form control that wraps the label, input, and help text.
+ * @csspart form-control-label - The label's wrapper.
+ * @csspart form-control-input - The select's wrapper.
+ * @csspart form-control-help-text - The help text's wrapper.
+ * @csspart combobox - The container the wraps the prefix, combobox, clear icon, and expand button.
+ * @csspart prefix - The container that wraps the prefix slot.
+ * @csspart display-input - The element that displays the selected option's label, an `<input>` element.
+ * @csspart listbox - The listbox container where options are slotted.
+ * @csspart tags - The container that houses option tags when `multiselect` is used.
+ * @csspart tag - The individual tags that represent each multiselect option.
+ * @csspart tag__base - The tag's base part.
+ * @csspart tag__content - The tag's content part.
+ * @csspart tag__remove-button - The tag's remove button.
+ * @csspart tag__remove-button__base - The tag's remove button base part.
+ * @csspart clear-button - The clear button.
+ * @csspart expand-icon - The container that wraps the expand icon.
+ */
+export declare class NileSelect extends NileElement implements NileFormControl {
+    static styles: CSSResultGroup;
+    private formControlController;
+    private virtualScrollHelper;
+    private readonly portalManager;
+    private readonly hasSlotController;
+    private typeToSelectString;
+    private typeToSelectTimeout;
+    private scrollTimeout;
+    private scrolling;
+    private options;
+    private resizeController?;
+    private visibilityManager?;
+    popup: NilePopup;
+    combobox: HTMLSlotElement;
+    displayInput: HTMLInputElement;
+    valueInput: HTMLInputElement;
+    listbox: HTMLSlotElement;
+    private hasFocus;
+    displayLabel: string;
+    currentOption: NileOption;
+    selectedOptions: NileOption[];
+    oldValue: string | string[];
+    /** The name of the select, submitted as a name/value pair with form data. */
+    name: string;
+    /**
+     * The current value of the select, submitted as a name/value pair with form data. When `multiple` is enabled, the
+     * value will be a space-delimited list of values based on the options selected.
+     */
+    value: string | string[];
+    /** The default value of the form control. Primarily used for resetting the form control. */
+    defaultValue: string | string[];
+    /** The select's size. */
+    size: 'small' | 'medium' | 'large';
+    /** Placeholder text to show as a hint when the select is empty. */
+    placeholder: string;
+    /** Placeholder text to show as a hint when the select is empty. */
+    searchValue: string;
+    searchEnabled: boolean;
+    internalSearchPlaceHolder: string;
+    enableVisibilityEffect: boolean;
+    blockValueChange: boolean;
+    disableLocalSearch: boolean;
+    optionsLoading: boolean;
+    noWidthSync: boolean;
+    /**
+     * When true, the listbox will be appended to the document body instead of the parent container.
+     * This is useful when the parent has overflow: hidden, clip-path, or transform applied.
+     */
+    portal: boolean;
+    /** Allows more than one option to be selected. */
+    multiple: boolean | string;
+    helpText: string;
+    help_text: string;
+    autoResize: boolean;
+    errorMessage: string;
+    /** Sets the input to a warning state, changing its visual appearance. */
+    warning: boolean;
+    /** Sets the input to an error state, changing its visual appearance. */
+    error: boolean;
+    /** Sets the input to a success state, changing its visual appearance. */
+    success: boolean;
+    /**
+     * The maximum number of selected options to show when `multiple` is true. After the maximum, "+n" will be shown to
+     * indicate the number of additional items that are selected. Set to 0 to remove the limit.
+     */
+    maxOptionsVisible: number;
+    /** Disables the select control. */
+    disabled: boolean;
+    /** Adds a clear button when the select is not empty. */
+    clearable: boolean;
+    /**
+     * Indicates whether or not the select is open. You can toggle this attribute to show and hide the menu, or you can
+     * use the `show()` and `hide()` methods and this attribute will reflect the select's open state.
+     */
+    open: boolean;
+    /**
+     * Enable this option to prevent the listbox from being clipped when the component is placed inside a container with
+     * `overflow: auto|scroll`. Hoisting uses a fixed positioning strategy that works in many, but not all, scenarios.
+     */
+    hoist: boolean;
+    /** Draws a filled select. */
+    filled: boolean;
+    /** Draws a pill-style select with rounded edges. */
+    pill: boolean;
+    /** The select's label. If you need to display HTML, use the `label` slot instead. */
+    label: string;
+    /**
+     * The preferred placement of the select's menu. Note that the actual placement may vary as needed to keep the listbox
+     * inside of the viewport.
+     */
+    placement: 'top' | 'bottom';
+    /**
+     * By default, form controls are associated with the nearest containing `<form>` element. This attribute allows you
+     * to place the form control outside of a form and associate it with the form that has this `id`. The form must be in
+     * the same document or shadow root for this to work.
+     */
+    form: string;
+    /** The select's required attribute. */
+    required: boolean;
+    showSelected: boolean;
+    oldMaxOptionsVisible: number;
+    enableTabClose: boolean;
+    showNoResults: boolean;
+    noResultsMessage: string;
+    /** Enhanced configuration for rendering items with support for display text, value, and search text */
+    renderItemConfig?: RenderItemConfig;
+    data: any;
+    enableVirtualScroll: boolean;
+    /** To enable the group header in the select */
+    enableGroupHeader: boolean;
+    /** To auto focus the search input when the select is opened */
+    autoFocusSearch: boolean;
+    /** loading indicator for virtual select */
+    loading: boolean;
+    /** Gets the validity state object */
+    get validity(): ValidityState;
+    /** Gets the validation message */
+    get validationMessage(): string;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private setupResizeObserver;
+    protected updated(_changedProperties: PropertyValues): void;
+    protected firstUpdated(_changedProperties: PropertyValues): void;
+    setCheckBoxInOption(checked: boolean): void;
+    private addOpenListeners;
+    private removeOpenListeners;
+    private handleFocus;
+    private handleBlur;
+    private handleDocumentFocusIn;
+    /**
+     * Handles the click event on the footer.
+     * @param event - The click event.
+     */
+    private handleFooterClick;
+    /**
+     * Toggles the display of selected options in the dropdown
+     * @param event - the event object
+     */
+    toggleShowSelected(event: Event): void;
+    /**
+     * Deselects all options and updates the value, selectedOptions, and displayLabel properties accordingly
+     */
+    unSlectAll(): void;
+    private handleDocumentKeyDown;
+    private handleDocumentMouseDown;
+    private handleWindowResize;
+    private handleWindowScroll;
+    private handleLabelClick;
+    private handleComboboxMouseDown;
+    private handleComboboxKeyDown;
+    private handleClearClick;
+    private handleClearMouseDown;
+    handleOptionClick(event: MouseEvent): void;
+    private handleDefaultSlotChange;
+    private handleTagRemove;
+    private getAllOptions;
+    private getOptionPrefix;
+    private getFirstOption;
+    private setCurrentOption;
+    private setSelectedOptions;
+    private toggleOptionSelection;
+    private selectionChanged;
+    handleSearchFocus(): void;
+    handleSearchBlur(): void;
+    handleSearchChange(e: any): void;
+    handleScroll(e: Event): void;
+    filterOptions(searchValue: string): NileOption[];
+    private handleInvalid;
+    handleDisabledChange(): void;
+    handleValueChange(): void;
+    handlePortalAppendChange(): void;
+    handleOpenChange(): Promise<void>;
+    private getAllGroupAttributes;
+    getUniqueGroupNames(arr: NileOption[]): string[];
+    handleGroupSearchChange(): void;
+    handleGroupShowSelected(): void;
+    /** Shows the listbox. */
+    show(): Promise<void>;
+    /** Hides the listbox. */
+    hide(): Promise<void>;
+    /** Checks for validity but does not show a validation message. Returns `true` when valid and `false` when invalid. */
+    checkValidity(): boolean;
+    /** Gets the associated form, if one exists. */
+    getForm(): HTMLFormElement | null;
+    /** Checks for validity and shows the browser's validation message if the control is invalid. */
+    reportValidity(): boolean;
+    /** Sets a custom validation message. Pass an empty string to restore validity. */
+    setCustomValidity(message: string): void;
+    /** Sets focus on the control. */
+    focus(options?: FocusOptions): void;
+    /** Removes focus from the control. */
+    blur(): void;
+    onInputChange(event: Event): void;
+    calculateWidthOfSelectTagsDiv(): number | undefined;
+    calculateTotalWidthOfTags(): void;
+    handleInputAfterInit(): void;
+    render(): any;
+    nileInput(value: any): void;
+    nileChange(value: any): void;
+}
+export default NileSelect;
+declare global {
+    interface HTMLElementTagNameMap {
+        'nile-select': NileSelect;
+    }
+}

package/dist/dist/types/src/nile-select/nile-select.interface.d.ts

@@ -0,0 +1,5 @@
+export interface GroupAttributes {
+    name: string;
+    data: any;
+    element: HTMLElement;
+}

package/dist/dist/types/src/nile-select/nile-select.test.d.ts

@@ -0,0 +1,6 @@
+import './nile-select';
+import '../nile-option/nile-option';
+import '../nile-input/nile-input';
+import '../nile-popup/nile-popup';
+import '../nile-tag/nile-tag';
+import '../nile-checkbox/nile-checkbox';

package/dist/dist/types/src/nile-select/portal-manager.d.ts

@@ -0,0 +1,50 @@
+import { type Placement, type MiddlewareData } from '@floating-ui/dom';
+export declare class PortalManager {
+    private portalContainer;
+    private originalListboxParent;
+    private measuredPopupHeight;
+    private component;
+    private clonedListbox;
+    private cleanupAutoUpdate;
+    private currentPlacement;
+    private currentMiddlewareData;
+    constructor(component: any);
+    private createPortalAppendContainer;
+    positionPortalAppend(): void;
+    private measurePopupHeight;
+    private computeFloatingUIPosition;
+    private calculateFloatingUIPosition;
+    private createFloatingUIMiddleware;
+    private handleSizeMiddleware;
+    private createCustomPlatform;
+    private applyFloatingUIPosition;
+    private fallbackPositioning;
+    private calculateAndSetAutoSizeProperties;
+    updatePortalAppendPosition(): void;
+    handleWindowResize(): void;
+    private setupAutoUpdatePositioning;
+    private cleanupAutoUpdatePositioning;
+    private injectStylesToDocument;
+    private adoptStylesToPortalAppend;
+    setupPortalAppend(): void;
+    private createPortalListbox;
+    private setupPortalEventListeners;
+    private updatePortalContent;
+    private updateFooterState;
+    cleanupPortalAppend(): void;
+    get portalContainerElement(): HTMLElement | null;
+    resetMeasuredHeight(): void;
+    updatePortalOptions(): void;
+    forceReposition(): void;
+    getCurrentPlacement(): Placement;
+    getCurrentMiddlewareData(): MiddlewareData | null;
+    isUsingFloatingUI(): boolean;
+    updatePositioningConfig(config: {
+        offset?: number;
+        padding?: number;
+        boundary?: Element[] | 'viewport';
+        fallbackPlacements?: Placement[];
+    }): void;
+    handleViewportChange(): void;
+    isPositioningOptimal(): boolean;
+}

package/dist/dist/types/src/nile-select/portal-utils.d.ts

@@ -0,0 +1,65 @@
+import { type Placement, type MiddlewareData, type ComputePositionConfig, type Boundary } from '@floating-ui/dom';
+export declare class PortalUtils {
+    static calculateAvailableSpace(referenceElement: HTMLElement): {
+        spaceAbove: number;
+        spaceBelow: number;
+        viewportHeight: number;
+    };
+    static getOptimalPlacement(referenceElement: HTMLElement): Placement;
+    static findBoundaryElements(component: HTMLElement): Element[] | undefined;
+    static calculateOptimalHeight(referenceRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, viewportHeight: number, placement: Placement): number;
+    static extractStylesAsCSS(styles: any): string;
+    static generateStyleId(): string;
+    static isPositioningOptimal(placement: Placement, referenceElement: HTMLElement): boolean;
+    static applyCollisionData(element: HTMLElement, middlewareData: MiddlewareData, placement: Placement): void;
+    static createFloatingUIMiddleware(boundary: Boundary, onSizeApply: (params: {
+        availableWidth: number;
+        availableHeight: number;
+        elements: {
+            floating: HTMLElement;
+        };
+        rects: {
+            reference: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            };
+        };
+    }) => void): ComputePositionConfig['middleware'];
+}
+export declare class PortalContentUtils {
+    static createBaseListbox(component: any): HTMLElement;
+    static addSearchSection(listbox: HTMLElement, component: any): void;
+    static addLoadingSection(listbox: HTMLElement, component: any): void;
+    static addOptionsSection(listbox: HTMLElement, component: any): void;
+    static addNoResultsMessage(container: HTMLElement, component: any): void;
+    static addClonedOptions(container: HTMLElement, component: any): void;
+    static cloneOption(option: HTMLElement): HTMLElement;
+    static copyOptionProperties(originalOption: HTMLElement, clonedOption: HTMLElement): void;
+    static addFooterSection(listbox: HTMLElement, component: any): void;
+    static createFooter(component: any): HTMLElement;
+    static addShowSelectedToggle(footer: HTMLElement, component: any): void;
+    static addClearAllButton(footer: HTMLElement, component: any): void;
+    static updateClonedOptions(clonedListbox: HTMLElement, component: any): void;
+    static updateClonedOption(originalOption: HTMLElement, clonedOption: HTMLElement): void;
+    static updateClonedOptionAttributes(originalOption: HTMLElement, clonedOption: HTMLElement): void;
+    static createPortalListbox(component: any): HTMLElement;
+}
+export declare class PortalEventUtils {
+    static setupPortalEventListeners(clonedListbox: HTMLElement, component: any): void;
+    static setupOptionClickListeners(clonedListbox: HTMLElement, component: any): void;
+    static handleOptionClick(option: HTMLElement, component: any): void;
+    static setupScrollListeners(clonedListbox: HTMLElement, component: any): void;
+    static setupSearchListeners(clonedListbox: HTMLElement, component: any): void;
+    static setupFooterListeners(clonedListbox: HTMLElement, component: any): void;
+    static setupFooterClickHandlers(footer: HTMLElement): void;
+    static setupShowSelectedToggle(footer: HTMLElement, component: any): void;
+    static setupClearAllHandler(footer: HTMLElement, component: any): void;
+    static setupSlotListeners(clonedListbox: HTMLElement, component: any): void;
+}

package/dist/dist/types/src/nile-select/virtual-scroll-helper.d.ts

@@ -0,0 +1,9 @@
+import type NileElement from '../internal/nile-element';
+/**
+ * Helper class to manage virtual scroll functionality for nile-select component
+ */
+export declare class VirtualScrollHelper {
+    private component;
+    constructor(component: NileElement);
+    renderVirtualizedContent(): any;
+}

package/dist/dist/types/src/nile-side-bar/index.d.ts

@@ -0,0 +1 @@
+export { NileSideBar } from './nile-side-bar';

package/dist/dist/types/src/nile-side-bar/nile-side-bar.css.d.ts

@@ -0,0 +1,12 @@
+/**
+* Copyright Aquera Inc 2023
+*
+* This source code is licensed under the BSD-3-Clause license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+/**
+ * SideBar CSS
+ */
+export declare const styles: import("lit").CSSResult;
+declare const _default: import("lit").CSSResult[];
+export default _default;