FileMaster
Search
Toggle Dark Mode
Home
/
.
/
wp-content
/
plugins
/
surecart
/
dist
/
components
/
esm
Edit File: sc-menu-label_2.entry.js
import { r as registerInstance, h, c as createEvent, a as getElement } from './index-745b6bec.js'; import { F as FormSubmitController } from './form-data-76641f16.js'; import { b as isValidURL } from './util-50af2a83.js'; const scMenuLabelCss = ":host{display:block}.menu-label{font-family:var(--sc-font-sans);font-size:var(--sc-font-size-x-small);font-weight:var(--sc-font-weight-semibold);line-height:var(--sc-line-height-normal);letter-spacing:var(--sc-letter-spacing-normal);color:var(--sc-color-gray-500);padding:var(--sc-spacing-small) var(--sc-spacing-large);user-select:none;text-transform:uppercase}"; const ScMenuLabelStyle0 = scMenuLabelCss; const ScMenuLabel = class { constructor(hostRef) { registerInstance(this, hostRef); } render() { return (h("div", { key: '1cb6403905221fda6ca8f161f46a7e449dc4832f', part: "base", class: "menu-label" }, h("slot", { key: '9d1de6afb50e466179724b4bb4d36fff8f521917' }))); } }; ScMenuLabel.style = ScMenuLabelStyle0; /** * Fuse.js v6.6.2 - Lightweight fuzzy-search (http://fusejs.io) * * Copyright (c) 2022 Kiro Risk (http://kiro.me) * All Rights Reserved. Apache Software License 2.0 * * http://www.apache.org/licenses/LICENSE-2.0 */ function isArray(value) { return !Array.isArray ? getTag(value) === '[object Array]' : Array.isArray(value) } // Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js const INFINITY = 1 / 0; function baseToString(value) { // Exit early for strings to avoid a performance hit in some environments. if (typeof value == 'string') { return value } let result = value + ''; return result == '0' && 1 / value == -INFINITY ? '-0' : result } function toString(value) { return value == null ? '' : baseToString(value) } function isString(value) { return typeof value === 'string' } function isNumber(value) { return typeof value === 'number' } // Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js function isBoolean(value) { return ( value === true || value === false || (isObjectLike(value) && getTag(value) == '[object Boolean]') ) } function isObject(value) { return typeof value === 'object' } // Checks if `value` is object-like. function isObjectLike(value) { return isObject(value) && value !== null } function isDefined(value) { return value !== undefined && value !== null } function isBlank(value) { return !value.trim().length } // Gets the `toStringTag` of `value`. // Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js function getTag(value) { return value == null ? value === undefined ? '[object Undefined]' : '[object Null]' : Object.prototype.toString.call(value) } const EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available'; const INCORRECT_INDEX_TYPE = "Incorrect 'index' type"; const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`; const PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`; const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`; const INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`; const hasOwn = Object.prototype.hasOwnProperty; class KeyStore { constructor(keys) { this._keys = []; this._keyMap = {}; let totalWeight = 0; keys.forEach((key) => { let obj = createKey(key); totalWeight += obj.weight; this._keys.push(obj); this._keyMap[obj.id] = obj; totalWeight += obj.weight; }); // Normalize weights so that their sum is equal to 1 this._keys.forEach((key) => { key.weight /= totalWeight; }); } get(keyId) { return this._keyMap[keyId] } keys() { return this._keys } toJSON() { return JSON.stringify(this._keys) } } function createKey(key) { let path = null; let id = null; let src = null; let weight = 1; let getFn = null; if (isString(key) || isArray(key)) { src = key; path = createKeyPath(key); id = createKeyId(key); } else { if (!hasOwn.call(key, 'name')) { throw new Error(MISSING_KEY_PROPERTY('name')) } const name = key.name; src = name; if (hasOwn.call(key, 'weight')) { weight = key.weight; if (weight <= 0) { throw new Error(INVALID_KEY_WEIGHT_VALUE(name)) } } path = createKeyPath(name); id = createKeyId(name); getFn = key.getFn; } return { path, id, weight, src, getFn } } function createKeyPath(key) { return isArray(key) ? key : key.split('.') } function createKeyId(key) { return isArray(key) ? key.join('.') : key } function get(obj, path) { let list = []; let arr = false; const deepGet = (obj, path, index) => { if (!isDefined(obj)) { return } if (!path[index]) { // If there's no path left, we've arrived at the object we care about. list.push(obj); } else { let key = path[index]; const value = obj[key]; if (!isDefined(value)) { return } // If we're at the last value in the path, and if it's a string/number/bool, // add it to the list if ( index === path.length - 1 && (isString(value) || isNumber(value) || isBoolean(value)) ) { list.push(toString(value)); } else if (isArray(value)) { arr = true; // Search each item in the array. for (let i = 0, len = value.length; i < len; i += 1) { deepGet(value[i], path, index + 1); } } else if (path.length) { // An object. Recurse further. deepGet(value, path, index + 1); } } }; // Backwards compatibility (since path used to be a string) deepGet(obj, isString(path) ? path.split('.') : path, 0); return arr ? list : list[0] } const MatchOptions = { // Whether the matches should be included in the result set. When `true`, each record in the result // set will include the indices of the matched characters. // These can consequently be used for highlighting purposes. includeMatches: false, // When `true`, the matching function will continue to the end of a search pattern even if // a perfect match has already been located in the string. findAllMatches: false, // Minimum number of characters that must be matched before a result is considered a match minMatchCharLength: 1 }; const BasicOptions = { // When `true`, the algorithm continues searching to the end of the input even if a perfect // match is found before the end of the same input. isCaseSensitive: false, // When true, the matching function will continue to the end of a search pattern even if includeScore: false, // List of properties that will be searched. This also supports nested properties. keys: [], // Whether to sort the result list, by score shouldSort: true, // Default sort function: sort by ascending score, ascending index sortFn: (a, b) => a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1 }; const FuzzyOptions = { // Approximately where in the text is the pattern expected to be found? location: 0, // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match // (of both letters and location), a threshold of '1.0' would match anything. threshold: 0.6, // Determines how close the match must be to the fuzzy location (specified above). // An exact letter match which is 'distance' characters away from the fuzzy location // would score as a complete mismatch. A distance of '0' requires the match be at // the exact location specified, a threshold of '1000' would require a perfect match // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold. distance: 100 }; const AdvancedOptions = { // When `true`, it enables the use of unix-like search commands useExtendedSearch: false, // The get function to use when fetching an object's properties. // The default will search nested paths *ie foo.bar.baz* getFn: get, // When `true`, search will ignore `location` and `distance`, so it won't matter // where in the string the pattern appears. // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score ignoreLocation: false, // When `true`, the calculation for the relevance score (used for sorting) will // ignore the field-length norm. // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm ignoreFieldNorm: false, // The weight to determine how much field length norm effects scoring. fieldNormWeight: 1 }; var Config = { ...BasicOptions, ...MatchOptions, ...FuzzyOptions, ...AdvancedOptions }; const SPACE = /[^ ]+/g; // Field-length norm: the shorter the field, the higher the weight. // Set to 3 decimals to reduce index size. function norm(weight = 1, mantissa = 3) { const cache = new Map(); const m = Math.pow(10, mantissa); return { get(value) { const numTokens = value.match(SPACE).length; if (cache.has(numTokens)) { return cache.get(numTokens) } // Default function is 1/sqrt(x), weight makes that variable const norm = 1 / Math.pow(numTokens, 0.5 * weight); // In place of `toFixed(mantissa)`, for faster computation const n = parseFloat(Math.round(norm * m) / m); cache.set(numTokens, n); return n }, clear() { cache.clear(); } } } class FuseIndex { constructor({ getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) { this.norm = norm(fieldNormWeight, 3); this.getFn = getFn; this.isCreated = false; this.setIndexRecords(); } setSources(docs = []) { this.docs = docs; } setIndexRecords(records = []) { this.records = records; } setKeys(keys = []) { this.keys = keys; this._keysMap = {}; keys.forEach((key, idx) => { this._keysMap[key.id] = idx; }); } create() { if (this.isCreated || !this.docs.length) { return } this.isCreated = true; // List is Array<String> if (isString(this.docs[0])) { this.docs.forEach((doc, docIndex) => { this._addString(doc, docIndex); }); } else { // List is Array<Object> this.docs.forEach((doc, docIndex) => { this._addObject(doc, docIndex); }); } this.norm.clear(); } // Adds a doc to the end of the index add(doc) { const idx = this.size(); if (isString(doc)) { this._addString(doc, idx); } else { this._addObject(doc, idx); } } // Removes the doc at the specified index of the index removeAt(idx) { this.records.splice(idx, 1); // Change ref index of every subsquent doc for (let i = idx, len = this.size(); i < len; i += 1) { this.records[i].i -= 1; } } getValueForItemAtKeyId(item, keyId) { return item[this._keysMap[keyId]] } size() { return this.records.length } _addString(doc, docIndex) { if (!isDefined(doc) || isBlank(doc)) { return } let record = { v: doc, i: docIndex, n: this.norm.get(doc) }; this.records.push(record); } _addObject(doc, docIndex) { let record = { i: docIndex, $: {} }; // Iterate over every key (i.e, path), and fetch the value at that key this.keys.forEach((key, keyIndex) => { let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path); if (!isDefined(value)) { return } if (isArray(value)) { let subRecords = []; const stack = [{ nestedArrIndex: -1, value }]; while (stack.length) { const { nestedArrIndex, value } = stack.pop(); if (!isDefined(value)) { continue } if (isString(value) && !isBlank(value)) { let subRecord = { v: value, i: nestedArrIndex, n: this.norm.get(value) }; subRecords.push(subRecord); } else if (isArray(value)) { value.forEach((item, k) => { stack.push({ nestedArrIndex: k, value: item }); }); } else ; } record.$[keyIndex] = subRecords; } else if (isString(value) && !isBlank(value)) { let subRecord = { v: value, n: this.norm.get(value) }; record.$[keyIndex] = subRecord; } }); this.records.push(record); } toJSON() { return { keys: this.keys, records: this.records } } } function createIndex( keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {} ) { const myIndex = new FuseIndex({ getFn, fieldNormWeight }); myIndex.setKeys(keys.map(createKey)); myIndex.setSources(docs); myIndex.create(); return myIndex } function parseIndex( data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {} ) { const { keys, records } = data; const myIndex = new FuseIndex({ getFn, fieldNormWeight }); myIndex.setKeys(keys); myIndex.setIndexRecords(records); return myIndex } function computeScore$1( pattern, { errors = 0, currentLocation = 0, expectedLocation = 0, distance = Config.distance, ignoreLocation = Config.ignoreLocation } = {} ) { const accuracy = errors / pattern.length; if (ignoreLocation) { return accuracy } const proximity = Math.abs(expectedLocation - currentLocation); if (!distance) { // Dodge divide by zero error. return proximity ? 1.0 : accuracy } return accuracy + proximity / distance } function convertMaskToIndices( matchmask = [], minMatchCharLength = Config.minMatchCharLength ) { let indices = []; let start = -1; let end = -1; let i = 0; for (let len = matchmask.length; i < len; i += 1) { let match = matchmask[i]; if (match && start === -1) { start = i; } else if (!match && start !== -1) { end = i - 1; if (end - start + 1 >= minMatchCharLength) { indices.push([start, end]); } start = -1; } } // (i-1 - start) + 1 => i - start if (matchmask[i - 1] && i - start >= minMatchCharLength) { indices.push([start, i - 1]); } return indices } // Machine word size const MAX_BITS = 32; function search( text, pattern, patternAlphabet, { location = Config.location, distance = Config.distance, threshold = Config.threshold, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, includeMatches = Config.includeMatches, ignoreLocation = Config.ignoreLocation } = {} ) { if (pattern.length > MAX_BITS) { throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS)) } const patternLen = pattern.length; // Set starting location at beginning text and initialize the alphabet. const textLen = text.length; // Handle the case when location > text.length const expectedLocation = Math.max(0, Math.min(location, textLen)); // Highest score beyond which we give up. let currentThreshold = threshold; // Is there a nearby exact match? (speedup) let bestLocation = expectedLocation; // Performance: only computer matches when the minMatchCharLength > 1 // OR if `includeMatches` is true. const computeMatches = minMatchCharLength > 1 || includeMatches; // A mask of the matches, used for building the indices const matchMask = computeMatches ? Array(textLen) : []; let index; // Get all exact matches, here for speed up while ((index = text.indexOf(pattern, bestLocation)) > -1) { let score = computeScore$1(pattern, { currentLocation: index, expectedLocation, distance, ignoreLocation }); currentThreshold = Math.min(score, currentThreshold); bestLocation = index + patternLen; if (computeMatches) { let i = 0; while (i < patternLen) { matchMask[index + i] = 1; i += 1; } } } // Reset the best location bestLocation = -1; let lastBitArr = []; let finalScore = 1; let binMax = patternLen + textLen; const mask = 1 << (patternLen - 1); for (let i = 0; i < patternLen; i += 1) { // Scan for the best match; each iteration allows for one more error. // Run a binary search to determine how far from the match location we can stray // at this error level. let binMin = 0; let binMid = binMax; while (binMin < binMid) { const score = computeScore$1(pattern, { errors: i, currentLocation: expectedLocation + binMid, expectedLocation, distance, ignoreLocation }); if (score <= currentThreshold) { binMin = binMid; } else { binMax = binMid; } binMid = Math.floor((binMax - binMin) / 2 + binMin); } // Use the result from this iteration as the maximum for the next. binMax = binMid; let start = Math.max(1, expectedLocation - binMid + 1); let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen; // Initialize the bit array let bitArr = Array(finish + 2); bitArr[finish + 1] = (1 << i) - 1; for (let j = finish; j >= start; j -= 1) { let currentLocation = j - 1; let charMatch = patternAlphabet[text.charAt(currentLocation)]; if (computeMatches) { // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`) matchMask[currentLocation] = +!!charMatch; } // First pass: exact match bitArr[j] = ((bitArr[j + 1] << 1) | 1) & charMatch; // Subsequent passes: fuzzy match if (i) { bitArr[j] |= ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1]; } if (bitArr[j] & mask) { finalScore = computeScore$1(pattern, { errors: i, currentLocation, expectedLocation, distance, ignoreLocation }); // This match will almost certainly be better than any existing match. // But check anyway. if (finalScore <= currentThreshold) { // Indeed it is currentThreshold = finalScore; bestLocation = currentLocation; // Already passed `loc`, downhill from here on in. if (bestLocation <= expectedLocation) { break } // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`. start = Math.max(1, 2 * expectedLocation - bestLocation); } } } // No hope for a (better) match at greater error levels. const score = computeScore$1(pattern, { errors: i + 1, currentLocation: expectedLocation, expectedLocation, distance, ignoreLocation }); if (score > currentThreshold) { break } lastBitArr = bitArr; } const result = { isMatch: bestLocation >= 0, // Count exact matches (those with a score of 0) to be "almost" exact score: Math.max(0.001, finalScore) }; if (computeMatches) { const indices = convertMaskToIndices(matchMask, minMatchCharLength); if (!indices.length) { result.isMatch = false; } else if (includeMatches) { result.indices = indices; } } return result } function createPatternAlphabet(pattern) { let mask = {}; for (let i = 0, len = pattern.length; i < len; i += 1) { const char = pattern.charAt(i); mask[char] = (mask[char] || 0) | (1 << (len - i - 1)); } return mask } class BitapSearch { constructor( pattern, { location = Config.location, threshold = Config.threshold, distance = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreLocation = Config.ignoreLocation } = {} ) { this.options = { location, threshold, distance, includeMatches, findAllMatches, minMatchCharLength, isCaseSensitive, ignoreLocation }; this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase(); this.chunks = []; if (!this.pattern.length) { return } const addChunk = (pattern, startIndex) => { this.chunks.push({ pattern, alphabet: createPatternAlphabet(pattern), startIndex }); }; const len = this.pattern.length; if (len > MAX_BITS) { let i = 0; const remainder = len % MAX_BITS; const end = len - remainder; while (i < end) { addChunk(this.pattern.substr(i, MAX_BITS), i); i += MAX_BITS; } if (remainder) { const startIndex = len - MAX_BITS; addChunk(this.pattern.substr(startIndex), startIndex); } } else { addChunk(this.pattern, 0); } } searchIn(text) { const { isCaseSensitive, includeMatches } = this.options; if (!isCaseSensitive) { text = text.toLowerCase(); } // Exact match if (this.pattern === text) { let result = { isMatch: true, score: 0 }; if (includeMatches) { result.indices = [[0, text.length - 1]]; } return result } // Otherwise, use Bitap algorithm const { location, distance, threshold, findAllMatches, minMatchCharLength, ignoreLocation } = this.options; let allIndices = []; let totalScore = 0; let hasMatches = false; this.chunks.forEach(({ pattern, alphabet, startIndex }) => { const { isMatch, score, indices } = search(text, pattern, alphabet, { location: location + startIndex, distance, threshold, findAllMatches, minMatchCharLength, includeMatches, ignoreLocation }); if (isMatch) { hasMatches = true; } totalScore += score; if (isMatch && indices) { allIndices = [...allIndices, ...indices]; } }); let result = { isMatch: hasMatches, score: hasMatches ? totalScore / this.chunks.length : 1 }; if (hasMatches && includeMatches) { result.indices = allIndices; } return result } } class BaseMatch { constructor(pattern) { this.pattern = pattern; } static isMultiMatch(pattern) { return getMatch(pattern, this.multiRegex) } static isSingleMatch(pattern) { return getMatch(pattern, this.singleRegex) } search(/*text*/) {} } function getMatch(pattern, exp) { const matches = pattern.match(exp); return matches ? matches[1] : null } // Token: 'file class ExactMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'exact' } static get multiRegex() { return /^="(.*)"$/ } static get singleRegex() { return /^=(.*)$/ } search(text) { const isMatch = text === this.pattern; return { isMatch, score: isMatch ? 0 : 1, indices: [0, this.pattern.length - 1] } } } // Token: !fire class InverseExactMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'inverse-exact' } static get multiRegex() { return /^!"(.*)"$/ } static get singleRegex() { return /^!(.*)$/ } search(text) { const index = text.indexOf(this.pattern); const isMatch = index === -1; return { isMatch, score: isMatch ? 0 : 1, indices: [0, text.length - 1] } } } // Token: ^file class PrefixExactMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'prefix-exact' } static get multiRegex() { return /^\^"(.*)"$/ } static get singleRegex() { return /^\^(.*)$/ } search(text) { const isMatch = text.startsWith(this.pattern); return { isMatch, score: isMatch ? 0 : 1, indices: [0, this.pattern.length - 1] } } } // Token: !^fire class InversePrefixExactMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'inverse-prefix-exact' } static get multiRegex() { return /^!\^"(.*)"$/ } static get singleRegex() { return /^!\^(.*)$/ } search(text) { const isMatch = !text.startsWith(this.pattern); return { isMatch, score: isMatch ? 0 : 1, indices: [0, text.length - 1] } } } // Token: .file$ class SuffixExactMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'suffix-exact' } static get multiRegex() { return /^"(.*)"\$$/ } static get singleRegex() { return /^(.*)\$$/ } search(text) { const isMatch = text.endsWith(this.pattern); return { isMatch, score: isMatch ? 0 : 1, indices: [text.length - this.pattern.length, text.length - 1] } } } // Token: !.file$ class InverseSuffixExactMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'inverse-suffix-exact' } static get multiRegex() { return /^!"(.*)"\$$/ } static get singleRegex() { return /^!(.*)\$$/ } search(text) { const isMatch = !text.endsWith(this.pattern); return { isMatch, score: isMatch ? 0 : 1, indices: [0, text.length - 1] } } } class FuzzyMatch extends BaseMatch { constructor( pattern, { location = Config.location, threshold = Config.threshold, distance = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreLocation = Config.ignoreLocation } = {} ) { super(pattern); this._bitapSearch = new BitapSearch(pattern, { location, threshold, distance, includeMatches, findAllMatches, minMatchCharLength, isCaseSensitive, ignoreLocation }); } static get type() { return 'fuzzy' } static get multiRegex() { return /^"(.*)"$/ } static get singleRegex() { return /^(.*)$/ } search(text) { return this._bitapSearch.searchIn(text) } } // Token: 'file class IncludeMatch extends BaseMatch { constructor(pattern) { super(pattern); } static get type() { return 'include' } static get multiRegex() { return /^'"(.*)"$/ } static get singleRegex() { return /^'(.*)$/ } search(text) { let location = 0; let index; const indices = []; const patternLen = this.pattern.length; // Get all exact matches while ((index = text.indexOf(this.pattern, location)) > -1) { location = index + patternLen; indices.push([index, location - 1]); } const isMatch = !!indices.length; return { isMatch, score: isMatch ? 0 : 1, indices } } } // ❗Order is important. DO NOT CHANGE. const searchers = [ ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch ]; const searchersLen = searchers.length; // Regex to split by spaces, but keep anything in quotes together const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/; const OR_TOKEN = '|'; // Return a 2D array representation of the query, for simpler parsing. // Example: // "^core go$ | rb$ | py$ xy$" => [["^core", "go$"], ["rb$"], ["py$", "xy$"]] function parseQuery(pattern, options = {}) { return pattern.split(OR_TOKEN).map((item) => { let query = item .trim() .split(SPACE_RE) .filter((item) => item && !!item.trim()); let results = []; for (let i = 0, len = query.length; i < len; i += 1) { const queryItem = query[i]; // 1. Handle multiple query match (i.e, once that are quoted, like `"hello world"`) let found = false; let idx = -1; while (!found && ++idx < searchersLen) { const searcher = searchers[idx]; let token = searcher.isMultiMatch(queryItem); if (token) { results.push(new searcher(token, options)); found = true; } } if (found) { continue } // 2. Handle single query matches (i.e, once that are *not* quoted) idx = -1; while (++idx < searchersLen) { const searcher = searchers[idx]; let token = searcher.isSingleMatch(queryItem); if (token) { results.push(new searcher(token, options)); break } } } return results }) } // These extended matchers can return an array of matches, as opposed // to a singl match const MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]); /** * Command-like searching * ====================== * * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`, * search in a given text. * * Search syntax: * * | Token | Match type | Description | * | ----------- | -------------------------- | -------------------------------------- | * | `jscript` | fuzzy-match | Items that fuzzy match `jscript` | * | `=scheme` | exact-match | Items that are `scheme` | * | `'python` | include-match | Items that include `python` | * | `!ruby` | inverse-exact-match | Items that do not include `ruby` | * | `^java` | prefix-exact-match | Items that start with `java` | * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` | * | `.js$` | suffix-exact-match | Items that end with `.js` | * | `!.go$` | inverse-suffix-exact-match | Items that do not end with `.go` | * * A single pipe character acts as an OR operator. For example, the following * query matches entries that start with `core` and end with either`go`, `rb`, * or`py`. * * ``` * ^core go$ | rb$ | py$ * ``` */ class ExtendedSearch { constructor( pattern, { isCaseSensitive = Config.isCaseSensitive, includeMatches = Config.includeMatches, minMatchCharLength = Config.minMatchCharLength, ignoreLocation = Config.ignoreLocation, findAllMatches = Config.findAllMatches, location = Config.location, threshold = Config.threshold, distance = Config.distance } = {} ) { this.query = null; this.options = { isCaseSensitive, includeMatches, minMatchCharLength, findAllMatches, ignoreLocation, location, threshold, distance }; this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase(); this.query = parseQuery(this.pattern, this.options); } static condition(_, options) { return options.useExtendedSearch } searchIn(text) { const query = this.query; if (!query) { return { isMatch: false, score: 1 } } const { includeMatches, isCaseSensitive } = this.options; text = isCaseSensitive ? text : text.toLowerCase(); let numMatches = 0; let allIndices = []; let totalScore = 0; // ORs for (let i = 0, qLen = query.length; i < qLen; i += 1) { const searchers = query[i]; // Reset indices allIndices.length = 0; numMatches = 0; // ANDs for (let j = 0, pLen = searchers.length; j < pLen; j += 1) { const searcher = searchers[j]; const { isMatch, indices, score } = searcher.search(text); if (isMatch) { numMatches += 1; totalScore += score; if (includeMatches) { const type = searcher.constructor.type; if (MultiMatchSet.has(type)) { allIndices = [...allIndices, ...indices]; } else { allIndices.push(indices); } } } else { totalScore = 0; numMatches = 0; allIndices.length = 0; break } } // OR condition, so if TRUE, return if (numMatches) { let result = { isMatch: true, score: totalScore / numMatches }; if (includeMatches) { result.indices = allIndices; } return result } } // Nothing was matched return { isMatch: false, score: 1 } } } const registeredSearchers = []; function register(...args) { registeredSearchers.push(...args); } function createSearcher(pattern, options) { for (let i = 0, len = registeredSearchers.length; i < len; i += 1) { let searcherClass = registeredSearchers[i]; if (searcherClass.condition(pattern, options)) { return new searcherClass(pattern, options) } } return new BitapSearch(pattern, options) } const LogicalOperator = { AND: '$and', OR: '$or' }; const KeyType = { PATH: '$path', PATTERN: '$val' }; const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]); const isPath = (query) => !!query[KeyType.PATH]; const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query); const convertToExplicit = (query) => ({ [LogicalOperator.AND]: Object.keys(query).map((key) => ({ [key]: query[key] })) }); // When `auto` is `true`, the parse function will infer and initialize and add // the appropriate `Searcher` instance function parse(query, options, { auto = true } = {}) { const next = (query) => { let keys = Object.keys(query); const isQueryPath = isPath(query); if (!isQueryPath && keys.length > 1 && !isExpression(query)) { return next(convertToExplicit(query)) } if (isLeaf(query)) { const key = isQueryPath ? query[KeyType.PATH] : keys[0]; const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key]; if (!isString(pattern)) { throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key)) } const obj = { keyId: createKeyId(key), pattern }; if (auto) { obj.searcher = createSearcher(pattern, options); } return obj } let node = { children: [], operator: keys[0] }; keys.forEach((key) => { const value = query[key]; if (isArray(value)) { value.forEach((item) => { node.children.push(next(item)); }); } }); return node }; if (!isExpression(query)) { query = convertToExplicit(query); } return next(query) } // Practical scoring function function computeScore( results, { ignoreFieldNorm = Config.ignoreFieldNorm } ) { results.forEach((result) => { let totalScore = 1; result.matches.forEach(({ key, norm, score }) => { const weight = key ? key.weight : null; totalScore *= Math.pow( score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm) ); }); result.score = totalScore; }); } function transformMatches(result, data) { const matches = result.matches; data.matches = []; if (!isDefined(matches)) { return } matches.forEach((match) => { if (!isDefined(match.indices) || !match.indices.length) { return } const { indices, value } = match; let obj = { indices, value }; if (match.key) { obj.key = match.key.src; } if (match.idx > -1) { obj.refIndex = match.idx; } data.matches.push(obj); }); } function transformScore(result, data) { data.score = result.score; } function format( results, docs, { includeMatches = Config.includeMatches, includeScore = Config.includeScore } = {} ) { const transformers = []; if (includeMatches) transformers.push(transformMatches); if (includeScore) transformers.push(transformScore); return results.map((result) => { const { idx } = result; const data = { item: docs[idx], refIndex: idx }; if (transformers.length) { transformers.forEach((transformer) => { transformer(result, data); }); } return data }) } class Fuse { constructor(docs, options = {}, index) { this.options = { ...Config, ...options }; if ( this.options.useExtendedSearch && !true ) { throw new Error(EXTENDED_SEARCH_UNAVAILABLE) } this._keyStore = new KeyStore(this.options.keys); this.setCollection(docs, index); } setCollection(docs, index) { this._docs = docs; if (index && !(index instanceof FuseIndex)) { throw new Error(INCORRECT_INDEX_TYPE) } this._myIndex = index || createIndex(this.options.keys, this._docs, { getFn: this.options.getFn, fieldNormWeight: this.options.fieldNormWeight }); } add(doc) { if (!isDefined(doc)) { return } this._docs.push(doc); this._myIndex.add(doc); } remove(predicate = (/* doc, idx */) => false) { const results = []; for (let i = 0, len = this._docs.length; i < len; i += 1) { const doc = this._docs[i]; if (predicate(doc, i)) { this.removeAt(i); i -= 1; len -= 1; results.push(doc); } } return results } removeAt(idx) { this._docs.splice(idx, 1); this._myIndex.removeAt(idx); } getIndex() { return this._myIndex } search(query, { limit = -1 } = {}) { const { includeMatches, includeScore, shouldSort, sortFn, ignoreFieldNorm } = this.options; let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query); computeScore(results, { ignoreFieldNorm }); if (shouldSort) { results.sort(sortFn); } if (isNumber(limit) && limit > -1) { results = results.slice(0, limit); } return format(results, this._docs, { includeMatches, includeScore }) } _searchStringList(query) { const searcher = createSearcher(query, this.options); const { records } = this._myIndex; const results = []; // Iterate over every string in the index records.forEach(({ v: text, i: idx, n: norm }) => { if (!isDefined(text)) { return } const { isMatch, score, indices } = searcher.searchIn(text); if (isMatch) { results.push({ item: text, idx, matches: [{ score, value: text, norm, indices }] }); } }); return results } _searchLogical(query) { const expression = parse(query, this.options); const evaluate = (node, item, idx) => { if (!node.children) { const { keyId, searcher } = node; const matches = this._findMatches({ key: this._keyStore.get(keyId), value: this._myIndex.getValueForItemAtKeyId(item, keyId), searcher }); if (matches && matches.length) { return [ { idx, item, matches } ] } return [] } const res = []; for (let i = 0, len = node.children.length; i < len; i += 1) { const child = node.children[i]; const result = evaluate(child, item, idx); if (result.length) { res.push(...result); } else if (node.operator === LogicalOperator.AND) { return [] } } return res }; const records = this._myIndex.records; const resultMap = {}; const results = []; records.forEach(({ $: item, i: idx }) => { if (isDefined(item)) { let expResults = evaluate(expression, item, idx); if (expResults.length) { // Dedupe when adding if (!resultMap[idx]) { resultMap[idx] = { idx, item, matches: [] }; results.push(resultMap[idx]); } expResults.forEach(({ matches }) => { resultMap[idx].matches.push(...matches); }); } } }); return results } _searchObjectList(query) { const searcher = createSearcher(query, this.options); const { keys, records } = this._myIndex; const results = []; // List is Array<Object> records.forEach(({ $: item, i: idx }) => { if (!isDefined(item)) { return } let matches = []; // Iterate over every key (i.e, path), and fetch the value at that key keys.forEach((key, keyIndex) => { matches.push( ...this._findMatches({ key, value: item[keyIndex], searcher }) ); }); if (matches.length) { results.push({ idx, item, matches }); } }); return results } _findMatches({ key, value, searcher }) { if (!isDefined(value)) { return [] } let matches = []; if (isArray(value)) { value.forEach(({ v: text, i: idx, n: norm }) => { if (!isDefined(text)) { return } const { isMatch, score, indices } = searcher.searchIn(text); if (isMatch) { matches.push({ score, key, value: text, idx, norm, indices }); } }); } else { const { v: text, n: norm } = value; const { isMatch, score, indices } = searcher.searchIn(text); if (isMatch) { matches.push({ score, key, value: text, norm, indices }); } } return matches } } Fuse.version = '6.6.2'; Fuse.createIndex = createIndex; Fuse.parseIndex = parseIndex; Fuse.config = Config; { Fuse.parseQuery = parse; } { register(ExtendedSearch); } const scSelectCss = ":host{display:block;--focus-ring:0 0 0 var(--sc-focus-ring-width) var(--sc-focus-ring-color-primary)}.search{margin:var(--sc-spacing-x-small) var(--sc-spacing-x-small) 0 var(--sc-spacing-x-small)}.loading{text-align:center;margin:var(--sc-spacing-small)}.select{font-family:var(--sc-input-font-family);font-weight:var(--sc-font-weight-normal)}sc-dropdown{display:block}.trigger{overflow:hidden;box-sizing:border-box;width:100%;display:flex;align-items:center;justify-content:space-between;width:100%;border-style:solid;border-width:var(--sc-input-border-width);background-color:var(--sc-select-background-color, var(--sc-color-white));border-color:var(--sc-select-border-color, var(--sc-color-gray-300));color:var(--sc-input-color);text-decoration:none;user-select:none;white-space:nowrap;vertical-align:middle;transition:var(--sc-input-transition, var(--sc-transition-medium)) background-color, var(--sc-input-transition, var(--sc-transition-medium)) color, var(--sc-input-transition, var(--sc-transition-medium)) border, var(--sc-input-transition, var(--sc-transition-medium)) box-shadow;cursor:inherit;box-shadow:var(--sc-shadow-small);font-size:var(--sc-button-font-size-medium);min-height:var(--sc-input-height-medium);line-height:calc(var(--sc-input-height-medium) - var(--sc-input-border-width) * 2);border-radius:var(--sc-input-border-radius-medium);padding:0 var(--sc-spacing-medium)}.trigger svg{display:block;width:1em;height:1em}.select.select--focused:not(.select--disabled) .trigger{background-color:var(--sc-input-background-color-focus);border-color:var(--sc-input-border-color-focus);box-shadow:var(--focus-ring);z-index:2}.select--disabled{cursor:not-allowed}.select--disabled sc-dropdown{opacity:0.65}.select__value{overflow:hidden;text-overflow:ellipsis}.select__empty{text-align:center;margin:var(--sc-spacing-small);color:var(--sc-color-gray-400)}.select--placeholder .trigger{color:var(--sc-input-placeholder-color)}.select__hidden-input{position:absolute;opacity:0;padding:0px;margin:0px;pointer-events:none;width:0}.select__suffix-description,.select__description{font-size:var(--sc-input-help-text-font-size-medium);opacity:0.65}.select__caret{transition:transform 0.25s ease;line-height:0}.select--is-open .select__caret{transform:rotate(180deg)}.select--squared .trigger{border-radius:0}.select--squared-top .trigger{border-top-left-radius:0;border-top-right-radius:0}.select--squared-bottom .trigger{border-bottom-left-radius:0;border-bottom-right-radius:0}.select--squared-left .trigger{border-top-left-radius:0;border-bottom-left-radius:0}.select--squared-right .trigger{border-top-right-radius:0;border-bottom-right-radius:0}.choice__icon--image{width:18px;height:18px;object-fit:contain}sc-menu-item.is-unavailable{--sc-menu-item-color:var(--sc-color-gray-500)}"; const ScSelectStyle0 = scSelectCss; let id = 0; let itemIndex = 0; let arrowFlag = ''; const ScSelectDropdown = class { constructor(hostRef) { registerInstance(this, hostRef); this.scSearch = createEvent(this, "scSearch", 7); this.scOpen = createEvent(this, "scOpen", 7); this.scClose = createEvent(this, "scClose", 7); this.scBlur = createEvent(this, "scBlur", 7); this.scFocus = createEvent(this, "scFocus", 7); this.scChange = createEvent(this, "scChange", 7); this.scScrollEnd = createEvent(this, "scScrollEnd", 7); this.inputId = `select-${++id}`; this.helpId = `select-help-text-${id}`; this.labelId = `select-label-${id}`; this.autocomplete = undefined; this.placeholder = ''; this.searchPlaceholder = ''; this.value = ''; this.choices = []; this.unselect = true; this.required = undefined; this.loading = undefined; this.search = undefined; this.closeOnSelect = true; this.name = undefined; this.help = undefined; this.label = undefined; this.size = 'medium'; this.position = 'bottom-right'; this.placement = 'bottom-start'; this.invalid = false; this.open = undefined; this.disabled = undefined; this.showParentLabel = true; this.hoist = false; this.squared = undefined; this.squaredBottom = undefined; this.squaredTop = undefined; this.squaredLeft = undefined; this.squaredRight = undefined; this.hasFocus = false; this.searchTerm = ''; this.filteredChoices = []; } /** Trigger focus on show */ handleShow() { this.open = true; setTimeout(() => { this.searchInput && this.searchInput.triggerFocus(); }, 50); } handleHide() { this.open = false; itemIndex = 0; this.scClose.emit(); } handleBlur() { this.hasFocus = false; this.scBlur.emit(); } handleFocus() { this.hasFocus = true; this.el.focus(); this.scFocus.emit(); } /** Get the display value of the item. */ displayValue() { var _a; if (!this.value) return false; let chosen = this.choices.find(choice => choice.value == this.value); let append = ''; if (!chosen) { if (this.showParentLabel) { append = (_a = this.choices.find(choice => { var _a, _b; return (_b = (_a = choice === null || choice === void 0 ? void 0 : choice.choices) === null || _a === void 0 ? void 0 : _a.some) === null || _b === void 0 ? void 0 : _b.call(_a, subChoice => subChoice.value === this.value); })) === null || _a === void 0 ? void 0 : _a.label; } const subchoices = (this.choices || []).map(choice => choice.choices).flat(); chosen = subchoices.find(choice => (choice === null || choice === void 0 ? void 0 : choice.value) == this.value); } if (chosen) { return `${append ? append + ' — ' : ''}${chosen === null || chosen === void 0 ? void 0 : chosen.label}`; } return false; } isChecked({ value, checked = false }) { if (checked) { return true; } return !!value && this.value === value; } /** Sets a custom validation message. If `message` is not empty, the field will be considered invalid. */ async setCustomValidity(message) { this.input.setCustomValidity(message); this.invalid = !this.input.checkValidity(); } async reportValidity() { return this.input.reportValidity(); } handleQuery(e) { this.searchTerm = e.target.value; this.scSearch.emit(this.searchTerm); } handleSelect(choice) { const { value } = choice; if (this.value === value && this.unselect) { this.value = ''; } else { this.value = value; } if (this.closeOnSelect) { this.searchTerm = ''; } this.scChange.emit(choice); } handleInputChange() { // Sync autofilled value to component state if (!this.input || this.input.value === this.value) return; const inputValue = this.input.value; // Match by value (code) or label (name) since Chrome may autofill either const choice = this.choices.find(c => c.value === inputValue || c.label === inputValue); if (choice) { this.value = choice.value; this.scChange.emit(choice); } } handleSearchChange() { const fuse = new Fuse(this.choices, { keys: ['value', 'label'], }); if (this.searchTerm) { const results = fuse.search(this.searchTerm); this.filteredChoices = results.map(result => result.item); } else { this.filteredChoices = this.choices; } } handleValueChange() { if (this.input) { this.invalid = !this.input.checkValidity(); } } handleOpenChange() { if (this.open) { this.scOpen.emit(); this.searchInput && this.searchInput.triggerFocus(); } else { this.scClose.emit(); } } handleMenuScroll(e) { const scrollTop = e.target.scrollTop; const scrollHeight = e.target.scrollHeight; const offsetHeight = e.target.offsetHeight; const contentHeight = scrollHeight - offsetHeight; if (contentHeight - scrollTop < 5) this.scScrollEnd.emit(); } componentWillLoad() { this.handleSearchChange(); } componentDidLoad() { this.formController = new FormSubmitController(this.el).addFormData(); if (this.open) { this.searchInput && this.searchInput.triggerFocus(); } } getItems() { return [...this.el.shadowRoot.querySelectorAll('sc-menu-item')]; } handleKeyDown(event) { var _a, _b; event.stopPropagation(); const target = event.target; const items = this.getItems(); // Ignore key presses on tags if (target.tagName.toLowerCase() === 'sc-tag') { return; } // Tabbing out of the control closes it if (event.key === 'Tab') { if (this.open) { this.handleHide(); } return; } // Up/down opens the menu if (['ArrowDown', 'ArrowUp'].includes(event.key)) { event.preventDefault(); // Show the menu if it's not already open if (!this.open) { this.handleShow(); } // Focus on a menu item if (event.key === 'ArrowDown') { if (arrowFlag == 'up') { itemIndex = itemIndex + 2; } if (itemIndex > items.length - 1) { itemIndex = 0; } items[itemIndex].setFocus(); arrowFlag = 'down'; itemIndex++; return; } if (event.key === 'ArrowUp') { if (arrowFlag == 'down') { itemIndex = itemIndex - 2; } if (itemIndex < 0) { itemIndex = items.length - 1; } items[itemIndex].setFocus(); arrowFlag = 'up'; itemIndex--; return; } } // Close select dropdown on Esc/Escape key if (event.key === 'Escape') { if (this.open) { this.input.focus(); this.handleHide(); } return; } // Open select dropdown with Enter if (event.key === 'Enter') { if (this.open) { (_b = (_a = items[itemIndex - 1]) === null || _a === void 0 ? void 0 : _a.click) === null || _b === void 0 ? void 0 : _b.call(_a); this.handleHide(); this.input.focus(); } else { this.handleShow(); } } // don't open the menu when a CTRL/Command key is pressed if (event.ctrlKey || event.metaKey) { return; } // All other "printable" keys open the menu and initiate type to select // TODO: this is closing out the dropdown during typing events. // FIX: It must have focus as well. And it fix the random closing issue. if (!this.open && this.hasFocus && event.key.length === 1) { this.handleShow(); } } disconnectedCallback() { var _a; (_a = this.formController) === null || _a === void 0 ? void 0 : _a.removeFormData(); } renderIcon(icon) { if (isValidURL(icon)) { return h("img", { src: icon, alt: "icon", slot: "prefix", class: "choice__icon--image" }); } return h("sc-icon", { name: icon, slot: "prefix", class: "choice__icon" }); } renderItem(choice, index) { var _a; const uniqueKey = `${(choice === null || choice === void 0 ? void 0 : choice.value) || (choice === null || choice === void 0 ? void 0 : choice.label) || 'item'}-${index}`; if ((_a = choice === null || choice === void 0 ? void 0 : choice.choices) === null || _a === void 0 ? void 0 : _a.length) { return h("sc-menu-label", { key: uniqueKey }, choice === null || choice === void 0 ? void 0 : choice.label); } return (h("sc-menu-item", { class: { 'is-unavailable': choice === null || choice === void 0 ? void 0 : choice.unavailable }, key: uniqueKey, checked: this.isChecked(choice), value: choice === null || choice === void 0 ? void 0 : choice.value, onClick: () => !choice.disabled && this.handleSelect(choice), onKeyDown: event => { if ((event.key === 'Enter' || event.key === ' ') && !choice.disabled) { event.preventDefault(); event.stopImmediatePropagation(); this.handleSelect(choice); } }, disabled: choice.disabled, "aria-label": choice.label, "aria-selected": this.isChecked(choice) ? 'true' : 'false', role: "option" }, choice.label, !!(choice === null || choice === void 0 ? void 0 : choice.description) && h("div", { class: "select__description" }, choice === null || choice === void 0 ? void 0 : choice.description), h("div", { slot: "suffix" }, choice === null || choice === void 0 ? void 0 : choice.suffix, " ", !!(choice === null || choice === void 0 ? void 0 : choice.suffixDescription) && h("div", { class: "select__suffix-description" }, choice === null || choice === void 0 ? void 0 : choice.suffixDescription)), !!(choice === null || choice === void 0 ? void 0 : choice.icon) && this.renderIcon(choice.icon))); } render() { var _a; return (h("div", { key: '8723f64204f4decb402ac16f0c89f8c29a837094', part: "base", class: { 'select': true, 'select--placeholder': !this.value, 'select--focused': this.hasFocus, 'select--is-open': !!this.open, 'select--disabled': this.disabled, 'select--has-choices': !!((_a = this === null || this === void 0 ? void 0 : this.choices) === null || _a === void 0 ? void 0 : _a.length), 'select--squared': this.squared, 'select--squared-bottom': this.squaredBottom, 'select--squared-top': this.squaredTop, 'select--squared-left': this.squaredLeft, 'select--squared-right': this.squaredRight, } }, h("sc-form-control", { key: '4a891c1a1df64282ca685fff5f0a45e0bbfcc192', exportparts: "label, help-text, form-control", size: this.size, required: this.required, label: this.label, help: this.help, inputId: this.inputId, helpId: this.helpId, labelId: this.labelId, name: this.name }, h("input", { key: '520ddaa285bc8673505e89e3fa38fa93ba85ba02', class: "select__hidden-input", name: this.name, ref: el => (this.input = el), value: this.value, required: this.required, disabled: this.disabled, autocomplete: this.autocomplete, tabindex: "-1", "aria-label": this.displayValue() || this.label || this.placeholder, onBlur: () => this.handleBlur(), onFocus: () => this.handleFocus(), onChange: () => this.handleInputChange() }), h("sc-dropdown", { key: '488b1b83550a2764566e911b081e86527ac83efc', exportparts: "trigger, panel", disabled: this.disabled, open: this.open, closeOnSelect: this.closeOnSelect, position: this.position, placement: this.placement, hoist: this.hoist, style: { '--panel-width': '100%' }, onScShow: () => this.handleShow(), onScHide: () => this.handleHide(), role: "select", "aria-open": this.open ? 'true' : 'false' }, h("slot", { key: 'b32837db2632b5dfaf7a6bf1c7616fbd6f2e04f6', name: "trigger", slot: "trigger" }, h("div", { key: '0fe498e85b915ca0e9fdcf2308f5dba16551d10e', class: "trigger", role: "button", tabIndex: -1, onFocus: () => this.handleFocus(), onBlur: () => this.handleBlur() }, h("div", { key: 'f625f7abf173ca51b09dacd5d90cbb0106855f4f', class: "select__value" }, h("slot", { key: '733f4db7431861f504d5a5355e55e0653b34ab0d' }, this.displayValue() || this.placeholder || wp.i18n.__('Select...', 'surecart'))), h("sc-icon", { key: '0c17d80847d5059775ae49d9e378c0057b97b868', exportparts: "base:caret", class: "select__caret", name: "chevron-down" }))), this.search && (h("sc-input", { key: '5b3cd56595c3b89d9e189b5bd9af11f2d0395347', exportparts: "base:search__base, input:search__input, form-control:search__form-control", placeholder: this.searchPlaceholder || wp.i18n.__('Search...', 'surecart'), onScInput: e => this.handleQuery(e), class: "search", clearable: true, part: "search", value: this.searchTerm, ref: el => (this.searchInput = el), "aria-label": wp.i18n.__('Type to search', 'surecart') }, this.loading && h("sc-spinner", { key: '340dcc9e21e47ce828af378fb9f00dba1440c96d', exportparts: "base:spinner__base", style: { '--spinner-size': '0.5em' }, slot: "suffix" }))), h("sc-menu", { key: 'eb7ae9ff421102944698c128c1b4c25652d92746', style: { maxHeight: this.open ? '210px' : '0px', overflow: 'auto' }, exportparts: "base:menu__base", onScroll: e => this.handleMenuScroll(e), "aria-multiselectable": "false" }, h("slot", { key: '624d5c6b7d50a47bac9a58ccf115e2fd249d0eec', name: "prefix" }), (this.filteredChoices || []).map((choice, index) => { return [this.renderItem(choice, index), (choice.choices || []).map(choice => this.renderItem(choice, index))]; }), this.loading && (h("div", { key: '3610d8abe3d18bf8f5532add0e50d7bf9a4d73bf', class: "loading" }, h("sc-spinner", { key: '5be658d486ee713f49463daad2b988427904f9c3', exportparts: "base:spinner__base" }))), !this.loading && !this.filteredChoices.length && (h("div", { key: 'f499f04d1216bfde2ddcddadb3994b86194f88be', class: "select__empty", part: "empty" }, wp.i18n.__('Nothing Found', 'surecart'))), h("slot", { key: '06f9386b4d9adf1c595ff18dad10c1f9c0d59988', name: "suffix" })))))); } get el() { return getElement(this); } static get watchers() { return { "searchTerm": ["handleSearchChange"], "choices": ["handleSearchChange"], "value": ["handleValueChange"], "open": ["handleOpenChange"] }; } }; ScSelectDropdown.style = ScSelectStyle0; export { ScMenuLabel as sc_menu_label, ScSelectDropdown as sc_select }; //# sourceMappingURL=sc-menu-label_2.entry.js.map
Save
Back