@hanzogui/dismissable 7.0.0 → 7.3.1

package/LICENSE

@@ -1,21 +1,42 @@
-MIT License
+BSD 3-Clause License
+
+Copyright (c) 2026-present, Hanzo AI, Inc.
+
+Portions of this software are derived from upstream code originally licensed under
+the MIT License, with the following copyright notices retained per its terms:
 
   Copyright (c) 2020 Nate Wienert
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-  
-  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
+  Copyright (c) 2015-present, Nicolas Gallagher.
+  Copyright (c) 2015-present, Facebook, Inc.
+  Copyright (c) 2021 Radix
+  Copyright (c) 2017 Carmelo Pullara
+  Copyright (c) 2018 Framer B.V.
+  Copyright (c) 2022 WorkOS
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

package/dist/cjs/Dismissable.cjs

@@ -0,0 +1,383 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var Dismissable_exports = {};
+__export(Dismissable_exports, {
+  Dismissable: () => Dismissable,
+  DismissableBranch: () => DismissableBranch,
+  debugDismissableLayers: () => debugDismissableLayers,
+  dispatchDiscreteCustomEvent: () => dispatchDiscreteCustomEvent,
+  getDismissableLayerCount: () => getDismissableLayerCount,
+  useDismissableLayersAbove: () => useDismissableLayersAbove,
+  useHasDismissableLayers: () => useHasDismissableLayers,
+  useIsInsideDismissable: () => useIsInsideDismissable
+});
+module.exports = __toCommonJS(Dismissable_exports);
+var import_compose_refs = require("@hanzogui/compose-refs");
+var import_core = require("@hanzogui/core");
+var import_use_escape_keydown = require("@hanzogui/use-escape-keydown");
+var import_use_event = require("@hanzogui/use-event");
+var React = __toESM(require("react"), 1);
+var ReactDOM = __toESM(require("react-dom"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+function dispatchDiscreteCustomEvent(target, event) {
+  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));
+}
+const DISMISSABLE_LAYER_NAME = "Dismissable";
+const CONTEXT_UPDATE = "dismissable.update";
+const POINTER_DOWN_OUTSIDE = "dismissable.pointerDownOutside";
+const FOCUS_OUTSIDE = "dismissable.focusOutside";
+let originalBodyPointerEvents;
+const globalLayers = /* @__PURE__ */new Set();
+const layerChangeListeners = /* @__PURE__ */new Set();
+let layersWithPointerEventsDisabledCount = 0;
+function notifyLayerChange() {
+  for (const listener of layerChangeListeners) {
+    listener();
+  }
+}
+function getDismissableLayerCount() {
+  return globalLayers.size;
+}
+function debugDismissableLayers() {
+  const layers = Array.from(globalLayers);
+  console.log("[Dismissable] Active layers:", layers.length, layers);
+  return layers;
+}
+function useHasDismissableLayers() {
+  const [count, setCount] = React.useState(() => globalLayers.size);
+  React.useEffect(() => {
+    setCount(globalLayers.size);
+    const update = () => setCount(globalLayers.size);
+    layerChangeListeners.add(update);
+    return () => {
+      layerChangeListeners.delete(update);
+    };
+  }, []);
+  return count > 0;
+}
+const DismissableContext = React.createContext({
+  layers: /* @__PURE__ */new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */new Set(),
+  branches: /* @__PURE__ */new Set()
+});
+function useIsInsideDismissable(ref) {
+  const context = React.useContext(DismissableContext);
+  const [isInside, setIsInside] = React.useState(false);
+  React.useEffect(() => {
+    const check = () => {
+      const el = ref.current;
+      if (!el) {
+        setIsInside(false);
+        return;
+      }
+      for (const layer of context.layers) {
+        if (layer.contains(el)) {
+          setIsInside(true);
+          return;
+        }
+      }
+      setIsInside(false);
+    };
+    check();
+    document.addEventListener(CONTEXT_UPDATE, check);
+    return () => document.removeEventListener(CONTEXT_UPDATE, check);
+  }, [context.layers, ref]);
+  return isInside;
+}
+function useDismissableLayersAbove(ref) {
+  const context = React.useContext(DismissableContext);
+  const [count, setCount] = React.useState(0);
+  React.useEffect(() => {
+    const check = () => {
+      const el = ref.current;
+      if (!el) {
+        setCount(0);
+        return;
+      }
+      let above = 0;
+      for (const layer of context.layers) {
+        if (layer.contains(el)) {
+          above++;
+        }
+      }
+      setCount(above);
+    };
+    check();
+    document.addEventListener(CONTEXT_UPDATE, check);
+    return () => document.removeEventListener(CONTEXT_UPDATE, check);
+  }, [context.layers, ref]);
+  return count;
+}
+const Dismissable = React.forwardRef((props, forwardedRef) => {
+  const {
+    disableOutsidePointerEvents = false,
+    forceUnmount,
+    onEscapeKeyDown,
+    onPointerDownOutside,
+    onFocusOutside,
+    onInteractOutside,
+    onDismiss,
+    asChild,
+    children,
+    branches: branchesProp,
+    ...layerProps
+  } = props;
+  const Comp = asChild ? import_core.Slot : import_core.View;
+  const context = React.useContext(DismissableContext);
+  const [node, setNode] = React.useState(null);
+  const [, force] = React.useState({});
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, node2 => setNode(node2));
+  const layers = Array.from(context.layers);
+  const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+  const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
+  const index = node ? layers.indexOf(node) : -1;
+  const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
+  const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;
+  const pointerDownOutside = usePointerDownOutside(event => {
+    const target = event.target;
+    const branches = branchesProp || context.branches;
+    const isPointerDownOnBranch = [...branches].some(branch => branch.contains(target));
+    if (!isPointerEventsEnabled || isPointerDownOnBranch) return;
+    onPointerDownOutside?.(event);
+    onInteractOutside?.(event);
+    if (!event.defaultPrevented) onDismiss?.();
+  });
+  const focusOutside = useFocusOutside(event => {
+    const target = event.target;
+    const branches = branchesProp || context.branches;
+    const isFocusInBranch = [...branches].some(branch => branch.contains(target));
+    if (isFocusInBranch) return;
+    onFocusOutside?.(event);
+    onInteractOutside?.(event);
+    if (!event.defaultPrevented) onDismiss?.();
+  });
+  const forceUnmountRef = React.useRef(forceUnmount);
+  React.useEffect(() => {
+    forceUnmountRef.current = forceUnmount;
+  }, [forceUnmount]);
+  (0, import_use_escape_keydown.useEscapeKeydown)(event => {
+    if (forceUnmountRef.current) return;
+    const currentLayers = Array.from(context.layers);
+    const currentIndex = node ? currentLayers.indexOf(node) : -1;
+    const isHighestLayer = currentIndex === currentLayers.length - 1;
+    if (!isHighestLayer) return;
+    onEscapeKeyDown?.(event);
+    if (!event.defaultPrevented && onDismiss) {
+      event.preventDefault();
+      onDismiss();
+    }
+  });
+  React.useEffect(() => {
+    if (!node) return;
+    if (forceUnmount) return;
+    if (disableOutsidePointerEvents) {
+      if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+        originalBodyPointerEvents = document.body.style.pointerEvents;
+        document.body.style.pointerEvents = "none";
+      }
+      context.layersWithOutsidePointerEventsDisabled.add(node);
+      layersWithPointerEventsDisabledCount++;
+    }
+    context.layers.add(node);
+    globalLayers.add(node);
+    if (disableOutsidePointerEvents || layersWithPointerEventsDisabledCount > 0) {
+      dispatchUpdate();
+    }
+    notifyLayerChange();
+    return () => {
+      if (disableOutsidePointerEvents) {
+        if (context.layersWithOutsidePointerEventsDisabled.size === 1) {
+          document.body.style.pointerEvents = originalBodyPointerEvents;
+        }
+      }
+    };
+  }, [node, disableOutsidePointerEvents, forceUnmount, context]);
+  React.useEffect(() => {
+    if (forceUnmount) return;
+    return () => {
+      if (!node) return;
+      const hadPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.has(node);
+      context.layers.delete(node);
+      context.layersWithOutsidePointerEventsDisabled.delete(node);
+      globalLayers.delete(node);
+      if (layersWithPointerEventsDisabledCount > 0) {
+        dispatchUpdate();
+      }
+      notifyLayerChange();
+      if (hadPointerEventsDisabled) {
+        layersWithPointerEventsDisabledCount--;
+      }
+    };
+  }, [node, context, forceUnmount]);
+  React.useEffect(() => {
+    const handleUpdate = () => {
+      if (layersWithPointerEventsDisabledCount > 0) {
+        force({});
+      }
+    };
+    document.addEventListener(CONTEXT_UPDATE, handleUpdate);
+    return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
+  }, []);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(Comp, {
+    ...layerProps,
+    ref: composedRefs,
+    ...(!asChild && {
+      display: "contents"
+    }),
+    pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
+    onFocusCapture: (0, import_core.composeEventHandlers)(props.onFocusCapture, focusOutside.onFocusCapture),
+    onBlurCapture: (0, import_core.composeEventHandlers)(props.onBlurCapture, focusOutside.onBlurCapture),
+    onPointerDownCapture: (0, import_core.composeEventHandlers)(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture),
+    children
+  });
+});
+Dismissable.displayName = DISMISSABLE_LAYER_NAME;
+const BRANCH_NAME = "DismissableBranch";
+const DismissableBranch = React.forwardRef((props, forwardedRef) => {
+  const {
+    branches: branchesProp,
+    ...rest
+  } = props;
+  const context = React.useContext(DismissableContext);
+  const ref = React.useRef(null);
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, ref);
+  React.useEffect(() => {
+    const node = ref.current;
+    if (!(node instanceof HTMLElement)) return;
+    const branches = branchesProp || context.branches;
+    if (node && branches) {
+      branches.add(node);
+      return () => {
+        branches.delete(node);
+      };
+    }
+  }, [branchesProp, context.branches]);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_core.View, {
+    asChild: "except-style",
+    ...rest,
+    ref: composedRefs
+  });
+});
+DismissableBranch.displayName = BRANCH_NAME;
+function usePointerDownOutside(onPointerDownOutside) {
+  const handlePointerDownOutside = (0, import_use_event.useEvent)(onPointerDownOutside);
+  const isPointerInsideReactTreeRef = React.useRef(false);
+  const handleClickRef = React.useRef(() => {});
+  React.useEffect(() => {
+    const handlePointerDown = event => {
+      if (event.target && !isPointerInsideReactTreeRef.current) {
+        let handleAndDispatchPointerDownOutsideEvent = function () {
+          handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, handlePointerDownOutside, eventDetail, {
+            discrete: true
+          });
+        };
+        const eventDetail = {
+          originalEvent: event
+        };
+        if (event.pointerType === "touch") {
+          document.removeEventListener("click", handleClickRef.current);
+          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;
+          document.addEventListener("click", handleClickRef.current, {
+            once: true
+          });
+        } else {
+          handleAndDispatchPointerDownOutsideEvent();
+        }
+      }
+      isPointerInsideReactTreeRef.current = false;
+    };
+    const timerId = setTimeout(() => {
+      document.addEventListener("pointerdown", handlePointerDown);
+    }, 0);
+    return () => {
+      window.clearTimeout(timerId);
+      document.removeEventListener("pointerdown", handlePointerDown);
+      document.removeEventListener("click", handleClickRef.current);
+    };
+  }, [handlePointerDownOutside]);
+  return {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => {
+      isPointerInsideReactTreeRef.current = true;
+    }
+  };
+}
+function useFocusOutside(onFocusOutside) {
+  const handleFocusOutside = (0, import_use_event.useEvent)(onFocusOutside);
+  const isFocusInsideReactTreeRef = React.useRef(false);
+  React.useEffect(() => {
+    const handleFocus = event => {
+      if (event.target && !isFocusInsideReactTreeRef.current) {
+        const eventDetail = {
+          originalEvent: event
+        };
+        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
+          discrete: false
+        });
+      }
+    };
+    document.addEventListener("focusin", handleFocus);
+    return () => document.removeEventListener("focusin", handleFocus);
+  }, [handleFocusOutside]);
+  return {
+    onFocusCapture: () => {
+      isFocusInsideReactTreeRef.current = true;
+    },
+    onBlurCapture: () => {
+      isFocusInsideReactTreeRef.current = false;
+    }
+  };
+}
+function dispatchUpdate() {
+  const event = new CustomEvent(CONTEXT_UPDATE);
+  document.dispatchEvent(event);
+}
+function handleAndDispatchCustomEvent(name, handler, detail, {
+  discrete
+}) {
+  const target = detail.originalEvent.target;
+  const event = new CustomEvent(name, {
+    bubbles: false,
+    cancelable: true,
+    detail
+  });
+  if (handler) target.addEventListener(name, handler, {
+    once: true
+  });
+  if (discrete) {
+    dispatchDiscreteCustomEvent(target, event);
+  } else {
+    target.dispatchEvent(event);
+  }
+}

