@orderingstack/front-hooks 3.0.0 → 3.2.0

package/dist/index.es.js

@@ -2981,13 +2981,13 @@ function CancelToken(executor) {
   this.promise = new Promise(function promiseExecutor(resolve) {
     resolvePromise = resolve;
   });
-  var token = this;
+  var token2 = this;
   executor(function cancel(message) {
-    if (token.reason) {
+    if (token2.reason) {
       return;
     }
-    token.reason = new Cancel(message);
-    resolvePromise(token.reason);
+    token2.reason = new Cancel(message);
+    resolvePromise(token2.reason);
   });
 }
 CancelToken.prototype.throwIfRequested = function throwIfRequested() {
@@ -2997,11 +2997,11 @@ CancelToken.prototype.throwIfRequested = function throwIfRequested() {
 };
 CancelToken.source = function source() {
   var cancel;
-  var token = new CancelToken(function executor(c) {
+  var token2 = new CancelToken(function executor(c) {
     cancel = c;
   });
   return {
-    token,
+    token: token2,
     cancel
   };
 };
@@ -3042,6 +3042,17 @@ axios$1.isAxiosError = isAxiosError;
 axios$2.exports = axios$1;
 axios$2.exports.default = axios$1;
 var axios = axios$2.exports;
+const getUrlFromLocalizedVenueMedia = (localizedVenueMedia, locale) => {
+  var _a, _b, _c;
+  if (localizedVenueMedia && ((_a = localizedVenueMedia == null ? void 0 : localizedVenueMedia.url) == null ? void 0 : _a.length) > 0) {
+    return ((_b = localizedVenueMedia.url.find((item) => item.locale === locale)) == null ? void 0 : _b.value) || ((_c = localizedVenueMedia.url.find((item) => item.locale === "*")) == null ? void 0 : _c.value) || null;
+  }
+  return null;
+};
+const getLocalizedVenueMediaFromArray = (localizedVenueMedia, venue) => {
+  var _a, _b;
+  return ((_a = localizedVenueMedia == null ? void 0 : localizedVenueMedia.find) == null ? void 0 : _a.call(localizedVenueMedia, (item) => item.venue === venue)) || ((_b = localizedVenueMedia == null ? void 0 : localizedVenueMedia.find) == null ? void 0 : _b.call(localizedVenueMedia, (item) => item.venue === "*"));
+};
 function useCms(id, intervalSeconds = 600, withLocalStorage = true, baseUrl, tenant) {
   var _a, _b;
   if (!baseUrl || !tenant) {
@@ -3129,6 +3140,30 @@ function useLocalizedVenueMedia(id, venue, locale, intervalSeconds = 300, withLo
   }
   return { url: localizedValue, fallbackUrl, isError };
 }
+function useKioskMediaCms({
+  kioskMediaId,
+  kioskMediaType,
+  intervalSeconds = 600,
+  withLocalStorage = true,
+  baseUrl,
+  tenant,
+  venue,
+  locale
+}) {
+  var _a;
+  const { value, isError, isLoading } = useCms(kioskMediaId, intervalSeconds, withLocalStorage, baseUrl, tenant);
+  const kioskMediaFoundType = (value == null ? void 0 : value[kioskMediaType]) || [];
+  const kioskMediaFoundTypeVenue = getLocalizedVenueMediaFromArray(kioskMediaFoundType, venue);
+  const localizedValue = getUrlFromLocalizedVenueMedia(kioskMediaFoundTypeVenue, locale);
+  const fallbackUrl = !localizedValue && kioskMediaFoundTypeVenue && ((_a = kioskMediaFoundTypeVenue == null ? void 0 : kioskMediaFoundTypeVenue.url) == null ? void 0 : _a.length) > 0 ? kioskMediaFoundTypeVenue.url[0].value : null;
+  return {
+    url: localizedValue,
+    fallbackUrl,
+    mediaType: kioskMediaFoundTypeVenue == null ? void 0 : kioskMediaFoundTypeVenue.mediaType,
+    isError,
+    isLoading
+  };
+}
 function useOnClickOutside(ref, handler) {
   useEffect(() => {
     const listener = (event) => {
@@ -3166,5 +3201,462 @@ function useKioskChannelsAvailability(channelConstrainst) {
   useInterval(checkOpen, 6e4);
   return { dineInOpen, takeAwayOpen };
 }
-export { getGroupedBucketLines, groupOrderLines, useAvailability, useCms, useDisplayPrice, useGroupOrderLines, useInterval, useKioskChannelsAvailability, useLocalizedVenueMedia, useOnClickOutside, useVenueCms };
+var queryString = {};
+var strictUriEncode = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+var token = "%[a-f0-9]{2}";
+var singleMatcher = new RegExp("(" + token + ")|([^%]+?)", "gi");
+var multiMatcher = new RegExp("(" + token + ")+", "gi");
+function decodeComponents(components, split) {
+  try {
+    return [decodeURIComponent(components.join(""))];
+  } catch (err) {
+  }
+  if (components.length === 1) {
+    return components;
+  }
+  split = split || 1;
+  var left = components.slice(0, split);
+  var right = components.slice(split);
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch (err) {
+    var tokens = input.match(singleMatcher) || [];
+    for (var i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join("");
+      tokens = input.match(singleMatcher) || [];
+    }
+    return input;
+  }
+}
+function customDecodeURIComponent(input) {
+  var replaceMap = {
+    "%FE%FF": "\uFFFD\uFFFD",
+    "%FF%FE": "\uFFFD\uFFFD"
+  };
+  var match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch (err) {
+      var result = decode(match[0]);
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+    match = multiMatcher.exec(input);
+  }
+  replaceMap["%C2"] = "\uFFFD";
+  var entries = Object.keys(replaceMap);
+  for (var i = 0; i < entries.length; i++) {
+    var key = entries[i];
+    input = input.replace(new RegExp(key, "g"), replaceMap[key]);
+  }
+  return input;
+}
+var decodeUriComponent = function(encodedURI) {
+  if (typeof encodedURI !== "string") {
+    throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
+  }
+  try {
+    encodedURI = encodedURI.replace(/\+/g, " ");
+    return decodeURIComponent(encodedURI);
+  } catch (err) {
+    return customDecodeURIComponent(encodedURI);
+  }
+};
+var splitOnFirst = (string, separator) => {
+  if (!(typeof string === "string" && typeof separator === "string")) {
+    throw new TypeError("Expected the arguments to be of type `string`");
+  }
+  if (separator === "") {
+    return [string];
+  }
+  const separatorIndex = string.indexOf(separator);
+  if (separatorIndex === -1) {
+    return [string];
+  }
+  return [
+    string.slice(0, separatorIndex),
+    string.slice(separatorIndex + separator.length)
+  ];
+};
+var filterObj = function(obj, predicate) {
+  var ret = {};
+  var keys2 = Object.keys(obj);
+  var isArr = Array.isArray(predicate);
+  for (var i = 0; i < keys2.length; i++) {
+    var key = keys2[i];
+    var val = obj[key];
+    if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
+      ret[key] = val;
+    }
+  }
+  return ret;
+};
+(function(exports) {
+  const strictUriEncode$1 = strictUriEncode;
+  const decodeComponent = decodeUriComponent;
+  const splitOnFirst$1 = splitOnFirst;
+  const filterObject = filterObj;
+  const isNullOrUndefined = (value) => value === null || value === void 0;
+  const encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
+  function encoderForArrayFormat(options) {
+    switch (options.arrayFormat) {
+      case "index":
+        return (key) => (result, value) => {
+          const index = result.length;
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode2(key, options), "[", index, "]"].join("")];
+          }
+          return [
+            ...result,
+            [encode2(key, options), "[", encode2(index, options), "]=", encode2(value, options)].join("")
+          ];
+        };
+      case "bracket":
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode2(key, options), "[]"].join("")];
+          }
+          return [...result, [encode2(key, options), "[]=", encode2(value, options)].join("")];
+        };
+      case "colon-list-separator":
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode2(key, options), ":list="].join("")];
+          }
+          return [...result, [encode2(key, options), ":list=", encode2(value, options)].join("")];
+        };
+      case "comma":
+      case "separator":
+      case "bracket-separator": {
+        const keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          value = value === null ? "" : value;
+          if (result.length === 0) {
+            return [[encode2(key, options), keyValueSep, encode2(value, options)].join("")];
+          }
+          return [[result, encode2(value, options)].join(options.arrayFormatSeparator)];
+        };
+      }
+      default:
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, encode2(key, options)];
+          }
+          return [...result, [encode2(key, options), "=", encode2(value, options)].join("")];
+        };
+    }
+  }
+  function parserForArrayFormat(options) {
+    let result;
+    switch (options.arrayFormat) {
+      case "index":
+        return (key, value, accumulator) => {
+          result = /\[(\d*)\]$/.exec(key);
+          key = key.replace(/\[\d*\]$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = {};
+          }
+          accumulator[key][result[1]] = value;
+        };
+      case "bracket":
+        return (key, value, accumulator) => {
+          result = /(\[\])$/.exec(key);
+          key = key.replace(/\[\]$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+      case "colon-list-separator":
+        return (key, value, accumulator) => {
+          result = /(:list)$/.exec(key);
+          key = key.replace(/:list$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+      case "comma":
+      case "separator":
+        return (key, value, accumulator) => {
+          const isArray2 = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+          const isEncodedArray = typeof value === "string" && !isArray2 && decode2(value, options).includes(options.arrayFormatSeparator);
+          value = isEncodedArray ? decode2(value, options) : value;
+          const newValue = isArray2 || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode2(item, options)) : value === null ? value : decode2(value, options);
+          accumulator[key] = newValue;
+        };
+      case "bracket-separator":
+        return (key, value, accumulator) => {
+          const isArray2 = /(\[\])$/.test(key);
+          key = key.replace(/\[\]$/, "");
+          if (!isArray2) {
+            accumulator[key] = value ? decode2(value, options) : value;
+            return;
+          }
+          const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map((item) => decode2(item, options));
+          if (accumulator[key] === void 0) {
+            accumulator[key] = arrayValue;
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], arrayValue);
+        };
+      default:
+        return (key, value, accumulator) => {
+          if (accumulator[key] === void 0) {
+            accumulator[key] = value;
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+    }
+  }
+  function validateArrayFormatSeparator(value) {
+    if (typeof value !== "string" || value.length !== 1) {
+      throw new TypeError("arrayFormatSeparator must be single character string");
+    }
+  }
+  function encode2(value, options) {
+    if (options.encode) {
+      return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
+    }
+    return value;
+  }
+  function decode2(value, options) {
+    if (options.decode) {
+      return decodeComponent(value);
+    }
+    return value;
+  }
+  function keysSorter(input) {
+    if (Array.isArray(input)) {
+      return input.sort();
+    }
+    if (typeof input === "object") {
+      return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
+    }
+    return input;
+  }
+  function removeHash(input) {
+    const hashStart = input.indexOf("#");
+    if (hashStart !== -1) {
+      input = input.slice(0, hashStart);
+    }
+    return input;
+  }
+  function getHash(url) {
+    let hash = "";
+    const hashStart = url.indexOf("#");
+    if (hashStart !== -1) {
+      hash = url.slice(hashStart);
+    }
+    return hash;
+  }
+  function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf("?");
+    if (queryStart === -1) {
+      return "";
+    }
+    return input.slice(queryStart + 1);
+  }
+  function parseValue(value, options) {
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
+      value = Number(value);
+    } else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+      value = value.toLowerCase() === "true";
+    }
+    return value;
+  }
+  function parse(query, options) {
+    options = Object.assign({
+      decode: true,
+      sort: true,
+      arrayFormat: "none",
+      arrayFormatSeparator: ",",
+      parseNumbers: false,
+      parseBooleans: false
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const formatter = parserForArrayFormat(options);
+    const ret = /* @__PURE__ */ Object.create(null);
+    if (typeof query !== "string") {
+      return ret;
+    }
+    query = query.trim().replace(/^[?#&]/, "");
+    if (!query) {
+      return ret;
+    }
+    for (const param of query.split("&")) {
+      if (param === "") {
+        continue;
+      }
+      let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, " ") : param, "=");
+      value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode2(value, options);
+      formatter(decode2(key, options), value, ret);
+    }
+    for (const key of Object.keys(ret)) {
+      const value = ret[key];
+      if (typeof value === "object" && value !== null) {
+        for (const k of Object.keys(value)) {
+          value[k] = parseValue(value[k], options);
+        }
+      } else {
+        ret[key] = parseValue(value, options);
+      }
+    }
+    if (options.sort === false) {
+      return ret;
+    }
+    return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+      const value = ret[key];
+      if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = keysSorter(value);
+      } else {
+        result[key] = value;
+      }
+      return result;
+    }, /* @__PURE__ */ Object.create(null));
+  }
+  exports.extract = extract;
+  exports.parse = parse;
+  exports.stringify = (object, options) => {
+    if (!object) {
+      return "";
+    }
+    options = Object.assign({
+      encode: true,
+      strict: true,
+      arrayFormat: "none",
+      arrayFormatSeparator: ","
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
+    const formatter = encoderForArrayFormat(options);
+    const objectCopy = {};
+    for (const key of Object.keys(object)) {
+      if (!shouldFilter(key)) {
+        objectCopy[key] = object[key];
+      }
+    }
+    const keys2 = Object.keys(objectCopy);
+    if (options.sort !== false) {
+      keys2.sort(options.sort);
+    }
+    return keys2.map((key) => {
+      const value = object[key];
+      if (value === void 0) {
+        return "";
+      }
+      if (value === null) {
+        return encode2(key, options);
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0 && options.arrayFormat === "bracket-separator") {
+          return encode2(key, options) + "[]";
+        }
+        return value.reduce(formatter(key), []).join("&");
+      }
+      return encode2(key, options) + "=" + encode2(value, options);
+    }).filter((x) => x.length > 0).join("&");
+  };
+  exports.parseUrl = (url, options) => {
+    options = Object.assign({
+      decode: true
+    }, options);
+    const [url_, hash] = splitOnFirst$1(url, "#");
+    return Object.assign({
+      url: url_.split("?")[0] || "",
+      query: parse(extract(url), options)
+    }, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode2(hash, options) } : {});
+  };
+  exports.stringifyUrl = (object, options) => {
+    options = Object.assign({
+      encode: true,
+      strict: true,
+      [encodeFragmentIdentifier]: true
+    }, options);
+    const url = removeHash(object.url).split("?")[0] || "";
+    const queryFromUrl = exports.extract(object.url);
+    const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
+    const query = Object.assign(parsedQueryFromUrl, object.query);
+    let queryString2 = exports.stringify(query, options);
+    if (queryString2) {
+      queryString2 = `?${queryString2}`;
+    }
+    let hash = getHash(object.url);
+    if (object.fragmentIdentifier) {
+      hash = `#${options[encodeFragmentIdentifier] ? encode2(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
+    }
+    return `${url}${queryString2}${hash}`;
+  };
+  exports.pick = (input, filter, options) => {
+    options = Object.assign({
+      parseFragmentIdentifier: true,
+      [encodeFragmentIdentifier]: false
+    }, options);
+    const { url, query, fragmentIdentifier } = exports.parseUrl(input, options);
+    return exports.stringifyUrl({
+      url,
+      query: filterObject(query, filter),
+      fragmentIdentifier
+    }, options);
+  };
+  exports.exclude = (input, filter, options) => {
+    const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
+    return exports.pick(input, exclusionFilter, options);
+  };
+})(queryString);
+const supported = [".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tiff"];
+function getMediaUrl(url, size = 500) {
+  const link = queryString.parseUrl(url);
+  if (!(url.startsWith("https://orderingstackmedia.blob.core.windows.net/pictures") || url.startsWith("https://orderingstack-mmedia-tools.azurewebsites.net/api/img/"))) {
+    return url;
+  }
+  const extension = link.url.substring(link.url.lastIndexOf("."));
+  if (!supported.includes(extension)) {
+    return url;
+  }
+  return queryString.stringifyUrl({
+    url: link.url.replace("https://orderingstackmedia.blob.core.windows.net/pictures/", "https://orderingstack-mmedia-tools.azurewebsites.net/api/img/"),
+    query: { ...link.query, w: size }
+  });
+}
+function useMediaUrl(url, size = 500) {
+  return getMediaUrl(url, size);
+}
+export { getGroupedBucketLines, getMediaUrl, groupOrderLines, useAvailability, useCms, useDisplayPrice, useGroupOrderLines, useInterval, useKioskChannelsAvailability, useKioskMediaCms, useLocalizedVenueMedia, useMediaUrl, useOnClickOutside, useVenueCms };
 //# sourceMappingURL=index.es.js.map