Add deep-merge functionality to Jodit configuration and update tests

- Introduced `Jodit.configure()` method for deep-merging options into global defaults.
- Enhanced `ConfigMerge` function to support nested merging without losing existing keys.
- Updated tests to validate new configuration behavior and ensure existing functionality remains intact.
- Added detailed documentation for new features in CHANGELOG.

Author: eric-mallac

CHANGELOG.md

@@ -9,6 +9,28 @@
 > - :house: [Internal]
 > - :nail_care: [Polish]
 
+## 4.11.16
+
+#### :rocket: New Feature
+
+- Add `Jodit.configure()` static method for deep-merging partial options into global defaults without losing existing keys. Previously, overriding nested defaults like `controls` or `createAttributes` required setting each property individually. Now you can patch only the keys you need:
+
+  ```js
+  // Add a button without losing existing controls
+  Jodit.configure({
+    controls: {
+      myButton: { icon: 'pencil', command: 'selectall' }
+    }
+  });
+
+  // Partially update createAttributes
+  Jodit.configure({
+    createAttributes: {
+      div: { class: 'my-class' }
+    }
+  });
+  ```
+
 ## 4.11.15
 
 #### :house: Internal

src/core/helpers/helpers.test.js

@@ -816,5 +816,255 @@ describe('Test helpers', () => {
 				});
 			});
 		});
