@golocalinteractive/golocal-cloud-wrapper 1.0.54 → 1.0.56

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

@@ -0,0 +1,417 @@
+import React__default, { useRef, useMemo, useCallback, useDebugValue } from "react";
+import { s as shimExports } from "./golocal-cloud-wrapper.es85.js";
+import { withArgs, subscribeCallback } from "./golocal-cloud-wrapper.es86.js";
+import { useSWRConfig } from "./golocal-cloud-wrapper.es86.js";
+import { O as OBJECT, g as SWRConfig$1, d as defaultConfig, b as SWRGlobalState, s as serialize, z as createCacheHelper, e as isUndefined, U as UNDEFINED, B as isPromiseLike, o as getTimestamp, a as isFunction, n as internalMutate, u as useIsomorphicLayoutEffect, r as IS_SERVER, t as rAF, I as IS_REACT_LEGACY, m as mergeObjects } from "./golocal-cloud-wrapper.es87.js";
+import { j } from "./golocal-cloud-wrapper.es87.js";
+import { ERROR_REVALIDATE_EVENT, FOCUS_EVENT, RECONNECT_EVENT, MUTATE_EVENT } from "./golocal-cloud-wrapper.es88.js";
+const use = React__default.use || // This extra generic is to avoid TypeScript mixing up the generic and JSX sytax
+// and emitting an error.
+// We assume that this is only for the `use(thenable)` case, not `use(context)`.
+// https://github.com/facebook/react/blob/aed00dacfb79d17c53218404c52b1c7aa59c4a89/packages/react-server/src/ReactFizzThenable.js#L45
+((thenable) => {
+  switch (thenable.status) {
+    case "pending":
+      throw thenable;
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      thenable.status = "pending";
+      thenable.then((v) => {
+        thenable.status = "fulfilled";
+        thenable.value = v;
+      }, (e) => {
+        thenable.status = "rejected";
+        thenable.reason = e;
+      });
+      throw thenable;
+  }
+});
+const WITH_DEDUPE = {
+  dedupe: true
+};
+const useSWRHandler = (_key, fetcher, config) => {
+  const { cache, compare, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData } = config;
+  const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache);
+  const [key, fnArg] = serialize(_key);
+  const initialMountedRef = useRef(false);
+  const unmountedRef = useRef(false);
+  const keyRef = useRef(key);
+  const fetcherRef = useRef(fetcher);
+  const configRef = useRef(config);
+  const getConfig = () => configRef.current;
+  const isActive = () => getConfig().isVisible() && getConfig().isOnline();
+  const [getCache, setCache, subscribeCache, getInitialCache] = createCacheHelper(cache, key);
+  const stateDependencies = useRef({}).current;
+  const fallback = isUndefined(fallbackData) ? isUndefined(config.fallback) ? UNDEFINED : config.fallback[key] : fallbackData;
+  const isEqual = (prev, current) => {
+    for (const _ in stateDependencies) {
+      const t = _;
+      if (t === "data") {
+        if (!compare(prev[t], current[t])) {
+          if (!isUndefined(prev[t])) {
+            return false;
+          }
+          if (!compare(returnedData, current[t])) {
+            return false;
+          }
+        }
+      } else {
+        if (current[t] !== prev[t]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+  const getSnapshot = useMemo(() => {
+    const shouldStartRequest = (() => {
+      if (!key) return false;
+      if (!fetcher) return false;
+      if (!isUndefined(revalidateOnMount)) return revalidateOnMount;
+      if (getConfig().isPaused()) return false;
+      if (suspense) return false;
+      return revalidateIfStale !== false;
+    })();
+    const getSelectedCache = (state) => {
+      const snapshot = mergeObjects(state);
+      delete snapshot._k;
+      if (!shouldStartRequest) {
+        return snapshot;
+      }
+      return {
+        isValidating: true,
+        isLoading: true,
+        ...snapshot
+      };
+    };
+    const cachedData2 = getCache();
+    const initialData = getInitialCache();
+    const clientSnapshot = getSelectedCache(cachedData2);
+    const serverSnapshot = cachedData2 === initialData ? clientSnapshot : getSelectedCache(initialData);
+    let memorizedSnapshot = clientSnapshot;
+    return [
+      () => {
+        const newSnapshot = getSelectedCache(getCache());
+        const compareResult = isEqual(newSnapshot, memorizedSnapshot);
+        if (compareResult) {
+          memorizedSnapshot.data = newSnapshot.data;
+          memorizedSnapshot.isLoading = newSnapshot.isLoading;
+          memorizedSnapshot.isValidating = newSnapshot.isValidating;
+          memorizedSnapshot.error = newSnapshot.error;
+          return memorizedSnapshot;
+        } else {
+          memorizedSnapshot = newSnapshot;
+          return newSnapshot;
+        }
+      },
+      () => serverSnapshot
+    ];
+  }, [
+    cache,
+    key
+  ]);
+  const cached = shimExports.useSyncExternalStore(useCallback(
+    (callback) => subscribeCache(key, (current, prev) => {
+      if (!isEqual(prev, current)) callback();
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      cache,
+      key
+    ]
+  ), getSnapshot[0], getSnapshot[1]);
+  const isInitialMount = !initialMountedRef.current;
+  const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
+  const cachedData = cached.data;
+  const data = isUndefined(cachedData) ? fallback && isPromiseLike(fallback) ? use(fallback) : fallback : cachedData;
+  const error = cached.error;
+  const laggyDataRef = useRef(data);
+  const returnedData = keepPreviousData ? isUndefined(cachedData) ? isUndefined(laggyDataRef.current) ? data : laggyDataRef.current : cachedData : data;
+  const shouldDoInitialRevalidation = (() => {
+    if (hasRevalidator && !isUndefined(error)) return false;
+    if (isInitialMount && !isUndefined(revalidateOnMount)) return revalidateOnMount;
+    if (getConfig().isPaused()) return false;
+    if (suspense) return isUndefined(data) ? false : revalidateIfStale;
+    return isUndefined(data) || revalidateIfStale;
+  })();
+  const defaultValidatingState = !!(key && fetcher && isInitialMount && shouldDoInitialRevalidation);
+  const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
+  const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
+  const revalidate = useCallback(
+    async (revalidateOpts) => {
+      const currentFetcher = fetcherRef.current;
+      if (!key || !currentFetcher || unmountedRef.current || getConfig().isPaused()) {
+        return false;
+      }
+      let newData;
+      let startAt;
+      let loading = true;
+      const opts = revalidateOpts || {};
+      const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
+      const callbackSafeguard = () => {
+        if (IS_REACT_LEGACY) {
+          return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
+        }
+        return key === keyRef.current;
+      };
+      const finalState = {
+        isValidating: false,
+        isLoading: false
+      };
+      const finishRequestAndUpdateState = () => {
+        setCache(finalState);
+      };
+      const cleanupState = () => {
+        const requestInfo = FETCH[key];
+        if (requestInfo && requestInfo[1] === startAt) {
+          delete FETCH[key];
+        }
+      };
+      const initialState = {
+        isValidating: true
+      };
+      if (isUndefined(getCache().data)) {
+        initialState.isLoading = true;
+      }
+      try {
+        if (shouldStartNewRequest) {
+          setCache(initialState);
+          if (config.loadingTimeout && isUndefined(getCache().data)) {
+            setTimeout(() => {
+              if (loading && callbackSafeguard()) {
+                getConfig().onLoadingSlow(key, config);
+              }
+            }, config.loadingTimeout);
+          }
+          FETCH[key] = [
+            currentFetcher(fnArg),
+            getTimestamp()
+          ];
+        }
+        ;
+        [newData, startAt] = FETCH[key];
+        newData = await newData;
+        if (shouldStartNewRequest) {
+          setTimeout(cleanupState, config.dedupingInterval);
+        }
+        if (!FETCH[key] || FETCH[key][1] !== startAt) {
+          if (shouldStartNewRequest) {
+            if (callbackSafeguard()) {
+              getConfig().onDiscarded(key);
+            }
+          }
+          return false;
+        }
+        finalState.error = UNDEFINED;
+        const mutationInfo = MUTATION[key];
+        if (!isUndefined(mutationInfo) && // case 1
+        (startAt <= mutationInfo[0] || // case 2
+        startAt <= mutationInfo[1] || // case 3
+        mutationInfo[1] === 0)) {
+          finishRequestAndUpdateState();
+          if (shouldStartNewRequest) {
+            if (callbackSafeguard()) {
+              getConfig().onDiscarded(key);
+            }
+          }
+          return false;
+        }
+        const cacheData = getCache().data;
+        finalState.data = compare(cacheData, newData) ? cacheData : newData;
+        if (shouldStartNewRequest) {
+          if (callbackSafeguard()) {
+            getConfig().onSuccess(newData, key, config);
+          }
+        }
+      } catch (err) {
+        cleanupState();
+        const currentConfig = getConfig();
+        const { shouldRetryOnError } = currentConfig;
+        if (!currentConfig.isPaused()) {
+          finalState.error = err;
+          if (shouldStartNewRequest && callbackSafeguard()) {
+            currentConfig.onError(err, key, currentConfig);
+            if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
+              if (!getConfig().revalidateOnFocus || !getConfig().revalidateOnReconnect || isActive()) {
+                currentConfig.onErrorRetry(err, key, currentConfig, (_opts) => {
+                  const revalidators = EVENT_REVALIDATORS[key];
+                  if (revalidators && revalidators[0]) {
+                    revalidators[0](ERROR_REVALIDATE_EVENT, _opts);
+                  }
+                }, {
+                  retryCount: (opts.retryCount || 0) + 1,
+                  dedupe: true
+                });
+              }
+            }
+          }
+        }
+      }
+      loading = false;
+      finishRequestAndUpdateState();
+      return true;
+    },
+    // `setState` is immutable, and `eventsCallback`, `fnArg`, and
+    // `keyValidating` are depending on `key`, so we can exclude them from
+    // the deps array.
+    //
+    // FIXME:
+    // `fn` and `config` might be changed during the lifecycle,
+    // but they might be changed every render like this.
+    // `useSWR('key', () => fetch('/api/'), { suspense: true })`
+    // So we omit the values from the deps array
+    // even though it might cause unexpected behaviors.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      key,
+      cache
+    ]
+  );
+  const boundMutate = useCallback(
+    // Use callback to make sure `keyRef.current` returns latest result every time
+    (...args) => {
+      return internalMutate(cache, keyRef.current, ...args);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  useIsomorphicLayoutEffect(() => {
+    fetcherRef.current = fetcher;
+    configRef.current = config;
+    if (!isUndefined(cachedData)) {
+      laggyDataRef.current = cachedData;
+    }
+  });
+  useIsomorphicLayoutEffect(() => {
+    if (!key) return;
+    const softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);
+    let nextFocusRevalidatedAt = 0;
+    if (getConfig().revalidateOnFocus) {
+      const initNow = Date.now();
+      nextFocusRevalidatedAt = initNow + getConfig().focusThrottleInterval;
+    }
+    const onRevalidate = (type, opts = {}) => {
+      if (type == FOCUS_EVENT) {
+        const now = Date.now();
+        if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
+          nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
+          softRevalidate();
+        }
+      } else if (type == RECONNECT_EVENT) {
+        if (getConfig().revalidateOnReconnect && isActive()) {
+          softRevalidate();
+        }
+      } else if (type == MUTATE_EVENT) {
+        return revalidate();
+      } else if (type == ERROR_REVALIDATE_EVENT) {
+        return revalidate(opts);
+      }
+      return;
+    };
+    const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
+    unmountedRef.current = false;
+    keyRef.current = key;
+    initialMountedRef.current = true;
+    setCache({
+      _k: fnArg
+    });
+    if (shouldDoInitialRevalidation) {
+      if (isUndefined(data) || IS_SERVER) {
+        softRevalidate();
+      } else {
+        rAF(softRevalidate);
+      }
+    }
+    return () => {
+      unmountedRef.current = true;
+      unsubEvents();
+    };
+  }, [
+    key
+  ]);
+  useIsomorphicLayoutEffect(() => {
+    let timer;
+    function next() {
+      const interval = isFunction(refreshInterval) ? refreshInterval(getCache().data) : refreshInterval;
+      if (interval && timer !== -1) {
+        timer = setTimeout(execute, interval);
+      }
+    }
+    function execute() {
+      if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) {
+        revalidate(WITH_DEDUPE).then(next);
+      } else {
+        next();
+      }
+    }
+    next();
+    return () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = -1;
+      }
+    };
+  }, [
+    refreshInterval,
+    refreshWhenHidden,
+    refreshWhenOffline,
+    key
+  ]);
+  useDebugValue(returnedData);
+  if (suspense && isUndefined(data) && key) {
+    if (!IS_REACT_LEGACY && IS_SERVER) {
+      throw new Error("Fallback data is required when using Suspense in SSR.");
+    }
+    fetcherRef.current = fetcher;
+    configRef.current = config;
+    unmountedRef.current = false;
+    const req = PRELOAD[key];
+    if (!isUndefined(req)) {
+      const promise = boundMutate(req);
+      use(promise);
+    }
+    if (isUndefined(error)) {
+      const promise = revalidate(WITH_DEDUPE);
+      if (!isUndefined(returnedData)) {
+        promise.status = "fulfilled";
+        promise.value = true;
+      }
+      use(promise);
+    } else {
+      throw error;
+    }
+  }
+  const swrResponse = {
+    mutate: boundMutate,
+    get data() {
+      stateDependencies.data = true;
+      return returnedData;
+    },
+    get error() {
+      stateDependencies.error = true;
+      return error;
+    },
+    get isValidating() {
+      stateDependencies.isValidating = true;
+      return isValidating;
+    },
+    get isLoading() {
+      stateDependencies.isLoading = true;
+      return isLoading;
+    }
+  };
+  return swrResponse;
+};
+const SWRConfig = OBJECT.defineProperty(SWRConfig$1, "defaultValue", {
+  value: defaultConfig
+});
+const useSWR = withArgs(useSWRHandler);
+export {
+  SWRConfig,
+  useSWR as default,
+  j as mutate,
+  useSWRConfig
+};

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

