@golocalinteractive/golocal-cloud-wrapper 1.0.53 → 1.0.56

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

@@ -0,0 +1,33 @@
+import { __exports as removePathPrefix } from "./golocal-cloud-wrapper.es273.js";
+import { __require as requirePathHasPrefix } from "./golocal-cloud-wrapper.es220.js";
+var hasRequiredRemovePathPrefix;
+function requireRemovePathPrefix() {
+  if (hasRequiredRemovePathPrefix) return removePathPrefix;
+  hasRequiredRemovePathPrefix = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "removePathPrefix", {
+      enumerable: true,
+      get: function() {
+        return removePathPrefix2;
+      }
+    });
+    const _pathhasprefix = requirePathHasPrefix();
+    function removePathPrefix2(path, prefix) {
+      if (!(0, _pathhasprefix.pathHasPrefix)(path, prefix)) {
+        return path;
+      }
+      const withoutPrefix = path.slice(prefix.length);
+      if (withoutPrefix.startsWith("/")) {
+        return withoutPrefix;
+      }
+      return "/" + withoutPrefix;
+    }
+  })(removePathPrefix);
+  return removePathPrefix;
+}
+export {
+  requireRemovePathPrefix as __require
+};

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

@@ -0,0 +1,23 @@
+import { accessToken } from "./golocal-cloud-wrapper.es83.js";
+import { jwtDecode } from "./golocal-cloud-wrapper.es84.js";
+async function getUserData() {
+  var _a, _b, _c, _d;
+  try {
+    const token = await accessToken();
+    if (!token)
+      return { essentialInsights: false, web: false, priceMonster: false };
+    const decoded = jwtDecode(token);
+    const products = (_a = decoded["https://cloud.golocal.com/org_metadata"]) == null ? void 0 : _a.metadata;
+    return {
+      essentialInsights: ((_b = products == null ? void 0 : products["essential-insights"]) == null ? void 0 : _b.enabled) === true,
+      web: ((_c = products == null ? void 0 : products["web"]) == null ? void 0 : _c.enabled) === true,
+      priceMonster: ((_d = products == null ? void 0 : products["price-monster"]) == null ? void 0 : _d.enabled) === true
+    };
+  } catch (error) {
+    console.error("Error getting user data:", error);
+    return { essentialInsights: false, web: false, priceMonster: false };
+  }
+}
+export {
+  getUserData
+};

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

@@ -0,0 +1,30 @@
+import { __exports as pathHasPrefix } from "./golocal-cloud-wrapper.es274.js";
+import { __require as requireParsePath } from "./golocal-cloud-wrapper.es269.js";
+var hasRequiredPathHasPrefix;
+function requirePathHasPrefix() {
+  if (hasRequiredPathHasPrefix) return pathHasPrefix;
+  hasRequiredPathHasPrefix = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "pathHasPrefix", {
+      enumerable: true,
+      get: function() {
+        return pathHasPrefix2;
+      }
+    });
+    const _parsepath = requireParsePath();
+    function pathHasPrefix2(path, prefix) {
+      if (typeof path !== "string") {
+        return false;
+      }
+      const { pathname } = (0, _parsepath.parsePath)(path);
+      return pathname === prefix || pathname.startsWith(prefix + "/");
+    }
+  })(pathHasPrefix);
+  return pathHasPrefix;
+}
+export {
+  requirePathHasPrefix as __require
+};

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

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

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

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

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

@@ -0,0 +1,78 @@
+import { __exports as asyncLocalStorage } from "./golocal-cloud-wrapper.es275.js";
+var hasRequiredAsyncLocalStorage;
+function requireAsyncLocalStorage() {
+  if (hasRequiredAsyncLocalStorage) return asyncLocalStorage;
+  hasRequiredAsyncLocalStorage = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      bindSnapshot: function() {
+        return bindSnapshot;
+      },
+      createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+      },
+      createSnapshot: function() {
+        return createSnapshot;
+      }
+    });
+    const sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"), "__NEXT_ERROR_CODE", {
+      value: "E504",
+      enumerable: false,
+      configurable: true
+    });
+    class FakeAsyncLocalStorage {
+      disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      getStore() {
+        return void 0;
+      }
+      run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      static bind(fn) {
+        return fn;
+      }
+    }
+    const maybeGlobalAsyncLocalStorage = typeof globalThis !== "undefined" && globalThis.AsyncLocalStorage;
+    function createAsyncLocalStorage() {
+      if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+      }
+      return new FakeAsyncLocalStorage();
+    }
+    function bindSnapshot(fn) {
+      if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+      }
+      return FakeAsyncLocalStorage.bind(fn);
+    }
+    function createSnapshot() {
+      if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.snapshot();
+      }
+      return function(fn, ...args) {
+        return fn(...args);
+      };
+    }
+  })(asyncLocalStorage);
+  return asyncLocalStorage;
+}
+export {
+  requireAsyncLocalStorage as __require
+};

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

@@ -0,0 +1,4 @@
+var appRouterHeaders = { exports: {} };
+export {
+  appRouterHeaders as __module
+};

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