+
+		describe('ConfigMerge', () => {
+			const ConfigMerge = Jodit.modules.Helpers.ConfigMerge;
+
+			it('Should deep-merge source into target without replacing sibling keys', () => {
+				const target = {
+					a: 1,
+					b: {
+						c: 2,
+						d: 3
+					}
+				};
+
+				ConfigMerge(target, { b: { c: 10 } });
+
+				expect(target.a).eq(1);
+				expect(target.b.c).eq(10);
+				expect(target.b.d).eq(3);
+			});
+
+			it('Should add new keys at any depth', () => {
+				const target = {
+					controls: {
+						bold: { icon: 'bold' }
+					}
+				};
+
+				ConfigMerge(target, {
+					controls: {
+						myButton: { icon: 'pencil', command: 'selectall' }
+					}
+				});
+
+				expect(target.controls.bold.icon).eq('bold');
+				expect(target.controls.myButton.icon).eq('pencil');
+				expect(target.controls.myButton.command).eq('selectall');
+			});
+
+			it('Should overwrite primitives', () => {
+				const target = { language: 'en', theme: 'default' };
+
+				ConfigMerge(target, { language: 'de' });
+
+				expect(target.language).eq('de');
+				expect(target.theme).eq('default');
+			});
+
+			it('Should replace atomic values entirely', () => {
+				const target = {
+					controls: {
+						fontsize: {
+							list: [10, 12, 14, 16],
+							icon: 'fontsize'
+						}
+					}
+				};
+
+				ConfigMerge(target, {
+					controls: {
+						fontsize: {
+							list: Jodit.atom([8, 9, 10])
+						}
+					}
+				});
+
+				expect(target.controls.fontsize.list).deep.eq([8, 9, 10]);
+				expect(target.controls.fontsize.icon).eq('fontsize');
+			});
+
+			it('Should replace arrays (non-atom) entirely', () => {
+				const target = { items: [1, 2, 3] };
+
+				ConfigMerge(target, { items: [4, 5] });
+
+				expect(target.items).deep.eq([4, 5]);
+			});
+
+			it('Should handle multiple nested levels', () => {
+				const target = {
+					a: {
+						b: {
+							c: {
+								d: 1,
+								e: 2
+							},
+							f: 3
+						}
+					}
+				};
+
+				ConfigMerge(target, { a: { b: { c: { d: 10 } } } });
+
+				expect(target.a.b.c.d).eq(10);
+				expect(target.a.b.c.e).eq(2);
+				expect(target.a.b.f).eq(3);
+			});
+		});
+
+		describe('Jodit.configure', () => {
+			let origControls;
+
+			beforeEach(() => {
+				origControls = { ...Jodit.defaultOptions.controls };
+			});
+
+			afterEach(() => {
+				// Restore controls to not affect other tests
+				Object.keys(Jodit.defaultOptions.controls).forEach(key => {
+					if (!(key in origControls)) {
+						delete Jodit.defaultOptions.controls[key];
+					}
+				});
+				Object.assign(Jodit.defaultOptions.controls, origControls);
+			});
+
+			it('Should deep-merge into defaultOptions.controls without losing existing buttons', () => {
+				const boldBefore = Jodit.defaultOptions.controls.bold;
+
+				Jodit.configure({
+					controls: {
+						testConfigureBtn: {
+							icon: 'pencil',
+							command: 'selectall'
+						}
+					}
+				});
+
+				expect(Jodit.defaultOptions.controls.testConfigureBtn.icon).eq(
+					'pencil'
+				);
+				expect(
+					Jodit.defaultOptions.controls.testConfigureBtn.command
+				).eq('selectall');
+				expect(Jodit.defaultOptions.controls.bold).eq(boldBefore);
+			});
+
+			it('Should partially update an existing control', () => {
+				Jodit.configure({
+					controls: {
+						testConfigureBtn: {
+							icon: 'pencil',
+							command: 'selectall',
+							group: 'custom'
+						}
+					}
+				});
+
+				// Now update only group
+				Jodit.configure({
+					controls: {
+						testConfigureBtn: {
+							group: 'other'
+						}
+					}
+				});
+
+				expect(Jodit.defaultOptions.controls.testConfigureBtn.icon).eq(
+					'pencil'
+				);
+				expect(Jodit.defaultOptions.controls.testConfigureBtn.group).eq(
+					'other'
+				);
+			});
+
+			it('Should deep-merge createAttributes without losing existing entries', () => {
+				const origTable = Jodit.defaultOptions.createAttributes.table;
+
+				Jodit.configure({
+					createAttributes: {
+						div: { class: 'test-class' }
+					}
+				});
+
+				expect(Jodit.defaultOptions.createAttributes.div.class).eq(
+					'test-class'
+				);
+				expect(Jodit.defaultOptions.createAttributes.table).eq(
+					origTable
+				);
+
+				// cleanup
+				delete Jodit.defaultOptions.createAttributes.div;
+			});
+
+			it('Should affect new editor instances created after configure', () => {
+				Jodit.configure({
+					controls: {
+						testConfigureBtn2: {
+							icon: 'check',
+							tooltip: 'Test'
+						}
+					}
+				});
+
+				const editor = getJodit();
+				expect(editor.o.controls.testConfigureBtn2.icon).eq('check');
+				editor.destruct();
+			});
+
+			it('Should apply configured createAttributes to elements created by the editor', () => {
+				Jodit.configure({
+					createAttributes: {
+						div: { class: 'configured-class' }
+					}
+				});
+
+				const editor = getJodit();
+				const div = editor.createInside.div();
+				expect(div.className).eq('configured-class');
+
+				// existing table default should still work
+				const table = editor.createInside.element('table');
+				expect(table.style.borderCollapse).eq('collapse');
+
+				editor.destruct();
+				delete Jodit.defaultOptions.createAttributes.div;
+			});
+
+			it('Should merge configure with per-instance options via prototype chain', () => {
+				Jodit.configure({
+					controls: {
+						testMergeBtn: {
+							icon: 'pencil',
+							command: 'selectall',
+							tooltip: 'Global tooltip'
+						}
+					}
+				});
+
+				// Per-instance option overrides only icon, rest comes from defaults
+				const editor = getJodit({
+					controls: {
+						testMergeBtn: {
+							icon: 'bold'
+						}
+					}
+				});
+
+				expect(editor.o.controls.testMergeBtn.icon).eq('bold');
+				expect(editor.o.controls.testMergeBtn.command).eq('selectall');
+				expect(editor.o.controls.testMergeBtn.tooltip).eq(
+					'Global tooltip'
+				);
+
+				// Built-in controls should still be accessible
+				expect(editor.o.controls.bold).not.eq(undefined);
+
+				editor.destruct();
+			});
+		});
 	});
 });