@@ -0,0 +1,68 @@
+import { j as jsxRuntimeExports } from "./golocal-cloud-wrapper.es18.js";
+import { useUser } from "./golocal-cloud-wrapper.es23.js";
+import "./golocal-cloud-wrapper.es19.js";
+import "react";
+import { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuItem } from "./golocal-cloud-wrapper.es11.js";
+import { Button } from "./golocal-cloud-wrapper.es8.js";
+import User from "./golocal-cloud-wrapper.es24.js";
+import LogOut from "./golocal-cloud-wrapper.es25.js";
+const ProfileDropdown = ({ onLogout }) => {
+  const { user, error, isLoading } = useUser();
+  const handleLogout = async () => {
+    try {
+      if (onLogout) {
+        await onLogout();
+      }
+      window.location.href = "/auth/logout";
+    } catch (error2) {
+      console.error("Error during logout:", error2);
+      window.location.href = "/auth/logout";
+    }
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "h-10 w-10 animate-pulse rounded-full bg-gray-200" });
+  }
+  if (error) return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+    "Error: ",
+    error.message
+  ] });
+  if (!user) return null;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "relative flex items-center gap-3", children: /* @__PURE__ */ jsxRuntimeExports.jsxs(DropdownMenu, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Button,
+      {
+        variant: "ghost",
+        size: "lg",
+        className: "rounded-full cursor-pointer p-0",
+        children: user.picture ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "img",
+          {
+            src: user.picture,
+            alt: user.name || "User profile",
+            width: 40,
+            height: 40,
+            className: "rounded-full"
+          }
+        ) : /* @__PURE__ */ jsxRuntimeExports.jsx(User, { className: "h-5 w-5 text-gray-500" })
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(DropdownMenuContent, { align: "end", className: "w-72", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(DropdownMenuLabel, { children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "flex flex-col space-y-1", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "flex flex-col space-y-1", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "text-xs text-gray-500", children: user.name }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "truncate text-xs text-gray-500", children: user.email })
+      ] }) }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(DropdownMenuSeparator, {}),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(DropdownMenuItem, { asChild: true, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: "/profile", className: "flex w-full cursor-default", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(User, { className: "mr-2 h-4 w-4" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Profile" })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs(DropdownMenuItem, { onClick: handleLogout, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(LogOut, { className: "mr-2 h-4 w-4" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: "Sign out" })
+      ] })
+    ] })
+  ] }) });
+};
+export {
+  ProfileDropdown
+};

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

