@golocalinteractive/golocal-cloud-wrapper 1.0.53 → 1.0.56

package/dist/golocal-cloud-wrapper.es192.js

@@ -0,0 +1,153 @@
+const sides = ["top", "right", "bottom", "left"];
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+const oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ["left", "right"];
+  const rl = ["right", "left"];
+  const tb = ["top", "bottom"];
+  const bt = ["bottom", "top"];
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case "left":
+    case "right":
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+export {
+  clamp,
+  createCoords,
+  evaluate,
+  expandPaddingObject,
+  floor,
+  getAlignment,
+  getAlignmentAxis,
+  getAlignmentSides,
+  getAxisLength,
+  getExpandedPlacements,
+  getOppositeAlignmentPlacement,
+  getOppositeAxis,
+  getOppositeAxisPlacements,
+  getOppositePlacement,
+  getPaddingObject,
+  getSide,
+  getSideAxis,
+  max,
+  min,
+  rectToClientRect,
+  round,
+  sides
+};

package/dist/golocal-cloud-wrapper.es193.js

@@ -0,0 +1,166 @@
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+}
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [":popover-open", ":modal"].some((selector) => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+export {
+  getComputedStyle,
+  getContainingBlock,
+  getDocumentElement,
+  getFrameElement,
+  getNearestOverflowAncestor,
+  getNodeName,
+  getNodeScroll,
+  getOverflowAncestors,
+  getParentNode,
+  getWindow,
+  isContainingBlock,
+  isElement,
+  isHTMLElement,
+  isLastTraversableNode,
+  isNode,
+  isOverflowElement,
+  isShadowRoot,
+  isTableElement,
+  isTopLayer,
+  isWebKit
+};

package/dist/golocal-cloud-wrapper.es194.js

@@ -0,0 +1,49 @@
+import derive from "./golocal-cloud-wrapper.es237.js";
+function normalizeDigest(digest) {
+  switch (digest) {
+    case "sha256":
+    case "sha384":
+    case "sha512":
+    case "sha1":
+      return digest;
+    default:
+      throw new TypeError('unsupported "digest" value');
+  }
+}
+function normalizeUint8Array(input, label) {
+  if (typeof input === "string")
+    return new TextEncoder().encode(input);
+  if (!(input instanceof Uint8Array))
+    throw new TypeError(`"${label}"" must be an instance of Uint8Array or a string`);
+  return input;
+}
+function normalizeIkm(input) {
+  const ikm = normalizeUint8Array(input, "ikm");
+  if (!ikm.byteLength)
+    throw new TypeError(`"ikm" must be at least one byte in length`);
+  return ikm;
+}
+function normalizeInfo(input) {
+  const info = normalizeUint8Array(input, "info");
+  if (info.byteLength > 1024) {
+    throw TypeError('"info" must not contain more than 1024 bytes');
+  }
+  return info;
+}
+function normalizeKeylen(input, digest) {
+  if (!Number.isInteger(input) || input < 1) {
+    throw new TypeError('"keylen" must be a positive integer');
+  }
+  const hashlen = parseInt(digest.substr(3), 10) >> 3 || 20;
+  if (input > 255 * hashlen) {
+    throw new TypeError('"keylen" too large');
+  }
+  return input;
+}
+async function hkdf(digest, ikm, salt, info, keylen) {
+  return derive(normalizeDigest(digest), normalizeIkm(ikm), normalizeUint8Array(salt, "salt"), normalizeInfo(info), normalizeKeylen(keylen, digest));
+}
+export {
+  hkdf as default,
+  hkdf
+};

package/dist/golocal-cloud-wrapper.es195.js

@@ -0,0 +1,71 @@
+import { CompactEncrypt } from "./golocal-cloud-wrapper.es255.js";
+import { encoder } from "./golocal-cloud-wrapper.es241.js";
+import { ProduceJWT } from "./golocal-cloud-wrapper.es260.js";
+class EncryptJWT extends ProduceJWT {
+  setProtectedHeader(protectedHeader) {
+    if (this._protectedHeader) {
+      throw new TypeError("setProtectedHeader can only be called once");
+    }
+    this._protectedHeader = protectedHeader;
+    return this;
+  }
+  setKeyManagementParameters(parameters) {
+    if (this._keyManagementParameters) {
+      throw new TypeError("setKeyManagementParameters can only be called once");
+    }
+    this._keyManagementParameters = parameters;
+    return this;
+  }
+  setContentEncryptionKey(cek) {
+    if (this._cek) {
+      throw new TypeError("setContentEncryptionKey can only be called once");
+    }
+    this._cek = cek;
+    return this;
+  }
+  setInitializationVector(iv) {
+    if (this._iv) {
+      throw new TypeError("setInitializationVector can only be called once");
+    }
+    this._iv = iv;
+    return this;
+  }
+  replicateIssuerAsHeader() {
+    this._replicateIssuerAsHeader = true;
+    return this;
+  }
+  replicateSubjectAsHeader() {
+    this._replicateSubjectAsHeader = true;
+    return this;
+  }
+  replicateAudienceAsHeader() {
+    this._replicateAudienceAsHeader = true;
+    return this;
+  }
+  async encrypt(key, options) {
+    const enc = new CompactEncrypt(encoder.encode(JSON.stringify(this._payload)));
+    if (this._replicateIssuerAsHeader) {
+      this._protectedHeader = { ...this._protectedHeader, iss: this._payload.iss };
+    }
+    if (this._replicateSubjectAsHeader) {
+      this._protectedHeader = { ...this._protectedHeader, sub: this._payload.sub };
+    }
+    if (this._replicateAudienceAsHeader) {
+      this._protectedHeader = { ...this._protectedHeader, aud: this._payload.aud };
+    }
+    enc.setProtectedHeader(this._protectedHeader);
+    if (this._iv) {
+      enc.setInitializationVector(this._iv);
+    }
+    if (this._cek) {
+      enc.setContentEncryptionKey(this._cek);
+    }
+    if (this._keyManagementParameters) {
+      enc.setKeyManagementParameters(this._keyManagementParameters);
+    }
+    return enc.encrypt(key, options);
+  }
+}
+export {
+  EncryptJWT
+};

package/dist/golocal-cloud-wrapper.es196.js

@@ -0,0 +1,25 @@
+import { compactDecrypt } from "./golocal-cloud-wrapper.es238.js";
+import jwtPayload from "./golocal-cloud-wrapper.es254.js";
+import { JWTClaimValidationFailed } from "./golocal-cloud-wrapper.es240.js";
+async function jwtDecrypt(jwt, key, options) {
+  const decrypted = await compactDecrypt(jwt, key, options);
+  const payload = jwtPayload(decrypted.protectedHeader, decrypted.plaintext, options);
+  const { protectedHeader } = decrypted;
+  if (protectedHeader.iss !== void 0 && protectedHeader.iss !== payload.iss) {
+    throw new JWTClaimValidationFailed('replicated "iss" claim header parameter mismatch', payload, "iss", "mismatch");
+  }
+  if (protectedHeader.sub !== void 0 && protectedHeader.sub !== payload.sub) {
+    throw new JWTClaimValidationFailed('replicated "sub" claim header parameter mismatch', payload, "sub", "mismatch");
+  }
+  if (protectedHeader.aud !== void 0 && JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)) {
+    throw new JWTClaimValidationFailed('replicated "aud" claim header parameter mismatch', payload, "aud", "mismatch");
+  }
+  const result = { payload, protectedHeader };
+  if (typeof key === "function") {
+    return { ...result, key: decrypted.key };
+  }
+  return result;
+}
+export {
+  jwtDecrypt
+};

