overlay-manager-rc/dist/index.cjs

React overlay component manager

"use strict";
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/index.tsx
var src_exports = {};
__export(src_exports, {
  OverlayContainer: () => OverlayContainer,
  overlays: () => overlays,
  useBeforeClose: () => useBeforeClose,
  useOverlayManager: () => useOverlayManager
});
module.exports = __toCommonJS(src_exports);

// src/use-overlay-manager.tsx
var import_signals_react = require("@preact/signals-react");
var import_nanoid = require("nanoid");

// src/awaitIfPromise.ts
function isPromise(value) {
  return value instanceof Promise;
}
function awaitIfPromise(value) {
  return __async(this, null, function* () {
    if (isPromise(value)) {
      const re = yield value;
      return re;
    }
    return value;
  });
}

// src/use-overlay-manager.tsx
var overlays = (0, import_signals_react.signal)([]);
var useOverlayManager = () => {
  const closeOverlay = (id) => {
    overlays.value = overlays.value.map((overlay) => {
      if (id === overlay.id) {
        return __spreadProps(__spreadValues({}, overlay), {
          open: false,
          closeTimestamp: Date.now()
        });
      }
      return overlay;
    });
  };
  const openOverlay = (options) => {
    return new Promise((resolve) => {
      var _a;
      const id = (_a = options.id) != null ? _a : (0, import_nanoid.nanoid)();
      const handleExistingOverlay = () => __async(void 0, null, function* () {
        var _a2;
        const existingOverlayIndex = overlays.value.findIndex(
          (o) => o.id === id
        );
        if (existingOverlayIndex > -1) {
          const existingOverlay = overlays.value[existingOverlayIndex];
          const canClose = yield awaitIfPromise(
            existingOverlay.beforeClose ? existingOverlay.beforeClose() : true
          );
          if (!canClose) {
            return false;
          }
          closeOverlay(id);
          void ((_a2 = existingOverlay.onClose) == null ? void 0 : _a2.call(existingOverlay, void 0));
        }
        return true;
      });
      const createNewOverlay = () => {
        var _a2;
        const newOverlay = __spreadProps(__spreadValues({}, options), {
          id,
          open: true,
          onClose: (result) => {
            var _a3;
            closeOverlay(id);
            void ((_a3 = options.onClose) == null ? void 0 : _a3.call(options, result));
            resolve(result);
          }
        });
        overlays.value = [...overlays.value, newOverlay];
        void ((_a2 = options.onOpen) == null ? void 0 : _a2.call(options, id));
      };
      void handleExistingOverlay().then((shouldContinue) => {
        if (shouldContinue) {
          createNewOverlay();
        }
      });
    });
  };
  const closeAllOverlays = () => overlays.value = [];
  const closeOverlayById = (id) => __async(void 0, null, function* () {
    var _a;
    const overlay = overlays.value.find((o) => o.id === id);
    if (overlay) {
      const canClose = yield awaitIfPromise(
        overlay.beforeClose ? overlay.beforeClose() : true
      );
      if (!canClose) {
        return;
      }
      closeOverlay(id);
      void ((_a = overlay.onClose) == null ? void 0 : _a.call(overlay, void 0));
    }
  });
  return {
    openOverlay,
    closeAllOverlays,
    closeOverlayById,
    overlays
  };
};

// src/overlay-container.tsx
var import_runtime3 = require("@preact/signals-react/runtime");
var import_react = require("react");
var import_jsx_runtime = require("react/jsx-runtime");
var CLEANUP_INTERVAL = 3e4;
function OverlayContainer() {
  (0, import_runtime3.useSignals)();
  const { overlays: activeOverlays, closeAllOverlays } = useOverlayManager();
  (0, import_react.useEffect)(() => {
    const cleanup = () => {
      const hasOpenOverlay = activeOverlays.value.some(
        (overlay) => overlay.open
      );
      if (!hasOpenOverlay) {
        closeAllOverlays();
      }
    };
    const cleanupInterval = setInterval(cleanup, CLEANUP_INTERVAL);
    return () => {
      clearInterval(cleanupInterval);
    };
  }, []);
  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: activeOverlays.value.map((overlay) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
    overlay.content,
    {
      close: (result) => {
        var _a;
        return (_a = overlay.onClose) == null ? void 0 : _a.call(overlay, result);
      },
      data: overlay.data,
      id: overlay.id,
      open: overlay.open
    },
    overlay.id
  )) });
}

// src/use-before-close.tsx
var import_react2 = require("react");
var useBeforeClose = (beforeClose, id) => {
  (0, import_react2.useEffect)(() => {
    if (!id) return;
    overlays.value = overlays.value.map(
      (o) => o.id === id ? __spreadProps(__spreadValues({}, o), { beforeClose }) : o
    );
    return () => {
      if (!id) return;
      overlays.value = overlays.value.map(
        (o) => o.id === id ? __spreadProps(__spreadValues({}, o), { beforeClose: void 0 }) : o
      );
    };
  }, [beforeClose, id]);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  OverlayContainer,
  overlays,
  useBeforeClose,
  useOverlayManager
});