@aquera/nile-elements 0.1.59-beta-1.0 → 0.1.59

package/src/nile-select/nile-select.ts

@@ -29,12 +29,15 @@ import { scrollIntoView } from '../internal/scroll';
 import { waitForEvent } from '../internal/event';
 import { watch } from '../internal/watch';
 import NileElement from '../internal/nile-element';
-import type { CSSResultGroup } from 'lit';
+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 { unsafeHTML } from 'lit/directives/unsafe-html.js';
 import { ifDefined } from 'lit/directives/if-defined.js';
+import '../nile-virtual-select/nile-virtual-select';
+import { VirtualScrollHelper } from './virtual-scroll-helper';
 
 type NileRemoveEvent = CustomEvent<Record<PropertyKey, never>>;
 
@@ -53,6 +56,7 @@ type NileRemoveEvent = CustomEvent<Record<PropertyKey, never>>;
  * @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.
@@ -91,14 +95,15 @@ type NileRemoveEvent = CustomEvent<Record<PropertyKey, never>>;
  */
 
 @customElement('nile-select')
-export class NileSelect extends NileElement implements NileFormControl {
+export class NileSelect extends NileElement implements NileFormControl{
   static styles: CSSResultGroup = styles;
 
   // protected override BUBBLES=false;
 
-  private readonly formControlController = new FormControlController(this, {
-    assumeInteractionOn: ['nile-blur', 'nile-input'],
-  });
+  private formControlController: FormControlController | null;
+  private virtualScrollHelper!: VirtualScrollHelper;
+
+
   private readonly hasSlotController = new HasSlotController(
     this,
     'help-text',
@@ -232,6 +237,13 @@ export class NileSelect extends NileElement implements NileFormControl {
 
   @property({ type: String }) noResultsMessage: string = 'No results found';
 
+  /** Enhanced configuration for rendering items with support for display text, value, and search text */
+  @property({ attribute: false }) renderItemConfig?: RenderItemConfig;
+
+  @property({ type: Array }) data: any = [];
+
+  @property({ type: Boolean }) enableVirtualScroll = false;
+
   /** Gets the validity state object */
   get validity() {
     return this.valueInput?.validity;
@@ -242,8 +254,18 @@ export class NileSelect extends NileElement implements NileFormControl {
     return this.valueInput?.validationMessage;
   }
 
+  constructor() {
+    super();
+  }
+
   connectedCallback() {
     super.connectedCallback();
+    if(!this.enableVirtualScroll) {
+      this.formControlController = new FormControlController(this, {
+          assumeInteractionOn: ['nile-blur', 'nile-input'],
+      });
+    }
+    this.virtualScrollHelper = new VirtualScrollHelper(this);
     this.handleDocumentFocusIn = this.handleDocumentFocusIn.bind(this);
     this.handleDocumentKeyDown = this.handleDocumentKeyDown.bind(this);
     this.handleDocumentMouseDown = this.handleDocumentMouseDown.bind(this);
@@ -258,6 +280,19 @@ export class NileSelect extends NileElement implements NileFormControl {
     this.emit('nile-destroy');
   }
 
+  protected updated(_changedProperties: PropertyValues): void {
+    if(_changedProperties.has('multiple')) {
+      this.setCheckBoxInOption(this.multiple);
+    }
+  }
+
+  setCheckBoxInOption(checked: boolean): void {
+    const options = this.getAllOptions();
+    options.forEach((option: NileOption) => {
+      option.showCheckbox = checked;
+    })
+  }
+
   private addOpenListeners() {
     document.addEventListener('focusin', this.handleDocumentFocusIn);
     document.addEventListener('keydown', this.handleDocumentKeyDown);
@@ -734,7 +769,7 @@ export class NileSelect extends NileElement implements NileFormControl {
 
     // Update validity
     this.updateComplete.then(() => {
-      this.formControlController.updateValidity();
+      this.formControlController?.updateValidity();
     });
 
     this.calculateTotalWidthOfTags();
@@ -785,8 +820,8 @@ export class NileSelect extends NileElement implements NileFormControl {
   }
 
   private handleInvalid(event: Event) {
-    this.formControlController.setValidity(false);
-    this.formControlController.emitInvalidEvent(event);
+    this.formControlController?.setValidity(false);
+    this.formControlController?.emitInvalidEvent(event);
   }
 
   @watch('disabled', { waitUntilFirstUpdate: true })
@@ -889,7 +924,7 @@ export class NileSelect extends NileElement implements NileFormControl {
 
   /** Gets the associated form, if one exists. */
   getForm(): HTMLFormElement | null {
-    return this.formControlController.getForm();
+    return this.formControlController?.getForm() || null;
   }
 
   /** Checks for validity and shows the browser's validation message if the control is invalid. */
@@ -900,7 +935,7 @@ export class NileSelect extends NileElement implements NileFormControl {
   /** Sets a custom validation message. Pass an empty string to restore validity. */
   setCustomValidity(message: string) {
     this.valueInput.setCustomValidity(message);
-    this.formControlController.updateValidity();
+    this.formControlController?.updateValidity();
   }
 
   /** Sets focus on the control. */
@@ -973,6 +1008,10 @@ export class NileSelect extends NileElement implements NileFormControl {
   }
 
   render() {
+    if(this.enableVirtualScroll) {
+      return this.virtualScrollHelper.renderVirtualizedContent();
+    }
+
     const hasLabelSlot = this.hasSlotController.test('label');
     const hasHelpTextSlot = this.hasSlotController.test('help-text');
     const hasLabelSuffixSlot = this.hasSlotController.test('label-suffix');

package/src/nile-select/virtual-scroll-helper.ts

@@ -0,0 +1,56 @@
+import { html } from 'lit';
+import type NileElement from '../internal/nile-element';
+
+/**
+ * Helper class to manage virtual scroll functionality for nile-select component
+ */
+export class VirtualScrollHelper {
+  private component: NileElement;
+
+  constructor(component: NileElement) {
+    this.component = component;
+  }
+
+  renderVirtualizedContent(): any {
+    const component = this.component as any;
+
+    return html`
+      <div class="virtual-select">
+        <nile-virtual-select
+          .name=${component.name}
+          .value=${component.value}
+          .placeholder=${component.placeholder}
+          .size=${component.size}
+          .searchEnabled=${component.searchEnabled}
+          .internalSearchPlaceHolder=${component.internalSearchPlaceHolder}
+          .disableLocalSearch=${component.disableLocalSearch}
+          .optionsLoading=${component.optionsLoading}
+          .multiple=${component.multiple}
+          .helpText=${component.helpText}
+          .errorMessage=${component.errorMessage}
+          .warning=${component.warning}
+          .error=${component.error}
+          .success=${component.success}
+          .disabled=${component.disabled}
+          .clearable=${component.clearable}
+          .hoist=${component.hoist}
+          .filled=${component.filled}
+          .pill=${component.pill}
+          .label=${component.label}
+          .placement=${component.placement}
+          .form=${component.form}
+          .required=${component.required}
+          .showNoResults=${component.showNoResults}
+          .noResultsMessage=${component.noResultsMessage}
+          .renderItemConfig=${component.renderItemConfig}
+          .blockValueChange=${component.blockValueChange}
+          .noWidthSync=${component.noWidthSync}
+          .maxOptionsVisible=${component.maxOptionsVisible}
+          .data=${component.data}
+        >
+          <slot name="prefix" slot="prefix"></slot>
+        </nile-virtual-select>
+      </div>
+    `;
+  }
+}

package/src/nile-slider/index.ts

@@ -0,0 +1 @@
+export { NileSlider } from './nile-slider';

package/src/nile-slider/nile-slider.css.ts

@@ -0,0 +1,119 @@
+/**
+* Copyright Aquera Inc 2025
+*
+* 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 { css } from 'lit';
+
+/**
+* Slider CSS
+*/
+export const styles = css`
+  :host {
+    display: block;
+  }
+
+  .container {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 10px;
+    height: 100px;
+  }
+
+  .align-item-center {
+    align-items: center;
+  }
+
+  slot.span {
+    font-size: var(--nile-font-size-micro);
+    margin-top: 14px;
+  }
+
+  .range-container {
+    display: flex;
+    flex-direction: column;
+    gap: var(--nile-spacing-sm);
+  }
+
+  .column-reverse {
+    flex-direction: column-reverse;
+  }
+
+  .label-container {
+    display: flex;
+    justify-content: space-between;
+  }
+
+  .label-container span {
+    margin: var(--nile-spacing-none);
+    padding: var(--nile-spacing-none);
+    font-size: var(--nile-font-size-micro);
+  }
+
+  .range {
+    position: relative;
+    width: 228px;
+    height: 4px;
+    background-color: var(--nile-colors-neutral-400);
+    user-select: none;
+    border-radius: var(--nile-radius-radius-3xl);
+  }
+
+  .range:hover {
+    cursor: pointer;
+  }
+
+  .range-completed {
+    position: absolute;
+    height: 100%;
+    width: 0%;
+    background-color: var(--nile-colors-primary-600);
+    top: 0px;
+    left: 0px;
+    z-index: 98;
+    border-radius: var(--nile-radius-radius-3xl);
+  }
+
+  .range-button {
+    height: 12px;
+    width: 12px;
+    background-color: var(--nile-colors-primary-600);
+    position: absolute;
+    top: 50%;
+    transform: translate(-50%, -50%);
+    border-radius: var(--nile-radius-radius-3xl);
+    left: 0;
+    z-index: 100;
+    box-shadow: rgba(0, 82, 145, 0.1) 0px 1px 2px 0px, rgba(0, 94, 166, 0.15) 0px 0px 0px 2px;
+    transition: box-shadow var(--nile-transition-duration-default) ease;
+  }
+
+  .range-button:hover, .range-button-two:hover {
+    cursor: pointer;
+    background-color: var(--nile-colors-primary-700);
+  }
+
+  .range-button:active, .range-button-two:active {
+    transition: box-shadow var(--nile-transition-duration-default) ease;
+    background-color: var(--nile-colors-primary-700);
+    box-shadow: rgba(0, 82, 145, 0.1) 0px 1px 2px 0px, rgba(0, 94, 166, 0.15) 0px 0px 0px 4px;
+  }
+
+  .range-button-two {
+    height: 12px;
+    width: 12px;
+    background-color: var(--nile-colors-primary-600);
+    position: absolute;
+    top: 50%;
+    transform: translate(-50%, -50%);
+    border-radius: var(--nile-radius-radius-3xl);
+    left: 100%;
+    z-index: 100;
+    box-shadow: rgba(0, 82, 145, 0.1) 0px 1px 2px 0px, rgba(0, 94, 166, 0.15) 0px 0px 0px 2px;
+    transition: box-shadow var(--nile-transition-duration-default) ease;
+  }
+`;
+
+export default [styles];

package/src/nile-slider/nile-slider.template.ts

@@ -0,0 +1,77 @@
+import { TemplateResult, html } from 'lit';
+import NileSlider from './nile-slider';
+import { classMap } from 'lit/directives/class-map.js';
+
+export const rangeSlider = (nileSlider: NileSlider): TemplateResult => {
+  return html`
+    <div>
+      <nile-tooltip
+        content=${nileSlider.rangeOneValue}
+        placement=${nileSlider.tooltipPosition}
+      >
+        <div 
+          id="range-one" 
+          class="range-button"
+          part="range-button"
+          role="slider"
+          tabindex="0"
+          aria-valuemin=${nileSlider.minValue}
+          aria-valuemax=${nileSlider.maxValue}
+          aria-valuenow=${nileSlider.rangeOneValue}
+          aria-label="Minimum value"
+        ></div>
+      </nile-tooltip>
+      <nile-tooltip
+        content=${nileSlider.rangeTwoValue}
+        placement=${nileSlider.tooltipPosition}
+      >
+        <div
+          id="range-two"
+          class="range-button-two"
+          part="range-button-two"
+          role="slider"
+          tabindex="0"
+          aria-valuemin=${nileSlider.minValue}
+          aria-valuemax=${nileSlider.maxValue}
+          aria-valuenow=${nileSlider.rangeTwoValue}
+          aria-label="Maximum value"
+        ></div>
+      </nile-tooltip>
+    </div>
+  `;
+};
+
+export const singleSlider = (nileSlider: NileSlider): TemplateResult => {
+  return html`
+    <div>
+      <nile-tooltip
+        content=${nileSlider.value}
+        placement=${nileSlider.tooltipPosition}
+      >
+        <div 
+          class=${classMap({
+            'range-button': true,
+            'range-button-active': nileSlider.activeThumb === 'one',
+          })} 
+          part="range-button"
+          role="slider"
+          tabindex="0"
+          aria-valuemin=${nileSlider.minValue}
+          aria-valuemax=${nileSlider.maxValue}
+          aria-valuenow=${nileSlider.value}
+          aria-label=${nileSlider.ariaLabel || "Slider value"}
+        ></div>
+      </nile-tooltip>
+    </div>
+  `;
+};
+
+
+export const lableContaier = (nileSlider: NileSlider): TemplateResult => {
+  return html`
+    <div part="label-container" class="label-container">
+      <span id="label-start">${nileSlider.labelStart}</span>
+      <span id="label-end">${nileSlider.labelEnd}</span>
+    </div>
+  `;
+};

package/src/nile-slider/nile-slider.ts

@@ -0,0 +1,215 @@
+/**
+ * Copyright Aquera Inc 2025
+ *
+ * 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 { styles } from './nile-slider.css';
+import NileElement from '../internal/nile-element';
+import { classMap } from 'lit/directives/class-map.js';
+import { html, CSSResultArray, TemplateResult } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { TooltipPosition } from './types/nile-slider.types';
+import { NileSliderEvents } from './types/nile-slider.enums';
+import { rangeSlider, singleSlider, lableContaier } from './nile-slider.template';
+import { 
+  handleSingleSlider, 
+  handleRangeOne, 
+  handleRangeTwo, 
+  getHtmlElements, 
+  removeMoveListeners,
+  valueToPercent,
+  handleTwoThumbClick,
+  addMoveListeners
+} from './utils/nile-slider.utils'
+
+/** 
+ * Nile slider component.
+ *
+ * @tag nile-slider
+ */
+@customElement('nile-slider')
+export class NileSlider extends NileElement {
+  public static get styles(): CSSResultArray {
+    return [styles];
+  }
+
+  @property({ type: Number }) minValue: number = 0;
+  @property({ type: Number }) value: number = this.minValue;
+  @property({ type: Number }) maxValue: number = 100;
+  @property({ type: Number }) rangeOneValue: number = this.minValue;
+  @property({ type: Number }) rangeTwoValue: number = this.maxValue;
+  @property({ type: Boolean}) showLabel: boolean = false;
+  @property({ type: String }) labelStart: string = "";
+  @property({ type: String }) labelEnd: string = "";
+  @property({ type: Boolean}) rangeSlider: boolean = false;
+  @property({ type: String }) labelPosition: string = "top";
+  @property({ type: String }) tooltipPosition: TooltipPosition = "top";
+
+  public buttonOne!: HTMLElement;
+  public buttonTwo!: HTMLElement;
+  public range!: HTMLElement;
+  public completed!: HTMLElement;
+  public activeThumb: 'one' | 'two' | null = null;
+
+  connectedCallback(): void {
+    super.connectedCallback();
+    this.emit(NileSliderEvents.NILE_INIT); 
+
+    if(this.rangeSlider) {
+      this.checkRangeValidity();
+    }
+  }
+
+  firstUpdated(changedProps: Map<string, any>): void {
+    getHtmlElements(this);
+
+    if (!this.rangeSlider && changedProps.has('value')) {
+      this.value = this.checkValueValidity(this.value, this.minValue, this.maxValue);
+      const percent = valueToPercent(this.value, this);
+      
+      this.buttonOne.style.left = `${percent}%`;
+      this.completed.style.width = `${percent}%`;
+    } else if (this.rangeSlider) {
+      
+      const percentOne = valueToPercent(this.rangeOneValue, this);
+      const percentTwo = valueToPercent(this.rangeTwoValue, this);
+      
+      if (this.buttonOne) this.buttonOne.style.left = `${percentOne}%`;
+      if (this.buttonTwo) this.buttonTwo.style.left = `${percentTwo}%`;
+      
+      const left = Math.min(percentOne, percentTwo);
+      const width = Math.abs(percentTwo - percentOne);
+      
+      this.completed.style.left = `${left}%`;
+      this.completed.style.width = `${width}%`;
+    }
+  }
+
+  checkValueValidity(value: number, min: number, max: number): number {
+    if(max - min <= 1) { 
+      return Math.max(min, Math.min(value, max));
+    }
+    return Math.floor(Math.max(min, Math.min(value, max)));
+  }
+
+  checkRangeValidity(): void {
+    if(this.rangeTwoValue > this.maxValue) {
+      this.rangeTwoValue = this.maxValue;
+    } else if(this.rangeTwoValue < this.rangeOneValue) {
+      this.rangeTwoValue = this.rangeOneValue;
+    }
+
+    if(this.rangeOneValue < this.minValue) {
+      this.rangeOneValue = this.minValue;
+    } else if(this.rangeOneValue > this.rangeTwoValue) {
+      this.rangeOneValue = this.rangeTwoValue;
+    }
+  }  
+
+  public onMouseMove = (e: MouseEvent): void => {
+    const rect = this.range.getBoundingClientRect();
+
+    if (!this.rangeSlider) {
+      handleSingleSlider(e, rect, this);
+    } else {
+      if (this.activeThumb === 'one') {
+        handleRangeOne(e, rect, this);
+      } else if (this.activeThumb === 'two') {
+        handleRangeTwo(e, rect, this);
+      }
+
+      const start = valueToPercent(this.rangeOneValue, this);
+      const end = valueToPercent(this.rangeTwoValue, this);
+      const left = Math.min(start, end);
+      const width = Math.abs(end - start);
+
+      if(this.rangeTwoValue >= this.rangeOneValue) {
+        this.completed.style.left = `${left}%`;
+        this.completed.style.width = `${width}%`;
+      }
+    }
+  };
+
+  public onMouseUp = (): void => {
+    if(!this.rangeSlider) this.emit(NileSliderEvents.NILE_CHANGE_END, { value: this.value });
+    else {
+      this.emit(NileSliderEvents.NILE_BUTTON_FIRST_CHANGE_END, { value: this.rangeOneValue });
+      this.emit(NileSliderEvents.NILE_BUTTON_LAST_CHANGE_END, { value: this.rangeTwoValue });
+    }
+    this.activeThumb = null;
+    removeMoveListeners(this);
+  };
+
+  public onMouseDown = (e: MouseEvent): void => {
+    const rect = this.range.getBoundingClientRect();
+    const clickX = e.clientX - rect.left;
+    const percent = (clickX / rect.width) * 100;
+    const value = this.minValue + (percent / 100) * (this.maxValue - this.minValue);
+  
+    if (!this.rangeSlider) {
+      handleSingleSlider(e, rect, this);
+      this.activeThumb = 'one';
+      addMoveListeners(this);
+    } else {
+      handleTwoThumbClick(value, this);
+      const distToOne = Math.abs(value - this.rangeOneValue);
+      const distToTwo = Math.abs(value - this.rangeTwoValue);
+      this.activeThumb = distToOne <= distToTwo ? 'one' : 'two';
+      addMoveListeners(this);
+    }
+  };
+
+  public render(): TemplateResult {
+    const hasLabels = this.showLabel;
+    const ariaLabelledby = hasLabels ? 'label-start label-end' : undefined;
+  
+    return html`
+      <div
+        part="base"
+        class=${classMap({
+          'container': true,
+          'align-item-center': !hasLabels
+        })}
+      >
+        <slot class="span" name="prefix"></slot>
+  
+        <div
+          part="range-container"
+          class=${classMap({
+            'range-container': true,
+            'column-reverse': this.labelPosition === 'bottom'
+          })}
+        >
+          ${hasLabels ? lableContaier(this) : html``}
+  
+          <div
+            class="range"
+            part="range"
+            role="group"
+            aria-labelledby=${ariaLabelledby}
+          >
+            <span class="range-completed" part="range-completed"></span>
+            ${this.rangeSlider ? rangeSlider(this) : singleSlider(this)}
+          </div>
+        </div>
+  
+        <slot class="span" name="suffix"></slot>
+      </div>
+    `;
+  }  
+
+  disconnectedCallback(): void {
+    super.disconnectedCallback();
+    this.emit(NileSliderEvents.NILE_DESTROY);
+  }
+}
+
+export default NileSlider;
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'nile-slider': NileSlider;
+  }
+}

package/src/nile-slider/types/nile-slider.enums.ts

@@ -0,0 +1,10 @@
+export const enum NileSliderEvents {
+  NILE_INIT = "nile-init",
+  NILE_CHANGE = "nile-change",
+  NILE_CHANGE_END = "nile-change-end",
+  NILE_BUTTON_FIRST_CHANGE = "nile-button-first-change",
+  NILE_BUTTON_LAST_CHANGE =  "nile-button-last-change",
+  NILE_BUTTON_FIRST_CHANGE_END = "nile-button-first-change-end",
+  NILE_BUTTON_LAST_CHANGE_END =  "nile-button-last-change-end",
+  NILE_DESTROY = "nile-destroy", 
+}

package/src/nile-slider/types/nile-slider.types.ts

@@ -0,0 +1,13 @@
+export type TooltipPosition =
+  | 'top'
+  | 'top-start'
+  | 'top-end'
+  | 'right'
+  | 'right-start'
+  | 'right-end'
+  | 'bottom'
+  | 'bottom-start'
+  | 'bottom-end'
+  | 'left'
+  | 'left-start'
+  | 'left-end';