@@ -0,0 +1,4 @@
+var hooksServerContext = { exports: {} };
+export {
+  hooksServerContext as __module
+};

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+import { __exports as afterTaskAsyncStorageInstance } from "./golocal-cloud-wrapper.es276.js";
+import { __require as requireAsyncLocalStorage } from "./golocal-cloud-wrapper.es223.js";
+var hasRequiredAfterTaskAsyncStorageInstance;
+function requireAfterTaskAsyncStorageInstance() {
+  if (hasRequiredAfterTaskAsyncStorageInstance) return afterTaskAsyncStorageInstance;
+  hasRequiredAfterTaskAsyncStorageInstance = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "afterTaskAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return afterTaskAsyncStorageInstance2;
+      }
+    });
+    const _asynclocalstorage = requireAsyncLocalStorage();
+    const afterTaskAsyncStorageInstance2 = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  })(afterTaskAsyncStorageInstance);
+  return afterTaskAsyncStorageInstance;
+}
+export {
+  requireAfterTaskAsyncStorageInstance as __require
+};

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

@@ -0,0 +1,38 @@
+import useSWR from "./golocal-cloud-wrapper.es59.js";
+import { normalizeWithBasePath } from "./golocal-cloud-wrapper.es60.js";
+function useUser() {
+  const { data, error, isLoading, mutate } = useSWR(normalizeWithBasePath(process.env.NEXT_PUBLIC_PROFILE_ROUTE || "/auth/profile"), (...args) => fetch(...args).then((res) => {
+    if (!res.ok) {
+      throw new Error("Unauthorized");
+    }
+    if (res.status === 204) {
+      return null;
+    }
+    return res.json();
+  }));
+  if (error) {
+    return {
+      user: null,
+      isLoading: false,
+      error,
+      invalidate: () => mutate()
+    };
+  }
+  if (data) {
+    return {
+      user: data,
+      isLoading: false,
+      error: null,
+      invalidate: () => mutate()
+    };
+  }
+  return {
+    user: data,
+    isLoading,
+    error,
+    invalidate: () => mutate()
+  };
+}
+export {
+  useUser
+};

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

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

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

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

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

@@ -0,0 +1,202 @@
+import { __exports as requestCookies } from "./golocal-cloud-wrapper.es281.js";
+import { __require as requireCookies } from "./golocal-cloud-wrapper.es123.js";
+import { __require as requireReflect } from "./golocal-cloud-wrapper.es125.js";
+import { __require as requireWorkAsyncStorage_external } from "./golocal-cloud-wrapper.es133.js";
+import { __require as requireWorkUnitAsyncStorage_external } from "./golocal-cloud-wrapper.es134.js";
+var hasRequiredRequestCookies;
+function requireRequestCookies() {
+  if (hasRequiredRequestCookies) return requestCookies;
+  hasRequiredRequestCookies = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+      },
+      RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+      },
+      appendMutableCookies: function() {
+        return appendMutableCookies;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return areCookiesMutableInCurrentPhase;
+      },
+      getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+      },
+      responseCookiesToRequestCookies: function() {
+        return responseCookiesToRequestCookies;
+      },
+      wrapWithMutableAccessCheck: function() {
+        return wrapWithMutableAccessCheck;
+      }
+    });
+    const _cookies = requireCookies();
+    const _reflect = requireReflect();
+    const _workasyncstorageexternal = requireWorkAsyncStorage_external();
+    const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
+    class ReadonlyRequestCookiesError extends Error {
+      constructor() {
+        super("Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options");
+      }
+      static callable() {
+        throw new ReadonlyRequestCookiesError();
+      }
+    }
+    class RequestCookiesAdapter {
+      static seal(cookies) {
+        return new Proxy(cookies, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case "clear":
+              case "delete":
+              case "set":
+                return ReadonlyRequestCookiesError.callable;
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+      }
+    }
+    const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for("next.mutated.cookies");
+    function getModifiedCookieValues(cookies) {
+      const modified = cookies[SYMBOL_MODIFY_COOKIE_VALUES];
+      if (!modified || !Array.isArray(modified) || modified.length === 0) {
+        return [];
+      }
+      return modified;
+    }
+    function appendMutableCookies(headers, mutableCookies) {
+      const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
+      if (modifiedCookieValues.length === 0) {
+        return false;
+      }
+      const resCookies = new _cookies.ResponseCookies(headers);
+      const returnedCookies = resCookies.getAll();
+      for (const cookie of modifiedCookieValues) {
+        resCookies.set(cookie);
+      }
+      for (const cookie of returnedCookies) {
+        resCookies.set(cookie);
+      }
+      return true;
+    }
+    class MutableRequestCookiesAdapter {
+      static wrap(cookies, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies.getAll()) {
+          responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = /* @__PURE__ */ new Set();
+        const updateResponseCookies = () => {
+          const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+          if (workStore) {
+            workStore.pathWasRevalidated = true;
+          }
+          const allCookies = responseCookies.getAll();
+          modifiedValues = allCookies.filter((c) => modifiedCookies.has(c.name));
+          if (onUpdateCookies) {
+            const serializedCookies = [];
+            for (const cookie of modifiedValues) {
+              const tempCookies = new _cookies.ResponseCookies(new Headers());
+              tempCookies.set(cookie);
+              serializedCookies.push(tempCookies.toString());
+            }
+            onUpdateCookies(serializedCookies);
+          }
+        };
+        const wrappedCookies = new Proxy(responseCookies, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              // A special symbol to get the modified cookie values
+              case SYMBOL_MODIFY_COOKIE_VALUES:
+                return modifiedValues;
+              // TODO: Throw error if trying to set a cookie after the response
+              // headers have been set.
+              case "delete":
+                return function(...args) {
+                  modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                  try {
+                    target.delete(...args);
+                    return wrappedCookies;
+                  } finally {
+                    updateResponseCookies();
+                  }
+                };
+              case "set":
+                return function(...args) {
+                  modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                  try {
+                    target.set(...args);
+                    return wrappedCookies;
+                  } finally {
+                    updateResponseCookies();
+                  }
+                };
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+        return wrappedCookies;
+      }
+    }
+    function wrapWithMutableAccessCheck(responseCookies) {
+      const wrappedCookies = new Proxy(responseCookies, {
+        get(target, prop, receiver) {
+          switch (prop) {
+            case "delete":
+              return function(...args) {
+                ensureCookiesAreStillMutable("cookies().delete");
+                target.delete(...args);
+                return wrappedCookies;
+              };
+            case "set":
+              return function(...args) {
+                ensureCookiesAreStillMutable("cookies().set");
+                target.set(...args);
+                return wrappedCookies;
+              };
+            default:
+              return _reflect.ReflectAdapter.get(target, prop, receiver);
+          }
+        }
+      });
+      return wrappedCookies;
+    }
+    function areCookiesMutableInCurrentPhase(requestStore) {
+      return requestStore.phase === "action";
+    }
+    function ensureCookiesAreStillMutable(callingExpression) {
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)(callingExpression);
+      if (!areCookiesMutableInCurrentPhase(requestStore)) {
+        throw new ReadonlyRequestCookiesError();
+      }
+    }
+    function responseCookiesToRequestCookies(responseCookies) {
+      const requestCookies2 = new _cookies.RequestCookies(new Headers());
+      for (const cookie of responseCookies.getAll()) {
+        requestCookies2.set(cookie);
+      }
+      return requestCookies2;
+    }
+  })(requestCookies);
+  return requestCookies;
+}
+export {
+  requireRequestCookies as __require
+};

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

