fastapi-rtk 0.1.12 → 0.1.14

package/dist/external/esm/@tanstack_match-sorter-utils@8.19.4/node_modules/@tanstack/match-sorter-utils/build/lib/index.mjs

@@ -0,0 +1,617 @@
+/**
+   * match-sorter-utils
+   *
+   * Copyright (c) TanStack
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   */
+const characterMap = {
+  À: "A",
+  Á: "A",
+  Â: "A",
+  Ã: "A",
+  Ä: "A",
+  Å: "A",
+  Ấ: "A",
+  Ắ: "A",
+  Ẳ: "A",
+  Ẵ: "A",
+  Ặ: "A",
+  Æ: "AE",
+  Ầ: "A",
+  Ằ: "A",
+  Ȃ: "A",
+  Ç: "C",
+  Ḉ: "C",
+  È: "E",
+  É: "E",
+  Ê: "E",
+  Ë: "E",
+  Ế: "E",
+  Ḗ: "E",
+  Ề: "E",
+  Ḕ: "E",
+  Ḝ: "E",
+  Ȇ: "E",
+  Ì: "I",
+  Í: "I",
+  Î: "I",
+  Ï: "I",
+  Ḯ: "I",
+  Ȋ: "I",
+  Ð: "D",
+  Ñ: "N",
+  Ò: "O",
+  Ó: "O",
+  Ô: "O",
+  Õ: "O",
+  Ö: "O",
+  Ø: "O",
+  Ố: "O",
+  Ṍ: "O",
+  Ṓ: "O",
+  Ȏ: "O",
+  Ù: "U",
+  Ú: "U",
+  Û: "U",
+  Ü: "U",
+  Ý: "Y",
+  à: "a",
+  á: "a",
+  â: "a",
+  ã: "a",
+  ä: "a",
+  å: "a",
+  ấ: "a",
+  ắ: "a",
+  ẳ: "a",
+  ẵ: "a",
+  ặ: "a",
+  æ: "ae",
+  ầ: "a",
+  ằ: "a",
+  ȃ: "a",
+  ç: "c",
+  ḉ: "c",
+  è: "e",
+  é: "e",
+  ê: "e",
+  ë: "e",
+  ế: "e",
+  ḗ: "e",
+  ề: "e",
+  ḕ: "e",
+  ḝ: "e",
+  ȇ: "e",
+  ì: "i",
+  í: "i",
+  î: "i",
+  ï: "i",
+  ḯ: "i",
+  ȋ: "i",
+  ð: "d",
+  ñ: "n",
+  ò: "o",
+  ó: "o",
+  ô: "o",
+  õ: "o",
+  ö: "o",
+  ø: "o",
+  ố: "o",
+  ṍ: "o",
+  ṓ: "o",
+  ȏ: "o",
+  ù: "u",
+  ú: "u",
+  û: "u",
+  ü: "u",
+  ý: "y",
+  ÿ: "y",
+  Ā: "A",
+  ā: "a",
+  Ă: "A",
+  ă: "a",
+  Ą: "A",
+  ą: "a",
+  Ć: "C",
+  ć: "c",
+  Ĉ: "C",
+  ĉ: "c",
+  Ċ: "C",
+  ċ: "c",
+  Č: "C",
+  č: "c",
+  C̆: "C",
+  c̆: "c",
+  Ď: "D",
+  ď: "d",
+  Đ: "D",
+  đ: "d",
+  Ē: "E",
+  ē: "e",
+  Ĕ: "E",
+  ĕ: "e",
+  Ė: "E",
+  ė: "e",
+  Ę: "E",
+  ę: "e",
+  Ě: "E",
+  ě: "e",
+  Ĝ: "G",
+  Ǵ: "G",
+  ĝ: "g",
+  ǵ: "g",
+  Ğ: "G",
+  ğ: "g",
+  Ġ: "G",
+  ġ: "g",
+  Ģ: "G",
+  ģ: "g",
+  Ĥ: "H",
+  ĥ: "h",
+  Ħ: "H",
+  ħ: "h",
+  Ḫ: "H",
+  ḫ: "h",
+  Ĩ: "I",
+  ĩ: "i",
+  Ī: "I",
+  ī: "i",
+  Ĭ: "I",
+  ĭ: "i",
+  Į: "I",
+  į: "i",
+  İ: "I",
+  ı: "i",
+  IJ: "IJ",
+  ij: "ij",
+  Ĵ: "J",
+  ĵ: "j",
+  Ķ: "K",
+  ķ: "k",
+  Ḱ: "K",
+  ḱ: "k",
+  K̆: "K",
+  k̆: "k",
+  Ĺ: "L",
+  ĺ: "l",
+  Ļ: "L",
+  ļ: "l",
+  Ľ: "L",
+  ľ: "l",
+  Ŀ: "L",
+  ŀ: "l",
+  Ł: "l",
+  ł: "l",
+  Ḿ: "M",
+  ḿ: "m",
+  M̆: "M",
+  m̆: "m",
+  Ń: "N",
+  ń: "n",
+  Ņ: "N",
+  ņ: "n",
+  Ň: "N",
+  ň: "n",
+  ʼn: "n",
+  N̆: "N",
+  n̆: "n",
+  Ō: "O",
+  ō: "o",
+  Ŏ: "O",
+  ŏ: "o",
+  Ő: "O",
+  ő: "o",
+  Œ: "OE",
+  œ: "oe",
+  P̆: "P",
+  p̆: "p",
+  Ŕ: "R",
+  ŕ: "r",
+  Ŗ: "R",
+  ŗ: "r",
+  Ř: "R",
+  ř: "r",
+  R̆: "R",
+  r̆: "r",
+  Ȓ: "R",
+  ȓ: "r",
+  Ś: "S",
+  ś: "s",
+  Ŝ: "S",
+  ŝ: "s",
+  Ş: "S",
+  Ș: "S",
+  ș: "s",
+  ş: "s",
+  Š: "S",
+  š: "s",
+  Ţ: "T",
+  ţ: "t",
+  ț: "t",
+  Ț: "T",
+  Ť: "T",
+  ť: "t",
+  Ŧ: "T",
+  ŧ: "t",
+  T̆: "T",
+  t̆: "t",
+  Ũ: "U",
+  ũ: "u",
+  Ū: "U",
+  ū: "u",
+  Ŭ: "U",
+  ŭ: "u",
+  Ů: "U",
+  ů: "u",
+  Ű: "U",
+  ű: "u",
+  Ų: "U",
+  ų: "u",
+  Ȗ: "U",
+  ȗ: "u",
+  V̆: "V",
+  v̆: "v",
+  Ŵ: "W",
+  ŵ: "w",
+  Ẃ: "W",
+  ẃ: "w",
+  X̆: "X",
+  x̆: "x",
+  Ŷ: "Y",
+  ŷ: "y",
+  Ÿ: "Y",
+  Y̆: "Y",
+  y̆: "y",
+  Ź: "Z",
+  ź: "z",
+  Ż: "Z",
+  ż: "z",
+  Ž: "Z",
+  ž: "z",
+  ſ: "s",
+  ƒ: "f",
+  Ơ: "O",
+  ơ: "o",
+  Ư: "U",
+  ư: "u",
+  Ǎ: "A",
+  ǎ: "a",
+  Ǐ: "I",
+  ǐ: "i",
+  Ǒ: "O",
+  ǒ: "o",
+  Ǔ: "U",
+  ǔ: "u",
+  Ǖ: "U",
+  ǖ: "u",
+  Ǘ: "U",
+  ǘ: "u",
+  Ǚ: "U",
+  ǚ: "u",
+  Ǜ: "U",
+  ǜ: "u",
+  Ứ: "U",
+  ứ: "u",
+  Ṹ: "U",
+  ṹ: "u",
+  Ǻ: "A",
+  ǻ: "a",
+  Ǽ: "AE",
+  ǽ: "ae",
+  Ǿ: "O",
+  ǿ: "o",
+  Þ: "TH",
+  þ: "th",
+  Ṕ: "P",
+  ṕ: "p",
+  Ṥ: "S",
+  ṥ: "s",
+  X́: "X",
+  x́: "x",
+  Ѓ: "Г",
+  ѓ: "г",
+  Ќ: "К",
+  ќ: "к",
+  A̋: "A",
+  a̋: "a",
+  E̋: "E",
+  e̋: "e",
+  I̋: "I",
+  i̋: "i",
+  Ǹ: "N",
+  ǹ: "n",
+  Ồ: "O",
+  ồ: "o",
+  Ṑ: "O",
+  ṑ: "o",
+  Ừ: "U",
+  ừ: "u",
+  Ẁ: "W",
+  ẁ: "w",
+  Ỳ: "Y",
+  ỳ: "y",
+  Ȁ: "A",
+  ȁ: "a",
+  Ȅ: "E",
+  ȅ: "e",
+  Ȉ: "I",
+  ȉ: "i",
+  Ȍ: "O",
+  ȍ: "o",
+  Ȑ: "R",
+  ȑ: "r",
+  Ȕ: "U",
+  ȕ: "u",
+  B̌: "B",
+  b̌: "b",
+  Č̣: "C",
+  č̣: "c",
+  Ê̌: "E",
+  ê̌: "e",
+  F̌: "F",
+  f̌: "f",
+  Ǧ: "G",
+  ǧ: "g",
+  Ȟ: "H",
+  ȟ: "h",
+  J̌: "J",
+  ǰ: "j",
+  Ǩ: "K",
+  ǩ: "k",
+  M̌: "M",
+  m̌: "m",
+  P̌: "P",
+  p̌: "p",
+  Q̌: "Q",
+  q̌: "q",
+  Ř̩: "R",
+  ř̩: "r",
+  Ṧ: "S",
+  ṧ: "s",
+  V̌: "V",
+  v̌: "v",
+  W̌: "W",
+  w̌: "w",
+  X̌: "X",
+  x̌: "x",
+  Y̌: "Y",
+  y̌: "y",
+  A̧: "A",
+  a̧: "a",
+  B̧: "B",
+  b̧: "b",
+  Ḑ: "D",
+  ḑ: "d",
+  Ȩ: "E",
+  ȩ: "e",
+  Ɛ̧: "E",
+  ɛ̧: "e",
+  Ḩ: "H",
+  ḩ: "h",
+  I̧: "I",
+  i̧: "i",
+  Ɨ̧: "I",
+  ɨ̧: "i",
+  M̧: "M",
+  m̧: "m",
+  O̧: "O",
+  o̧: "o",
+  Q̧: "Q",
+  q̧: "q",
+  U̧: "U",
+  u̧: "u",
+  X̧: "X",
+  x̧: "x",
+  Z̧: "Z",
+  z̧: "z"
+};
+const chars = Object.keys(characterMap).join("|");
+const allAccents = new RegExp(chars, "g");
+function removeAccents(str) {
+  return str.replace(allAccents, (match) => {
+    return characterMap[match];
+  });
+}
+/**
+ * @name match-sorter
+ * @license MIT license.
+ * @copyright (c) 2099 Kent C. Dodds
+ * @author Kent C. Dodds <me@kentcdodds.com> (https://kentcdodds.com)
+ */
+const rankings = {
+  CASE_SENSITIVE_EQUAL: 7,
+  EQUAL: 6,
+  STARTS_WITH: 5,
+  WORD_STARTS_WITH: 4,
+  CONTAINS: 3,
+  ACRONYM: 2,
+  MATCHES: 1,
+  NO_MATCH: 0
+};
+function rankItem(item, value, options) {
+  var _options$threshold;
+  options = options || {};
+  options.threshold = (_options$threshold = options.threshold) != null ? _options$threshold : rankings.MATCHES;
+  if (!options.accessors) {
+    const rank = getMatchRanking(item, value, options);
+    return {
+      // ends up being duplicate of 'item' in matches but consistent
+      rankedValue: item,
+      rank,
+      accessorIndex: -1,
+      accessorThreshold: options.threshold,
+      passed: rank >= options.threshold
+    };
+  }
+  const valuesToRank = getAllValuesToRank(item, options.accessors);
+  const rankingInfo = {
+    rankedValue: item,
+    rank: rankings.NO_MATCH,
+    accessorIndex: -1,
+    accessorThreshold: options.threshold,
+    passed: false
+  };
+  for (let i = 0; i < valuesToRank.length; i++) {
+    const rankValue = valuesToRank[i];
+    let newRank = getMatchRanking(rankValue.itemValue, value, options);
+    const {
+      minRanking,
+      maxRanking,
+      threshold = options.threshold
+    } = rankValue.attributes;
+    if (newRank < minRanking && newRank >= rankings.MATCHES) {
+      newRank = minRanking;
+    } else if (newRank > maxRanking) {
+      newRank = maxRanking;
+    }
+    newRank = Math.min(newRank, maxRanking);
+    if (newRank >= threshold && newRank > rankingInfo.rank) {
+      rankingInfo.rank = newRank;
+      rankingInfo.passed = true;
+      rankingInfo.accessorIndex = i;
+      rankingInfo.accessorThreshold = threshold;
+      rankingInfo.rankedValue = rankValue.itemValue;
+    }
+  }
+  return rankingInfo;
+}
+function getMatchRanking(testString, stringToRank, options) {
+  testString = prepareValueForComparison(testString, options);
+  stringToRank = prepareValueForComparison(stringToRank, options);
+  if (stringToRank.length > testString.length) {
+    return rankings.NO_MATCH;
+  }
+  if (testString === stringToRank) {
+    return rankings.CASE_SENSITIVE_EQUAL;
+  }
+  testString = testString.toLowerCase();
+  stringToRank = stringToRank.toLowerCase();
+  if (testString === stringToRank) {
+    return rankings.EQUAL;
+  }
+  if (testString.startsWith(stringToRank)) {
+    return rankings.STARTS_WITH;
+  }
+  if (testString.includes(` ${stringToRank}`)) {
+    return rankings.WORD_STARTS_WITH;
+  }
+  if (testString.includes(stringToRank)) {
+    return rankings.CONTAINS;
+  } else if (stringToRank.length === 1) {
+    return rankings.NO_MATCH;
+  }
+  if (getAcronym(testString).includes(stringToRank)) {
+    return rankings.ACRONYM;
+  }
+  return getClosenessRanking(testString, stringToRank);
+}
+function getAcronym(string) {
+  let acronym = "";
+  const wordsInString = string.split(" ");
+  wordsInString.forEach((wordInString) => {
+    const splitByHyphenWords = wordInString.split("-");
+    splitByHyphenWords.forEach((splitByHyphenWord) => {
+      acronym += splitByHyphenWord.substr(0, 1);
+    });
+  });
+  return acronym;
+}
+function getClosenessRanking(testString, stringToRank) {
+  let matchingInOrderCharCount = 0;
+  let charNumber = 0;
+  function findMatchingCharacter(matchChar, string, index) {
+    for (let j = index, J = string.length; j < J; j++) {
+      const stringChar = string[j];
+      if (stringChar === matchChar) {
+        matchingInOrderCharCount += 1;
+        return j + 1;
+      }
+    }
+    return -1;
+  }
+  function getRanking(spread2) {
+    const spreadPercentage = 1 / spread2;
+    const inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
+    const ranking = rankings.MATCHES + inOrderPercentage * spreadPercentage;
+    return ranking;
+  }
+  const firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
+  if (firstIndex < 0) {
+    return rankings.NO_MATCH;
+  }
+  charNumber = firstIndex;
+  for (let i = 1, I = stringToRank.length; i < I; i++) {
+    const matchChar = stringToRank[i];
+    charNumber = findMatchingCharacter(matchChar, testString, charNumber);
+    const found = charNumber > -1;
+    if (!found) {
+      return rankings.NO_MATCH;
+    }
+  }
+  const spread = charNumber - firstIndex;
+  return getRanking(spread);
+}
+function compareItems(a, b) {
+  return a.rank === b.rank ? 0 : a.rank > b.rank ? -1 : 1;
+}
+function prepareValueForComparison(value, _ref) {
+  let {
+    keepDiacritics
+  } = _ref;
+  value = `${value}`;
+  if (!keepDiacritics) {
+    value = removeAccents(value);
+  }
+  return value;
+}
+function getItemValues(item, accessor) {
+  let accessorFn = accessor;
+  if (typeof accessor === "object") {
+    accessorFn = accessor.accessor;
+  }
+  const value = accessorFn(item);
+  if (value == null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return [String(value)];
+}
+function getAllValuesToRank(item, accessors) {
+  const allValues = [];
+  for (let j = 0, J = accessors.length; j < J; j++) {
+    const accessor = accessors[j];
+    const attributes = getAccessorAttributes(accessor);
+    const itemValues = getItemValues(item, accessor);
+    for (let i = 0, I = itemValues.length; i < I; i++) {
+      allValues.push({
+        itemValue: itemValues[i],
+        attributes
+      });
+    }
+  }
+  return allValues;
+}
+const defaultKeyAttributes = {
+  maxRanking: Infinity,
+  minRanking: -Infinity
+};
+function getAccessorAttributes(accessor) {
+  if (typeof accessor === "function") {
+    return defaultKeyAttributes;
+  }
+  return {
+    ...defaultKeyAttributes,
+    ...accessor
+  };
+}
+export {
+  compareItems,
+  rankItem,
+  rankings
+};

package/dist/external/esm/@tanstack_query-core@5.75.0/node_modules/@tanstack/query-core/build/modern/focusManager.mjs

@@ -0,0 +1,77 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _focused, _cleanup, _setup, _a;
+import { Subscribable } from "./subscribable.mjs";
+import { isServer } from "./utils.mjs";
+var FocusManager = (_a = class extends Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _focused);
+    __privateAdd(this, _cleanup);
+    __privateAdd(this, _setup);
+    __privateSet(this, _setup, (onFocus) => {
+      if (!isServer && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    });
+  }
+  onSubscribe() {
+    if (!__privateGet(this, _cleanup)) {
+      this.setEventListener(__privateGet(this, _setup));
+    }
+  }
+  onUnsubscribe() {
+    var _a2;
+    if (!this.hasListeners()) {
+      (_a2 = __privateGet(this, _cleanup)) == null ? void 0 : _a2.call(this);
+      __privateSet(this, _cleanup, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a2;
+    __privateSet(this, _setup, setup);
+    (_a2 = __privateGet(this, _cleanup)) == null ? void 0 : _a2.call(this);
+    __privateSet(this, _cleanup, setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    }));
+  }
+  setFocused(focused) {
+    const changed = __privateGet(this, _focused) !== focused;
+    if (changed) {
+      __privateSet(this, _focused, focused);
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach((listener) => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    var _a2;
+    if (typeof __privateGet(this, _focused) === "boolean") {
+      return __privateGet(this, _focused);
+    }
+    return ((_a2 = globalThis.document) == null ? void 0 : _a2.visibilityState) !== "hidden";
+  }
+}, _focused = new WeakMap(), _cleanup = new WeakMap(), _setup = new WeakMap(), _a);
+var focusManager = new FocusManager();
+export {
+  FocusManager,
+  focusManager
+};