@wix/entity-advanced-permissions 1.1132.0 → 1.1134.0

package/dist/statics/entity-advanced-permissions.umd.js

@@ -33493,7 +33493,7 @@ var __webpack_exports__ = {};
 (() => {
 "use strict";
 /*!********************************!*\
-  !*** ./index.ts + 453 modules ***!
+  !*** ./index.ts + 456 modules ***!
   \********************************/
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
@@ -54075,6 +54075,19 @@ var index = manageState(Select);
 /* harmony default export */ const react_select_browser_esm = (index);
 
 
+;// CONCATENATED MODULE: ../../../node_modules/@vtaits/use-lazy-ref/dist/index.js
+// src/index.ts
+
+var EMPTY_VALUE = Symbol("useLazyRef empty value");
+var useLazyRef = (init) => {
+  const resultRef = (0,external_React_.useRef)(EMPTY_VALUE);
+  if (resultRef.current === EMPTY_VALUE) {
+    resultRef.current = init();
+  }
+  return resultRef;
+};
+
+//# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ../../../node_modules/use-is-mounted-ref/dist/use-is-mounted-ref.es.js
 
 
@@ -54092,18 +54105,194 @@ function useIsMountedRef() {
 
 //# sourceMappingURL=use-is-mounted-ref.es.js.map
 
-;// CONCATENATED MODULE: ../../../node_modules/@vtaits/use-lazy-ref/dist/use-lazy-ref.js
+;// CONCATENATED MODULE: ../../../node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.browser.esm.js
 
-const EMPTY_VALUE = Symbol("useLazyRef empty value");
-const useLazyRef = (init) => {
-  const resultRef = (0,external_React_.useRef)(EMPTY_VALUE);
-  if (resultRef.current === EMPTY_VALUE) {
-    resultRef.current = init();
+
+var use_isomorphic_layout_effect_browser_esm_index =  external_React_.useLayoutEffect ;
+
+/* harmony default export */ const use_isomorphic_layout_effect_browser_esm = (use_isomorphic_layout_effect_browser_esm_index);
+
+;// CONCATENATED MODULE: ../../../node_modules/use-latest/dist/use-latest.esm.js
+
+
+
+var useLatest = function useLatest(value) {
+  var ref = external_React_.useRef(value);
+  use_isomorphic_layout_effect_browser_esm(function () {
+    ref.current = value;
+  });
+  return ref;
+};
+
+
+
+;// CONCATENATED MODULE: ../../../node_modules/krustykrab/dist/esm/index.js
+// src/option_result.ts
+function Ok(result) {
+  const self = {
+    isOk: () => true,
+    isOkAnd: (fn) => fn(result),
+    isErr: () => false,
+    isErrAnd: () => false,
+    ok: () => Some(result),
+    err: () => None(),
+    map: (fn) => Ok(fn(result)),
+    mapOr: (_, fn) => fn(result),
+    mapOrElse: (_, fn) => fn(result),
+    mapErr: () => Ok(result),
+    expect: () => result,
+    expectErr: (msg) => {
+      throw new Error(msg);
+    },
+    unwrap: () => result,
+    unwrapErr: () => {
+      throw new Error(`${result}`);
+    },
+    unwrapOr: () => result,
+    unwrapOrElse: () => result,
+    and: (res) => res,
+    andThen: (getRes) => getRes(result),
+    or: () => Ok(result),
+    orElse: () => Ok(result)
+  };
+  return self;
+}
+function Err(err) {
+  const self = {
+    isOk: () => false,
+    isOkAnd: () => false,
+    isErr: () => true,
+    isErrAnd: (fn) => fn(err),
+    ok: () => None(),
+    err: () => Some(err),
+    map: () => Err(err),
+    mapOr: (defaultValue) => defaultValue,
+    mapOrElse: (getDefaultValue) => getDefaultValue(err),
+    mapErr: (fn) => Err(fn(err)),
+    expect: (msg) => {
+      throw new Error(msg);
+    },
+    expectErr: () => err,
+    unwrap: () => {
+      throw new Error(`${err}`);
+    },
+    unwrapErr: () => err,
+    unwrapOr: (defaultValue) => defaultValue,
+    unwrapOrElse: (getDefaultValue) => getDefaultValue(err),
+    and: () => Err(err),
+    andThen: () => Err(err),
+    or: (res) => res,
+    orElse: (getRes) => getRes(err)
+  };
+  return self;
+}
+function None() {
+  const self = {
+    and: () => None(),
+    andThen: () => None(),
+    expect: (msg) => {
+      throw new Error(msg);
+    },
+    filter: () => self,
+    isSome: () => false,
+    isSomeAnd: () => false,
+    isNone: () => true,
+    map: () => None(),
+    mapOr: (defaultValue) => defaultValue,
+    mapOrElse: (getDefaultValue) => getDefaultValue(),
+    okOr: (err) => Err(err),
+    okOrElse: (getErr) => Err(getErr()),
+    or: (opt) => opt,
+    orElse: (fn) => fn(),
+    unwrap: () => {
+      throw new Error("panic! call `unwrap` on a `None` value");
+    },
+    unwrapOr: (defaultValue) => defaultValue,
+    unwrapOrElse: (getDefaultValue) => getDefaultValue(),
+    xor: (opt) => {
+      if (opt.isSome()) {
+        return opt;
+      }
+      return self;
+    }
+  };
+  return self;
+}
+function Some(value) {
+  const self = {
+    and: (opt) => opt,
+    andThen: (fn) => fn(value),
+    expect: () => value,
+    filter: (fn) => {
+      if (fn(value)) {
+        return self;
+      }
+      return None();
+    },
+    isSome: () => true,
+    isSomeAnd: (fn) => fn(value),
+    isNone: () => false,
+    map: (fn) => Some(fn(value)),
+    mapOr: (_, fn) => fn(value),
+    mapOrElse: (_, fn) => fn(value),
+    okOr: () => Ok(value),
+    okOrElse: () => Ok(value),
+    or: () => self,
+    orElse: () => self,
+    unwrap: () => value,
+    unwrapOr: () => value,
+    unwrapOrElse: () => value,
+    xor: (opt) => {
+      if (opt.isNone()) {
+        return self;
+      }
+      return None();
+    }
+  };
+  return self;
+}
+
+// src/to_option.ts
+function toOption(arg) {
+  if (arg === null || arg === void 0) {
+    return None();
   }
-  return resultRef;
-};
+  return Some(arg);
+}
+
+// src/get_result.ts
+function getResult(promise) {
+  return promise.then(
+    (response) => Ok(response),
+    (err) => Err(err)
+  );
+}
+
+// src/unwrap.ts
+function esm_unwrap(value) {
+  if (value === null || value === void 0) {
+    throw new Error(`panic! call \`unwrap\` on a \`${value}\` value`);
+  }
+  return value;
+}
+
+// src/unwrap_or.ts
+function unwrapOr(value, defaultValue) {
+  if (value === null || value === void 0) {
+    return defaultValue;
+  }
+  return value;
+}
 
+// src/unwrap_or_else.ts
+function unwrapOrElse(value, getDefaultValue) {
+  if (value === null || value === void 0) {
+    return getDefaultValue();
+  }
+  return value;
+}
 
+//# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ../../../node_modules/sleep-promise/build/esm.mjs
 var e=setTimeout;function esm_t(t,n){var u=n.useCachedSetTimeout?e:setTimeout;return new Promise((function(e){u(e,t)}))}function esm_n(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},u=n.useCachedSetTimeout,r=esm_t(e,{useCachedSetTimeout:u});function o(e){return r.then((function(){return e}))}return o.then=function(){return r.then.apply(r,arguments)},o.catch=Promise.resolve().catch,o}/* harmony default export */ const esm = (esm_n);
 
@@ -54123,6 +54312,17 @@ var jsx_runtime = __webpack_require__(4512);
 
 
 
+
+// src/defaultReduceOptions.ts
+var defaultReduceOptions = (prevOptions, loadedOptions) => [...prevOptions, ...loadedOptions];
+
+// src/defaultShouldLoadMore.ts
+var AVAILABLE_DELTA = 10;
+var defaultShouldLoadMore = (scrollHeight, clientHeight, scrollTop) => {
+  const bottomBorder = scrollHeight - clientHeight - AVAILABLE_DELTA;
+  return bottomBorder < scrollTop;
+};
+
 // src/getInitialCache.ts
 var getInitialCache = (params) => ({
   isFirstLoad: true,
@@ -54139,7 +54339,7 @@ var getInitialOptionsCache = ({
   additional,
   defaultAdditional
 }) => {
-  const initialOptions = defaultOptions === true ? null : defaultOptions instanceof Array ? defaultOptions : options;
+  const initialOptions = defaultOptions === true ? null : Array.isArray(defaultOptions) ? defaultOptions : options;
   if (initialOptions) {
     return {
       "": {
@@ -54154,29 +54354,17 @@ var getInitialOptionsCache = ({
   return {};
 };
 
-// src/defaultShouldLoadMore.ts
-var AVAILABLE_DELTA = 10;
-var defaultShouldLoadMore = (scrollHeight, clientHeight, scrollTop) => {
-  const bottomBorder = scrollHeight - clientHeight - AVAILABLE_DELTA;
-  return bottomBorder < scrollTop;
-};
-
-// src/defaultReduceOptions.ts
-var defaultReduceOptions = (prevOptions, loadedOptions) => [...prevOptions, ...loadedOptions];
-
 // src/requestOptions.ts
 
 
+
 // src/validateResponse.ts
 var errorText = '[react-select-async-paginate] response of "loadOptions" should be an object with "options" prop, which contains array of options.';
 var checkIsResponse = (response) => {
   if (!response) {
     return false;
   }
-  const {
-    options,
-    hasMore
-  } = response;
+  const { options, hasMore } = response;
   if (!Array.isArray(options)) {
     return false;
   }
@@ -54201,23 +54389,22 @@ var requestOptions = async (caller, paramsRef, optionsCacheRef, debounceTimeout,
   if (currentOptions.isLoading || !currentOptions.hasMore) {
     return;
   }
-  setOptionsCache((prevOptionsCache) => ({
-    ...prevOptionsCache,
-    [currentInputValue]: {
-      ...currentOptions,
-      isLoading: true
-    }
-  }));
+  setOptionsCache(
+    (prevOptionsCache) => ({
+      ...prevOptionsCache,
+      [currentInputValue]: {
+        ...currentOptions,
+        isLoading: true
+      }
+    })
+  );
   if (debounceTimeout > 0 && caller === "input-change") {
     await esm(debounceTimeout);
     const newInputValue = paramsRef.current.inputValue;
     if (currentInputValue !== newInputValue) {
       setOptionsCache((prevOptionsCache) => {
         if (isCacheEmpty) {
-          const {
-            [currentInputValue]: itemForDelete,
-            ...restCache
-          } = prevOptionsCache;
+          const { [currentInputValue]: itemForDelete, ...restCache } = prevOptionsCache;
           return restCache;
         }
         return {
@@ -54231,21 +54418,17 @@ var requestOptions = async (caller, paramsRef, optionsCacheRef, debounceTimeout,
       return;
     }
   }
-  let response;
-  let hasError = false;
-  try {
-    const {
-      loadOptions
-    } = paramsRef.current;
-    response = await loadOptions(
-      currentInputValue,
-      currentOptions.options,
-      currentOptions.additional
-    );
-  } catch (e) {
-    hasError = true;
-  }
-  if (hasError) {
+  const { loadOptions } = paramsRef.current;
+  const result = await getResult(
+    Promise.resolve().then(
+      () => loadOptions(
+        currentInputValue,
+        currentOptions.options,
+        currentOptions.additional
+      )
+    )
+  );
+  if (result.isErr()) {
     setOptionsCache((prevOptionsCache) => ({
       ...prevOptionsCache,
       [currentInputValue]: {
@@ -54255,12 +54438,10 @@ var requestOptions = async (caller, paramsRef, optionsCacheRef, debounceTimeout,
     }));
     return;
   }
+  const response = result.unwrap();
   if (validateResponse(response)) {
-    const {
-      options,
-      hasMore
-    } = response;
-    const newAdditional = response.hasOwnProperty("additional") ? response.additional : currentOptions.additional;
+    const { options, hasMore } = response;
+    const newAdditional = Object.hasOwn(response, "additional") ? response.additional : currentOptions.additional;
     setOptionsCache((prevOptionsCache) => ({
       ...prevOptionsCache,
       [currentInputValue]: {
@@ -54289,33 +54470,37 @@ var useAsyncPaginateBase = (params, deps = []) => {
     shouldLoadMore = defaultShouldLoadMore
   } = params;
   const isMountedRef = useIsMountedRef();
+  const reduceOptionsRef = useLatest(reduceOptions);
+  const loadOptionsOnMenuOpenRef = useLatest(loadOptionsOnMenuOpen);
   const isInitRef = (0,external_React_.useRef)(true);
   const paramsRef = (0,external_React_.useRef)(params);
   paramsRef.current = params;
-  const setStateId = (0,external_React_.useState)(0)[1];
+  const [_stateId, setStateId] = (0,external_React_.useState)(0);
   const optionsCacheRef = useLazyRef(() => getInitialOptionsCache(params));
-  const callRequestOptions = (0,external_React_.useCallback)((caller) => {
-    requestOptions(
-      caller,
-      paramsRef,
-      optionsCacheRef,
-      debounceTimeout,
-      (reduceState) => {
-        optionsCacheRef.current = reduceState(optionsCacheRef.current);
-        if (isMountedRef.current) {
-          setStateId(increaseStateId);
-        }
-      },
-      reduceOptions
-    );
-  }, [debounceTimeout]);
+  const callRequestOptionsRef = useLatest(
+    (caller) => {
+      requestOptions(
+        caller,
+        paramsRef,
+        optionsCacheRef,
+        debounceTimeout,
+        (reduceState) => {
+          optionsCacheRef.current = reduceState(optionsCacheRef.current);
+          if (isMountedRef.current) {
+            setStateId(increaseStateId);
+          }
+        },
+        reduceOptionsRef.current
+      );
+    }
+  );
   const handleScrolledToBottom = (0,external_React_.useCallback)(() => {
     const currentInputValue = paramsRef.current.inputValue;
     const currentOptions2 = optionsCacheRef.current[currentInputValue];
     if (currentOptions2) {
-      callRequestOptions("menu-scroll");
+      callRequestOptionsRef.current("menu-scroll");
     }
-  }, [callRequestOptions]);
+  }, [callRequestOptionsRef, optionsCacheRef]);
   (0,external_React_.useEffect)(() => {
     if (isInitRef.current) {
       isInitRef.current = false;
@@ -54324,19 +54509,24 @@ var useAsyncPaginateBase = (params, deps = []) => {
       setStateId(increaseStateId);
     }
     if (defaultOptions === true) {
-      callRequestOptions("autoload");
+      callRequestOptionsRef.current("autoload");
     }
   }, deps);
   (0,external_React_.useEffect)(() => {
     if (menuIsOpen && !optionsCacheRef.current[inputValue]) {
-      callRequestOptions("input-change");
+      callRequestOptionsRef.current("input-change");
     }
-  }, [inputValue]);
+  }, [callRequestOptionsRef, inputValue, menuIsOpen, optionsCacheRef]);
   (0,external_React_.useEffect)(() => {
-    if (menuIsOpen && !optionsCacheRef.current[""] && loadOptionsOnMenuOpen) {
-      callRequestOptions("menu-toggle");
+    if (menuIsOpen && !optionsCacheRef.current[""] && loadOptionsOnMenuOpenRef.current) {
+      callRequestOptionsRef.current("menu-toggle");
     }
-  }, [menuIsOpen]);
+  }, [
+    callRequestOptionsRef,
+    loadOptionsOnMenuOpenRef,
+    menuIsOpen,
+    optionsCacheRef
+  ]);
   const currentOptions = optionsCacheRef.current[inputValue] || getInitialCache(params);
   return {
     handleScrolledToBottom,
@@ -54362,17 +54552,18 @@ var useAsyncPaginate = (params, deps = []) => {
   const [inputValueState, setInputValue] = (0,external_React_.useState)(
     defaultInputValueParam || ""
   );
-  const [menuIsOpenState, setMenuIsOpen] = (0,external_React_.useState)(
-    !!defaultMenuIsOpenParam
-  );
+  const [menuIsOpenState, setMenuIsOpen] = (0,external_React_.useState)(!!defaultMenuIsOpenParam);
   const inputValue = typeof inputValueParam === "string" ? inputValueParam : inputValueState;
   const menuIsOpen = typeof menuIsOpenParam === "boolean" ? menuIsOpenParam : menuIsOpenState;
-  const onInputChange = (0,external_React_.useCallback)((nextInputValue, actionMeta) => {
-    if (onInputChangeParam) {
-      onInputChangeParam(nextInputValue, actionMeta);
-    }
-    setInputValue(nextInputValue);
-  }, [onInputChangeParam]);
+  const onInputChange = (0,external_React_.useCallback)(
+    (nextInputValue, actionMeta) => {
+      if (onInputChangeParam) {
+        onInputChangeParam(nextInputValue, actionMeta);
+      }
+      setInputValue(nextInputValue);
+    },
+    [onInputChangeParam]
+  );
   const onMenuClose = (0,external_React_.useCallback)(() => {
     if (onMenuCloseParam) {
       onMenuCloseParam();
@@ -54414,14 +54605,8 @@ var useAsyncPaginate = (params, deps = []) => {
 var CHECK_TIMEOUT = 300;
 function wrapMenuList(MenuList2) {
   function WrappedMenuList(props) {
-    const {
-      selectProps,
-      innerRef
-    } = props;
-    const {
-      handleScrolledToBottom,
-      shouldLoadMore
-    } = selectProps;
+    const { selectProps, innerRef } = props;
+    const { handleScrolledToBottom, shouldLoadMore } = selectProps;
     const checkTimeoutRef = (0,external_React_.useRef)();
     const menuListRef = (0,external_React_.useRef)(null);
     const shouldHandle = (0,external_React_.useCallback)(() => {
@@ -54429,11 +54614,7 @@ function wrapMenuList(MenuList2) {
       if (!el) {
         return false;
       }
-      const {
-        scrollTop,
-        scrollHeight,
-        clientHeight
-      } = el;
+      const { scrollTop, scrollHeight, clientHeight } = el;
       return shouldLoadMore(scrollHeight, clientHeight, scrollTop);
     }, [shouldLoadMore]);
     const checkAndHandle = (0,external_React_.useCallback)(() => {
@@ -54443,9 +54624,12 @@ function wrapMenuList(MenuList2) {
         }
       }
     }, [shouldHandle, handleScrolledToBottom]);
-    const setCheckAndHandleTimeout = (0,external_React_.useCallback)(() => {
-      checkAndHandle();
-      checkTimeoutRef.current = setTimeout(setCheckAndHandleTimeout, CHECK_TIMEOUT);
+    const setCheckAndHandleTimeout = (0,external_React_.useMemo)(() => {
+      const res = () => {
+        checkAndHandle();
+        checkTimeoutRef.current = setTimeout(res, CHECK_TIMEOUT);
+      };
+      return res;
     }, [checkAndHandle]);
     (0,external_React_.useEffect)(() => {
       setCheckAndHandleTimeout();
@@ -54468,10 +54652,13 @@ function wrapMenuList(MenuList2) {
 
 // src/useComponents.ts
 var esm_MenuList = wrapMenuList(components.MenuList);
-var useComponents = (components) => (0,external_React_.useMemo)(() => ({
-  MenuList: esm_MenuList,
-  ...components
-}), [components]);
+var useComponents = (components) => (0,external_React_.useMemo)(
+  () => ({
+    MenuList: esm_MenuList,
+    ...components
+  }),
+  [components]
+);
 
 // src/withAsyncPaginate.tsx
 
@@ -54486,11 +54673,10 @@ function withAsyncPaginate(SelectComponent) {
       cacheUniqs = defaultCacheUniqs,
       ...rest
     } = props;
-    const asyncPaginateProps = useAsyncPaginate(
-      rest,
-      cacheUniqs
+    const asyncPaginateProps = useAsyncPaginate(rest, cacheUniqs);
+    const processedComponents = useComponents(
+      components
     );
-    const processedComponents = useComponents(components);
     const isLoading = typeof isLoadingProp === "boolean" ? isLoadingProp : asyncPaginateProps.isLoading;
     return /* @__PURE__ */ (0,jsx_runtime.jsx)(
       SelectComponent,
@@ -54511,10 +54697,7 @@ var checkGroup = (group) => {
   if (!group) {
     return false;
   }
-  const {
-    label,
-    options
-  } = group;
+  const { label, options } = group;
   if (typeof label !== "string" && typeof label !== "undefined") {
     return false;
   }
@@ -54528,13 +54711,11 @@ var reduceGroupedOptions = (prevOptions, loadedOptions) => {
   const mapLabelToIndex = {};
   let prevOptionsIndex = 0;
   const prevOptionsLength = prevOptions.length;
-  loadedOptions.forEach((optionOrGroup) => {
+  for (const optionOrGroup of loadedOptions) {
     const group = checkGroup(optionOrGroup) ? optionOrGroup : {
       options: [optionOrGroup]
     };
-    const {
-      label = ""
-    } = group;
+    const { label = "" } = group;
     let groupIndex = mapLabelToIndex[label];
     if (typeof groupIndex !== "number") {
       for (; prevOptionsIndex < prevOptionsLength && typeof mapLabelToIndex[label] !== "number"; ++prevOptionsIndex) {
@@ -54548,13 +54729,13 @@ var reduceGroupedOptions = (prevOptions, loadedOptions) => {
     if (typeof groupIndex !== "number") {
       mapLabelToIndex[label] = res.length;
       res.push(group);
-      return;
+    } else {
+      res[groupIndex] = {
+        ...res[groupIndex],
+        options: [...res[groupIndex].options, ...group.options]
+      };
     }
-    res[groupIndex] = {
-      ...res[groupIndex],
-      options: [...res[groupIndex].options, ...group.options]
-    };
-  });
+  }
   return res;
 };