@@ -0,0 +1,25 @@
+function ensureLeadingSlash(value) {
+  return value && !value.startsWith("/") ? `/${value}` : value;
+}
+function ensureTrailingSlash(value) {
+  return value && !value.endsWith("/") ? `${value}/` : value;
+}
+function ensureNoLeadingSlash(value) {
+  return value && value.startsWith("/") ? value.substring(1, value.length) : value;
+}
+const removeTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+const normalizeWithBasePath = (path) => {
+  const basePath = process.env.NEXT_PUBLIC_BASE_PATH;
+  if (!basePath) {
+    return path;
+  }
+  const sanitizedBasePath = ensureLeadingSlash(basePath);
+  return ensureTrailingSlash(sanitizedBasePath) + ensureNoLeadingSlash(path);
+};
+export {
+  ensureLeadingSlash,
+  ensureNoLeadingSlash,
+  ensureTrailingSlash,
+  normalizeWithBasePath,
+  removeTrailingSlash
+};

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

@@ -0,0 +1,28 @@
+import { forwardRef, createElement } from "react";
+import { mergeClasses, toKebabCase, toPascalCase } from "./golocal-cloud-wrapper.es62.js";
+import Icon from "./golocal-cloud-wrapper.es63.js";
+/**
+ * @license lucide-react v0.522.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const createLucideIcon = (iconName, iconNode) => {
+  const Component = forwardRef(
+    ({ className, ...props }, ref) => createElement(Icon, {
+      ref,
+      iconNode,
+      className: mergeClasses(
+        `lucide-${toKebabCase(toPascalCase(iconName))}`,
+        `lucide-${iconName}`,
+        className
+      ),
+      ...props
+    })
+  );
+  Component.displayName = toPascalCase(iconName);
+  return Component;
+};
+export {
+  createLucideIcon as default
+};

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

@@ -0,0 +1,32 @@
+/**
+ * @license lucide-react v0.522.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const toCamelCase = (string) => string.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase()
+);
+const toPascalCase = (string) => {
+  const camelCase = toCamelCase(string);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+};
+const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+const hasA11yProp = (props) => {
+  for (const prop in props) {
+    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+      return true;
+    }
+  }
+};
+export {
+  hasA11yProp,
+  mergeClasses,
+  toCamelCase,
+  toKebabCase,
+  toPascalCase
+};

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

@@ -0,0 +1,41 @@
+import { forwardRef, createElement } from "react";
+import defaultAttributes from "./golocal-cloud-wrapper.es64.js";
+import { mergeClasses, hasA11yProp } from "./golocal-cloud-wrapper.es62.js";
+/**
+ * @license lucide-react v0.522.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Icon = forwardRef(
+  ({
+    color = "currentColor",
+    size = 24,
+    strokeWidth = 2,
+    absoluteStrokeWidth,
+    className = "",
+    children,
+    iconNode,
+    ...rest
+  }, ref) => createElement(
+    "svg",
+    {
+      ref,
+      ...defaultAttributes,
+      width: size,
+      height: size,
+      stroke: color,
+      strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
+      className: mergeClasses("lucide", className),
+      ...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+      ...rest
+    },
+    [
+      ...iconNode.map(([tag, attrs]) => createElement(tag, attrs)),
+      ...Array.isArray(children) ? children : [children]
+    ]
+  )
+);
+export {
+  Icon as default
+};

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

@@ -0,0 +1,20 @@
+/**
+ * @license lucide-react v0.522.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+export {
+  defaultAttributes as default
+};

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

@@ -0,0 +1,11 @@
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler == null ? void 0 : originalEventHandler(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler == null ? void 0 : ourEventHandler(event);
+    }
+  };
+}
+export {
+  composeEventHandlers
+};