Status: release 1.3.0-rc1
+A consistent approach to naming of assets, devices and building control system control points is fundamental to:
+The purpose of this document is to indicate the process to be followed for building projects to name and label assets and devices.
+The following definitions apply:
+The following specification clause is provided so that BDNS naming can be included in projects:
+The convention for building control device naming shall/must follow the Building Device Naming Standard (BDNS) during the project design and construction stages.
+For a physical device i.e. FCU, CAV etc. the naming conventions for creating these names shall/must be taken from the following links:
+Each device or asset will be assigned as a minimum, the following attributes:
+The structure and purpose of these attributes is described in the subsequent sections.
+Where a device or asset is represented in control system software then it shall be named in accordance with this naming standard within the control system software, e.g. a controller or an inverter must be named.
+Wherever possible, the naming shall be applied as close to the edge as possible, i.e. within the device itself rather than at a gateway device, e.g. an M-Bus meter may not be able to adopt the naming within the meters software itself due to the simplicity of the M-Bus protocol, meaning that a mapping would be required between the meter’s software identifier and the naming convention at a gateway.
+During early stages of design, or for generic components (/ BIM objects) where can_be_connected = False, and there are many instances in the BIM model that do not need individual identification (e.g. cables, data cables, pipework, ductwork, …); it may be appropriate to give only a type identification of the object. In these scenarios refer to the asset type naming guidance only.
All devices or assets shall have a unique identifier. Once generated, this shall not be changed at any point for a specific device or asset instance.
+The device/asset instance globally unique identifier (GUID) is a machine generated and machine readable unique identifier. It is an auto-generated 128-bit number, which can be encoded using the modalities of the RFC 4122 standard or as an IFC GlobalId object of type ifcGloballyUniqueId.
+Generated by a BIM operator, design team, project team, manufacturer or facilities team, depending on the project stage.
+In projects which are utilising BIM, this would be generated by the software without human intervention and shall be converted to the latest Industry Foundation Classes encoding.
+For new projects which do not utilise BIM or for application to existing projects this can be generated using one of several freely available GUID tools (e.g. https://www.guidgenerator.com/).
+Alternatively, a unique identifier may be provided by the manufacturer and input to a project master database such as the BIM model.
+Auto-generated 128-bit integer number.
+If generated from BIM processes, the GUID is represented by 22 IFC base 64 characters encoding.
+If generated by GUID tools, the GUID is usually represented by a 32 digits hexadecimal integer number.
+Flexibility of format is to allow for multiple workflows, for example some projects may choose to automatically generate a GUID using BIM software.
+58e6591f-0cef-4bb1-ac9c-6ef03ec58111(32 digits hexadecimal integer)
04aEp5ymD_$u5IxhJN2aGi(IFC base 64 format)
For BIM workflows, the validation procedure shall include the following tests:
+Regular expression matching to validate the ID format and avoid non-base641 characters and longer or shorter lengths than 22 characters
Uniqueness of the ID across all device instances
([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}(32 digits hexadecimal integer)
[A-Za-z0-9_$]{22}(IFC base 64 format)
The device or asset type is a human-generated identifier that is unique for a type of assets to the building. It combines a standard abbreviation for device/asset types and a numerical ID that is unique to each specific device/asset type.
+Generated by the BIM operator, design team, project team or facilities team, depending on project stage.
+<X><Z>where:
+X=
Z=
The type abbreviation shall be according to the Building Device and Asset Abbreviation Registry.
+The format is composed of a 2 to 6 uppercase alphabetical characters long type abbreviation according to the name abbreviation (X) and a variable length character numeric sequence that is unique to the building (Z) for each asset type. No leading zeros are allowed in the asset type incremental number to avoid ambiguity.
Only uppercase alphabetic characters and numeric characters are allowed, according to the regular expression below. There is no separator character between the type abbreviation and the incremental number for the asset.type.
If there is only one asset type per abbreviation, the asset type incremental number can be omitted.
+Asset type example for a lighting fixture asset type: LT3
Asset type example for an air handling unit asset type: AHU10
Asset type example for a distribution board asset type: DB7
Asset type example for a lighting fixture asset type when there is only one type: LT
Asset type example for an air handling unit asset type when there is only one type: AHU
Asset type example for a distribution board asset type when there is only one type: DB
The validation procedure shall include the following tests:
+[A-Z]{2,6}(?:[1-9][0-9]*)?The device or asset role name is a human-generated identifier that is unique to the building. It combines a standard abbreviation for device/asset types and a numerical ID that is unique to each specific device/asset.
+Generated by the BIM operator, design team, project team or facilities team, depending on project stage.
+<X>-<Y>or
+<XZ>-<Y>where:
+X=
Y=
Z=
The use of the Z field is optional, only in case there is a need to include asset.type definitions.
The type abbreviation shall be according to the Building Device and Asset Abbreviation Registry.
+The format is composed of a 2 to 6 uppercase alphabetical characters long type abbreviation according to the name abbreviation (X) and a variable length character numeric sequence that is unique to the building (Y). No leading zeros are allowed in the building unique incremental number to avoid ambiguity.
Only uppercase alphabetic characters and numeric characters are allowed, according to the regular expression below. The separator character between the type abbreviation and incremental number is a hyphen (-).
For practical reasons, at the discretion of the user and as long as there are no name clashes between devices in the same building, the digits forming the second part of the device role name can be assigned following spatial or discipline specific scoping methods. For instance, the lighting fixtures on zone 1 of level 3 of a 20 storey building can all share the same first part of the name LT-103#### and the subsequent integer numbers can be attributed incrementally.
Name example for a lighting fixture: LT-15
Name example for an air handling unit: AHU-3
Name example for a distribution board: DB-2
Name example for a lighting fixture including an asset type: LT3-375
Name example for an air handling unit including an asset type: AHU10-46
Name example for a distribution board including an asset type: DB3-21
The validation procedure shall include the following tests:
+[A-Z]{2,6}(?:[1-9][0-9]*)?-[1-9][0-9]*Physical device/asset labels shall contain the following items:
+QR codes and NFC tags are intended for use cases facilitating the maintenance of equipment and for providing a code or a web based user interface to a physical object.
+
The human readable label shall be based on the device/asset role name (asset.name) as indicated above.
For quick interpretation and conciseness, the recommendation is to keep the label to a minimum.
+Optionally, the human-readable label could be augmented by:
+System integrator, master system integrator or 3rd party subcontractor, using information from manufacturer, BIM and/or asset tag registry.
+<COUNTRY>-<CITY>-<BUILDING>where:
+<COUNTRY>-<CITY>-<BUILDING> = assigned location code for building, composed of:
<COUNTRY> = ISO Alpha-2 Country Code
<CITY> = UN LOCODE City Code
<BUILDING> = the project specific abbreviation for the building
The location code identification guarantees global uniqueness.
+The name deliberately omits information like floor, area or connection that can change in it. The optional suffix in the physical label can however contain additional information such as floor level if useful for the specific use case.
+asset.name)<X>-<Y>_<text>where
+text = a free text alphanumeric sequence without underscores and without white spaces that adds useful information to the label that can be immediately seen. Text can be hyphenated (-) to represent floor information, room information, distribution board or related equipment.
The suffix in the physical label (not in device.name) allows practical use of the labels to maintenance technicians and facility managers to avoid disrupting traditional workflows. With time, apps and automation, the suffix is likely to disappear.
Compulsory short format name label
+TSTAT-1Prefix format label
+UK-LON-BLD1_TSTAT-1Suffix format label example (optional for capturing existing tagging information)
+TSTAT-1_RH-2-3-25-CO2
+TSTAT-2_EF
The machine readable label is a physical adhesive label that encodes identification and naming to enable automation for identification, provisioning, commissioning and maintenance of devices throughout their lifecycle, from initial configuration and installation to operation and decommissioning.
+Master system integrator or 3rd party subcontractor, using information from the contractor’s BIM workflow, asset tag registry and device manufacturers.
+The QR code shall be created according to ISO/IEC 18004:2015. The QR code payload shall be minified to reduce the number of characters and shall include the following information.
+{
+ "asset": {
+ "guid": "ifc://04aEp5ymD_$u5IxhJN2aGi",
+ "site": "GB-LON-BLD1",
+ "name": "AHU-1"
+ }
+}{"asset":{"guid":"ifc://04aEp5ymD_$u5IxhJN2aGi","site":"GB-LON-BLD1","name":"AHU-1"}}{
+ "asset": {
+ "guid": "uuid://d3501378-dd50-47c5-ae26-806726e1b749",
+ "site": "GB-LON-BLD1",
+ "name": "AHU-1"
+ }
+}{
+ "asset": {
+ "guid": "drw://AHU001",
+ "site": "GB-LON-BLD1",
+ "name": "AHU-1"
+ }
+}If necessary, it would be easy to do a simple 1:1 mapping for _ ⇔ / and $ ⇔ + if necessary for other parts of the system that may treat $ or _ as reserved characters.
Note that the IFC standard is slightly different than the web-standard base64 encoding, specifically using _ and $ instead of / and +.↩︎
${missingFields[0]} field.`,
+ message: `The items being returned for this search do not include all the required fields. Please ensure that your index items include the ${missingFields[0]} field or use index-fields in your _quarto.yml file to specify the field names.`,
+ };
+ } else if (missingFields.length > 1) {
+ const missingFieldList = missingFields
+ .map((field) => {
+ return `${field}`;
+ })
+ .join(", ");
+
+ throw {
+ name: `Error: Search index is missing the following fields: ${missingFieldList}.`,
+ message: `The items being returned for this search do not include all the required fields. Please ensure that your index items includes the following fields: ${missingFieldList}, or use index-fields in your _quarto.yml file to specify the field names.`,
+ };
+ }
+ }
+}
+
+let lastQuery = null;
+function showCopyLink(query, options) {
+ const language = options.language;
+ lastQuery = query;
+ // Insert share icon
+ const inputSuffixEl = window.document.body.querySelector(
+ ".aa-Form .aa-InputWrapperSuffix"
+ );
+
+ if (inputSuffixEl) {
+ let copyButtonEl = window.document.body.querySelector(
+ ".aa-Form .aa-InputWrapperSuffix .aa-CopyButton"
+ );
+
+ if (copyButtonEl === null) {
+ copyButtonEl = window.document.createElement("button");
+ copyButtonEl.setAttribute("class", "aa-CopyButton");
+ copyButtonEl.setAttribute("type", "button");
+ copyButtonEl.setAttribute("title", language["search-copy-link-title"]);
+ copyButtonEl.onmousedown = (e) => {
+ e.preventDefault();
+ e.stopPropagation();
+ };
+
+ const linkIcon = "bi-clipboard";
+ const checkIcon = "bi-check2";
+
+ const shareIconEl = window.document.createElement("i");
+ shareIconEl.setAttribute("class", `bi ${linkIcon}`);
+ copyButtonEl.appendChild(shareIconEl);
+ inputSuffixEl.prepend(copyButtonEl);
+
+ const clipboard = new window.ClipboardJS(".aa-CopyButton", {
+ text: function (_trigger) {
+ const copyUrl = new URL(window.location);
+ copyUrl.searchParams.set(kQueryArg, lastQuery);
+ copyUrl.searchParams.set(kResultsArg, "1");
+ return copyUrl.toString();
+ },
+ });
+ clipboard.on("success", function (e) {
+ // Focus the input
+
+ // button target
+ const button = e.trigger;
+ const icon = button.querySelector("i.bi");
+
+ // flash "checked"
+ icon.classList.add(checkIcon);
+ icon.classList.remove(linkIcon);
+ setTimeout(function () {
+ icon.classList.remove(checkIcon);
+ icon.classList.add(linkIcon);
+ }, 1000);
+ });
+ }
+
+ // If there is a query, show the link icon
+ if (copyButtonEl) {
+ if (lastQuery && options["copy-button"]) {
+ copyButtonEl.style.display = "flex";
+ } else {
+ copyButtonEl.style.display = "none";
+ }
+ }
+ }
+}
+
+/* Search Index Handling */
+// create the index
+var fuseIndex = undefined;
+var shownWarning = false;
+
+// fuse index options
+const kFuseIndexOptions = {
+ keys: [
+ { name: "title", weight: 20 },
+ { name: "section", weight: 20 },
+ { name: "text", weight: 10 },
+ ],
+ ignoreLocation: true,
+ threshold: 0.1,
+};
+
+async function readSearchData() {
+ // Initialize the search index on demand
+ if (fuseIndex === undefined) {
+ if (window.location.protocol === "file:" && !shownWarning) {
+ window.alert(
+ "Search requires JavaScript features disabled when running in file://... URLs. In order to use search, please run this document in a web server."
+ );
+ shownWarning = true;
+ return;
+ }
+ const fuse = new window.Fuse([], kFuseIndexOptions);
+
+ // fetch the main search.json
+ const response = await fetch(offsetURL("search.json"));
+ if (response.status == 200) {
+ return response.json().then(function (searchDocs) {
+ searchDocs.forEach(function (searchDoc) {
+ fuse.add(searchDoc);
+ });
+ fuseIndex = fuse;
+ return fuseIndex;
+ });
+ } else {
+ return Promise.reject(
+ new Error(
+ "Unexpected status from search index request: " + response.status
+ )
+ );
+ }
+ }
+
+ return fuseIndex;
+}
+
+function inputElement() {
+ return window.document.body.querySelector(".aa-Form .aa-Input");
+}
+
+function focusSearchInput() {
+ setTimeout(() => {
+ const inputEl = inputElement();
+ if (inputEl) {
+ inputEl.focus();
+ }
+ }, 50);
+}
+
+/* Panels */
+const kItemTypeDoc = "document";
+const kItemTypeMore = "document-more";
+const kItemTypeItem = "document-item";
+const kItemTypeError = "error";
+
+function renderItem(
+ item,
+ createElement,
+ state,
+ setActiveItemId,
+ setContext,
+ refresh,
+ quartoSearchOptions
+) {
+ switch (item.type) {
+ case kItemTypeDoc:
+ return createDocumentCard(
+ createElement,
+ "file-richtext",
+ item.title,
+ item.section,
+ item.text,
+ item.href,
+ item.crumbs,
+ quartoSearchOptions
+ );
+ case kItemTypeMore:
+ return createMoreCard(
+ createElement,
+ item,
+ state,
+ setActiveItemId,
+ setContext,
+ refresh
+ );
+ case kItemTypeItem:
+ return createSectionCard(
+ createElement,
+ item.section,
+ item.text,
+ item.href
+ );
+ case kItemTypeError:
+ return createErrorCard(createElement, item.title, item.text);
+ default:
+ return undefined;
+ }
+}
+
+function createDocumentCard(
+ createElement,
+ icon,
+ title,
+ section,
+ text,
+ href,
+ crumbs,
+ quartoSearchOptions
+) {
+ const iconEl = createElement("i", {
+ class: `bi bi-${icon} search-result-icon`,
+ });
+ const titleEl = createElement("p", { class: "search-result-title" }, title);
+ const titleContents = [iconEl, titleEl];
+ const showParent = quartoSearchOptions["show-item-context"];
+ if (crumbs && showParent) {
+ let crumbsOut = undefined;
+ const crumbClz = ["search-result-crumbs"];
+ if (showParent === "root") {
+ crumbsOut = crumbs.length > 1 ? crumbs[0] : undefined;
+ } else if (showParent === "parent") {
+ crumbsOut = crumbs.length > 1 ? crumbs[crumbs.length - 2] : undefined;
+ } else {
+ crumbsOut = crumbs.length > 1 ? crumbs.join(" > ") : undefined;
+ crumbClz.push("search-result-crumbs-wrap");
+ }
+
+ const crumbEl = createElement(
+ "p",
+ { class: crumbClz.join(" ") },
+ crumbsOut
+ );
+ titleContents.push(crumbEl);
+ }
+
+ const titleContainerEl = createElement(
+ "div",
+ { class: "search-result-title-container" },
+ titleContents
+ );
+
+ const textEls = [];
+ if (section) {
+ const sectionEl = createElement(
+ "p",
+ { class: "search-result-section" },
+ section
+ );
+ textEls.push(sectionEl);
+ }
+ const descEl = createElement("p", {
+ class: "search-result-text",
+ dangerouslySetInnerHTML: {
+ __html: text,
+ },
+ });
+ textEls.push(descEl);
+
+ const textContainerEl = createElement(
+ "div",
+ { class: "search-result-text-container" },
+ textEls
+ );
+
+ const containerEl = createElement(
+ "div",
+ {
+ class: "search-result-container",
+ },
+ [titleContainerEl, textContainerEl]
+ );
+
+ const linkEl = createElement(
+ "a",
+ {
+ href: offsetURL(href),
+ class: "search-result-link",
+ },
+ containerEl
+ );
+
+ const classes = ["search-result-doc", "search-item"];
+ if (!section) {
+ classes.push("document-selectable");
+ }
+
+ return createElement(
+ "div",
+ {
+ class: classes.join(" "),
+ },
+ linkEl
+ );
+}
+
+function createMoreCard(
+ createElement,
+ item,
+ state,
+ setActiveItemId,
+ setContext,
+ refresh
+) {
+ const moreCardEl = createElement(
+ "div",
+ {
+ class: "search-result-more search-item",
+ onClick: (e) => {
+ // Handle expanding the sections by adding the expanded
+ // section to the list of expanded sections
+ toggleExpanded(item, state, setContext, setActiveItemId, refresh);
+ e.stopPropagation();
+ },
+ },
+ item.title
+ );
+
+ return moreCardEl;
+}
+
+function toggleExpanded(item, state, setContext, setActiveItemId, refresh) {
+ const expanded = state.context.expanded || [];
+ if (expanded.includes(item.target)) {
+ setContext({
+ expanded: expanded.filter((target) => target !== item.target),
+ });
+ } else {
+ setContext({ expanded: [...expanded, item.target] });
+ }
+
+ refresh();
+ setActiveItemId(item.__autocomplete_id);
+}
+
+function createSectionCard(createElement, section, text, href) {
+ const sectionEl = createSection(createElement, section, text, href);
+ return createElement(
+ "div",
+ {
+ class: "search-result-doc-section search-item",
+ },
+ sectionEl
+ );
+}
+
+function createSection(createElement, title, text, href) {
+ const descEl = createElement("p", {
+ class: "search-result-text",
+ dangerouslySetInnerHTML: {
+ __html: text,
+ },
+ });
+
+ const titleEl = createElement("p", { class: "search-result-section" }, title);
+ const linkEl = createElement(
+ "a",
+ {
+ href: offsetURL(href),
+ class: "search-result-link",
+ },
+ [titleEl, descEl]
+ );
+ return linkEl;
+}
+
+function createErrorCard(createElement, title, text) {
+ const descEl = createElement("p", {
+ class: "search-error-text",
+ dangerouslySetInnerHTML: {
+ __html: text,
+ },
+ });
+
+ const titleEl = createElement("p", {
+ class: "search-error-title",
+ dangerouslySetInnerHTML: {
+ __html: ` ${title}`,
+ },
+ });
+ const errorEl = createElement("div", { class: "search-error" }, [
+ titleEl,
+ descEl,
+ ]);
+ return errorEl;
+}
+
+function positionPanel(pos) {
+ const panelEl = window.document.querySelector(
+ "#quarto-search-results .aa-Panel"
+ );
+ const inputEl = window.document.querySelector(
+ "#quarto-search .aa-Autocomplete"
+ );
+
+ if (panelEl && inputEl) {
+ panelEl.style.top = `${Math.round(panelEl.offsetTop)}px`;
+ if (pos === "start") {
+ panelEl.style.left = `${Math.round(inputEl.left)}px`;
+ } else {
+ panelEl.style.right = `${Math.round(inputEl.offsetRight)}px`;
+ }
+ }
+}
+
+/* Highlighting */
+// highlighting functions
+function highlightMatch(query, text) {
+ if (text) {
+ const start = text.toLowerCase().indexOf(query.toLowerCase());
+ if (start !== -1) {
+ const startMark = "";
+ const endMark = "";
+
+ const end = start + query.length;
+ text =
+ text.slice(0, start) +
+ startMark +
+ text.slice(start, end) +
+ endMark +
+ text.slice(end);
+ const startInfo = clipStart(text, start);
+ const endInfo = clipEnd(
+ text,
+ startInfo.position + startMark.length + endMark.length
+ );
+ text =
+ startInfo.prefix +
+ text.slice(startInfo.position, endInfo.position) +
+ endInfo.suffix;
+
+ return text;
+ } else {
+ return text;
+ }
+ } else {
+ return text;
+ }
+}
+
+function clipStart(text, pos) {
+ const clipStart = pos - 50;
+ if (clipStart < 0) {
+ // This will just return the start of the string
+ return {
+ position: 0,
+ prefix: "",
+ };
+ } else {
+ // We're clipping before the start of the string, walk backwards to the first space.
+ const spacePos = findSpace(text, pos, -1);
+ return {
+ position: spacePos.position,
+ prefix: "",
+ };
+ }
+}
+
+function clipEnd(text, pos) {
+ const clipEnd = pos + 200;
+ if (clipEnd > text.length) {
+ return {
+ position: text.length,
+ suffix: "",
+ };
+ } else {
+ const spacePos = findSpace(text, clipEnd, 1);
+ return {
+ position: spacePos.position,
+ suffix: spacePos.clipped ? "…" : "",
+ };
+ }
+}
+
+function findSpace(text, start, step) {
+ let stepPos = start;
+ while (stepPos > -1 && stepPos < text.length) {
+ const char = text[stepPos];
+ if (char === " " || char === "," || char === ":") {
+ return {
+ position: step === 1 ? stepPos : stepPos - step,
+ clipped: stepPos > 1 && stepPos < text.length,
+ };
+ }
+ stepPos = stepPos + step;
+ }
+
+ return {
+ position: stepPos - step,
+ clipped: false,
+ };
+}
+
+// removes highlighting as implemented by the mark tag
+function clearHighlight(searchterm, el) {
+ const childNodes = el.childNodes;
+ for (let i = childNodes.length - 1; i >= 0; i--) {
+ const node = childNodes[i];
+ if (node.nodeType === Node.ELEMENT_NODE) {
+ if (
+ node.tagName === "MARK" &&
+ node.innerText.toLowerCase() === searchterm.toLowerCase()
+ ) {
+ el.replaceChild(document.createTextNode(node.innerText), node);
+ } else {
+ clearHighlight(searchterm, node);
+ }
+ }
+ }
+}
+
+function escapeRegExp(string) {
+ return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+
+// highlight matches
+function highlight(term, el) {
+ const termRegex = new RegExp(term, "ig");
+ const childNodes = el.childNodes;
+
+ // walk back to front avoid mutating elements in front of us
+ for (let i = childNodes.length - 1; i >= 0; i--) {
+ const node = childNodes[i];
+
+ if (node.nodeType === Node.TEXT_NODE) {
+ // Search text nodes for text to highlight
+ const text = node.nodeValue;
+
+ let startIndex = 0;
+ let matchIndex = text.search(termRegex);
+ if (matchIndex > -1) {
+ const markFragment = document.createDocumentFragment();
+ while (matchIndex > -1) {
+ const prefix = text.slice(startIndex, matchIndex);
+ markFragment.appendChild(document.createTextNode(prefix));
+
+ const mark = document.createElement("mark");
+ mark.appendChild(
+ document.createTextNode(
+ text.slice(matchIndex, matchIndex + term.length)
+ )
+ );
+ markFragment.appendChild(mark);
+
+ startIndex = matchIndex + term.length;
+ matchIndex = text.slice(startIndex).search(new RegExp(term, "ig"));
+ if (matchIndex > -1) {
+ matchIndex = startIndex + matchIndex;
+ }
+ }
+ if (startIndex < text.length) {
+ markFragment.appendChild(
+ document.createTextNode(text.slice(startIndex, text.length))
+ );
+ }
+
+ el.replaceChild(markFragment, node);
+ }
+ } else if (node.nodeType === Node.ELEMENT_NODE) {
+ // recurse through elements
+ highlight(term, node);
+ }
+ }
+}
+
+/* Link Handling */
+// get the offset from this page for a given site root relative url
+function offsetURL(url) {
+ var offset = getMeta("quarto:offset");
+ return offset ? offset + url : url;
+}
+
+// read a meta tag value
+function getMeta(metaName) {
+ var metas = window.document.getElementsByTagName("meta");
+ for (let i = 0; i < metas.length; i++) {
+ if (metas[i].getAttribute("name") === metaName) {
+ return metas[i].getAttribute("content");
+ }
+ }
+ return "";
+}
+
+function algoliaSearch(query, limit, algoliaOptions) {
+ const { getAlgoliaResults } = window["@algolia/autocomplete-preset-algolia"];
+
+ const applicationId = algoliaOptions["application-id"];
+ const searchOnlyApiKey = algoliaOptions["search-only-api-key"];
+ const indexName = algoliaOptions["index-name"];
+ const indexFields = algoliaOptions["index-fields"];
+ const searchClient = window.algoliasearch(applicationId, searchOnlyApiKey);
+ const searchParams = algoliaOptions["params"];
+ const searchAnalytics = !!algoliaOptions["analytics-events"];
+
+ return getAlgoliaResults({
+ searchClient,
+ queries: [
+ {
+ indexName: indexName,
+ query,
+ params: {
+ hitsPerPage: limit,
+ clickAnalytics: searchAnalytics,
+ ...searchParams,
+ },
+ },
+ ],
+ transformResponse: (response) => {
+ if (!indexFields) {
+ return response.hits.map((hit) => {
+ return hit.map((item) => {
+ return {
+ ...item,
+ text: highlightMatch(query, item.text),
+ };
+ });
+ });
+ } else {
+ const remappedHits = response.hits.map((hit) => {
+ return hit.map((item) => {
+ const newItem = { ...item };
+ ["href", "section", "title", "text", "crumbs"].forEach(
+ (keyName) => {
+ const mappedName = indexFields[keyName];
+ if (
+ mappedName &&
+ item[mappedName] !== undefined &&
+ mappedName !== keyName
+ ) {
+ newItem[keyName] = item[mappedName];
+ delete newItem[mappedName];
+ }
+ }
+ );
+ newItem.text = highlightMatch(query, newItem.text);
+ return newItem;
+ });
+ });
+ return remappedHits;
+ }
+ },
+ });
+}
+
+let subSearchTerm = undefined;
+let subSearchFuse = undefined;
+const kFuseMaxWait = 125;
+
+async function fuseSearch(query, fuse, fuseOptions) {
+ let index = fuse;
+ // Fuse.js using the Bitap algorithm for text matching which runs in
+ // O(nm) time (no matter the structure of the text). In our case this
+ // means that long search terms mixed with large index gets very slow
+ //
+ // This injects a subIndex that will be used once the terms get long enough
+ // Usually making this subindex is cheap since there will typically be
+ // a subset of results matching the existing query
+ if (subSearchFuse !== undefined && query.startsWith(subSearchTerm)) {
+ // Use the existing subSearchFuse
+ index = subSearchFuse;
+ } else if (subSearchFuse !== undefined) {
+ // The term changed, discard the existing fuse
+ subSearchFuse = undefined;
+ subSearchTerm = undefined;
+ }
+
+ // Search using the active fuse
+ const then = performance.now();
+ const resultsRaw = await index.search(query, fuseOptions);
+ const now = performance.now();
+
+ const results = resultsRaw.map((result) => {
+ const addParam = (url, name, value) => {
+ const anchorParts = url.split("#");
+ const baseUrl = anchorParts[0];
+ const sep = baseUrl.search("\\?") > 0 ? "&" : "?";
+ anchorParts[0] = baseUrl + sep + name + "=" + value;
+ return anchorParts.join("#");
+ };
+
+ return {
+ title: result.item.title,
+ section: result.item.section,
+ href: addParam(result.item.href, kQueryArg, query),
+ text: highlightMatch(query, result.item.text),
+ crumbs: result.item.crumbs,
+ };
+ });
+
+ // If we don't have a subfuse and the query is long enough, go ahead
+ // and create a subfuse to use for subsequent queries
+ if (
+ now - then > kFuseMaxWait &&
+ subSearchFuse === undefined &&
+ resultsRaw.length < fuseOptions.limit
+ ) {
+ subSearchTerm = query;
+ subSearchFuse = new window.Fuse([], kFuseIndexOptions);
+ resultsRaw.forEach((rr) => {
+ subSearchFuse.add(rr.item);
+ });
+ }
+ return results;
+}
diff --git a/styles.css b/styles.css
new file mode 100644
index 0000000..2ddf50c
--- /dev/null
+++ b/styles.css
@@ -0,0 +1 @@
+/* css styles */