package/dist/golocal-cloud-wrapper.es197.js

@@ -0,0 +1,5 @@
+import { encode as encode$1 } from "./golocal-cloud-wrapper.es242.js";
+const encode = encode$1;
+export {
+  encode
+};

package/dist/golocal-cloud-wrapper.es198.js

@@ -0,0 +1,118 @@
+import { decode } from "./golocal-cloud-wrapper.es242.js";
+import verify from "./golocal-cloud-wrapper.es251.js";
+import { JWSInvalid, JOSEAlgNotAllowed, JWSSignatureVerificationFailed } from "./golocal-cloud-wrapper.es240.js";
+import { decoder, concat, encoder } from "./golocal-cloud-wrapper.es241.js";
+import isDisjoint from "./golocal-cloud-wrapper.es244.js";
+import isObject from "./golocal-cloud-wrapper.es245.js";
+import { checkKeyTypeWithJwk } from "./golocal-cloud-wrapper.es252.js";
+import validateCrit from "./golocal-cloud-wrapper.es248.js";
+import validateAlgorithms from "./golocal-cloud-wrapper.es249.js";
+import { isJWK } from "./golocal-cloud-wrapper.es253.js";
+import { importJWK } from "./golocal-cloud-wrapper.es156.js";
+async function flattenedVerify(jws, key, options) {
+  if (!isObject(jws)) {
+    throw new JWSInvalid("Flattened JWS must be an object");
+  }
+  if (jws.protected === void 0 && jws.header === void 0) {
+    throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members');
+  }
+  if (jws.protected !== void 0 && typeof jws.protected !== "string") {
+    throw new JWSInvalid("JWS Protected Header incorrect type");
+  }
+  if (jws.payload === void 0) {
+    throw new JWSInvalid("JWS Payload missing");
+  }
+  if (typeof jws.signature !== "string") {
+    throw new JWSInvalid("JWS Signature missing or incorrect type");
+  }
+  if (jws.header !== void 0 && !isObject(jws.header)) {
+    throw new JWSInvalid("JWS Unprotected Header incorrect type");
+  }
+  let parsedProt = {};
+  if (jws.protected) {
+    try {
+      const protectedHeader = decode(jws.protected);
+      parsedProt = JSON.parse(decoder.decode(protectedHeader));
+    } catch {
+      throw new JWSInvalid("JWS Protected Header is invalid");
+    }
+  }
+  if (!isDisjoint(parsedProt, jws.header)) {
+    throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
+  }
+  const joseHeader = {
+    ...parsedProt,
+    ...jws.header
+  };
+  const extensions = validateCrit(JWSInvalid, /* @__PURE__ */ new Map([["b64", true]]), options == null ? void 0 : options.crit, parsedProt, joseHeader);
+  let b64 = true;
+  if (extensions.has("b64")) {
+    b64 = parsedProt.b64;
+    if (typeof b64 !== "boolean") {
+      throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
+    }
+  }
+  const { alg } = joseHeader;
+  if (typeof alg !== "string" || !alg) {
+    throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
+  }
+  const algorithms = options && validateAlgorithms("algorithms", options.algorithms);
+  if (algorithms && !algorithms.has(alg)) {
+    throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
+  }
+  if (b64) {
+    if (typeof jws.payload !== "string") {
+      throw new JWSInvalid("JWS Payload must be a string");
+    }
+  } else if (typeof jws.payload !== "string" && !(jws.payload instanceof Uint8Array)) {
+    throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
+  }
+  let resolvedKey = false;
+  if (typeof key === "function") {
+    key = await key(parsedProt, jws);
+    resolvedKey = true;
+    checkKeyTypeWithJwk(alg, key, "verify");
+    if (isJWK(key)) {
+      key = await importJWK(key, alg);
+    }
+  } else {
+    checkKeyTypeWithJwk(alg, key, "verify");
+  }
+  const data = concat(encoder.encode(jws.protected ?? ""), encoder.encode("."), typeof jws.payload === "string" ? encoder.encode(jws.payload) : jws.payload);
+  let signature;
+  try {
+    signature = decode(jws.signature);
+  } catch {
+    throw new JWSInvalid("Failed to base64url decode the signature");
+  }
+  const verified = await verify(alg, key, signature, data);
+  if (!verified) {
+    throw new JWSSignatureVerificationFailed();
+  }
+  let payload;
+  if (b64) {
+    try {
+      payload = decode(jws.payload);
+    } catch {
+      throw new JWSInvalid("Failed to base64url decode the payload");
+    }
+  } else if (typeof jws.payload === "string") {
+    payload = encoder.encode(jws.payload);
+  } else {
+    payload = jws.payload;
+  }
+  const result = { payload };
+  if (jws.protected !== void 0) {
+    result.protectedHeader = parsedProt;
+  }
+  if (jws.header !== void 0) {
+    result.unprotectedHeader = jws.header;
+  }
+  if (resolvedKey) {
+    return { ...result, key };
+  }
+  return result;
+}
+export {
+  flattenedVerify
+};