src/core/helpers/utils/config-proto.ts

@@ -123,6 +123,39 @@ export function ConfigFlatten(obj: IDictionary): IDictionary {
  * console.log(JSON.stringify(plain)); // {"dialogWidth":500, "openOnDblClick": true, "editSrc": true, ...}
  * ```
  */
+/**
+ * Deep-merges `source` into `target` in-place.
+ * Uses the same merge semantics as {@link ConfigProto}:
+ * - Nested plain objects are merged recursively
+ * - {@link isAtom | Atomic} values replace the target entirely
+ * - Everything else (primitives, arrays, class instances) replaces the target value
+ *
+ * Designed for patching `Config.defaultOptions` without losing existing keys:
+ *
+ * ```js
+ * Jodit.configure({
+ *   controls: {
+ *     someButton: { group: 'custom' }
+ *   }
+ * });
+ * // Only `controls.someButton` is touched — all other controls remain intact.
+ * ```
+ *
+ * @see {@link ConfigProto} for the prototype-chain variant used at editor creation time
+ */
+export function ConfigMerge(target: IDictionary, source: IDictionary): void {
+	Object.keys(source).forEach(key => {
+		const srcVal = source[key];
+		const tgtVal = target[key];
+
+		if (isPlainObject(srcVal) && isPlainObject(tgtVal) && !isAtom(srcVal)) {
+			ConfigMerge(tgtVal, srcVal);
+		} else {
+			target[key] = srcVal;
+		}
+	});
+}
+
 export function ConfigDeepFlatten(obj: IDictionary): IDictionary {
 	return keys(obj, false).reduce((app, key) => {
 		app[key] = isPlainObject(obj[key])

src/jodit.ts

@@ -54,6 +54,7 @@ import {
 	asArray,
 	attr,
 	callPromise,
+	ConfigMerge,
 	ConfigProto,
 	css,
 	error,
@@ -209,6 +210,53 @@ export class Jodit extends ViewWithToolbar implements IJodit, Dlgs {
 		return Config.defaultOptions;
 	}
 
+	/**
+	 * Deep-merges partial options into the global defaults without replacing
+	 * top-level objects. This lets you patch nested settings (e.g. a single
+	 * button inside `controls`) without losing the rest:
+	 *
+	 * ```js
+	 * // Add a custom button — all existing controls remain untouched
+	 * Jodit.configure({
+	 *   controls: {
+	 *     myButton: {
+	 *       icon: 'pencil',
+	 *       command: 'selectall'
+	 *     }
+	 *   }
+	 * });
+	 *
+	 * // Override only the `group` of an existing button
+	 * Jodit.configure({
+	 *   controls: {
+	 *     someButton: { group: 'custom' }
+	 *   }
+	 * });
+	 *
+	 * // Works with any nested option
+	 * Jodit.configure({
+	 *   createAttributes: {
+	 *     div: { class: 'my-class' }
+	 *   }
+	 * });
+	 *
+	 * // Use Jodit.atom() to replace a nested value entirely instead of merging
+	 * Jodit.configure({
+	 *   controls: {
+	 *     fontsize: {
+	 *       list: Jodit.atom([8, 9, 10])
+	 *     }
+	 *   }
+	 * });
+	 * ```
+	 *
+	 * @see {@link ConfigMerge} for the merge algorithm
+	 * @see {@link ConfigProto} for per-instance prototype-based merge used at editor creation time
+	 */
+	static configure(options: IDictionary): void {
+		ConfigMerge(Jodit.defaultOptions, options);
+	}
+
 	static fatMode: boolean = FAT_MODE;
 
 	static readonly plugins: IPluginSystem = pluginSystem;