react-confirm 0.5.0-1 → 0.5.0-4

package/README.md

@@ -70,6 +70,23 @@ const handleDelete = async (): Promise<void> => {
 <button onClick={handleDelete}>Delete Item</button>
 ```
 
+## External Control
+
+You can close pending confirmation dialogs from outside using the `proceed` function. This is useful when you need to close a dialog from a different part of your application.
+
+```typescript
+import { proceed } from 'react-confirm';
+
+const p = confirm({ message: 'Continue?' });
+
+// Auto-close after 10 seconds
+setTimeout(() => {
+  proceed(p, false);
+}, 10000);
+
+const result = await p;
+```
+
 ## Using with React Context
 
 If your dialog needs to access React Context (themes, authentication, etc.), use the context-aware approach:

package/dist/controls.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Control handle for a confirmation dialog
+ */
+export type ConfirmationHandle<R> = {
+    resolve: (value: R) => void;
+    reject: (reason?: any) => void;
+    dispose: () => void;
+    settled?: boolean;
+};
+/**
+ * Register a Promise and its handle to the registry
+ */
+export declare function register<R>(promise: Promise<R>, handle: ConfirmationHandle<R>): void;
+/**
+ * Resolve a confirmation dialog and close it
+ * @param promise The Promise to resolve
+ * @param response The response value to resolve with
+ * @returns true if successful
+ */
+export declare function proceed<R>(promise: Promise<R>, response: R): boolean;
+/**
+ * Close a confirmation dialog without resolving or rejecting the Promise
+ * The Promise remains pending
+ * @param promise The Promise to dismiss
+ * @returns true if successful
+ */
+export declare function dismiss<R>(promise: Promise<R>): boolean;
+/**
+ * Reject a confirmation dialog and close it
+ * @param promise The Promise to reject
+ * @param reason The rejection reason
+ * @returns true if successful
+ */
+export declare function cancel<R>(promise: Promise<R>, reason?: unknown): boolean;

package/dist/controls.js

@@ -0,0 +1,93 @@
+"use strict";
+// Lightweight registry to control pending confirmations from outside
+// Stores only control handles (resolve/reject/dispose), not UI state
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+exports.proceed = proceed;
+exports.dismiss = dismiss;
+exports.cancel = cancel;
+var active = new Map();
+/**
+ * Register a Promise and its handle to the registry
+ */
+function register(promise, handle) {
+    active.set(promise, handle);
+    // Auto cleanup after settlement
+    promise
+        .finally(function () {
+        var h = active.get(promise);
+        if (h)
+            h.settled = true;
+        active.delete(promise);
+    })
+        .catch(function () {
+        // Already handled by finally
+    });
+}
+/**
+ * Resolve a confirmation dialog and close it
+ * @param promise The Promise to resolve
+ * @param response The response value to resolve with
+ * @returns true if successful
+ */
+function proceed(promise, response) {
+    var handle = active.get(promise);
+    if (!handle || handle.settled)
+        return false;
+    try {
+        handle.resolve(response);
+    }
+    finally {
+        try {
+            handle.dispose();
+        }
+        catch (_a) {
+            // Ignore
+        }
+        active.delete(promise);
+    }
+    return true;
+}
+/**
+ * Close a confirmation dialog without resolving or rejecting the Promise
+ * The Promise remains pending
+ * @param promise The Promise to dismiss
+ * @returns true if successful
+ */
+function dismiss(promise) {
+    var handle = active.get(promise);
+    if (!handle || handle.settled)
+        return false;
+    try {
+        handle.dispose();
+    }
+    catch (_a) {
+        // Ignore
+    }
+    active.delete(promise);
+    return true;
+}
+/**
+ * Reject a confirmation dialog and close it
+ * @param promise The Promise to reject
+ * @param reason The rejection reason
+ * @returns true if successful
+ */
+function cancel(promise, reason) {
+    var handle = active.get(promise);
+    if (!handle || handle.settled)
+        return false;
+    try {
+        handle.reject(reason);
+    }
+    finally {
+        try {
+            handle.dispose();
+        }
+        catch (_a) {
+            // Ignore
+        }
+        active.delete(promise);
+    }
+    return true;
+}

package/dist/createConfirmation.js

@@ -13,12 +13,22 @@ var __assign = (this && this.__assign) || function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createConfirmationCreater = void 0;
 var domTree_1 = require("./mounter/domTree");
+var controls_1 = require("./controls");
 var createConfirmationCreater = function (mounter) {
     return function (Component, unmountDelay, mountingNode) {
         if (unmountDelay === void 0) { unmountDelay = 1000; }
         return function (props) {
             var mountId;
-            var promise = new Promise(function (resolve, reject) {
+            var resolveRef = function () { };
+            function dispose() {
+                setTimeout(function () {
+                    mounter.unmount(mountId);
+                }, unmountDelay);
+            }
+            var rejectRef = function () { };
+            var inner = new Promise(function (resolve, reject) {
+                resolveRef = resolve;
+                rejectRef = reject;
                 try {
                     mountId = mounter.mount(Component, __assign({ reject: reject, resolve: resolve, dispose: dispose }, props), mountingNode);
                 }
@@ -28,18 +38,16 @@ var createConfirmationCreater = function (mounter) {
                     throw e;
                 }
             });
-            function dispose() {
-                setTimeout(function () {
-                    mounter.unmount(mountId);
-                }, unmountDelay);
-            }
-            return promise.then(function (result) {
+            var wrapped = inner.then(function (result) {
                 dispose();
                 return result;
-            }, function (result) {
+            }, function (err) {
                 dispose();
-                return Promise.reject(result);
+                return Promise.reject(err);
             });
+            // Register to controls layer for external control
+            (0, controls_1.register)(wrapped, { resolve: resolveRef, reject: rejectRef, dispose: dispose });
+            return wrapped;
         };
     };
 };

package/dist/index.d.ts

@@ -3,5 +3,6 @@ import createConfirmation, { createConfirmationCreater } from './createConfirmat
 import { createDomTreeMounter } from './mounter/domTree';
 import { createReactTreeMounter, createMountPoint } from './mounter/reactTree';
 import { createConfirmationContext, ContextAwareConfirmation } from './context';
+import { proceed, dismiss, cancel } from './controls';
 export type { ConfirmDialogProps, ConfirmDialog, ConfirmableDialog, Mounter, TreeMounter, ConfirmationContext, } from './types';
-export { confirmable, createConfirmation, createConfirmationCreater, createDomTreeMounter, createReactTreeMounter, createMountPoint, createConfirmationContext, ContextAwareConfirmation };
+export { confirmable, createConfirmation, createConfirmationCreater, createDomTreeMounter, createReactTreeMounter, createMountPoint, createConfirmationContext, ContextAwareConfirmation, proceed, dismiss, cancel, };

package/dist/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextAwareConfirmation = exports.createConfirmationContext = exports.createMountPoint = exports.createReactTreeMounter = exports.createDomTreeMounter = exports.createConfirmationCreater = exports.createConfirmation = exports.confirmable = void 0;
+exports.cancel = exports.dismiss = exports.proceed = exports.ContextAwareConfirmation = exports.createConfirmationContext = exports.createMountPoint = exports.createReactTreeMounter = exports.createDomTreeMounter = exports.createConfirmationCreater = exports.createConfirmation = exports.confirmable = void 0;
 var confirmable_1 = __importDefault(require("./confirmable"));
 exports.confirmable = confirmable_1.default;
 var createConfirmation_1 = __importStar(require("./createConfirmation"));
@@ -50,3 +50,7 @@ Object.defineProperty(exports, "createMountPoint", { enumerable: true, get: func
 var context_1 = require("./context");
 Object.defineProperty(exports, "createConfirmationContext", { enumerable: true, get: function () { return context_1.createConfirmationContext; } });
 Object.defineProperty(exports, "ContextAwareConfirmation", { enumerable: true, get: function () { return context_1.ContextAwareConfirmation; } });
+var controls_1 = require("./controls");
+Object.defineProperty(exports, "proceed", { enumerable: true, get: function () { return controls_1.proceed; } });
+Object.defineProperty(exports, "dismiss", { enumerable: true, get: function () { return controls_1.dismiss; } });
+Object.defineProperty(exports, "cancel", { enumerable: true, get: function () { return controls_1.cancel; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-confirm",
-  "version": "0.5.0-1",
+  "version": "0.5.0-4",
   "description": "A lightweight React library that simplifies confirmation dialogs with a Promise-based API — like window.confirm(), but fully customizable.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controls.ts

@@ -0,0 +1,103 @@
+// Lightweight registry to control pending confirmations from outside
+// Stores only control handles (resolve/reject/dispose), not UI state
+
+/**
+ * Control handle for a confirmation dialog
+ */
+export type ConfirmationHandle<R> = {
+  resolve: (value: R) => void;
+  reject: (reason?: any) => void;
+  dispose: () => void;
+  settled?: boolean;
+};
+
+const active = new Map<Promise<unknown>, ConfirmationHandle<unknown>>();
+
+/**
+ * Register a Promise and its handle to the registry
+ */
+export function register<R>(
+  promise: Promise<R>,
+  handle: ConfirmationHandle<R>
+): void {
+  active.set(promise, handle as ConfirmationHandle<unknown>);
+
+  // Auto cleanup after settlement
+  promise
+    .finally(() => {
+      const h = active.get(promise);
+      if (h) h.settled = true;
+      active.delete(promise);
+    })
+    .catch(() => {
+      // Already handled by finally
+    });
+}
+
+/**
+ * Resolve a confirmation dialog and close it
+ * @param promise The Promise to resolve
+ * @param response The response value to resolve with
+ * @returns true if successful
+ */
+export function proceed<R>(promise: Promise<R>, response: R): boolean {
+  const handle = active.get(promise) as ConfirmationHandle<R> | undefined;
+  if (!handle || handle.settled) return false;
+
+  try {
+    handle.resolve(response);
+  } finally {
+    try {
+      handle.dispose();
+    } catch {
+      // Ignore
+    }
+    active.delete(promise);
+  }
+
+  return true;
+}
+
+/**
+ * Close a confirmation dialog without resolving or rejecting the Promise
+ * The Promise remains pending
+ * @param promise The Promise to dismiss
+ * @returns true if successful
+ */
+export function dismiss<R>(promise: Promise<R>): boolean {
+  const handle = active.get(promise) as ConfirmationHandle<R> | undefined;
+  if (!handle || handle.settled) return false;
+
+  try {
+    handle.dispose();
+  } catch {
+    // Ignore
+  }
+  active.delete(promise);
+
+  return true;
+}
+
+/**
+ * Reject a confirmation dialog and close it
+ * @param promise The Promise to reject
+ * @param reason The rejection reason
+ * @returns true if successful
+ */
+export function cancel<R>(promise: Promise<R>, reason?: unknown): boolean {
+  const handle = active.get(promise) as ConfirmationHandle<R> | undefined;
+  if (!handle || handle.settled) return false;
+
+  try {
+    handle.reject(reason);
+  } finally {
+    try {
+      handle.dispose();
+    } catch {
+      // Ignore
+    }
+    active.delete(promise);
+  }
+
+  return true;
+}

package/src/createConfirmation.ts

@@ -1,12 +1,25 @@
 import type React from 'react';
 import { createDomTreeMounter } from './mounter/domTree';
 import type { ConfirmableDialog, Mounter } from './types';
+import { register } from './controls';
 
 export const createConfirmationCreater = (mounter: Mounter) =>
   <P, R>(Component: ConfirmableDialog<P, R>, unmountDelay: number = 1000, mountingNode?: HTMLElement) => {
     return (props: P): Promise<R> => {
       let mountId: string;
-      const promise = new Promise<R>((resolve, reject) => {
+      let resolveRef: (value: R) => void = () => {};
+
+      function dispose() {
+        setTimeout(() => {
+          mounter.unmount(mountId);
+        }, unmountDelay);
+      }
+
+      let rejectRef: (reason?: any) => void = () => {};
+
+      const inner = new Promise<R>((resolve, reject) => {
+        resolveRef = resolve;
+        rejectRef = reject;
         try {
           mountId = mounter.mount(Component as React.ComponentType<any>, { reject, resolve, dispose, ...props }, mountingNode);
         } catch (e) {
@@ -16,22 +29,21 @@ export const createConfirmationCreater = (mounter: Mounter) =>
         }
       });
 
-      function dispose() {
-        setTimeout(() => {
-          mounter.unmount(mountId);
-        }, unmountDelay);
-      }
-
-      return promise.then(
+      const wrapped = inner.then(
         (result) => {
           dispose();
           return result;
         },
-        (result) => {
+        (err) => {
           dispose();
-          return Promise.reject(result);
+          return Promise.reject(err);
         }
       );
+
+      // Register to controls layer for external control
+      register(wrapped, { resolve: resolveRef, reject: rejectRef, dispose });
+
+      return wrapped;
     };
   };
 

package/src/index.ts

@@ -2,10 +2,11 @@ import confirmable from './confirmable';
 import createConfirmation, { createConfirmationCreater } from './createConfirmation';
 import { createDomTreeMounter } from './mounter/domTree';
 import { createReactTreeMounter, createMountPoint } from './mounter/reactTree';
-import { 
-  createConfirmationContext, 
+import {
+  createConfirmationContext,
   ContextAwareConfirmation
 } from './context';
+import { proceed, dismiss, cancel } from './controls';
 
 export type {
   ConfirmDialogProps,
@@ -16,13 +17,16 @@ export type {
   ConfirmationContext,
 } from './types';
 
-export { 
-  confirmable, 
-  createConfirmation, 
-  createConfirmationCreater, 
-  createDomTreeMounter, 
-  createReactTreeMounter, 
+export {
+  confirmable,
+  createConfirmation,
+  createConfirmationCreater,
+  createDomTreeMounter,
+  createReactTreeMounter,
   createMountPoint,
   createConfirmationContext,
-  ContextAwareConfirmation
+  ContextAwareConfirmation,
+  proceed,
+  dismiss,
+  cancel,
 };

package/src/types.ts

@@ -34,6 +34,7 @@ export type TreeMounter = {
   };
 } & Mounter;
 
+
 // Context-aware confirmation system
 export interface ConfirmationContext {
   /**