react-dialogger 1.1.112 → 1.1.114

package/components/Actions.d.ts

@@ -2,6 +2,6 @@ import { DialogAction } from "../models/index.js";
 import { DialogBase } from "./index.js";
 declare const Actions: ({ actions, dialog }: {
     actions?: DialogAction[];
-    dialog: DialogBase<any, any, any>;
+    dialog: DialogBase<any, any>;
 }) => import("react/jsx-runtime").JSX.Element;
 export { Actions };

package/components/Actions.js

@@ -6,7 +6,7 @@ var _components_1 = require("./index.js");
 var Actions = function (_a) {
     var actions = _a.actions, dialog = _a.dialog;
     var dialogOptions = dialog.dialogOptions;
-    return (0, jsx_runtime_1.jsx)("div", { style: { position: 'relative', display: 'flex', flexDirection: 'row', columnGap: 10, alignItems: 'center' }, children: actions.map(function (action, index) {
+    return (0, jsx_runtime_1.jsx)("div", { style: { position: 'relative', display: 'flex', flexDirection: 'row', columnGap: 10, alignItems: 'center' }, children: actions === null || actions === void 0 ? void 0 : actions.map(function (action, index) {
             var referencedAction = dialog.initializeActionRef(action.name);
             action._actionComponent = referencedAction;
             return (0, jsx_runtime_1.jsx)(_components_1.DialogActionBase, { name: action.name, ref: referencedAction, dialogBaseComponent: dialog, 

package/components/DialogActionBase.d.ts

@@ -16,7 +16,7 @@ export declare const BASE_INTENTS: {
     };
 };
 declare class DialogActionBase extends Component<ActionProps, ActionState> {
-    get dialogBaseComponent(): DialogBase<any, any, any>;
+    get dialogBaseComponent(): DialogBase<any, any>;
     protected _options: DialogActionOptionsType;
     protected _intent: ActionIntent;
     _stateListener: TDialogStateListenerForActionCallbackType;

package/components/DialogBase.d.ts

@@ -1,11 +1,11 @@
 import { Component, RefObject } from 'react';
 import { FormikProps } from "formik";
 import { DialogActionBase } from "./index.js";
-import { BaseDialogProps, BaseDialogState, IDialogSize, DialogOptionsType, TDialogCallbackFn, TDialogCallbackVoidFn, WithBackdrop, IDialogSnackbar, IInProcess, TInitialHolder, ISnackbarAnchor, TSeverity, TAccessFrom, ActionApiDef, DialogContentFooterReturnType, DialogFormikAdapter, DialogExternalHandlers, DialogExternalHandler, Dialogify, DialogExternalRefs, DialogExternalRef } from "../types/index.js";
+import { BaseDialogProps, BaseDialogState, IDialogSize, DialogOptionsType, TDialogCallbackFn, WithBackdrop, IDialogSnackbar, IInProcess, TInitialHolder, ISnackbarAnchor, TSeverity, TAccessFrom, ActionApiDef, DialogContentFooterReturnType, DialogFormikAdapter, Dialogify, DialogInjectDef } from "../types/index.js";
 import Dialog, { DialogAction } from "../models/index.js";
 interface IFormikAdapter extends Pick<FormikProps<any>, 'setValues' | 'setFieldValue' | 'values'> {
 }
-declare class DialogBase<Values extends Record<string, any>, StockDialogHandlers extends Record<string, DialogExternalHandler> = {}, StockDialogRefs extends Record<string, DialogExternalRef> = {}> extends Component<BaseDialogProps<Values, StockDialogHandlers, StockDialogRefs>, BaseDialogState> {
+declare class DialogBase<V, I> extends Component<BaseDialogProps<V, I>, BaseDialogState<V, I>> {
     _dialogTranslate: {
         lastX: number;
         lastY: number;
@@ -14,8 +14,8 @@ declare class DialogBase<Values extends Record<string, any>, StockDialogHandlers
         [key: string]: RefObject<DialogActionBase>;
     };
     protected _inlineFormikProps: IFormikAdapter;
-    protected _header: TDialogCallbackFn;
-    protected _body: TDialogCallbackFn;
+    protected _header: TDialogCallbackFn<V, I>;
+    protected _body: TDialogCallbackFn<V, I>;
     protected _actions: DialogAction[];
     protected _dialogSize: IDialogSize;
     protected _holder?: TInitialHolder;
@@ -25,13 +25,11 @@ declare class DialogBase<Values extends Record<string, any>, StockDialogHandlers
     protected readonly _dialogBodyRef: RefObject<any>;
     protected readonly _snackbarRef: WithBackdrop['snackbarRef'];
     protected _dialogOptions?: DialogOptionsType;
-    protected _onClose: TDialogCallbackVoidFn;
+    protected _onClose: TDialogCallbackFn<V, I, void>;
     protected _shInterval: number;
     protected _snackbarAnchor: ISnackbarAnchor;
-    protected _parent: Dialog<Values, StockDialogHandlers, StockDialogRefs>;
-    protected _xhandlers: DialogExternalHandlers<StockDialogHandlers>;
-    protected _xrefs: DialogExternalRefs<StockDialogRefs>;
-    protected _initialValues: Dialogify<Values>;
+    protected _parent: Dialog<V, I>;
+    protected _initialValues: Dialogify<V>;
     private _inProcess;
     private _footerRef;
     protected _headerRef: RefObject<DialogContentFooterReturnType>;
@@ -39,15 +37,14 @@ declare class DialogBase<Values extends Record<string, any>, StockDialogHandlers
     private _accessFrom;
     private readonly _processingListeners;
     private readonly _abortedListeners;
-    constructor(props: BaseDialogProps<Values, StockDialogHandlers, StockDialogRefs> & {
-        parent: Dialog<Values, StockDialogHandlers, StockDialogRefs>;
-    });
+    deps(): DialogInjectDef<I>;
+    get values(): Readonly<{
+        [K in keyof V]: Dialogify<V[K]>;
+    }>;
+    inject<T>(key: string, value: DialogInjectDef<T>): DialogBase<V, T>;
+    constructor(props: BaseDialogProps<V, I> & {});
     setValue<T>(key: string, value: Dialogify<T>): void;
-    get xhandlers(): StockDialogHandlers;
-    appendXHandler<H>(key: string, handler: DialogExternalHandler): void;
-    get xrefs(): DialogExternalRefs<DialogExternalRef>;
-    appendXRef<R>(key: R, ref: DialogExternalRef): void;
-    get parent(): Dialog<Values, StockDialogHandlers, StockDialogRefs>;
+    get parent(): Dialog<V, I>;
     get dialogTranslate(): {
         lastX: number;
         lastY: number;
@@ -61,7 +58,6 @@ declare class DialogBase<Values extends Record<string, any>, StockDialogHandlers
     set formikProps(value: FormikProps<any>);
     get formikValidate(): Promise<DialogFormikAdapter<any>>;
     set inlineFormikProps(inlineFormikProps: IFormikAdapter);
-    get values(): Values;
     setValues<T>(values: Dialogify<T>, callbackFn?: () => void): void;
     componentDidMount(): void;
     setInProcess: (process: boolean, message?: string, holder?: TInitialHolder) => this;
@@ -72,9 +68,9 @@ declare class DialogBase<Values extends Record<string, any>, StockDialogHandlers
     get actions(): {
         [key: string]: ActionApiDef;
     };
-    updateBody(body: TDialogCallbackFn): void;
+    updateBody(body: TDialogCallbackFn<V, I>): void;
     processingListener(listener: (inProcess: boolean) => void): this;
-    onAbort(callbackFn: TDialogCallbackFn<void>): this;
+    onAbort(callbackFn: TDialogCallbackFn<V, I, void>): this;
     getDom: () => HTMLDivElement;
     get snackbar(): {
         open: (message: string, severity: TSeverity, key?: string, action?: IDialogSnackbar["action"], autoHideDuration?: number | null) => void;

package/components/DialogBase.js

@@ -66,7 +66,6 @@ var lodash_1 = require("lodash");
 var _components_1 = require("./index.js");
 var _helpers_1 = require("../helpers/index.js");
 var _context_1 = require("../context/index.js");
-var isRefObject_1 = require("../helpers/isRefObject");
 var DialogBase = /** @class */ (function (_super) {
     __extends(DialogBase, _super);
     function DialogBase(props) {
@@ -192,11 +191,13 @@ var DialogBase = /** @class */ (function (_super) {
                 // Refs Props
                 dialogRef: _this._dialogRef, headerRef: _this._headerRef, bodyRef: _this._dialogBodyRef, footerRef: _this._footerRef, backdropRef: _this._backdropRef, snackbarRef: _this._snackbarRef, prevDialogRect: _this.state.prevDialogRect, children: (0, jsx_runtime_1.jsx)(_components_1.DialogWithBackdropWrapper, {}) });
         };
+        // this.inject(props.inject);
         _this.state = {
             inProcess: { inProcess: false },
             prevDialogRect: (0, _helpers_1.dialogRectAuto)(),
             body: props.body,
-            aborted: false
+            aborted: false,
+            inject: props.inject
         };
         var defaultOptions = {
             base: {
@@ -243,46 +244,28 @@ var DialogBase = /** @class */ (function (_super) {
         _this._processingListeners = (_a = props.processingListeners) !== null && _a !== void 0 ? _a : [];
         _this._abortedListeners = (_b = props.abortedListeners) !== null && _b !== void 0 ? _b : [];
         _this._initialValues = props.initialValues;
-        _this._xhandlers = props.xhandlers;
-        _this._xrefs = props.xrefs;
         return _this;
     }
-    DialogBase.prototype.setValue = function (key, value) {
-        var _a;
-        (_a = this._inlineFormikProps) === null || _a === void 0 ? void 0 : _a.setFieldValue(key, value);
+    DialogBase.prototype.deps = function () {
+        return this.state.inject;
     };
-    Object.defineProperty(DialogBase.prototype, "xhandlers", {
+    Object.defineProperty(DialogBase.prototype, "values", {
         get: function () {
-            // @ts-ignore
-            return this._xhandlers;
+            return this._inlineFormikProps.values;
         },
         enumerable: false,
         configurable: true
     });
-    DialogBase.prototype.appendXHandler = function (key, handler) {
-        // public appendXHandler(key: string, handler: DialogExternalHandler) {
-        if (!key)
-            throw new Error('Handler key is required');
-        if (typeof handler !== 'function')
-            throw new Error("Handler \"".concat(String(key), "\" must be a function"));
-        // @ts-ignore
-        this._xhandlers[key] = handler;
+    DialogBase.prototype.inject = function (key, value) {
+        this.setState(function (prevState) {
+            var _a;
+            return (__assign(__assign({}, prevState), { inject: __assign(__assign({}, prevState.inject), (_a = {}, _a[key] = value, _a)) }));
+        });
+        return this;
     };
-    Object.defineProperty(DialogBase.prototype, "xrefs", {
-        get: function () {
-            // @ts-ignore
-            return this._xrefs;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DialogBase.prototype.appendXRef = function (key, ref) {
-        if (!key)
-            throw new Error('Ref key is required');
-        if (!(0, isRefObject_1.isRefObject)(ref))
-            throw new Error("Ref \"".concat(String(key), "\" must be a Reference RefObject"));
-        // @ts-ignore
-        this._xrefs[key] = ref;
+    DialogBase.prototype.setValue = function (key, value) {
+        var _a;
+        (_a = this._inlineFormikProps) === null || _a === void 0 ? void 0 : _a.setFieldValue(key, value);
     };
     Object.defineProperty(DialogBase.prototype, "parent", {
         get: function () {
@@ -360,13 +343,9 @@ var DialogBase = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(DialogBase.prototype, "values", {
-        get: function () {
-            return this._inlineFormikProps.values;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    // get values(): V {
+    //     return this._inlineFormikProps.values;
+    // }
     DialogBase.prototype.setValues = function (values, callbackFn) {
         this._inlineFormikProps.setValues(values);
         if (typeof callbackFn === "function") {
@@ -412,8 +391,9 @@ var DialogBase = /** @class */ (function (_super) {
     Object.defineProperty(DialogBase.prototype, "actions", {
         get: function () {
             var _this = this;
+            var _a;
             var __actions = {};
-            this._actions.forEach(function (action, index) {
+            (_a = this._actions) === null || _a === void 0 ? void 0 : _a.forEach(function (action, index) {
                 var _a;
                 __actions[action.name] = (_a = _this._actionRefs[action.name]) === null || _a === void 0 ? void 0 : _a.current; // ?? action;
             });

package/components/DialogContentBody.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { TDialogCallbackFn } from "../types/index.js";
 interface IContentBodyProps {
-    body: TDialogCallbackFn;
+    body: TDialogCallbackFn<any, any>;
 }
 declare const DialogContentBody: React.FC<IContentBodyProps>;
 export { DialogContentBody };

package/components/DialogContentFooter.js

@@ -81,6 +81,7 @@ var DialogContentFooter = (0, react_1.forwardRef)(function (props, ref) {
         // footerProps = {...dialogOptions.slotProps.footer, dialogOptions: dialogOptions, inProcess: dialog.isInProcess() }
         footerProps = dialogOptions.slotProps.footer;
     }
+    console.log('DialogBase_Render', dialog.actions);
     return (0, jsx_runtime_1.jsxs)("div", { className: 'dialog-footer', style: (_c = (_b = dialogOptions.base) === null || _b === void 0 ? void 0 : _b.footer) === null || _c === void 0 ? void 0 : _c.style, children: [(0, jsx_runtime_1.jsx)("div", { children: (0, jsx_runtime_1.jsx)(_context_1.WithHeaderFooterContext, __assign({}, staticProps, { dialog: dialog, children: dialogOptions.slot.footer ?
                         (0, jsx_runtime_1.jsx)(CustomFooter, __assign({}, staticProps, footerProps))
                         :

package/components/DialogContentHeader.d.ts

@@ -1,7 +1,7 @@
 import { TDialogCallbackFn, IDialogBoundsDef } from "../types/index.js";
 import * as React from "react";
 interface IContentHeaderProps {
-    header: TDialogCallbackFn;
+    header: TDialogCallbackFn<any, any>;
     bounds: IDialogBoundsDef;
 }
 declare const DialogContentHeader: React.FC<IContentHeaderProps>;

package/components/DialogContentHeader.js

@@ -75,6 +75,7 @@ var DialogContentHeader = function (_a) {
     var CustomHeader = (_b = dialogOptions.slot) === null || _b === void 0 ? void 0 : _b.header;
     var staticProps = {
         dialogOptions: dialogOptions,
+        // @ts-ignore
         dialog: dialog
     };
     if (dialogOptions.slot.header) {

package/context/DialogContentContextProvider.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
 import { DialogContentContextProviderProps, DialogContentContextProviderSharedProps } from "../types/index.js";
-export declare const DialogContentContext: React.Context<DialogContentContextProviderSharedProps>;
+export declare const DialogContentContext: React.Context<DialogContentContextProviderSharedProps<Record<string, any>, unknown>>;
 declare const DialogContentContextProvider: React.FC<DialogContentContextProviderProps>;
 export { DialogContentContextProvider };

package/models/Dialog.d.ts

@@ -1,7 +1,9 @@
 import * as React from "react";
 import { DialogAction } from "./DialogAction";
-import { TInitialHolder, IDialogSize, TDialogStateListenerCallbackType, DialogOptionsType, IDialogApiDef, TDialogCallbackVoidFn, TDialogCallbackFn, DialogExternalHandlers, Dialogify, DialogExternalRefs } from "../types/index.js";
-declare class Dialog<Values extends Record<string, any>, StockDialogHandlers extends Record<string, any> = {}, StockDialogRefs extends Record<string, any> = {}> {
+import { TInitialHolder, IDialogSize, TDialogStateListenerCallbackType, DialogOptionsType, IDialogApiDef, TDialogCallbackFn, Dialogify, DialogInjectDef } from "../types/index.js";
+declare class Dialog<V, I> {
+    private _initialValues?;
+    private _inject?;
     private readonly _processingListeners;
     private readonly _abortedListeners;
     private _stateListener;
@@ -23,29 +25,27 @@ declare class Dialog<Values extends Record<string, any>, StockDialogHandlers ext
     private _headerRef;
     private readonly _apiRef;
     private _onCloseCallback;
-    private _initialValues;
-    private _xhandlers;
-    private _xrefs;
-    constructor(dialogRef?: React.RefObject<IDialogApiDef | undefined | null> | null, options?: DialogOptionsType);
-    setHeader(header: TDialogCallbackFn): this;
-    setBody(body: TDialogCallbackFn): this;
+    constructor(dialogRef?: React.RefObject<IDialogApiDef | undefined | null> | null, options?: DialogOptionsType, _initialValues?: Dialogify<V>, _inject?: DialogInjectDef<I>);
+    inject<T>(args: DialogInjectDef<T>): Dialog<V, T>;
+    initialValues<K>(args: Dialogify<K>): Dialog<K, I>;
+    setHeader(header: TDialogCallbackFn<V, I>): this;
+    setBody(body: TDialogCallbackFn<V, I>): this;
     addActions(actions: Array<DialogAction>): this;
     addAction(action: DialogAction): this;
     /**
      * Only from init */
     stateListener(listener: TDialogStateListenerCallbackType): this;
     processingListener(listener: (inProcess: boolean) => void): this;
-    onAbort(callbackFn: TDialogCallbackFn<void>): this;
-    initialValues<T extends Record<string, any>>(values: Dialogify<T>): Dialog<T, any, any>;
-    registerHandlers<H extends StockDialogHandlers>(handlers: DialogExternalHandlers<H>): Dialog<any, H, any>;
-    registerRefs<R extends StockDialogRefs>(refs: DialogExternalRefs<R>): Dialog<any, any, R>;
+    onAbort(callbackFn: TDialogCallbackFn<V, I, void>): this;
     initialHolder(holder: TInitialHolder): this;
     keyboardListener(listener: (key: string, dialog: IDialogApiDef) => void): this;
     resizeListener(listener: (size: IDialogSize, dialog: IDialogApiDef) => void): this;
-    onClose(callback: TDialogCallbackVoidFn): this;
+    onClose(callback: TDialogCallbackFn<V, I, void>): this;
     private highestZ;
     private createDom;
-    get values(): Dialogify<Values>;
-    show(callback?: TDialogCallbackVoidFn): void;
+    /**
+     * @deprecated only from inline */
+    get values(): Dialogify<V>;
+    show(callback?: TDialogCallbackFn<V, I, void>): void;
 }
 export default Dialog;

package/models/Dialog.js

@@ -52,8 +52,11 @@ var DialogBase_1 = __importDefault(require("../components/DialogBase"));
 var client_1 = require("react-dom/client");
 var appLogger_1 = require("../helpers/appLogger");
 var Dialog = /** @class */ (function () {
-    function Dialog(dialogRef, options) {
+    // private _initialValues                :Dialogify<V>;
+    function Dialog(dialogRef, options, _initialValues, _inject) {
         var _this = this;
+        this._initialValues = _initialValues;
+        this._inject = _inject;
         // ✨✨✨✨✨✨✨✨✨✨✨
         this._processingListeners = [];
         this._abortedListeners = [];
@@ -104,6 +107,22 @@ var Dialog = /** @class */ (function () {
         }
         // this._xrefs = {} as DialogExternalRefs<StockDialogRefs>;
     }
+    Dialog.prototype.inject = function (args) {
+        // @ts-ignore
+        var t = new Dialog(this._apiRef, this._dialogOptions, this._initialValues, args);
+        var newDialog = Object.assign(this, t);
+        return newDialog;
+    };
+    // public initialValues<T extends Record<string, any>>( values: Dialogify<T> ): Dialog<T, I> {
+    Dialog.prototype.initialValues = function (args) {
+        // const next = this as unknown as Dialog<K, I>;
+        // next._initialValues = values;
+        // return next;
+        // @ts-ignore
+        var t = new Dialog(this._apiRef, this._dialogOptions, args, this._inject);
+        var newDialog = Object.assign(this, t);
+        return newDialog;
+    };
     Dialog.prototype.setHeader = function (header) {
         this._header = header;
         return this;
@@ -136,29 +155,6 @@ var Dialog = /** @class */ (function () {
         this._abortedListeners.push(callbackFn);
         return this;
     };
-    // 👌Ok
-    // public initialValues<T>( values: Dialogify<T> ): this {
-    //     this._initialValues = values as Dialogify<Values>;;
-    //     return this;
-    // }
-    // 👌Ok Combined with Dialog Class
-    Dialog.prototype.initialValues = function (values) {
-        var next = this;
-        next._initialValues = values;
-        return next;
-    };
-    Dialog.prototype.registerHandlers = function (handlers) {
-        // this._xhandlers = handlers;
-        // return this;
-        var next = this;
-        this._xhandlers = handlers;
-        return next;
-    };
-    Dialog.prototype.registerRefs = function (refs) {
-        var next = this;
-        this._xrefs = refs;
-        return next;
-    };
     Dialog.prototype.initialHolder = function (holder) {
         this._initialHolder = holder;
         return this;
@@ -176,6 +172,8 @@ var Dialog = /** @class */ (function () {
         return this;
     };
     Object.defineProperty(Dialog.prototype, "values", {
+        /**
+         * @deprecated only from inline */
         get: function () {
             return this._initialValues;
         },
@@ -183,11 +181,12 @@ var Dialog = /** @class */ (function () {
         configurable: true
     });
     Dialog.prototype.show = function (callback) {
+        // public show ( callback?: (dialog: DialogBase<Values, I> & IDialogApiDef ) => void ): void {
         var dom = this.createDom();
         var root = (0, client_1.createRoot)(dom);
         var props = __assign(__assign({ 
             // Initials
-            initialOptions: this._dialogOptions, initialValues: this._initialValues, xhandlers: this._xhandlers, xrefs: this._xrefs, didMountCallback: callback, 
+            initialOptions: this._dialogOptions, initialValues: this._initialValues, didMountCallback: callback, 
             // Component contents
             header: this._header, body: this._body, actions: this._actions, 
             // Refs
@@ -195,8 +194,11 @@ var Dialog = /** @class */ (function () {
             // Listeners
             stateListener: this._stateListener, keyboardListener: this._keyboardListener, resizeListener: this._resizeListener, processingListeners: this._processingListeners, abortedListeners: this._abortedListeners, 
             // Others
-            dialogSize: this._dialogSize, initialHolder: this._initialHolder, snackbarAnchor: this._snackbarAnchor, root: root, dom: dom, parent: this }, this._apiRef ? { ref: this._apiRef } : null), { onClose: this._onCloseCallback });
+            dialogSize: this._dialogSize, initialHolder: this._initialHolder, snackbarAnchor: this._snackbarAnchor, root: root, dom: dom, parent: this }, this._apiRef ? { ref: this._apiRef } : null), { onClose: this._onCloseCallback, inject: this._inject });
         // @ts-ignore
+        // root.render( React.createElement( DialogBase as React.ComponentType<
+        //     typeof this._initialValues
+        // >, props ) );
         root.render(React.createElement(DialogBase_1.default, props));
     };
     return Dialog;

package/models/test.js

@@ -0,0 +1,79 @@
+// import Dialog from "./Dialog";
+//
+// const myRef = { current: "HELLO" };
+// const myFunction = (name: string, age: number) => {
+//     return 21;
+// };
+//
+// const f = (new Dialog(null, {}))
+//     const z = f.inject({
+//         // name: 'Suleyman',
+//         myFunc: myFunction,
+//         myRef,
+//         array_: {
+//             name: myFunction
+//         }
+//     })
+//     const name = z.getInject().myFunc('Suleyman', 22)
+//     const refika = z.getInject().array_.name('Suleyman', 44);
+//     const d = z.showMe( data => {
+//         data.getInject().myFunc('Suleyman', 21);
+//     })
+// // // const typedDialog = f.inject({}); // ✅ BOZMAYACAK
+//
+// // f.getInject().test('Suleyman', 21); // ✅
+// // f.getInject().rt.;
+//
+// // // typedDialog.getInject().test()// ✅
+//
+//
+// // function bar<T>(arg: T){
+// //     return arg;
+// // }
+//
+// // const retval = bar({
+// //     a: 1, b: 2, c: 3
+// // });
+//
+// // retval.a
+//
+// class M<T> {
+//
+//     private _name: string;
+//     constructor(private b?: T) {}
+//
+//     static create<U>(args: U): M<U> {
+//         return new M(args);
+//     }
+//
+//     public name(name: string): this {
+//         this._name = name;
+//         return this;
+//     }
+//
+//     initialValues<U>(args: U): M<U> {
+//         return new M(args);
+//     }
+//
+//     getD(): T {
+//         return this.b;
+//     }
+//
+//     getC( callback: (data: T) => void): M<T>{
+//         callback(this.b);
+//         return this;
+//     }
+// }
+//
+// // const t = M.create({ a: 1 });
+// const t = new M();
+//
+// // t.getD().; // ✅
+// t.name('Suleyman')
+// .initialValues({
+//     b: 2, c: 3, name: 'Suleyman', age: 29
+// })
+// .getC( data => {
+//     console.log('getC', data.age);
+// }).getD().age
+//

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "react-dialogger",
-  "version": "1.1.112",
+  "version": "1.1.114",
   "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",
   "license": "MIT",
   "dependencies": {
-    "notistack": "^3.0.2",
     "formik": "^2.4.6",
-    "react-draggable": "^4.4.6",
     "lodash": "^4.17.21",
     "lodash.isequal": "^4.5.0",
+    "notistack": "^3.0.2",
     "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "react-dom": "^18.2.0",
+    "react-draggable": "^4.4.6"
   },
   "maintainers": [
     {
@@ -29,5 +29,8 @@
     "react-component",
     "dynamic dialog",
     "react-dialogger"
-  ]
+  ],
+  "devDependencies": {
+    "tsx": "^4.21.0"
+  }
 }

package/types/DialogActionTypes.d.ts

@@ -3,13 +3,13 @@ import { DialogBase, DialogActionBase } from "../components/index.js";
 import * as React from "react";
 import { DialogAction } from "../models/index.js";
 import { CSSProperties } from "react";
-export type ActionDialogDef = Omit<IDialogApiDef, 'switchFullScreen'>;
+export type ActionDialogDef<V, I> = Omit<IDialogApiDef, 'switchFullScreen'>;
 export type ActionDef = Pick<DialogAction, 'onClick' | 'setOptions' | 'name'>;
 export type ActionApiDef = Pick<InstanceType<typeof DialogActionBase>, 'updateOptions' | 'updateColor' | 'updateVariant' | 'updateLabel' | 'updateIntent' | 'setOptions' | 'setInProcess' | 'getLabel' | 'options' | 'click' | 'remove' | 'name'>;
 export interface IDialogActionDef extends ActionApiDef {
 }
 export type DialogActionType = (button: ActionApiDef, dialog: Omit<IDialogApiDef, 'switchFullScreen'>) => void;
-export interface ActionProps {
+export interface ActionProps<V extends Record<string, any> = Record<string, any>, I extends Record<string, any> = Record<string, any>> {
     name: string;
     options?: DialogActionOptionsType;
     /**
@@ -17,7 +17,7 @@ export interface ActionProps {
      * @see options.label */
     label?: string;
     onClick: DialogActionType;
-    dialogBaseComponent?: DialogBase<any, any, any>;
+    dialogBaseComponent?: DialogBase<V, I>;
     /**
      * @deprecated
      * @see options.variant */

package/types/DialogContentContextTypes.d.ts

@@ -3,9 +3,9 @@ import DialogBase from "../components/DialogBase";
 import { ReactNode, RefObject } from "react";
 import { BaseDialogDOMRect } from "./index.js";
 import { Resizeable } from "../helpers/index.js";
-export interface DialogContentContextProviderProps {
-    dialogBase: DialogBase<any, any, any>;
-    body: TDialogCallbackFn<ReturnType<any>>;
+export interface DialogContentContextProviderProps<V extends Record<string, any> = Record<string, any>, I = unknown> {
+    dialogBase: DialogBase<V, I>;
+    body: TDialogCallbackFn<V, I, ReturnType<any>>;
     dialogRef: RefObject<any>;
     headerRef: RefObject<any>;
     bodyRef: RefObject<any>;
@@ -15,8 +15,8 @@ export interface DialogContentContextProviderProps {
     prevDialogRect: BaseDialogDOMRect;
     children: ReactNode;
 }
-export interface DialogContentContextProviderSharedProps extends Partial<Pick<DialogContentContextProviderProps, 'body' | 'dialogRef' | 'headerRef' | 'bodyRef' | 'footerRef' | 'backdropRef' | 'snackbarRef' | 'prevDialogRect'>> {
+export interface DialogContentContextProviderSharedProps<V extends Record<string, any> = Record<string, any>, I = unknown> extends Partial<Pick<DialogContentContextProviderProps<V, I>, 'body' | 'dialogRef' | 'headerRef' | 'bodyRef' | 'footerRef' | 'backdropRef' | 'snackbarRef' | 'prevDialogRect'>> {
     baseZoomEffect: () => void;
-    dialog: DialogBase<any, any, any>;
+    dialog: DialogBase<V, I>;
     resizeableObject: Resizeable | null;
 }

package/types/DialogTypes.d.ts

@@ -10,19 +10,20 @@ import { SharedProps, SnackbarKey, SnackbarProvider, VariantType } from "notista
 export interface TBaseDialogState {
     [K: string]: any;
 }
-export interface BaseDialogState {
+export interface BaseDialogState<V, I> {
     /**@deprecated use FormikProps Values*/
     values: DialogValues<Record<string, any>>;
     inProcess: IInProcess;
     fullscreenMode?: boolean;
     prevDialogRect: WithBackdrop['prevDialogRect'];
-    body: TDialogCallbackFn;
+    body: TDialogCallbackFn<any, any>;
     /**
      * Indicates whether the operation was aborted by the user or the system.
      * - true: The dialog or background process (e.g., API request) was aborted.
      * - false: The operation is continuing or completed normally.
      */
     aborted: boolean;
+    inject: DialogInjectDef<I>;
 }
 export interface DialogFormikAdapter<Values> extends Omit<FormikProps<any>, 'values' | 'setValues' | 'setFieldValue' | 'validateForm' | 'errors'> {
     values: Values;
@@ -31,27 +32,26 @@ export interface DialogFormikAdapter<Values> extends Omit<FormikProps<any>, 'val
     validateForm(): Promise<any>;
     errors: any;
 }
-export interface BaseDialogProps<Values extends Record<string, any>, StockDialogHandlers extends Record<string, any>, StockDialogRefs extends Record<string, any>> {
-    initialValues: Dialogify<Values>;
+export interface BaseDialogProps<V extends Record<string, any>, I> {
+    inject: DialogInjectDef<I>;
+    initialValues: Dialogify<V>;
     initialOptions?: DialogOptionsType;
-    body: TDialogCallbackFn;
-    header?: TDialogCallbackFn;
+    body: TDialogCallbackFn<V, I>;
+    header?: TDialogCallbackFn<V, I>;
     actions?: Array<DialogAction>;
-    didMountCallback?: TDialogCallbackVoidFn;
+    didMountCallback?: TDialogCallbackFn<V, I, void>;
     dialogSize?: IDialogSize;
     stateListener: TDialogStateListenerCallbackType;
-    xhandlers: DialogExternalHandlers<StockDialogHandlers>;
-    xrefs: DialogExternalRefs<StockDialogRefs>;
     initialHolder: TInitialHolder;
     snackbarAnchor?: ISnackbarAnchor;
     dom: HTMLDivElement;
     parent?: DialogValues<Record<string, any>>;
-    onClose?: TDialogCallbackVoidFn;
+    onClose?: TDialogCallbackFn<V, I, void>;
     root?: any;
-    keyboardListener: (key: string, dialog: IDialogApiDef) => void;
-    resizeListener?: (size: IDialogSize, dialog: IDialogApiDef) => void;
+    keyboardListener: (key: string, dialog: IDialogApiDef<V, I>) => void;
+    resizeListener?: (size: IDialogSize, dialog: IDialogApiDef<V, I>) => void;
     processingListeners?: Array<(inProcess: boolean) => void>;
-    abortedListeners?: Array<(dialog: IDialogApiDef) => void>;
+    abortedListeners?: Array<(dialog: IDialogApiDef<V, I>) => void>;
 }
 export interface IDialogSize {
     width?: ITypeWidth | number;
@@ -141,15 +141,19 @@ export interface BaseDialogSlotProps {
     dialogOptions: DialogOptionsType;
     dialog?: IDialogApiDef;
 }
-export interface IStateDef extends Pick<BaseDialogState, "values" | "fullscreenMode" | "inProcess"> {
+export interface IStateDef extends Pick<BaseDialogState<any, any>, "values" | "fullscreenMode" | "inProcess"> {
 }
 export interface IListenerDialogDef extends Omit<IDialogApiDef, "values" | "setValues"> {
 }
 export type TDialogStateListenerCallbackType = (values: FormikProps<any>['values'], dialog: IListenerDialogDef) => void;
-export type TDialogCallbackFn<T = React.ReactNode | React.ReactElement> = (dialog: IDialogApiDef) => T;
-export type TDialogHeader = TDialogCallbackFn | React.ReactNode | React.JSX.Element;
-export type TDialogCallbackVoidFn = TDialogCallbackFn<void>;
-export interface IDialogApiDef extends Pick<DialogBase<any, any, any>, 'isInProcess' | 'setInProcess' | 'values' | 'setValue' | 'setValues' | 'close' | 'dialogOptions' | 'actions' | 'snackbar' | 'formikValidate' | 'formikProps' | 'focus' | 'updateBody' | 'processingListener' | 'onAbort' | 'xhandlers' | 'appendXHandler' | 'xrefs' | 'appendXRef'> {
+export type TDialogCallbackFn<V, I, T = React.ReactNode | React.ReactElement> = (dialog: DialogBase<V, I> & IDialogApiDef) => T;
+export type DialogValues<V extends Record<string, any>> = {
+    [K in keyof V]: Dialogify<V[K]>;
+};
+export type DialogInjects<I extends Record<string, any>> = {
+    [K in keyof I]: DialogInjectDef<I[K]>;
+};
+export interface IDialogApiDef<V extends Record<string, any> = Record<string, any>, I extends Record<string, any> = Record<string, any>> extends Pick<DialogBase<V, I>, 'isInProcess' | 'setInProcess' | 'values' | 'setValue' | 'setValues' | 'close' | 'dialogOptions' | 'actions' | 'snackbar' | 'formikValidate' | 'formikProps' | 'focus' | 'updateBody' | 'processingListener' | 'onAbort' | 'deps' | 'inject'> {
 }
 interface OpenArgs {
     message: any;
@@ -173,10 +177,10 @@ export interface IDialogSnackbar {
 }
 export interface WithBackdrop {
     ref: React.RefObject<any>;
-    body: TDialogCallbackFn;
-    header: TDialogCallbackFn;
+    body: TDialogCallbackFn<any, any>;
+    header: TDialogCallbackFn<any, any>;
     actions?: DialogAction[];
-    dialog: DialogBase<any, any, any>;
+    dialog: DialogBase<any, any>;
     backdropRef: RefObject<any>;
     initialValues: Partial<Record<string, any>>;
     dialogRef: RefObject<any>;
@@ -194,8 +198,8 @@ export interface DialogWithBackdropWrapperRefProps {
     formikProps?: FormikProps<any>;
 }
 export interface IContentProps {
-    body: TDialogCallbackFn;
-    header: TDialogCallbackFn;
+    body: TDialogCallbackFn<any, any>;
+    header: TDialogCallbackFn<any, any>;
     actions: DialogAction[];
     dialogRef: React.RefObject<any>;
     headerRef: React.RefObject<any>;
@@ -203,7 +207,7 @@ export interface IContentProps {
     footerRef: React.RefObject<DialogContentFooterReturnType>;
     backdropRef: React.RefObject<any>;
     dialogOptions: DialogOptionsType;
-    dialog: DialogBase<any, any, any>;
+    dialog: DialogBase<any, any>;
     resizeableObject?: Resizeable | null;
     prevDialogRect: WithBackdrop['prevDialogRect'];
     snackbarRef: WithBackdrop['snackbarRef'];
@@ -248,10 +252,6 @@ export type NonFunction<T> = T extends Function ? never : T;
 export type DialogValue<T> = string | number | boolean | null | undefined | DialogValue<T>[] | {
     [key: string]: DialogValue<T>;
 };
-export type ModelDialogValues<T> = {
-    [K in keyof T]: DialogValue<T>;
-};
-export type DialogValues<T extends Record<string, any>> = ModelDialogValues<T>;
 export type Dialogify<T> = T extends Function ? never : T extends {
     current: null;
 } ? never : T extends string | number | boolean | null | undefined | Date ? T : T extends Array<infer U> ? Dialogify<U>[] : T extends object ? {
@@ -269,6 +269,11 @@ export type DialogExternalRefs<T> = T extends {
 } ? DialogExternalRef : T extends object ? {
     [K in keyof T]: DialogExternalRefs<T[K]>;
 } : never;
+export type DialogInjectDef<T> = T extends Function ? T : T extends {
+    current: any;
+} ? T : T extends string | number | boolean | null | undefined | Date ? never : T extends Array<infer U> ? never : T extends object ? {
+    [K in keyof T]: DialogInjectDef<T[K]>;
+} : never;
 export interface BaseDialogDOMRect {
     height?: number;
     width?: number;
@@ -292,6 +297,6 @@ export interface ICoords {
     y: number;
 }
 export interface DialogProps {
-    setHeader(header: TDialogCallbackFn): Dialog<any, any, any>;
+    setHeader(header: TDialogCallbackFn<any, any>): Dialog<any, any>;
 }
 export {};

package/utils/resizeManager.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
 import { DialogBase } from "../components/index.js";
 import { Resizeable } from "../helpers/index.js";
-declare const resizeManager: (dialogRef: React.RefObject<HTMLDivElement>, dialog: DialogBase<any, any, any>) => Resizeable | null;
+declare const resizeManager: <V, I>(dialogRef: React.RefObject<HTMLDivElement>, dialog: DialogBase<V, I>) => Resizeable | null;
 export { resizeManager };