Skip to content

Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.

Rust
11.8 KB
Raw Blame
// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
'use strict';
// A combobox is a text field with a filtered option list. It replaces native <select> menus so
// long lists of routes, endpoints, and models can be searched. A strict combobox keeps a value
// from its list, like a <select>. A free combobox keeps any typed text and offers the list as
// suggestions, which model ID fields need because endpoints accept unlisted IDs.

// This function returns a score and the matched character positions when every query
// character appears in `text` in order. Substring matches rank above scattered matches.
function fuzzyMatch(query, text) {
  const q = query.toLowerCase(), t = text.toLowerCase();
  const boundary = index => index === 0 || /[^a-z0-9]/.test(t[index - 1]);
  const at = t.indexOf(q);
  if (at >= 0) return {score: 1000 + (boundary(at) ? 300 : 0) - at - t.length / 100, positions: Array.from(q, (_, i) => at + i)};
  let best = null;
  for (let start = t.indexOf(q[0]); start >= 0; start = t.indexOf(q[0], start + 1)) {
    const positions = [start];
    for (let i = 1, j = start + 1; i < q.length; i++, j++) {
      j = t.indexOf(q[i], j);
      if (j < 0) break;
      positions.push(j);
    }
    // A later start leaves fewer characters, so it cannot match when this one failed.
    if (positions.length !== q.length) break;
    let score = 500 - start / 10;
    positions.forEach((p, i) => {
      if (i) score += p === positions[i - 1] + 1 ? 15 : -Math.min(p - positions[i - 1], 10);
      if (boundary(p)) score += 10;
    });
    if (!best || score > best.score) best = {score, positions};
  }
  return best;
}

// Every whitespace-separated token must match the label or the option's other search text.
// Label matches rank higher and are the only ones highlighted.
function rankOptions(options, query) {
  const tokens = query.trim().split(/\s+/).filter(Boolean);
  if (!tokens.length) return options.map(option => ({option, positions: []}));
  const ranked = [];
  options.forEach((option, index) => {
    let score = 0;
    const positions = new Set();
    for (const token of tokens) {
      const label = fuzzyMatch(token, option.label), other = fuzzyMatch(token, option.search);
      if (!label && !other) return;
      if (label && (!other || label.score * 1.5 >= other.score)) {
        score += label.score * 1.5;
        label.positions.forEach(p => positions.add(p));
      } else score += other.score;
    }
    ranked.push({option, positions: [...positions], score, index});
  });
  return ranked.sort((a, b) => b.score - a.score || a.index - b.index);
}

// Options are [value, label, detail, keywords] arrays. Only value is required.
function comboboxOption(option) {
  const [value, label = value, detail = '', keywords = ''] = option;
  return {value: String(value), label: String(label), detail: detail || '', search: [value, detail, keywords].filter(Boolean).join(' ')};
}

