| /* |
| * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/ |
| */ |
| "use strict"; |
| const messages = { |
| enterTerm: "Enter a search term", |
| noResult: "No results found", |
| oneResult: "Found one result", |
| manyResults: "Found {0} results", |
| loading: "Loading search index...", |
| searching: "Searching...", |
| redirecting: "Redirecting to first result...", |
| } |
| const categories = { |
| modules: "Modules", |
| packages: "Packages", |
| types: "Classes and Interfaces", |
| members: "Members", |
| searchTags: "Search Tags" |
| }; |
| // Localized element descriptors must match values in enum IndexItem.Kind. |
| const itemDesc = [ |
| // Members |
| ["Enum constant in {0}"], |
| ["Variable in {0}"], |
| ["Static variable in {0}"], |
| ["Constructor for {0}"], |
| ["Element in {0}"], |
| ["Method in {0}"], |
| ["Static method in {0}"], |
| ["Record component of {0}"], |
| // Types in upper and lower case |
| ["Annotation Interface", "annotation interface"], |
| ["Enum Class", "enum class"], |
| ["Interface", "interface"], |
| ["Record Class", "record class"], |
| ["Class", "class"], |
| ["Exception Class", "exception class"], |
| // Tags |
| ["Search tag in {0}"], |
| ["System property in {0}"], |
| ["Section in {0}"], |
| ["External specification in {0}"], |
| // Other |
| ["Summary Page"], |
| ]; |
| const mbrDesc = "Member"; |
| const clsDesc = "Class" |
| const pkgDesc = "Package"; |
| const mdlDesc = "Module"; |
| const pkgDescLower = "package"; |
| const mdlDescLower = "module"; |
| const tagDesc = "Search Tag"; |
| const inDesc = "{0} in {1}"; |
| const descDesc = "Description"; |
| const linkLabel = "Go to search page"; |
| const NO_MATCH = {}; |
| const MAX_RESULTS = 300; |
| const UNICODE_LETTER = 0; |
| const UNICODE_DIGIT = 1; |
| const UNICODE_OTHER = 2; |
| function checkUnnamed(name, separator) { |
| return name === "<Unnamed>" || !name ? "" : name + separator; |
| } |
| function escapeHtml(str) { |
| return str.replace(/</g, "<").replace(/>/g, ">"); |
| } |
| function getHighlightedText(str, boundaries, from, to) { |
| var start = from; |
| var text = ""; |
| for (var i = 0; i < boundaries.length; i += 2) { |
| var b0 = boundaries[i]; |
| var b1 = boundaries[i + 1]; |
| if (b0 >= to || b1 <= from) { |
| continue; |
| } |
| text += escapeHtml(str.slice(start, Math.max(start, b0))); |
| text += "<span class='result-highlight'>"; |
| text += escapeHtml(str.slice(Math.max(start, b0), Math.min(to, b1))); |
| text += "</span>"; |
| start = Math.min(to, b1); |
| } |
| text += escapeHtml(str.slice(start, to)); |
| return text; |
| } |
| function getURLPrefix(item, category) { |
| var urlPrefix = ""; |
| var slash = "/"; |
| if (category === "modules") { |
| return item.l + slash; |
| } else if (category === "packages" && item.m) { |
| return item.m + slash; |
| } else if (category === "types" || category === "members") { |
| if (item.m) { |
| urlPrefix = item.m + slash; |
| } else { |
| $.each(packageSearchIndex, function(index, it) { |
| if (it.m && item.p === it.l) { |
| urlPrefix = it.m + slash; |
| item.m = it.m; |
| return false; |
| } |
| }); |
| } |
| } |
| return urlPrefix; |
| } |
| function getURL(item, category) { |
| if (item.url) { |
| return item.url; |
| } |
| var url = getURLPrefix(item, category); |
| if (category === "modules") { |
| url += "module-summary.html"; |
| } else if (category === "packages") { |
| if (item.u) { |
| url = item.u; |
| } else { |
| url += item.l.replace(/\./g, '/') + "/package-summary.html"; |
| } |
| } else if (category === "types") { |
| if (item.u) { |
| url = item.u; |
| } else { |
| url += checkUnnamed(item.p, "/").replace(/\./g, '/') + item.l + ".html"; |
| } |
| } else if (category === "members") { |
| url += checkUnnamed(item.p, "/").replace(/\./g, '/') + item.c + ".html" + "#"; |
| if (item.u) { |
| url += item.u; |
| } else { |
| url += item.l; |
| } |
| } else if (category === "searchTags") { |
| url += item.u; |
| } |
| item.url = url; |
| return url; |
| } |
| function createMatcher(term, camelCase) { |
| if (camelCase && !isUpperCase(term)) { |
| return null; // no need for camel-case matcher for lower case query |
| } |
| var pattern = ""; |
| var upperCase = []; |
| term.trim().split(/\s+/).forEach(function(w, index, array) { |
| var tokens = w.split(/(?=[\p{Lu},.()<>?[\/])/u); |
| for (var i = 0; i < tokens.length; i++) { |
| var s = tokens[i]; |
| // ',' and '?' are the only delimiters commonly followed by space in java signatures |
| pattern += "(" + escapeUnicodeRegex(s).replace(/[,?]/g, "$&\\s*?") + ")"; |
| upperCase.push(false); |
| if (i === tokens.length - 1 && index < array.length - 1) { |
| // space in query string matches all delimiters |
| pattern += "(.*?)"; |
| upperCase.push(isUpperCase(s[0])); |
| } else { |
| if (!camelCase && isUpperCase(s) && s.length === 1) { |
| pattern += "()"; |
| } else { |
| pattern += "([\\p{L}\\p{Nd}\\p{Sc}<>?[\\]]*?)"; |
| } |
| upperCase.push(isUpperCase(s[0])); |
| } |
| } |
| }); |
| var re = new RegExp(pattern, camelCase ? "gu" : "gui"); |
| re.upperCase = upperCase; |
| return re; |
| } |
| // Unicode regular expressions do not allow certain characters to be escaped |
| function escapeUnicodeRegex(pattern) { |
| return pattern.replace(/[\[\]{}()*+?.\\^$|\s]/g, '\\$&'); |
| } |
| function findMatch(matcher, input, startOfName, endOfName, prefixLength) { |
| var from = startOfName; |
| matcher.lastIndex = from; |
| var match = matcher.exec(input); |
| // Expand search area until we get a valid result or reach the beginning of the string |
| while (!match || match.index + match[0].length < startOfName || endOfName < match.index) { |
| if (from === 0) { |
| return NO_MATCH; |
| } |
| from = input.lastIndexOf(".", from - 2) + 1; |
| matcher.lastIndex = from; |
| match = matcher.exec(input); |
| } |
| var boundaries = []; |
| var matchEnd = match.index + match[0].length; |
| var score = 5; |
| var start = match.index; |
| var prevEnd = -1; |
| for (var i = 1; i < match.length; i += 2) { |
| var charType = getCharType(input[start]); |
| // capturing groups come in pairs, match and non-match |
| boundaries.push(start, start + match[i].length); |
| var prevChar = input[start - 1] || ""; |
| var nextChar = input[start + 1] || ""; |
| // make sure group is anchored on a word boundary |
| if (start !== 0 && start !== startOfName) { |
| if (charType === UNICODE_DIGIT && getCharType(prevChar) === UNICODE_DIGIT) { |
| return NO_MATCH; // Numeric token must match at first digit |
| } else if (charType === UNICODE_LETTER && getCharType(prevChar) === UNICODE_LETTER) { |
| if (!isUpperCase(input[start]) || (!isLowerCase(prevChar) && !isLowerCase(nextChar))) { |
| // Not returning NO_MATCH below is to enable upper-case query strings |
| if (!matcher.upperCase[i] || start !== prevEnd) { |
| return NO_MATCH; |
| } else if (!isUpperCase(input[start])) { |
| score -= 1.0; |
| } |
| } |
| } |
| } |
| prevEnd = start + match[i].length; |
| start += match[i].length + match[i + 1].length; |
| |
| // Lower score for unmatched parts between matches |
| if (match[i + 1]) { |
| score -= rateDistance(match[i + 1]); |
| } |
| } |
| |
| // Lower score for unmatched leading part of name |
| if (startOfName < match.index) { |
| score -= rateDistance(input.substring(startOfName, match.index)); |
| } |
| // Favor child or parent variety depending on whether parent is included in search |
| var matchIncludesContaining = match.index < startOfName; |
| // Lower score for unmatched trailing part of name, but exclude member listings |
| if (matchEnd < endOfName && input[matchEnd - 1] !== ".") { |
| let factor = matchIncludesContaining ? 0.1 : 0.8; |
| score -= rateDistance(input.substring(matchEnd, endOfName)) * factor; |
| } |
| // Lower score for unmatched prefix in member class name |
| if (prefixLength < match.index && prefixLength < startOfName) { |
| let factor = matchIncludesContaining ? 0.8 : 0.4; |
| score -= rateDistance(input.substring(prefixLength, Math.min(match.index, startOfName))) * factor; |
| } |
| // Rank qualified names by package name |
| if (prefixLength > 0) { |
| score -= rateDistance(input.substring(0, prefixLength)) * 0.2; |
| } |
| // Reduce score of constructors in member listings |
| if (matchEnd === prefixLength) { |
| score -= 0.1; |
| } |
| |
| return score > 0 ? { |
| input: input, |
| score: score, |
| boundaries: boundaries |
| } : NO_MATCH; |
| } |
| function isLetter(s) { |
| return /\p{L}/u.test(s); |
| } |
| function isUpperCase(s) { |
| return /\p{Lu}/u.test(s); |
| } |
| function isLowerCase(s) { |
| return /\p{Ll}/u.test(s); |
| } |
| function isDigit(s) { |
| return /\p{Nd}/u.test(s); |
| } |
| function getCharType(s) { |
| if (isLetter(s)) { |
| return UNICODE_LETTER; |
| } else if (isDigit(s)) { |
| return UNICODE_DIGIT; |
| } else { |
| return UNICODE_OTHER; |
| } |
| } |
| function rateDistance(str) { |
| // Rate distance of string by counting word boundaries and camel-case tokens |
| return !str ? 0 |
| : (str.split(/\b|(?<=[\p{Ll}_])\p{Lu}/u).length * 0.1 |
| + (isUpperCase(str[0]) ? 0.08 : 0)); |
| } |
| function doSearch(request, response) { |
| var term = request.term.trim(); |
| var maxResults = request.maxResults || MAX_RESULTS; |
| var module = checkUnnamed(request.module, "/"); |
| var matcher = { |
| plainMatcher: createMatcher(term, false), |
| camelCaseMatcher: createMatcher(term, true) |
| } |
| var indexLoaded = indexFilesLoaded(); |
| |
| function getPrefix(item, category) { |
| switch (category) { |
| case "packages": |
| return checkUnnamed(item.m, "/"); |
| case "types": |
| case "members": |
| return checkUnnamed(item.p, "."); |
| default: |
| return ""; |
| } |
| } |
| function getClassPrefix(item, category) { |
| if (category === "members" && (!item.k || (item.k < 8 && item.k !== "3"))) { |
| return item.c + "."; |
| } |
| return ""; |
| } |
| function searchIndex(indexArray, category) { |
| var matches = []; |
| if (!indexArray) { |
| if (!indexLoaded) { |
| matches.push({ l: messages.loading, category: category }); |
| } |
| return matches; |
| } |
| $.each(indexArray, function (i, item) { |
| if (module) { |
| var modulePrefix = getURLPrefix(item, category) || item.u; |
| if (modulePrefix.indexOf("/") > -1 && !modulePrefix.startsWith(module)) { |
| return; |
| } |
| } |
| var prefix = getPrefix(item, category); |
| var classPrefix = getClassPrefix(item, category); |
| var simpleName = classPrefix + item.l; |
| if (item.d) { |
| simpleName += " - " + item.d; |
| } |
| var qualName = prefix + simpleName; |
| var startOfName = classPrefix.length + prefix.length; |
| var endOfName = category === "members" && qualName.indexOf("(", startOfName) > -1 |
| ? qualName.indexOf("(", startOfName) : qualName.length; |
| var m = findMatch(matcher.plainMatcher, qualName, startOfName, endOfName, prefix.length); |
| if (m === NO_MATCH && matcher.camelCaseMatcher) { |
| m = findMatch(matcher.camelCaseMatcher, qualName, startOfName, endOfName, prefix.length); |
| } |
| if (m !== NO_MATCH) { |
| m.indexItem = item; |
| m.name = simpleName; |
| m.category = category; |
| if (m.boundaries[0] < prefix.length) { |
| m.name = qualName; |
| } else { |
| m.boundaries = m.boundaries.map(function(b) { |
| return b - prefix.length; |
| }); |
| } |
| // m.name = m.name + " " + m.score.toFixed(3); |
| matches.push(m); |
| } |
| return true; |
| }); |
| return matches.sort(function(e1, e2) { |
| return e2.score - e1.score |
| || (category !== "members" |
| ? e1.name.localeCompare(e2.name) : 0); |
| }).slice(0, maxResults); |
| } |
| |
| var result = searchIndex(moduleSearchIndex, "modules") |
| .concat(searchIndex(packageSearchIndex, "packages")) |
| .concat(searchIndex(typeSearchIndex, "types")) |
| .concat(searchIndex(memberSearchIndex, "members")) |
| .concat(searchIndex(tagSearchIndex, "searchTags")); |
| |
| if (!indexLoaded) { |
| updateSearchResults = function() { |
| doSearch(request, response); |
| } |
| } else { |
| updateSearchResults = function() {}; |
| } |
| response(result); |
| } |
| // JQuery search menu implementation |
| $.widget("custom.catcomplete", $.ui.autocomplete, { |
| _create: function() { |
| this._super(); |
| this.widget().menu("option", "items", "> .result-item"); |
| // workaround for search result scrolling |
| this.menu._scrollIntoView = function _scrollIntoView( item ) { |
| var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight; |
| if ( this._hasScroll() ) { |
| borderTop = parseFloat( $.css( this.activeMenu[ 0 ], "borderTopWidth" ) ) || 0; |
| paddingTop = parseFloat( $.css( this.activeMenu[ 0 ], "paddingTop" ) ) || 0; |
| offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop; |
| scroll = this.activeMenu.scrollTop(); |
| elementHeight = this.activeMenu.height() - 26; |
| itemHeight = item.outerHeight(); |
| |
| if ( offset < 0 ) { |
| this.activeMenu.scrollTop( scroll + offset ); |
| } else if ( offset + itemHeight > elementHeight ) { |
| this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight ); |
| } |
| } |
| }; |
| }, |
| _renderMenu: function(ul, items) { |
| var currentCategory = ""; |
| var widget = this; |
| widget.menu.bindings = $(); |
| $.each(items, function(index, item) { |
| if (item.category && item.category !== currentCategory) { |
| ul.append("<li class='ui-autocomplete-category'>" + categories[item.category] + "</li>"); |
| currentCategory = item.category; |
| } |
| var li = widget._renderItemData(ul, item); |
| if (item.category) { |
| li.attr("aria-label", categories[item.category] + " : " + item.l); |
| } else { |
| li.attr("aria-label", item.l); |
| } |
| li.attr("class", "result-item"); |
| }); |
| ul.append("<li class='ui-static-link'><div><a href='" + pathtoroot + "search.html?q=" |
| + encodeURI(widget.term) + "'>" + linkLabel + "</a></div></li>"); |
| }, |
| _renderItem: function(ul, item) { |
| var label = getResultLabel(item); |
| var resultDesc = getResultDescription(item); |
| return $("<li/>") |
| .append($("<div/>") |
| .append($("<span/>").addClass("search-result-label").html(label)) |
| .append($("<span/>").addClass("search-result-desc").html(resultDesc))) |
| .appendTo(ul); |
| }, |
| _resizeMenu: function () { |
| var ul = this.menu.element; |
| var missing = 0; |
| ul.children().each((i, e) => { |
| if (e.hasChildNodes() && e.firstChild.hasChildNodes()) { |
| var label = e.firstChild.firstChild; |
| missing = Math.max(missing, label.scrollWidth - label.clientWidth); |
| } |
| }); |
| ul.outerWidth( Math.max( |
| ul.width("").outerWidth() + missing + 40, |
| this.element.outerWidth() |
| )); |
| } |
| }); |
| function getResultLabel(item) { |
| if (item.l) { |
| return item.l; |
| } |
| return getHighlightedText(item.name, item.boundaries, 0, item.name.length); |
| } |
| function getResultDescription(item) { |
| if (!item.indexItem) { |
| return ""; |
| } |
| var kind; |
| switch (item.category) { |
| case "members": |
| var typeName = checkUnnamed(item.indexItem.p, ".") + item.indexItem.c; |
| var typeDesc = getEnclosingTypeDesc(item.indexItem); |
| kind = itemDesc[item.indexItem.k || 5][0]; |
| return kind.replace("{0}", typeDesc + " " + typeName); |
| case "types": |
| var pkgName = checkUnnamed(item.indexItem.p, ""); |
| kind = itemDesc[item.indexItem.k || 12][0]; |
| if (!pkgName) { |
| // Handle "All Classes" summary page and unnamed package |
| return item.indexItem.k === "18" ? kind : kind + " " + item.indexItem.l; |
| } |
| return getEnclosingDescription(kind, pkgDescLower, pkgName); |
| case "packages": |
| if (item.indexItem.k === "18") { |
| return itemDesc[item.indexItem.k][0]; // "All Packages" summary page |
| } else if (!item.indexItem.m) { |
| return pkgDesc + " " + item.indexItem.l; |
| } |
| var mdlName = item.indexItem.m; |
| return getEnclosingDescription(pkgDesc, mdlDescLower, mdlName); |
| case "modules": |
| return mdlDesc + " " + item.indexItem.l; |
| case "searchTags": |
| if (item.indexItem) { |
| var holder = item.indexItem.h; |
| kind = itemDesc[item.indexItem.k || 14][0]; |
| return holder ? kind.replace("{0}", holder) : kind; |
| } |
| } |
| return ""; |
| } |
| function getEnclosingDescription(elem, desc, label) { |
| return inDesc.replace("{0}", elem).replace("{1}", desc + " " + label); |
| } |
| function getEnclosingTypeDesc(item) { |
| if (!item.typeDesc) { |
| $.each(typeSearchIndex, function(index, it) { |
| if (it.l === item.c && it.p === item.p && it.m === item.m) { |
| item.typeDesc = itemDesc[it.k || 12][1]; |
| return false; |
| } |
| }); |
| } |
| return item.typeDesc || ""; |
| } |
| $(function() { |
| var search = $("#search-input"); |
| var reset = $("#reset-search"); |
| search.catcomplete({ |
| minLength: 1, |
| delay: 200, |
| source: function(request, response) { |
| if (request.term.trim() === "") { |
| return this.close(); |
| } |
| // Prevent selection of item at current mouse position |
| this.menu.previousFilter = "_"; |
| this.menu.filterTimer = this.menu._delay(function() { |
| delete this.previousFilter; |
| }, 1000); |
| return doSearch(request, response); |
| }, |
| response: function(event, ui) { |
| if (!ui.content.length) { |
| ui.content.push({ l: messages.noResult }); |
| } |
| }, |
| autoFocus: true, |
| focus: function(event, ui) { |
| return false; |
| }, |
| position: { |
| collision: "flip" |
| }, |
| select: function(event, ui) { |
| if (ui.item.indexItem) { |
| var url = getURL(ui.item.indexItem, ui.item.category); |
| window.location.href = pathtoroot + url; |
| search.blur(); |
| } |
| } |
| }); |
| search.val(''); |
| search.on("input", () => reset.css("visibility", search.val() ? "visible" : "hidden")) |
| search.prop("disabled", false); |
| search.attr("autocapitalize", "off"); |
| reset.prop("disabled", false); |
| reset.click(function() { |
| search.val('').focus(); |
| }); |
| }); |
