background.js

const MAX_SUGGESTIONS = 8;
const DESTINATION_LABEL_MAX_LENGTH = 52;

let latestInputRequest = 0;

function formatUrl(url) {
  if (!url.startsWith('http://') && !url.startsWith('https://')) {
    return `https://${url}`;
  }

  return url;
}

function escapeOmniboxText(text) {
  return String(text)
    .replaceAll('&', '&')
    .replaceAll('<', '&lt;')
    .replaceAll('>', '&gt;')
    .replaceAll('"', '&quot;')
    .replaceAll("'", '&apos;');
}

function truncate(text, maxLength) {
  if (text.length <= maxLength) {
    return text;
  }

  return `${text.slice(0, maxLength - 1)}\u2026`;
}

function getDestinationLabel(url) {
  try {
    const parsedUrl = new URL(formatUrl(url));
    const hostname = parsedUrl.hostname.replace(/^www\./, '');
    const path = parsedUrl.pathname === '/' ? '' : parsedUrl.pathname;

    return truncate(`${hostname}${path}`, DESTINATION_LABEL_MAX_LENGTH);
  } catch {
    return truncate(url, DESTINATION_LABEL_MAX_LENGTH);
  }
}

function getMatchingLinks(items, text) {
  const query = text.toLocaleLowerCase();

  return Object.entries(items)
    .filter(([, url]) => typeof url === 'string')
    .map(([key, url]) => {
      const lowerCaseKey = key.toLocaleLowerCase();
      let rank = 2;

      if (lowerCaseKey === query) {
        rank = 0;
      } else if (lowerCaseKey.startsWith(query)) {
        rank = 1;
      }

      return { key, url, lowerCaseKey, rank };
    })
    .filter(({ lowerCaseKey }) => lowerCaseKey.includes(query))
    .sort((first, second) =>
      first.rank - second.rank ||
      first.key.localeCompare(second.key, undefined, { sensitivity: 'base' })
    );
}

function normalizeOmniboxInput(text) {
  return /^\s*$/.test(text) ? '' : text;
}

function formatHighlightedKey(key, text) {
  if (!text) {
    return `<match>${escapeOmniboxText(key)}</match>`;
  }

  const matchIndex = key.toLocaleLowerCase().indexOf(text.toLocaleLowerCase());
  if (matchIndex === -1) {
    return escapeOmniboxText(key);
  }

  const prefix = key.slice(0, matchIndex);
  const match = key.slice(matchIndex, matchIndex + text.length);
  const suffix = key.slice(matchIndex + text.length);

  return `${escapeOmniboxText(prefix)}<match>${escapeOmniboxText(match)}</match>${escapeOmniboxText(suffix)}`;
}

function formatSuggestionDescription(link, text) {
  const key = formatHighlightedKey(link.key, text);
  const destination = escapeOmniboxText(getDestinationLabel(link.url));

  return `<match>TextLink</match><dim>: </dim>${key}<dim>  \u2192  </dim><url>${destination}</url>`;
}

function setDefaultSuggestion(description) {
  chrome.omnibox.setDefaultSuggestion({ description });
}

function updateDefaultSuggestion(text, matches, totalLinks) {
  const escapedText = escapeOmniboxText(text);

  if (!text) {
    if (totalLinks === 0) {
      setDefaultSuggestion('<dim>No saved TextLinks yet</dim>');
      return;
    }

    const noun = totalLinks === 1 ? 'TextLink' : 'TextLinks';
    setDefaultSuggestion(
      `<match>${totalLinks} saved ${noun}</match><dim>  \u2014  start typing to filter</dim>`
    );
    return;
  }

  if (matches.length === 0) {
    setDefaultSuggestion(`<dim>No TextLinks match \u201c</dim>${escapedText}<dim>\u201d</dim>`);
    return;
  }

  if (matches.length === 1) {
    setDefaultSuggestion(formatSuggestionDescription(matches[0], text));
    return;
  }

  setDefaultSuggestion(
    `<match>${matches.length} TextLinks</match><dim> match \u201c</dim>${escapedText}<dim>\u201d  \u2014  press \u2193 to choose</dim>`
  );
}

function loadLinks(callback) {
  chrome.storage.sync.get(null, (items) => callback(items || {}));
}

setDefaultSuggestion('<dim>Start typing to filter, or press Space to list all TextLinks</dim>');

chrome.omnibox.onInputStarted.addListener(() => {
  const requestId = ++latestInputRequest;

  loadLinks((items) => {
    if (requestId !== latestInputRequest) {
      return;
    }

    const links = getMatchingLinks(items, '');
    updateDefaultSuggestion('', links, links.length);
  });
});

chrome.omnibox.onInputChanged.addListener((text, suggest) => {
  const requestId = ++latestInputRequest;
  const query = normalizeOmniboxInput(text);

  loadLinks((items) => {
    if (requestId !== latestInputRequest) {
      return;
    }

    const allLinks = getMatchingLinks(items, '');
    const matches = getMatchingLinks(items, query);
    const suggestions = matches.length === 1 ? [] : matches;

    updateDefaultSuggestion(query, matches, allLinks.length);
    suggest(
      suggestions.slice(0, MAX_SUGGESTIONS).map((link) => ({
        content: link.key,
        description: formatSuggestionDescription(link, query),
      }))
    );
  });
});

chrome.omnibox.onInputEntered.addListener((text) => {
  ++latestInputRequest;
  const query = normalizeOmniboxInput(text);

  loadLinks((items) => {
    const matches = getMatchingLinks(items, query);
    const exactMatch = matches.find(
      ({ key }) => key.toLocaleLowerCase() === query.toLocaleLowerCase()
    );
    const selectedLink = exactMatch || (matches.length === 1 ? matches[0] : null);

    if (!selectedLink) {
      return;
    }

    chrome.tabs.update({ url: formatUrl(selectedLink.url) });
  });
});

chrome.omnibox.onInputCancelled.addListener(() => {
  ++latestInputRequest;
  setDefaultSuggestion('<dim>Start typing to filter, or press Space to list all TextLinks</dim>');
});