@@ -0,0 +1,97 @@
+import { __exports as createDedupedByCallsiteServerErrorLogger } from "./golocal-cloud-wrapper.es280.js";
+import React__default from "react";
+var hasRequiredCreateDedupedByCallsiteServerErrorLogger;
+function requireCreateDedupedByCallsiteServerErrorLogger() {
+  if (hasRequiredCreateDedupedByCallsiteServerErrorLogger) return createDedupedByCallsiteServerErrorLogger;
+  hasRequiredCreateDedupedByCallsiteServerErrorLogger = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "createDedupedByCallsiteServerErrorLoggerDev", {
+      enumerable: true,
+      get: function() {
+        return createDedupedByCallsiteServerErrorLoggerDev;
+      }
+    });
+    const _react = /* @__PURE__ */ _interop_require_wildcard(React__default);
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function") return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interop_require_wildcard(obj, nodeInterop) {
+      if (obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+          default: obj
+        };
+      }
+      var cache2 = _getRequireWildcardCache(nodeInterop);
+      if (cache2 && cache2.has(obj)) {
+        return cache2.get(obj);
+      }
+      var newObj = {
+        __proto__: null
+      };
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache2) {
+        cache2.set(obj, newObj);
+      }
+      return newObj;
+    }
+    const errorRef = {
+      current: null
+    };
+    const cache = typeof _react.cache === "function" ? _react.cache : (fn) => fn;
+    const logErrorOrWarn = process.env.__NEXT_DYNAMIC_IO ? console.error : console.warn;
+    const flushCurrentErrorIfNew = cache(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+      (key) => {
+        try {
+          logErrorOrWarn(errorRef.current);
+        } finally {
+          errorRef.current = null;
+        }
+      }
+    );
+    function createDedupedByCallsiteServerErrorLoggerDev(getMessage) {
+      return function logDedupedError(...args) {
+        const message = getMessage(...args);
+        if (process.env.NODE_ENV !== "production") {
+          var _stack;
+          const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split("\n");
+          if (callStackFrames === void 0 || callStackFrames.length < 4) {
+            logErrorOrWarn(message);
+          } else {
+            const key = callStackFrames[4];
+            errorRef.current = message;
+            flushCurrentErrorIfNew(key);
+          }
+        } else {
+          logErrorOrWarn(message);
+        }
+      };
+    }
+  })(createDedupedByCallsiteServerErrorLogger);
+  return createDedupedByCallsiteServerErrorLogger;
+}
+export {
+  requireCreateDedupedByCallsiteServerErrorLogger as __require
+};

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

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