let comboboxCount = 0;
// This function returns the text input. Its `host` property holds the element to insert into
// the page, and `setOptions` replaces the list. A strict combobox reports the chosen option's
// value through `value` and fires `change` only when that value changes.
function combobox(options, chosen, {free = false, mono = false, placeholder = '', limit = 200} = {}) {
  const id = `combobox-${++comboboxCount}`;
  // The strict field replaces `value`, so it reads and writes its visible text through the prototype.
  const nativeInputValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value');
  const host = document.createElement('div');
  host.className = `combobox${mono ? ' mono' : ''}${free ? ' free' : ''}`;
  const input = document.createElement('input');
  Object.assign(input, {type: 'text', autocomplete: 'off', spellcheck: false, placeholder});
  for (const [name, value] of [['role', 'combobox'], ['aria-autocomplete', 'list'], ['aria-expanded', 'false'], ['aria-controls', `${id}-list`], ['autocapitalize', 'off']]) input.setAttribute(name, value);
  const toggle = document.createElement('button');
  Object.assign(toggle, {type: 'button', tabIndex: -1, className: 'combobox-toggle'});
  toggle.setAttribute('aria-hidden', 'true');
  const list = document.createElement('div');
  Object.assign(list, {id: `${id}-list`, className: 'combobox-list', hidden: true});
  list.setAttribute('role', 'listbox');
  host.append(input, toggle, list);

  let source = [], items = [], selected = '', shown = [], active = -1, query = '';
  const typed = () => nativeInputValue.get.call(input);
  const current = () => free ? typed() : selected;
  const show = value => nativeInputValue.set.call(input, free ? value : items.find(item => item.value === value)?.label ?? value);
  function setOptions(next) {
    source = next;
    items = next.map(comboboxOption);
    if (!free && selected && !items.some(item => item.value === selected)) items.push({value: selected, label: selected, detail: 'Unavailable in current data', search: selected});
    if (!list.hidden) render();
  }
  function note(text) {
    const row = document.createElement('p');
    row.className = 'combobox-note';
    row.textContent = text;
    list.append(row);
  }
  function activate(index, scroll = true) {
    list.querySelector('.active')?.classList.remove('active');
    active = index;
    const row = index >= 0 ? list.querySelector(`#${id}-option-${index}`) : null;
    if (!row) { input.removeAttribute('aria-activedescendant'); return; }
    row.classList.add('active');
    input.setAttribute('aria-activedescendant', row.id);
    if (scroll) row.scrollIntoView?.({block: 'nearest'});
  }
  function render() {
    const ranked = rankOptions(items, query);
    shown = ranked.slice(0, limit);
    list.replaceChildren();
    const custom = free && query.trim() && !items.some(item => item.value === query.trim());
    if (custom) note(`Uses “${query.trim()}” as typed, or choose a suggestion.`);
    shown.forEach(({option, positions}, index) => {
      const row = document.createElement('div');
      row.id = `${id}-option-${index}`;
      row.className = 'combobox-option';
      row.setAttribute('role', 'option');
      row.setAttribute('aria-selected', String(option.value === current()));
      const label = document.createElement('span');
      label.className = 'combobox-label';
      const marked = new Set(positions);
      let run = '', highlighted = false;
      const flush = () => { if (!run) return; if (highlighted) { const mark = document.createElement('mark'); mark.textContent = run; label.append(mark); } else label.append(run); run = ''; };
      [...option.label].forEach((character, index) => { if (marked.has(index) !== highlighted) { flush(); highlighted = !highlighted; } run += character; });
      flush();
      row.append(label);
      if (option.detail) { const detail = document.createElement('small'); detail.textContent = option.detail; row.append(detail); }
      row.onmousedown = event => event.preventDefault();
      row.onclick = () => commit(option.value);
      row.onmousemove = () => { if (active !== index) activate(index, false); };
      list.append(row);
    });
    if (!shown.length && !custom) note(items.length ? 'No matches. Try fewer letters.' : free ? 'No suggestions loaded. Type an ID.' : 'No options available.');
    if (ranked.length > shown.length) note(`Showing ${shown.length} of ${ranked.length}. Keep typing to narrow the list.`);
    // Typed text in a free field stays the value until the user picks a suggestion.
    const selectedIndex = shown.findIndex(entry => entry.option.value === current());
    activate(query ? (free || !shown.length ? -1 : 0) : selectedIndex, false);
  }
  // The list opens below the field unless the nearest scrolling container has more room above.
  function place() {
    const box = input.getBoundingClientRect();
    let top = 0, bottom = window.innerHeight;
    for (let parent = host.parentElement; parent && parent !== document.body; parent = parent.parentElement) {
      if (!['auto', 'scroll'].includes(getComputedStyle(parent).overflowY)) continue;
      const bounds = parent.getBoundingClientRect();
      top = Math.max(top, bounds.top);
      bottom = Math.min(bottom, bounds.bottom);
      break;
    }
    const below = bottom - box.bottom - 12, above = box.top - top - 12, upward = below < 200 && above > below;
    host.dataset.placement = upward ? 'top' : 'bottom';
    list.style.maxHeight = `${Math.round(Math.max(120, Math.min(320, upward ? above : below)))}px`;
  }
  function open() {
    if (input.disabled || (free && !items.length)) return;
    if (list.hidden) {
      list.hidden = false;
      input.setAttribute('aria-expanded', 'true');
      host.dataset.open = 'true';
    }
    render();
    place();
    if (active >= 0) list.querySelector(`#${id}-option-${active}`)?.scrollIntoView?.({block: 'nearest'});
  }
  function close() {
    list.hidden = true;
    input.setAttribute('aria-expanded', 'false');
    delete host.dataset.open;
    input.removeAttribute('aria-activedescendant');
    query = '';
    active = -1;
    // A focused strict field keeps its label selected so typing starts a new search.
    if (!free && document.activeElement === input) input.select();
  }
  function revert() {
    if (!free) show(selected);
    close();
  }
  function commit(value) {
    const changed = value !== current();
    if (!free) selected = value;
    show(value);
    close();
    if (!changed) return;
    if (free) input.dispatchEvent(new Event('input', {bubbles: true}));
    input.dispatchEvent(new Event('change', {bubbles: true}));
  }

  // A strict field's typed text is only a search query, so the browser's own change event is
  // not a selection. The capture listener runs before any `onchange` handler and stops it.
  if (!free) input.addEventListener('change', event => { if (event.isTrusted) event.stopImmediatePropagation(); }, true);
  input.addEventListener('input', event => { if (!event.isTrusted) return; query = typed(); open(); });
  input.addEventListener('focus', () => { if (!free) input.select(); });
  // Reopening a strict field selects its label so typing starts a new search.
  input.addEventListener('click', () => { if (!list.hidden) return; if (!free) input.select(); open(); });
  input.addEventListener('keydown', event => {
    const isOpen = !list.hidden;
    if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
      event.preventDefault();
      if (!isOpen) { open(); return; }
      if (!shown.length) return;
      const step = event.key === 'ArrowDown' ? 1 : -1;
      activate(active < 0 ? (step > 0 ? 0 : shown.length - 1) : Math.max(0, Math.min(shown.length - 1, active + step)));
    } else if (event.key === 'Enter' && isOpen) {
      if (active >= 0) { event.preventDefault(); commit(shown[active].option.value); }
      else if (!free) { event.preventDefault(); revert(); }
      else close();
    } else if (event.key === 'Escape' && isOpen) {
      // The list closes first; a second Escape reaches the surrounding dialog.
      event.preventDefault();
      event.stopPropagation();
      revert();
    } else if (event.key === 'Tab' && isOpen) {
      if (!free && query && active >= 0) commit(shown[active].option.value);
      else revert();
    }
  });
  host.addEventListener('focusout', event => { if (!host.contains(event.relatedTarget)) revert(); });
  toggle.onmousedown = event => {
    event.preventDefault();
    if (input.disabled) return;
    if (list.hidden) { input.focus(); open(); } else revert();
  };

  if (!free) selected = chosen !== undefined ? String(chosen) : options.length ? String(options[0][0]) : '';
  setOptions(options);
  show(free ? String(chosen ?? '') : selected);
  if (!free) Object.defineProperty(input, 'value', {
    configurable: true,
    get: () => selected,
    set: value => { selected = value == null ? '' : String(value); setOptions(source); show(selected); },
  });
  input.host = host;
  input.setOptions = setOptions;
  return input;
}