package/dist/golocal-cloud-wrapper.es199.js

@@ -0,0 +1,16 @@
+import { __exports as headers } from "./golocal-cloud-wrapper.es200.js";
+import { __require as requireCookies } from "./golocal-cloud-wrapper.es201.js";
+import { __require as requireHeaders$1 } from "./golocal-cloud-wrapper.es202.js";
+import { __require as requireDraftMode } from "./golocal-cloud-wrapper.es203.js";
+var hasRequiredHeaders;
+function requireHeaders() {
+  if (hasRequiredHeaders) return headers;
+  hasRequiredHeaders = 1;
+  headers.cookies = requireCookies().cookies;
+  headers.headers = requireHeaders$1().headers;
+  headers.draftMode = requireDraftMode().draftMode;
+  return headers;
+}
+export {
+  requireHeaders as __require
+};

package/dist/golocal-cloud-wrapper.es20.js

@@ -0,0 +1,12 @@
+import React__default from "react";
+import { SWRConfig } from "./golocal-cloud-wrapper.es59.js";
+function Auth0Provider({ user, children }) {
+  return React__default.createElement(SWRConfig, { value: {
+    fallback: {
+      [process.env.NEXT_PUBLIC_PROFILE_ROUTE || "/auth/profile"]: user
+    }
+  } }, children);
+}
+export {
+  Auth0Provider
+};

package/dist/golocal-cloud-wrapper.es200.js

@@ -0,0 +1,4 @@
+var headers = {};
+export {
+  headers as __exports
+};