package/dist/cjs/Dismissable.native.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var Dismissable_native_exports = {};
+__export(Dismissable_native_exports, {
+  Dismissable: () => Dismissable,
+  DismissableBranch: () => DismissableBranch,
+  dispatchDiscreteCustomEvent: () => dispatchDiscreteCustomEvent,
+  getDismissableLayerCount: () => getDismissableLayerCount,
+  useDismissableLayersAbove: () => useDismissableLayersAbove,
+  useHasDismissableLayers: () => useHasDismissableLayers,
+  useIsInsideDismissable: () => useIsInsideDismissable
+});
+module.exports = __toCommonJS(Dismissable_native_exports);
+var import_react = __toESM(require("react"), 1);
+function dispatchDiscreteCustomEvent(_target, _event) {}
+function getDismissableLayerCount() {
+  return 0;
+}
+function useHasDismissableLayers() {
+  return false;
+}
+function useIsInsideDismissable(_ref) {
+  return false;
+}
+function useDismissableLayersAbove(_ref) {
+  return 0;
+}
+var Dismissable = /* @__PURE__ */import_react.default.forwardRef(function (props, _ref) {
+  return props.children;
+});
+var DismissableBranch = /* @__PURE__ */import_react.default.forwardRef(function (props, _ref) {
+  return props.children;
+});
+//# sourceMappingURL=Dismissable.native.js.map

