react-dialogger 1.1.82 → 1.1.83

package/README.md

@@ -12,6 +12,17 @@ You can find the example code about the project on our [Codesandbox](https://cod
 # Youtube
 You can watch simple example on Youtube [Youtube](https://www.youtube.com/watch?v=vhSroEgdj1c)
 
+# Why react-dialogger?
+> react-dialogger is built for React applications that need dynamic, runtime-managed dialogs rather than static JSX-based modals.
+It enables centralized dialog configuration, action-driven logic, and dialog-owned state, making complex dialog flows easier to manage and scale.
+Perfect for applications with dynamic forms, async workflows, and advanced UI orchestration.
+
+## Philosophy
+
+To understand why react-dialogger exists and when to use it,
+see the detailed philosophy document:
+
+👉 [Dialogger Philosophy](./docs/philosophy.md)
 
 # react-dialogger - Custom Dialog Component Documentation
 
@@ -330,6 +341,29 @@ This basic usage setup enables you to quickly configure and display a custom dia
 > This package is a continuation of the `react-araci` package.  
 > Due to an error, `react-araci` was removed, and it has been decided to continue under the new package name **`react-dialogger`**.
 
+
+## React-Dialogger vs MUI Dialog / AntD Modal
+```js
+| Feature / Aspect                    | **react-dialogger**                                                         | **MUI Dialog**                                      | **AntD Modal**                                                |
+| ----------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------- | ------------------------------------------------------------- |
+| **Dialog Creation**                 | Runtime / dynamic (`new Dialog().show()`)                                   | JSX-based, usually static (`<Dialog open={...} />`) | JSX-based, usually static (`<Modal visible={...} />`)         |
+| **State Management**                | Dialog owns its own state (`initialValues`, `setValues`)                    | State often in React components                     | State often in React components                               |
+| **Centralized Global Config**       | `baseDialogOptions` allows global styling, intents, localization            | Global theme only, per-dialog config needed         | Global config via `ConfigProvider`, per-modal override needed |
+| **Actions / Buttons**               | Action-driven, first-class citizens (`DialogAction`) with intents & onClick | Children buttons, manual click handling             | `okText` / `cancelText` props and footer buttons              |
+| **Dynamic Header & Body**           | Fully dynamic via functions                                                 | JSX render, can be dynamic but bound to component   | JSX render, can be dynamic but bound to component             |
+| **Dialog Overwrites / Flexibility** | Local overrides of global options                                           | Limited, mostly via props                           | Limited, mostly via props                                     |
+| **Complex Flows / Wizards**         | Fully supported via action chaining and dialog-owned state                  | Needs extra state management                        | Needs extra state management                                  |
+| **Async / Runtime Use**             | Designed for runtime invocation                                             | Typically requires state lift                       | Typically requires state lift                                 |
+| **Animation / Backdrop**            | Built-in customizable animations & backdrop settings                        | Default MUI transitions                             | Default AntD transitions                                      |
+| **Use Case**                        | Large, dynamic, enterprise apps, multi-step wizards, async workflows        | Standard dialogs with simple static content         | Standard dialogs with simple static content                   |
+
+
+```
+
+
+
+
+
 ## 📩 Contact
 For support or inquiries, please reach out via email:  
 ✉️ [developer@appinsource.eu](mailto:developer@appinsource.eu)

package/docs/philosophy.md

@@ -0,0 +1,81 @@
+## Philosophy
+## Why react-dialogger Exists
+
+Modern React applications often require dialogs that are **dynamic, stateful, and context-aware**.  
+However, most dialog solutions are built around **static JSX components** that are tightly coupled to the component tree and local state.
+
+**react-dialogger** was created to overcome these limitations.
+
+Instead of treating dialogs as static UI components, react-dialogger treats them as **runtime-managed UI flows**.
+
+> Dialogs are not rendered — they are **invoked**.
+
+### The Core Idea
+react-dialogger is built on three fundamental principles:
+
+### 1. Runtime-First Dialog Creation
+     Dialogs are created when needed, not pre-declared in JSX.
+```ts
+new Dialog().setHeader(...).setBody(...).addActions(...).show();
+```
+This allows dialogs to be triggered from:
+ * async operations
+ * validation flows
+ * business logic
+ * service layers
+
+without coupling them to React render cycles.
+
+### 2. Centralized Configuration, Local Overrides
+With baseDialogOptions, applications define a global dialog behavior and style once.
+* Consistent UI and UX
+* Shared intents, localization, and defaults
+* Predictable behavior across the app
+
+At the same time, each dialog can override these options when necessary, keeping flexibility without sacrificing consistency.
+
+### 3. Action-Driven Architecture
+In react-dialogger, actions are first-class citizens.
+Dialogs don’t own logic — actions do.
+```ts
+new DialogAction('confirm')
+  .setIntent('positive')
+  .onClick((button, dialog) => {
+    dialog.setValue('confirmed', true);
+  });
+```
+#### <b>This makes dialog flows:</b>
+* explicit
+* testable
+* reusable
+* easy to reason about
+
+### Dialog State Belongs to the Dialog
+Instead of pushing dialog state into React components, react-dialogger allows dialogs to own their own state.
+```ts
+dialog.initialValues({ step: 1 });
+dialog.setValue('step', 2);
+```
+
+This keeps React components:
+* cleaner
+* simpler
+* focused on rendering, not orchestration
+
+## When to Use react-dialogger
+### ✅ Best suited for:
+* Large or enterprise React applications
+* Dynamic forms and wizards
+* Async or flow-based UI logic
+* Centralized dialog management
+* Complex dialog interactions
+
+### ❌ Not ideal for:
+* Single static modal dialogs
+* Very simple UI-only popups
+* Cases where JSX-only dialogs are sufficient
+
+## In One Sentence
+
+> react-dialogger is a runtime dialog orchestration system for React, designed to manage complex dialog flows with centralized configuration and action-driven logic.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-dialogger",
-  "version": "1.1.82",
+  "version": "1.1.83",
   "description": "This package is a continuation of the react-araci package. Due to an error, react-araci was removed, and it has been decided to continue under the new package name react-dialogger",
   "main": "index.js",
   "author": "Sueleyman Topaloglu",