@aquera/nile-elements 1.6.1 → 1.6.2

package/src/nile-otp-input/nile-otp-input.ts

@@ -0,0 +1,835 @@
+/**
+ * Copyright Aquera Inc 2026
+ *
+ * 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 { html } from 'lit';
+import {
+  customElement,
+  property,
+  query,
+  queryAll,
+  state,
+} from 'lit/decorators.js';
+import { classMap } from 'lit/directives/class-map.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { live } from 'lit/directives/live.js';
+import { defaultValue } from '../internal/default-value';
+import { FormControlController, validValidityState } from '../internal/form';
+import { HasSlotController } from '../internal/slot';
+import { watch } from '../internal/watch';
+import NileElement from '../internal/nile-element';
+import { KeyCode, Nile_Events } from '../internal/enum';
+import type { CSSResultGroup } from 'lit';
+import type { NileFormControl } from '../internal/nile-element';
+import { styles } from './nile-otp-input.css';
+import {
+  OtpInputMode,
+  OtpInputType,
+  OtpEnterKeyHint,
+  OtpAutoComplete,
+  OtpCellPattern,
+} from './nile-otp-input.enum';
+import '../nile-form-help-text';
+import '../nile-form-error-message';
+
+/**
+ * @summary OTP input renders a segmented set of cells but behaves like a single logical form control.
+ * @tag nile-otp-input
+ *
+ * @slot label - The input label. Alternatively, use the `label` attribute.
+ * @slot help-text - Helpful guidance text. Alternatively, use the `help-text` attribute.
+ *
+ * @event nile-input - Emitted whenever the OTP value changes from user input.
+ * @event nile-change - Emitted whenever the OTP value changes from user input.
+ * @event nile-complete - Emitted when all OTP cells are filled.
+ * @event nile-focus - Emitted when focus enters the component.
+ * @event nile-blur - Emitted when focus leaves the component.
+ * @event nile-paste - Emitted when OTP text is pasted.
+ * @event nile-invalid - Emitted when the control is invalid.
+ *
+ * @csspart form-control - Wrapper for label, input, and help/error content.
+ * @csspart form-control-label - Label wrapper.
+ * @csspart form-control-input - Input wrapper.
+ * @csspart form-control-help-text - Help text wrapper.
+ * @csspart form-control-error-message - Error message wrapper.
+ * @csspart base - OTP cell container.
+ * @csspart cell - Individual OTP cell.
+ * @csspart separator - Separator element between cell groups.
+ */
+@customElement('nile-otp-input')
+export class NileOtpInput extends NileElement implements NileFormControl {
+  static styles: CSSResultGroup = styles;
+
+  private readonly formControlController: FormControlController =
+    new FormControlController(this, {
+      assumeInteractionOn: [Nile_Events.NILE_BLUR, Nile_Events.NILE_INPUT],
+    });
+
+  private readonly hasSlotController = new HasSlotController(
+    this,
+    'help-text',
+    'label'
+  );
+
+  private customValidationMessage = '';
+  private wasComplete = false;
+
+  @query('.otp__value-input') valueInput: HTMLInputElement;
+  @queryAll('.otp__cell') cellInputs: NodeListOf<HTMLInputElement>;
+
+  @state() private hasFocus = false;
+  @state() private activeIndex = -1;
+  @state() private cells: string[] = this.createCells('');
+
+  /** The name of the input, submitted as a name/value pair with form data. */
+  @property({ reflect: true, type: String, attribute: true }) name = '';
+
+  /** The current value of the OTP control. */
+  @property({ reflect: true, type: String, attribute: true }) value = '';
+
+  /** The default value of the form control. Primarily used for resetting the form control. */
+  @defaultValue() defaultValue = '';
+
+  /** Number of OTP cells. Values below 4 are clamped to 4. */
+  @property({ type: Number, reflect: true, attribute: true }) length = 6;
+
+  /** Restricts input to numeric digits when true. Overridden by `alphanumeric`. */
+  @property({ type: Boolean, reflect: true, attribute: true }) numericOnly = true;
+
+  /** Allows both letters and digits. When present, overrides `numeric-only`. */
+  @property({ type: Boolean, reflect: true, attribute: true }) alphanumeric = false;
+
+  /** The input's label. */
+  @property({ reflect: true, attribute: true, type: String }) label = '';
+
+  @property({ attribute: true, reflect: true, type: String }) helpText = '';
+
+  @property({ attribute: true, reflect: true, type: String }) errorMessage = '';
+
+  /** Placeholder shown inside each OTP cell. */
+  @property({ reflect: true, attribute: true, type: String }) placeholder = '';
+
+  /** Optional separator text rendered between configured OTP groups (for example "-"). */
+  @property({ reflect: true, type: String }) separator = '';
+
+  /** Renders a separator after each N cells when `separator` is set. */
+  @property({ type: Number, attribute: true, reflect: true }) separatorEvery = 0;
+
+  /** Comma-separated zero-based cell indexes after which separators are rendered. */
+  @property({ attribute: 'separator-positions', type: String, reflect: true }) separatorPositions = '';
+
+  /** Masks filled cells with dots, showing each character briefly while typing. */
+  @property({ type: Boolean, reflect: true }) masked = false;
+
+  /** Sets the input to a warning state, changing its visual appearance. */
+  @property({ type: Boolean, attribute: true, reflect: true }) warning = false;
+
+  /** Sets the input to an error state, changing its visual appearance. */
+  @property({ type: Boolean, attribute: true, reflect: true }) error = false;
+
+  /** Sets the input to a success state, changing its visual appearance. */
+  @property({ type: Boolean, attribute: true, reflect: true }) success = false;
+
+  /** Disables the control. */
+  @property({ type: Boolean, reflect: true, attribute: true }) disabled = false;
+
+  /** Makes the control readonly. */
+  @property({ type: Boolean, attribute: true, reflect: true }) readonly = false;
+
+  /**
+   * 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`.
+   */
+  @property({ reflect: true, attribute: true, type: String }) form = '';
+
+  /** Makes this field required. */
+  @property({ type: Boolean, reflect: true, attribute: true }) required = false;
+
+  /** Optional regex pattern for full OTP validation. */
+  @property({ reflect: true, attribute: true, type: String }) pattern: string;
+
+  /** Indicates that the input should receive focus on page load. */
+  @property({ type: Boolean, reflect: true, attribute: true }) autofocus = false;
+
+  /** Controls keyboard type shown on supporting virtual keyboards. */
+  @property({ reflect: true, attribute: true, type: String }) inputmode:
+    | 'none'
+    | 'text'
+    | 'decimal'
+    | 'numeric'
+    | 'tel'
+    | 'search'
+    | 'email'
+    | 'url';
+
+  /** The autocomplete mode used on the first OTP cell. */
+  @property({ reflect: true, type: String }) autocomplete: string = OtpAutoComplete.ONE_TIME_CODE;
+
+  connectedCallback() {
+    super.connectedCallback();
+    this.emit(Nile_Events.NILE_INIT);
+  }
+
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.emit(Nile_Events.NILE_DESTROY);
+  }
+
+  firstUpdated() {
+    const normalized = this.normalizeValue(this.value);
+    if (normalized !== this.value) {
+      this.value = normalized;
+      return;
+    }
+
+    this.syncCellsFromValue(normalized);
+    this.wasComplete = this.isComplete(normalized);
+    this.valueInput.setCustomValidity(this.customValidationMessage);
+    this.formControlController.updateValidity();
+
+    if (this.autofocus) {
+      this.focus();
+    }
+  }
+
+  /** Gets the validity state object. */
+  get validity() {
+    return this.valueInput?.validity ?? validValidityState;
+  }
+
+  /** Gets the validation message. */
+  get validationMessage() {
+    return this.valueInput?.validationMessage ?? '';
+  }
+
+  /** Returns true when all OTP cells have values. */
+  get complete() {
+    return this.isComplete(this.value);
+  }
+
+  private getNormalizedLength() {
+    const parsed = Number.isFinite(this.length) ? Math.trunc(this.length) : 6;
+    return Math.max(4, parsed);
+  }
+
+  private isNumericMode() {
+    return this.numericOnly && !this.alphanumeric;
+  }
+
+  private getResolvedInputMode() {
+    return this.inputmode ?? (this.isNumericMode() ? OtpInputMode.NUMERIC : OtpInputMode.TEXT);
+  }
+
+  private getValidationPattern() {
+    if (this.pattern) {
+      return this.pattern;
+    }
+
+    const normalizedLength = this.getNormalizedLength();
+    return this.isNumericMode()
+      ? `[0-9]{${normalizedLength}}`
+      : `[A-Za-z0-9]{${normalizedLength}}`;
+  }
+
+  private isAllowedCharacter(char: string) {
+    return this.isNumericMode() ? /^[0-9]$/.test(char) : /^[A-Za-z0-9]$/.test(char);
+  }
+
+  private toOtpCharacters(value: string) {
+    return Array.from(value ?? '').filter(char =>
+      this.isAllowedCharacter(char)
+    );
+  }
+
+  private normalizeValue(value: string) {
+    return this.toOtpCharacters(value ?? '')
+      .slice(0, this.getNormalizedLength())
+      .join('');
+  }
+
+  private createCells(value: string) {
+    const normalizedLength = this.getNormalizedLength();
+    const normalizedChars = this.toOtpCharacters(value).slice(
+      0,
+      normalizedLength
+    );
+    return Array.from(
+      { length: normalizedLength },
+      (_, index) => normalizedChars[index] ?? ''
+    );
+  }
+
+  private syncCellsFromValue(value: string) {
+    this.cells = this.createCells(value);
+  }
+
+  private isComplete(value: string) {
+    return value.length === this.getNormalizedLength();
+  }
+
+  private getFirstEmptyIndex() {
+    const index = this.cells.findIndex(char => char === '');
+    return index === -1 ? this.getNormalizedLength() - 1 : index;
+  }
+
+  private getSeparatorIndices() {
+    const maxIndex = this.getNormalizedLength() - 2;
+    const indices = new Set<number>();
+
+    if (Number.isInteger(this.separatorEvery) && this.separatorEvery > 0) {
+      for (
+        let index = this.separatorEvery - 1;
+        index <= maxIndex;
+        index += this.separatorEvery
+      ) {
+        indices.add(index);
+      }
+    }
+
+    if (this.separatorPositions.trim().length > 0) {
+      this.separatorPositions
+        .split(',')
+        .map(value => Number.parseInt(value.trim(), 10))
+        .filter(
+          index => Number.isInteger(index) && index >= 0 && index <= maxIndex
+        )
+        .forEach(index => indices.add(index));
+    }
+
+    return indices;
+  }
+
+  private getCellPlaceholder(index: number) {
+    if (!this.placeholder || this.cells[index]) {
+      return undefined;
+    }
+
+    if (this.activeIndex === -1) {
+      return index === this.getFirstEmptyIndex() ? this.placeholder : undefined;
+    }
+
+    return index === this.activeIndex ? this.placeholder : undefined;
+  }
+
+  private focusCell(index: number, options?: FocusOptions) {
+    const input = this.cellInputs?.[index];
+    if (input) {
+      input.focus(options);
+      input.select();
+    }
+  }
+
+  private updateCell(index: number, value: string) {
+    const nextCells = [...this.cells];
+    nextCells[index] = value;
+    this.cells = nextCells;
+  }
+
+  private fillFromIndex(startIndex: number, chars: string[]) {
+    const nextCells = [...this.cells];
+    let cursor = startIndex;
+
+    for (const char of chars) {
+      if (cursor >= nextCells.length) {
+        break;
+      }
+
+      nextCells[cursor] = char;
+      cursor += 1;
+    }
+
+    this.cells = nextCells;
+    return cursor;
+  }
+
+  private commitUserValueUpdate() {
+    const previousValue = this.value;
+    const nextValue = this.cells.join('');
+    const isNowComplete = this.isComplete(nextValue);
+
+    this.value = nextValue;
+    this.valueInput.value = nextValue;
+    this.valueInput.setCustomValidity(this.customValidationMessage);
+    this.formControlController.updateValidity();
+
+    this.emit(Nile_Events.NILE_INPUT, { value: nextValue, complete: isNowComplete });
+    if (previousValue !== nextValue) {
+      this.emit(Nile_Events.NILE_CHANGE, { value: nextValue, complete: isNowComplete });
+    }
+
+    if (isNowComplete && !this.wasComplete) {
+      this.emit(Nile_Events.NILE_COMPLETE, { value: nextValue });
+    }
+
+    this.wasComplete = isNowComplete;
+  }
+
+  private handleInvalid(event: Event) {
+    this.formControlController.setValidity(false);
+    this.formControlController.emitInvalidEvent(event);
+  }
+
+  private handleCellFocus(event: Event) {
+    const target = event.target as HTMLInputElement;
+    const index = Number(target.dataset.index ?? -1);
+    const firstEmpty = this.getFirstEmptyIndex();
+
+    if (index > firstEmpty) {
+      this.focusCell(firstEmpty);
+      return;
+    }
+
+    if (index < firstEmpty && !this.cells[index]) {
+      this.focusCell(firstEmpty);
+      return;
+    }
+
+    this.activeIndex = index;
+    target.select();
+
+    if (!this.hasFocus) {
+      this.hasFocus = true;
+      this.emit(Nile_Events.NILE_FOCUS, { value: this.value });
+    }
+  }
+
+  private handleCellBlur() {
+    queueMicrotask(() => {
+      const active = this.shadowRoot?.activeElement;
+      const isInsideOtp =
+        active instanceof HTMLInputElement &&
+        active.classList.contains('otp__cell');
+
+      if (!isInsideOtp && this.hasFocus) {
+        this.hasFocus = false;
+        this.activeIndex = -1;
+        this.emit(Nile_Events.NILE_BLUR, { value: this.value });
+      }
+    });
+  }
+
+  private handleCellInput(event: Event) {
+    const target = event.target as HTMLInputElement;
+    const index = Number(target.dataset.index ?? 0);
+
+    if (this.disabled || this.readonly) {
+      target.value = this.cells[index] ?? '';
+      return;
+    }
+
+    const chars = this.toOtpCharacters(target.value);
+
+    if (chars.length === 0) {
+      this.updateCell(index, '');
+      this.commitUserValueUpdate();
+      return;
+    }
+
+    if (chars.length === 1) {
+      this.updateCell(index, chars[0]);
+      this.commitUserValueUpdate();
+
+      const nextEmpty = this.getFirstEmptyIndex();
+      this.focusCell(nextEmpty);
+      return;
+    }
+
+    const nextCursor = this.fillFromIndex(index, chars);
+    this.commitUserValueUpdate();
+    const nextEmpty = this.getFirstEmptyIndex();
+    this.focusCell(nextEmpty);
+  }
+
+  private handleCellPaste(event: ClipboardEvent) {
+    if (this.disabled || this.readonly) {
+      return;
+    }
+
+    const pasted = event.clipboardData?.getData('text') ?? '';
+    const chars = this.toOtpCharacters(pasted);
+
+    if (!chars.length) {
+      return;
+    }
+
+    event.preventDefault();
+
+    this.fillFromIndex(0, chars);
+    this.commitUserValueUpdate();
+    const nextEmpty = this.getFirstEmptyIndex();
+    this.focusCell(nextEmpty);
+    this.emit(Nile_Events.NILE_PASTE, { value: this.value });
+  }
+
+  private handleCellKeyDown(event: KeyboardEvent) {
+    const hasModifier = event.metaKey || event.ctrlKey || event.altKey;
+    const target = event.target as HTMLInputElement;
+    const index = Number(target.dataset.index ?? 0);
+
+    if (event.key === KeyCode.ENTER && !hasModifier && !event.shiftKey) {
+      setTimeout(() => {
+        if (!event.defaultPrevented && !event.isComposing) {
+          this.formControlController.submit();
+        }
+      });
+      return;
+    }
+
+    if (this.disabled || this.readonly) {
+      return;
+    }
+
+    const isHandledKey =
+      event.key === KeyCode.BACKSPACE ||
+      event.key === KeyCode.DELETE ||
+      event.key === KeyCode.ARROW_LEFT ||
+      event.key === KeyCode.ARROW_RIGHT ||
+      event.key === KeyCode.HOME ||
+      event.key === KeyCode.END ||
+      event.key === KeyCode.SPACE ||
+      (event.key.length === 1 && !hasModifier);
+
+    if (!isHandledKey) {
+      return;
+    }
+
+    event.preventDefault();
+
+    if (event.key === KeyCode.BACKSPACE) {
+      if (this.cells[index]) {
+        this.updateCell(index, '');
+        this.commitUserValueUpdate();
+        if (index > 0) {
+          this.focusCell(index - 1);
+        }
+        return;
+      }
+
+      if (index > 0) {
+        this.updateCell(index - 1, '');
+        this.commitUserValueUpdate();
+        this.focusCell(index - 1);
+      }
+
+      return;
+    }
+
+    if (event.key === KeyCode.DELETE) {
+      if (this.cells[index]) {
+        this.updateCell(index, '');
+        this.commitUserValueUpdate();
+      }
+      return;
+    }
+
+    if (event.key === KeyCode.ARROW_LEFT) {
+      if (index > 0) {
+        this.focusCell(index - 1);
+      }
+      return;
+    }
+
+    if (event.key === KeyCode.ARROW_RIGHT) {
+      const firstEmpty = this.getFirstEmptyIndex();
+      if (index < firstEmpty) {
+        this.focusCell(index + 1);
+      }
+      return;
+    }
+
+    if (event.key === KeyCode.HOME) {
+      this.focusCell(0);
+      return;
+    }
+
+    if (event.key === KeyCode.END) {
+      this.focusCell(this.getFirstEmptyIndex());
+      return;
+    }
+
+    if (event.key === KeyCode.SPACE) {
+      return;
+    }
+
+    if (event.key.length === 1 && !hasModifier && this.isAllowedCharacter(event.key)) {
+      this.updateCell(index, event.key);
+      this.commitUserValueUpdate();
+      const nextEmpty = this.getFirstEmptyIndex();
+      this.focusCell(nextEmpty);
+    }
+  }
+
+  @watch('length', { waitUntilFirstUpdate: true })
+  handleLengthChange() {
+    const normalizedLength = this.getNormalizedLength();
+    if (this.length !== normalizedLength) {
+      this.length = normalizedLength;
+      return;
+    }
+
+    const normalizedValue = this.normalizeValue(this.value);
+    this.syncCellsFromValue(normalizedValue);
+
+    if (normalizedValue !== this.value) {
+      this.value = normalizedValue;
+      return;
+    }
+
+    this.wasComplete = this.isComplete(normalizedValue);
+    this.valueInput.value = normalizedValue;
+    this.valueInput.setCustomValidity(this.customValidationMessage);
+    this.formControlController.updateValidity();
+  }
+
+  @watch('value', { waitUntilFirstUpdate: true })
+  handleValueChange() {
+    const normalizedValue = this.normalizeValue(this.value);
+    if (normalizedValue !== this.value) {
+      this.value = normalizedValue;
+      return;
+    }
+
+    this.syncCellsFromValue(normalizedValue);
+    this.wasComplete = this.isComplete(normalizedValue);
+    this.valueInput.value = normalizedValue;
+    this.valueInput.setCustomValidity(this.customValidationMessage);
+    this.formControlController.updateValidity();
+  }
+
+  @watch('disabled', { waitUntilFirstUpdate: true })
+  handleDisabledChange() {
+    if (this.disabled) {
+      this.hasFocus = false;
+      this.activeIndex = -1;
+      this.formControlController.setValidity(true);
+    } else {
+      this.formControlController.updateValidity();
+    }
+  }
+
+  @watch('numericOnly', { waitUntilFirstUpdate: true })
+  handleNumericOnlyChange() {
+    const normalizedValue = this.normalizeValue(this.value);
+    if (normalizedValue !== this.value) {
+      this.value = normalizedValue;
+      return;
+    }
+
+    this.syncCellsFromValue(normalizedValue);
+    this.wasComplete = this.isComplete(normalizedValue);
+    this.valueInput.value = normalizedValue;
+    this.valueInput.setCustomValidity(this.customValidationMessage);
+    this.formControlController.updateValidity();
+  }
+
+  @watch('pattern', { waitUntilFirstUpdate: true })
+  handlePatternChange() {
+    this.valueInput.setCustomValidity(this.customValidationMessage);
+    this.formControlController.updateValidity();
+  }
+
+  /** Checks validity without showing browser UI. */
+  checkValidity() {
+    return this.valueInput.checkValidity();
+  }
+
+  /** Returns associated form if one exists. */
+  getForm(): HTMLFormElement | null {
+    return this.formControlController.getForm();
+  }
+
+  /** Checks validity and shows browser UI when invalid. */
+  reportValidity() {
+    return this.valueInput.reportValidity();
+  }
+
+  /** Sets a custom validation message. Pass empty string to restore validity. */
+  setCustomValidity(message: string) {
+    this.customValidationMessage = message;
+    if (this.valueInput) {
+      this.valueInput.setCustomValidity(message);
+    }
+    this.formControlController.updateValidity();
+  }
+
+  /** Focuses the first empty cell, or the last one when complete. */
+  focus(options?: FocusOptions) {
+    this.focusCell(this.getFirstEmptyIndex(), options);
+  }
+
+  /** Removes focus from whichever OTP cell is currently focused. */
+  blur() {
+    const active = this.shadowRoot?.activeElement;
+    if (active instanceof HTMLElement) {
+      active.blur();
+    }
+  }
+
+  /** Clears all OTP cells. */
+  clear() {
+    if (this.disabled || this.readonly) {
+      return;
+    }
+
+    this.cells = Array.from({ length: this.getNormalizedLength() }, () => '');
+    this.commitUserValueUpdate();
+    this.focusCell(0);
+  }
+
+  render() {
+    const normalizedLength = this.getNormalizedLength();
+    const separatorIndices = this.getSeparatorIndices();
+    const hasLabelSlot = this.hasSlotController.test('label');
+    const hasHelpTextSlot = this.hasSlotController.test('help-text');
+    const hasLabel = Boolean(this.label || hasLabelSlot);
+    const hasHelpText = Boolean(this.helpText || hasHelpTextSlot);
+    const hasErrorMessage = Boolean(this.errorMessage);
+    const describedBy = [
+      hasHelpText ? 'help-text' : '',
+      hasErrorMessage ? 'error-message' : '',
+    ]
+      .filter(Boolean)
+      .join(' ');
+
+    return html`
+      <div
+        part="form-control"
+        class=${classMap({
+          'form-control': true,
+          'form-control--has-label': hasLabel,
+        })}
+      >
+        <label
+          id="label"
+          part="form-control-label"
+          class="form-control__label"
+          aria-hidden=${hasLabel ? 'false' : 'true'}
+        >
+          <slot name="label">${this.label}</slot>
+        </label>
+
+        <div part="form-control-input" class="form-control-input">
+          <div
+            part="base"
+            class=${classMap({
+              otp: true,
+              'otp--warning': this.warning,
+              'otp--error': this.error,
+              'otp--success': this.success,
+              'otp--disabled': this.disabled,
+              'otp--readonly': this.readonly,
+            })}
+            role="group"
+            aria-labelledby=${ifDefined(hasLabel ? 'label' : undefined)}
+            aria-label=${ifDefined(hasLabel ? undefined : 'One-time password')}
+            aria-describedby=${ifDefined(describedBy || undefined)}
+            aria-disabled=${this.disabled ? 'true' : 'false'}
+          >
+            ${Array.from({ length: normalizedLength }, (_, index) => {
+              const value = this.cells[index] ?? '';
+              return html`
+                <input
+                  part="cell"
+                  class=${classMap({
+                    otp__cell: true,
+                    'otp__cell--active': this.activeIndex === index,
+                  })}
+                  data-index=${index}
+                  type=${this.masked && value && this.activeIndex !== index ? OtpInputType.PASSWORD : OtpInputType.TEXT}
+                  maxlength="1"
+                  .value=${live(value)}
+                  ?disabled=${this.disabled}
+                  ?readonly=${this.readonly}
+                  placeholder=${ifDefined(this.getCellPlaceholder(index))}
+                  inputmode=${ifDefined(this.getResolvedInputMode())}
+                  pattern=${this.isNumericMode() ? OtpCellPattern.NUMERIC : OtpCellPattern.ALPHANUMERIC}
+                  autocapitalize="none"
+                  autocorrect="off"
+                  spellcheck="false"
+                  autocomplete=${index === 0 ? this.autocomplete : OtpAutoComplete.OFF}
+                  enterkeyhint=${index === normalizedLength - 1
+                    ? OtpEnterKeyHint.DONE
+                    : OtpEnterKeyHint.NEXT}
+                  aria-label=${`Digit ${index + 1} of ${normalizedLength}`}
+                  aria-describedby=${ifDefined(describedBy || undefined)}
+                  aria-invalid=${this.hasAttribute('data-user-invalid')
+                    ? 'true'
+                    : 'false'}
+                  @focus=${this.handleCellFocus}
+                  @blur=${this.handleCellBlur}
+                  @keydown=${this.handleCellKeyDown}
+                  @input=${this.handleCellInput}
+                  @paste=${this.handleCellPaste}
+                />
+                ${this.separator && separatorIndices.has(index)
+                  ? html`
+                      <span
+                        class="otp__separator"
+                        part="separator"
+                        aria-hidden="true"
+                      >
+                        ${this.separator}
+                      </span>
+                    `
+                  : ''}
+              `;
+            })}
+
+            <input
+              class="otp__value-input"
+              type="text"
+              .value=${live(this.value)}
+              ?required=${this.required}
+              ?disabled=${this.disabled}
+              minlength=${normalizedLength}
+              maxlength=${normalizedLength}
+              pattern=${this.getValidationPattern()}
+              tabindex="-1"
+              aria-hidden="true"
+              @focus=${() => this.focus()}
+              @invalid=${this.handleInvalid}
+            />
+          </div>
+        </div>
+
+        ${hasHelpText
+          ? html`
+              <div
+                id="help-text"
+                part="form-control-help-text"
+                class="form-control__help-text"
+              >
+                <nile-form-help-text>
+                  <slot name="help-text">${this.helpText}</slot>
+                </nile-form-help-text>
+              </div>
+            `
+          : ``}
+        ${hasErrorMessage
+          ? html`
+              <div
+                id="error-message"
+                part="form-control-error-message"
+                class="form-control__error-message"
+              >
+                <nile-form-error-message
+                  >${this.errorMessage}</nile-form-error-message
+                >
+              </div>
+            `
+          : ``}
+      </div>
+    `;
+  }
+}
+
+export default NileOtpInput;
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'nile-otp-input': NileOtpInput;
+  }
+}