package/dist/cjs/Dismissable.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Dismissable_native_exports","__export","Dismissable","DismissableBranch","dispatchDiscreteCustomEvent","getDismissableLayerCount","useDismissableLayersAbove","useHasDismissableLayers","useIsInsideDismissable","module","exports","__toCommonJS","import_react","__toESM","require","_target","_event","_ref","default","forwardRef","props","children"],"sources":["../../src/Dismissable.native.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,0BAAA;AAAAC,QAAA,CAAAD,0BAAA;EAAAE,WAAA,EAAAA,CAAA,KAAAA,WAAA;EAAAC,iBAAA,EAAAA,CAAA,KAAAA,iBAAA;EAAAC,2BAAA,EAAAA,CAAA,KAAAA,2BAAA;EAAAC,wBAAA,EAAAA,CAAA,KAAAA,wBAAA;EAAAC,yBAAA,EAAAA,CAAA,KAAAA,yBAAA;EAAAC,uBAAA,EAAAA,CAAA,KAAAA,uBAAA;EAAAC,sBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAC,YAAA,CAAAX,0BAAA;AAAA,IAAAY,YAAA,GAAkBC,OAAA,CAAAC,OAAA;AAEX,SAASV,4BAA4BW,OAAA,EAASC,MAAA,EAAQ,CAAC;AACvD,SAASX,yBAAA,EAA2B;EACvC,OAAO;AACX;AACO,SAASE,wBAAA,EAA0B;EACtC,OAAO;AACX;AACO,SAASC,uBAAuBS,IAAA,EAAM;EACzC,OAAO;AACX;AACO,SAASX,0BAA0BW,IAAA,EAAM;EAC5C,OAAO;AACX;AACO,IAAIf,WAAA,GAA4B,eAAAU,YAAA,CAAAM,OAAA,CAAMC,UAAA,CAAW,UAASC,KAAA,EAAOH,IAAA,EAAM;EAC1E,OAAOG,KAAA,CAAMC,QAAA;AACjB,CAAC;AACM,IAAIlB,iBAAA,GAAkC,eAAAS,YAAA,CAAAM,OAAA,CAAMC,UAAA,CAAW,UAASC,KAAA,EAAOH,IAAA,EAAM;EAChF,OAAOG,KAAA,CAAMC,QAAA;AACjB,CAAC","ignoreList":[]}

package/dist/cjs/DismissableProps.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var DismissableProps_exports = {};
+module.exports = __toCommonJS(DismissableProps_exports);

package/dist/cjs/DismissableProps.native.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var DismissableProps_exports = {};
+module.exports = __toCommonJS(DismissableProps_exports);
+//# sourceMappingURL=DismissableProps.native.js.map

package/dist/cjs/DismissableProps.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","DismissableProps_exports"],"sources":["../../src/DismissableProps.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,wBAAA","ignoreList":[]}

package/dist/cjs/index.cjs

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./Dismissable.cjs"), module.exports);

package/dist/cjs/index.native.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./Dismissable.native.js"), module.exports);
+//# sourceMappingURL=index.native.js.map

package/dist/cjs/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","module","exports"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAP,YAAc,CAAAK,aAAA","ignoreList":[]}