@schukai/monster 3.86.5 → 3.87.1

package/source/components/datatable/datatable.mjs

@@ -12,75 +12,75 @@
  * SPDX-License-Identifier: AGPL-3.0
  */
 
-import { Datasource } from "./datasource.mjs";
+import {Datasource} from "./datasource.mjs";
 import {
-	assembleMethodSymbol,
-	CustomElement,
-	registerCustomElement,
-	getSlottedElements,
+    assembleMethodSymbol,
+    CustomElement,
+    registerCustomElement,
+    getSlottedElements,
 } from "../../dom/customelement.mjs";
 import {
-	findTargetElementFromEvent,
-	fireCustomEvent,
+    findTargetElementFromEvent,
+    fireCustomEvent,
 } from "../../dom/events.mjs";
-import { clone } from "../../util/clone.mjs";
+import {clone} from "../../util/clone.mjs";
 import {
-	isString,
-	isFunction,
-	isInstance,
-	isObject,
-	isArray,
+    isString,
+    isFunction,
+    isInstance,
+    isObject,
+    isArray,
 } from "../../types/is.mjs";
 import {
-	validateArray,
-	validateInteger,
-	validateObject,
+    validateArray,
+    validateInteger,
+    validateObject,
 } from "../../types/validate.mjs";
-import { Observer } from "../../types/observer.mjs";
+import {Observer} from "../../types/observer.mjs";
 import {
-	ATTRIBUTE_DATATABLE_HEAD,
-	ATTRIBUTE_DATATABLE_GRID_TEMPLATE,
-	ATTRIBUTE_DATASOURCE_SELECTOR,
-	ATTRIBUTE_DATATABLE_ALIGN,
-	ATTRIBUTE_DATATABLE_SORTABLE,
-	ATTRIBUTE_DATATABLE_MODE,
-	ATTRIBUTE_DATATABLE_INDEX,
-	ATTRIBUTE_DATATABLE_MODE_HIDDEN,
-	ATTRIBUTE_DATATABLE_MODE_VISIBLE,
-	ATTRIBUTE_DATATABLE_RESPONSIVE_BREAKPOINT,
-	ATTRIBUTE_DATATABLE_MODE_FIXED,
+    ATTRIBUTE_DATATABLE_HEAD,
+    ATTRIBUTE_DATATABLE_GRID_TEMPLATE,
+    ATTRIBUTE_DATASOURCE_SELECTOR,
+    ATTRIBUTE_DATATABLE_ALIGN,
+    ATTRIBUTE_DATATABLE_SORTABLE,
+    ATTRIBUTE_DATATABLE_MODE,
+    ATTRIBUTE_DATATABLE_INDEX,
+    ATTRIBUTE_DATATABLE_MODE_HIDDEN,
+    ATTRIBUTE_DATATABLE_MODE_VISIBLE,
+    ATTRIBUTE_DATATABLE_RESPONSIVE_BREAKPOINT,
+    ATTRIBUTE_DATATABLE_MODE_FIXED,
 } from "./constants.mjs";
-import { instanceSymbol } from "../../constants.mjs";
+import {instanceSymbol} from "../../constants.mjs";
 import {
-	Header,
-	createOrderStatement,
-	DIRECTION_ASC,
-	DIRECTION_DESC,
-	DIRECTION_NONE,
+    Header,
+    createOrderStatement,
+    DIRECTION_ASC,
+    DIRECTION_DESC,
+    DIRECTION_NONE,
 } from "./datatable/header.mjs";
-import { DatatableStyleSheet } from "./stylesheet/datatable.mjs";
+import {DatatableStyleSheet} from "./stylesheet/datatable.mjs";
 import {
-	handleDataSourceChanges,
-	datasourceLinkedElementSymbol,
+    handleDataSourceChanges,
+    datasourceLinkedElementSymbol,
 } from "./util.mjs";
 import "./columnbar.mjs";
 import "./filter-button.mjs";
 import {
-	findElementWithSelectorUpwards,
-	getDocument,
-	getWindow,
+    findElementWithSelectorUpwards,
+    getDocument,
+    getWindow,
 } from "../../dom/util.mjs";
-import { addAttributeToken } from "../../dom/attributes.mjs";
-import { ATTRIBUTE_ERRORMESSAGE } from "../../dom/constants.mjs";
-import { getDocumentTranslations } from "../../i18n/translations.mjs";
+import {addAttributeToken} from "../../dom/attributes.mjs";
+import {ATTRIBUTE_ERRORMESSAGE} from "../../dom/constants.mjs";
+import {getDocumentTranslations} from "../../i18n/translations.mjs";
 import "../state/state.mjs";
 import "../host/collapse.mjs";
-import { generateUniqueConfigKey } from "../host/util.mjs";
+import {generateUniqueConfigKey} from "../host/util.mjs";
 
 import "./datasource/dom.mjs";
 import "./datasource/rest.mjs";
 
-export { DataTable };
+export {DataTable};
 
 /**
  * @private
@@ -106,6 +106,12 @@ const gridHeadersElementSymbol = Symbol("gridHeadersElement");
  */
 const columnBarElementSymbol = Symbol("columnBarElement");
 
+/**
+ * @private
+ * @type {symbol}
+ */
+const copyAllElementSymbol = Symbol("copyAllElement");
+
 /**
  * @private
  * @type {symbol}
@@ -142,387 +148,398 @@ const resizeObserverSymbol = Symbol("resizeObserver");
  * @fires monster-datatable-row-added
  **/
 class DataTable extends CustomElement {
-	/**
-	 * This method is called by the `instanceof` operator.
-	 * @return {symbol}
-	 */
-	static get [instanceSymbol]() {
-		return Symbol.for("@schukai/monster/components/datatable@@instance");
-	}
-
-	/**
-	 * To set the options via the HTML tag, the attribute `data-monster-options` must be used.
-	 * @see {@link https://monsterjs.org/en/doc/#configurate-a-monster-control}
-	 *
-	 * The individual configuration values can be found in the table.
-	 *
-	 * @property {Object} templates Template definitions
-	 * @property {string} templates.main Main template
-	 * @property {Object} datasource Datasource configuration
-	 * @property {string} datasource.selector Selector for the datasource
-	 * @property {Object} mapping Mapping configuration
-	 * @property {string} mapping.data Data mapping
-	 * @property {Array} data Data
-	 * @property {Array} headers Headers
-	 * @property {Object} responsive Responsive configuration
-	 * @property {number} responsive.breakpoint Breakpoint for responsive mode
-	 * @property {Object} labels Labels
-	 * @property {string} labels.theListContainsNoEntries Label for empty state
-	 * @property {Object} classes Classes
-	 * @property {string} classes.container Container class
-	 * @property {Object} features Features
-	 * @property {boolean} features.settings Settings feature
-	 * @property {boolean} features.footer Footer feature
-	 * @property {boolean} features.autoInit Auto init feature (init datasource automatically)
-	 * @property {Object} templateMapping Template mapping
-	 * @property {string} templateMapping.row-key Row key
-	 * @property {string} templateMapping.filter-id Filter id
-	 **/
-	get defaults() {
-		return Object.assign(
-			{},
-			super.defaults,
-			{
-				templates: {
-					main: getTemplate(),
-					emptyState: getEmptyTemplate(),
-				},
-
-				datasource: {
-					selector: null,
-				},
-
-				mapping: {
-					data: "dataset",
-				},
-
-				data: [],
-				headers: [],
-
-				responsive: {
-					breakpoint: 900,
-				},
-
-				labels: {
-					theListContainsNoEntries: "The list contains no entries",
-				},
-
-				classes: {
-					control: "monster-theme-control-container-1",
-					container: "",
-					row: "monster-theme-control-row-1",
-				},
-
-				features: {
-					settings: true,
-					footer: true,
-					autoInit: true,
-				},
-
-				templateMapping: {
-					"row-key": null,
-					"filter-id": null,
-				},
-			},
-			initOptionsFromArguments.call(this),
-		);
-	}
-
-	/**
-	 *
-	 * @param {string} selector
-	 * @return {NodeListOf<*>}
-	 */
-	getGridElements(selector) {
-		return this[gridElementSymbol].querySelectorAll(selector);
-	}
-
-	/**
-	 *
-	 * @return {string}
-	 */
-	static getTag() {
-		return "monster-datatable";
-	}
-
-	/**
-	 * @return {void}
-	 */
-	disconnectedCallback() {
-		super.disconnectedCallback();
-		if (this?.[resizeObserverSymbol] instanceof ResizeObserver) {
-			this[resizeObserverSymbol].disconnect();
-		}
-	}
-
-	/**
-	 * @return {void}
-	 */
-	connectedCallback() {
-		const self = this;
-		super.connectedCallback();
-
-		this[resizeObserverSymbol] = new ResizeObserver((entries) => {
-			updateGrid.call(self);
-		});
-
-		this[resizeObserverSymbol].observe(this.parentNode);
-	}
-
-	/**
-	 * @return void
-	 */
-	[assembleMethodSymbol]() {
-		const rawKey = this.getOption("templateMapping.row-key");
-
-		if (rawKey === null) {
-			if (this.id !== null && this.id !== "") {
-				const rawKey = this.getOption("templateMapping.row-key");
-				if (rawKey === null) {
-					this.setOption("templateMapping.row-key", this.id + "-row");
-				}
-			} else {
-				this.setOption("templateMapping.row-key", "row");
-			}
-		}
-
-		if (this.id !== null && this.id !== "") {
-			this.setOption("templateMapping.filter-id", "" + this.id + "-filter");
-		} else {
-			this.setOption("templateMapping.filter-id", "filter");
-		}
-
-		super[assembleMethodSymbol]();
-
-		initControlReferences.call(this);
-		initEventHandler.call(this);
-
-		const selector = this.getOption("datasource.selector");
-
-		if (isString(selector)) {
-			const element = findElementWithSelectorUpwards(this, selector);
-			if (element === null) {
-				throw new Error("the selector must match exactly one element");
-			}
-
-			if (!isInstance(element, Datasource)) {
-				throw new TypeError("the element must be a datasource");
-			}
-
-			this[datasourceLinkedElementSymbol] = element;
-
-			queueMicrotask(() => {
-				handleDataSourceChanges.call(this);
-				element.datasource.attachObserver(
-					new Observer(handleDataSourceChanges.bind(this)),
-				);
-			});
-		}
-
-		getHostConfig
-			.call(this, getColumnVisibilityConfigKey)
-			.then((config) => {
-				const headerOrderMap = new Map();
-
-				getHostConfig
-					.call(this, getStoredOrderConfigKey)
-					.then((orderConfig) => {
-						if (isArray(orderConfig) || orderConfig.length > 0) {
-							for (let i = 0; i < orderConfig.length; i++) {
-								const item = orderConfig[i];
-								const parts = item.split(" ");
-								const field = parts[0];
-								const direction = parts[1] || DIRECTION_ASC;
-								headerOrderMap.set(field, direction);
-							}
-						}
-					})
-					.then(() => {
-						try {
-							initGridAndStructs.call(this, config, headerOrderMap);
-						} catch (error) {
-							addAttributeToken(
-								this,
-								ATTRIBUTE_ERRORMESSAGE,
-								error?.message || error.toString(),
-							);
-						}
-
-						updateColumnBar.call(this);
-					})
-					.catch((error) => {
-						addAttributeToken(
-							this,
-							ATTRIBUTE_ERRORMESSAGE,
-							error?.message || error.toString(),
-						);
-					});
-			})
-			.catch((error) => {
-				addAttributeToken(
-					this,
-					ATTRIBUTE_ERRORMESSAGE,
-					error?.message || error.toString(),
-				);
-			});
-	}
-
-	/**
-	 * @return {CSSStyleSheet[]}
-	 */
-	static getCSSStyleSheet() {
-		return [DatatableStyleSheet];
-	}
-
-	/**
-	 * Copy a row from the datatable
-	 *
-	 * @param {number|string} fromIndex
-	 * @param {number|string} toIndex
-	 * @return {DataTable}
-	 * @fires monster-datatable-row-copied
-	 */
-	copyRow(fromIndex, toIndex) {
-		const datasource = this[datasourceLinkedElementSymbol];
-		if (!datasource) {
-			return this;
-		}
-		let d = datasource.data;
-		let c = clone(d);
-
-		let rows = c;
-		const mapping = this.getOption("mapping.data");
-
-		if (mapping) {
-			rows = c?.[mapping];
-		}
-
-		if (rows === undefined || rows === null) {
-			rows = [];
-		}
-
-		if (toIndex === undefined) {
-			toIndex = rows.length;
-		}
-
-		if (isString(fromIndex)) {
-			fromIndex = parseInt(fromIndex);
-		}
-		if (isString(toIndex)) {
-			toIndex = parseInt(toIndex);
-		}
-
-		if (toIndex < 0 || toIndex > rows.length) {
-			throw new RangeError("index out of bounds");
-		}
-
-		validateArray(rows);
-		validateInteger(fromIndex);
-		validateInteger(toIndex);
-
-		if (fromIndex < 0 || fromIndex >= rows.length) {
-			throw new RangeError("index out of bounds");
-		}
-
-		rows.splice(toIndex, 0, clone(rows[fromIndex]));
-		datasource.data = c;
-
-		fireCustomEvent(this, "monster-datatable-row-copied", {
-			index: toIndex,
-		});
-
-		return this;
-	}
-
-	/**
-	 * Remove a row from the datatable
-	 *
-	 * @param {number|string} index
-	 * @return {DataTable}
-	 * @fires monster-datatable-row-removed
-	 */
-	removeRow(index) {
-		const datasource = this[datasourceLinkedElementSymbol];
-		if (!datasource) {
-			return this;
-		}
-		let d = datasource.data;
-		let c = clone(d);
-
-		let rows = c;
-		const mapping = this.getOption("mapping.data");
-
-		if (mapping) {
-			rows = c?.[mapping];
-		}
-
-		if (rows === undefined || rows === null) {
-			rows = [];
-		}
-
-		if (isString(index)) {
-			index = parseInt(index);
-		}
-
-		validateArray(rows);
-		validateInteger(index);
-
-		if (index < 0 || index >= rows.length) {
-			throw new RangeError("index out of bounds");
-		}
-		if (mapping) {
-			rows = c?.[mapping];
-		}
-
-		rows.splice(index, 1);
-		datasource.data = c;
-
-		fireCustomEvent(this, "monster-datatable-row-removed", {
-			index: index,
-		});
-
-		return this;
-	}
-
-	/**
-	 * Add a row to the datatable
-	 *
-	 * @param {Object} data
-	 * @return {DataTable}
-	 *
-	 * @fires monster-datatable-row-added
-	 **/
-	addRow(data) {
-		const datasource = this[datasourceLinkedElementSymbol];
-		if (!datasource) {
-			return this;
-		}
-		let d = datasource.data;
-		let c = clone(d);
-
-		let rows = c;
-
-		const mapping = this.getOption("mapping.data");
-		if (mapping) {
-			rows = c?.[mapping];
-		}
-
-		if (rows === undefined || rows === null) {
-			rows = [];
-		}
-
-		validateArray(rows);
-		validateObject(data);
-
-		rows.push(data);
-		datasource.data = c;
-
-		fireCustomEvent(this, "monster-datatable-row-added", {
-			index: rows.length - 1,
-		});
-
-		return this;
-	}
+    /**
+     * This method is called by the `instanceof` operator.
+     * @return {symbol}
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/components/datatable@@instance");
+    }
+
+    /**
+     * To set the options via the HTML tag, the attribute `data-monster-options` must be used.
+     * @see {@link https://monsterjs.org/en/doc/#configurate-a-monster-control}
+     *
+     * The individual configuration values can be found in the table.
+     *
+     * @property {Object} templates Template definitions
+     * @property {string} templates.main Main template
+     * @property {Object} datasource Datasource configuration
+     * @property {string} datasource.selector Selector for the datasource
+     * @property {Object} mapping Mapping configuration
+     * @property {string} mapping.data Data mapping
+     * @property {Array} data Data
+     * @property {Array} headers Headers
+     * @property {Object} responsive Responsive configuration
+     * @property {number} responsive.breakpoint Breakpoint for responsive mode
+     * @property {Object} labels Labels
+     * @property {string} labels.theListContainsNoEntries Label for empty state
+     * @property {Object} classes Classes
+     * @property {string} classes.container Container class
+     * @property {Object} features Features
+     * @property {boolean} features.settings Settings feature
+     * @property {boolean} features.footer Footer feature
+     * @property {boolean} features.autoInit Auto init feature (init datasource automatically)
+     * @property {boolean} features.doubleClickCopyToClipboard Double click copy to clipboard feature
+     * @property {Object} templateMapping Template mapping
+     * @property {string} templateMapping.row-key Row key
+     * @property {string} templateMapping.filter-id Filter id
+     **/
+    get defaults() {
+        return Object.assign(
+            {},
+            super.defaults,
+            {
+                templates: {
+                    main: getTemplate(),
+                    emptyState: getEmptyTemplate(),
+                },
+
+                datasource: {
+                    selector: null,
+                },
+
+                mapping: {
+                    data: "dataset",
+                },
+
+                data: [],
+                headers: [],
+
+                responsive: {
+                    breakpoint: 900,
+                },
+
+                labels: {
+                    theListContainsNoEntries: "The list contains no entries",
+                    copyAll: "Copy all",
+                },
+
+                classes: {
+                    control: "monster-theme-control-container-1",
+                    container: "",
+                    row: "monster-theme-control-row-1",
+                },
+
+                features: {
+                    settings: true,
+                    footer: true,
+                    autoInit: true,
+                    doubleClickCopyToClipboard: true,
+                    copyAll: true,
+                },
+                
+                copy: {
+                    delimiter: ";",
+                    quoteOpen: '"',
+                    quoteClose: '"',
+                    rowBreak: "\n",
+                },
+
+                templateMapping: {
+                    "row-key": null,
+                    "filter-id": null,
+                },
+            },
+            initOptionsFromArguments.call(this),
+        );
+    }
+
+    /**
+     *
+     * @param {string} selector
+     * @return {NodeListOf<*>}
+     */
+    getGridElements(selector) {
+        return this[gridElementSymbol].querySelectorAll(selector);
+    }
+
+    /**
+     *
+     * @return {string}
+     */
+    static getTag() {
+        return "monster-datatable";
+    }
+
+    /**
+     * @return {void}
+     */
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        if (this?.[resizeObserverSymbol] instanceof ResizeObserver) {
+            this[resizeObserverSymbol].disconnect();
+        }
+    }
+
+    /**
+     * @return {void}
+     */
+    connectedCallback() {
+        const self = this;
+        super.connectedCallback();
+
+        this[resizeObserverSymbol] = new ResizeObserver((entries) => {
+            updateGrid.call(self);
+        });
+
+        this[resizeObserverSymbol].observe(this.parentNode);
+    }
+
+    /**
+     * @return void
+     */
+    [assembleMethodSymbol]() {
+        const rawKey = this.getOption("templateMapping.row-key");
+
+        if (rawKey === null) {
+            if (this.id !== null && this.id !== "") {
+                const rawKey = this.getOption("templateMapping.row-key");
+                if (rawKey === null) {
+                    this.setOption("templateMapping.row-key", this.id + "-row");
+                }
+            } else {
+                this.setOption("templateMapping.row-key", "row");
+            }
+        }
+
+        if (this.id !== null && this.id !== "") {
+            this.setOption("templateMapping.filter-id", "" + this.id + "-filter");
+        } else {
+            this.setOption("templateMapping.filter-id", "filter");
+        }
+
+        super[assembleMethodSymbol]();
+
+        initControlReferences.call(this);
+        initEventHandler.call(this);
+
+        const selector = this.getOption("datasource.selector");
+
+        if (isString(selector)) {
+            const element = findElementWithSelectorUpwards(this, selector);
+            if (element === null) {
+                throw new Error("the selector must match exactly one element");
+            }
+
+            if (!isInstance(element, Datasource)) {
+                throw new TypeError("the element must be a datasource");
+            }
+
+            this[datasourceLinkedElementSymbol] = element;
+
+            queueMicrotask(() => {
+                handleDataSourceChanges.call(this);
+                element.datasource.attachObserver(
+                    new Observer(handleDataSourceChanges.bind(this)),
+                );
+            });
+        }
+
+        getHostConfig
+            .call(this, getColumnVisibilityConfigKey)
+            .then((config) => {
+                const headerOrderMap = new Map();
+
+                getHostConfig
+                    .call(this, getStoredOrderConfigKey)
+                    .then((orderConfig) => {
+                        if (isArray(orderConfig) || orderConfig.length > 0) {
+                            for (let i = 0; i < orderConfig.length; i++) {
+                                const item = orderConfig[i];
+                                const parts = item.split(" ");
+                                const field = parts[0];
+                                const direction = parts[1] || DIRECTION_ASC;
+                                headerOrderMap.set(field, direction);
+                            }
+                        }
+                    })
+                    .then(() => {
+                        try {
+                            initGridAndStructs.call(this, config, headerOrderMap);
+                        } catch (error) {
+                            addAttributeToken(
+                                this,
+                                ATTRIBUTE_ERRORMESSAGE,
+                                error?.message || error.toString(),
+                            );
+                        }
+
+                        updateColumnBar.call(this);
+                    })
+                    .catch((error) => {
+                        addAttributeToken(
+                            this,
+                            ATTRIBUTE_ERRORMESSAGE,
+                            error?.message || error.toString(),
+                        );
+                    });
+            })
+            .catch((error) => {
+                addAttributeToken(
+                    this,
+                    ATTRIBUTE_ERRORMESSAGE,
+                    error?.message || error.toString(),
+                );
+            });
+    }
+
+    /**
+     * @return {CSSStyleSheet[]}
+     */
+    static getCSSStyleSheet() {
+        return [DatatableStyleSheet];
+    }
+
+    /**
+     * Copy a row from the datatable
+     *
+     * @param {number|string} fromIndex
+     * @param {number|string} toIndex
+     * @return {DataTable}
+     * @fires monster-datatable-row-copied
+     */
+    copyRow(fromIndex, toIndex) {
+        const datasource = this[datasourceLinkedElementSymbol];
+        if (!datasource) {
+            return this;
+        }
+        let d = datasource.data;
+        let c = clone(d);
+
+        let rows = c;
+        const mapping = this.getOption("mapping.data");
+
+        if (mapping) {
+            rows = c?.[mapping];
+        }
+
+        if (rows === undefined || rows === null) {
+            rows = [];
+        }
+
+        if (toIndex === undefined) {
+            toIndex = rows.length;
+        }
+
+        if (isString(fromIndex)) {
+            fromIndex = parseInt(fromIndex);
+        }
+        if (isString(toIndex)) {
+            toIndex = parseInt(toIndex);
+        }
+
+        if (toIndex < 0 || toIndex > rows.length) {
+            throw new RangeError("index out of bounds");
+        }
+
+        validateArray(rows);
+        validateInteger(fromIndex);
+        validateInteger(toIndex);
+
+        if (fromIndex < 0 || fromIndex >= rows.length) {
+            throw new RangeError("index out of bounds");
+        }
+
+        rows.splice(toIndex, 0, clone(rows[fromIndex]));
+        datasource.data = c;
+
+        fireCustomEvent(this, "monster-datatable-row-copied", {
+            index: toIndex,
+        });
+
+        return this;
+    }
+
+    /**
+     * Remove a row from the datatable
+     *
+     * @param {number|string} index
+     * @return {DataTable}
+     * @fires monster-datatable-row-removed
+     */
+    removeRow(index) {
+        const datasource = this[datasourceLinkedElementSymbol];
+        if (!datasource) {
+            return this;
+        }
+        let d = datasource.data;
+        let c = clone(d);
+
+        let rows = c;
+        const mapping = this.getOption("mapping.data");
+
+        if (mapping) {
+            rows = c?.[mapping];
+        }
+
+        if (rows === undefined || rows === null) {
+            rows = [];
+        }
+
+        if (isString(index)) {
+            index = parseInt(index);
+        }
+
+        validateArray(rows);
+        validateInteger(index);
+
+        if (index < 0 || index >= rows.length) {
+            throw new RangeError("index out of bounds");
+        }
+        if (mapping) {
+            rows = c?.[mapping];
+        }
+
+        rows.splice(index, 1);
+        datasource.data = c;
+
+        fireCustomEvent(this, "monster-datatable-row-removed", {
+            index: index,
+        });
+
+        return this;
+    }
+
+    /**
+     * Add a row to the datatable
+     *
+     * @param {Object} data
+     * @return {DataTable}
+     *
+     * @fires monster-datatable-row-added
+     **/
+    addRow(data) {
+        const datasource = this[datasourceLinkedElementSymbol];
+        if (!datasource) {
+            return this;
+        }
+        let d = datasource.data;
+        let c = clone(d);
+
+        let rows = c;
+
+        const mapping = this.getOption("mapping.data");
+        if (mapping) {
+            rows = c?.[mapping];
+        }
+
+        if (rows === undefined || rows === null) {
+            rows = [];
+        }
+
+        validateArray(rows);
+        validateObject(data);
+
+        rows.push(data);
+        datasource.data = c;
+
+        fireCustomEvent(this, "monster-datatable-row-added", {
+            index: rows.length - 1,
+        });
+
+        return this;
+    }
 }
 
 /**
@@ -530,7 +547,7 @@ class DataTable extends CustomElement {
  * @return {string}
  */
 function getColumnVisibilityConfigKey() {
-	return generateUniqueConfigKey("datatable", this?.id, "columns-visibility");
+    return generateUniqueConfigKey("datatable", this?.id, "columns-visibility");
 }
 
 /**
@@ -538,7 +555,7 @@ function getColumnVisibilityConfigKey() {
  * @return {string}
  */
 function getFilterConfigKey() {
-	return generateUniqueConfigKey("datatable", this?.id, "filter");
+    return generateUniqueConfigKey("datatable", this?.id, "filter");
 }
 
 /**
@@ -546,287 +563,403 @@ function getFilterConfigKey() {
  * @return {Promise}
  */
 function getHostConfig(callback) {
-	const host = findElementWithSelectorUpwards(this, "monster-host");
-
-	if (!(host && this.id)) {
-		return Promise.resolve({});
-	}
-
-	if (!host || !isFunction(host?.getConfig)) {
-		throw new TypeError("the host must be a monster-host");
-	}
-
-	const configKey = callback.call(this);
-	return host.hasConfig(configKey).then((hasConfig) => {
-		if (hasConfig) {
-			return host.getConfig(configKey);
-		} else {
-			return {};
-		}
-	});
+    const host = findElementWithSelectorUpwards(this, "monster-host");
+
+    if (!(host && this.id)) {
+        return Promise.resolve({});
+    }
+
+    if (!host || !isFunction(host?.getConfig)) {
+        throw new TypeError("the host must be a monster-host");
+    }
+
+    const configKey = callback.call(this);
+    return host.hasConfig(configKey).then((hasConfig) => {
+        if (hasConfig) {
+            return host.getConfig(configKey);
+        } else {
+            return {};
+        }
+    });
 }
 
 /**
  * @private
  */
 function updateColumnBar() {
-	if (!this[columnBarElementSymbol]) {
-		return;
-	}
-
-	const columns = [];
-	for (const header of this.getOption("headers")) {
-		const mode = header.getInternal("mode");
-
-		if (mode === ATTRIBUTE_DATATABLE_MODE_FIXED) {
-			continue;
-		}
-
-		columns.push({
-			visible: mode !== ATTRIBUTE_DATATABLE_MODE_HIDDEN,
-			name: header.label,
-			index: header.index,
-		});
-	}
-
-	this[columnBarElementSymbol].setOption("columns", columns);
+    if (!this[columnBarElementSymbol]) {
+        return;
+    }
+
+    const columns = [];
+    for (const header of this.getOption("headers")) {
+        const mode = header.getInternal("mode");
+
+        if (mode === ATTRIBUTE_DATATABLE_MODE_FIXED) {
+            continue;
+        }
+
+        columns.push({
+            visible: mode !== ATTRIBUTE_DATATABLE_MODE_HIDDEN,
+            name: header.label,
+            index: header.index,
+        });
+    }
+
+    this[columnBarElementSymbol].setOption("columns", columns);
 }
 
 /**
  * @private
  */
 function updateHeaderFromColumnBar() {
-	if (!this[columnBarElementSymbol]) {
-		return;
-	}
+    if (!this[columnBarElementSymbol]) {
+        return;
+    }
 
-	const options = this[columnBarElementSymbol].getOption("columns");
-	if (!isArray(options)) return;
+    const options = this[columnBarElementSymbol].getOption("columns");
+    if (!isArray(options)) return;
 
-	const invisibleMap = {};
+    const invisibleMap = {};
 
-	for (let i = 0; i < options.length; i++) {
-		const option = options[i];
-		invisibleMap[option.index] = option.visible;
-	}
+    for (let i = 0; i < options.length; i++) {
+        const option = options[i];
+        invisibleMap[option.index] = option.visible;
+    }
 
-	for (const header of this.getOption("headers")) {
-		const mode = header.getInternal("mode");
+    for (const header of this.getOption("headers")) {
+        const mode = header.getInternal("mode");
 
-		if (mode === ATTRIBUTE_DATATABLE_MODE_FIXED) {
-			continue;
-		}
+        if (mode === ATTRIBUTE_DATATABLE_MODE_FIXED) {
+            continue;
+        }
 
-		if (invisibleMap[header.index] === false) {
-			header.setInternal("mode", ATTRIBUTE_DATATABLE_MODE_HIDDEN);
-		} else {
-			header.setInternal("mode", ATTRIBUTE_DATATABLE_MODE_VISIBLE);
-		}
-	}
+        if (invisibleMap[header.index] === false) {
+            header.setInternal("mode", ATTRIBUTE_DATATABLE_MODE_HIDDEN);
+        } else {
+            header.setInternal("mode", ATTRIBUTE_DATATABLE_MODE_VISIBLE);
+        }
+    }
 }
 
 /**
  * @private
  */
 function updateConfigColumnBar() {
-	if (!this[columnBarElementSymbol]) {
-		return;
-	}
-
-	const options = this[columnBarElementSymbol].getOption("columns");
-	if (!isArray(options)) return;
-
-	const map = {};
-	for (let i = 0; i < options.length; i++) {
-		const option = options[i];
-		map[option.name] = option.visible;
-	}
-
-	const host = findElementWithSelectorUpwards(this, "monster-host");
-	if (!(host && this.id)) {
-		return;
-	}
-	const configKey = getColumnVisibilityConfigKey.call(this);
-
-	try {
-		host.setConfig(configKey, map);
-	} catch (error) {
-		addAttributeToken(this, ATTRIBUTE_ERRORMESSAGE, String(error));
-	}
+    if (!this[columnBarElementSymbol]) {
+        return;
+    }
+
+    const options = this[columnBarElementSymbol].getOption("columns");
+    if (!isArray(options)) return;
+
+    const map = {};
+    for (let i = 0; i < options.length; i++) {
+        const option = options[i];
+        map[option.name] = option.visible;
+    }
+
+    const host = findElementWithSelectorUpwards(this, "monster-host");
+    if (!(host && this.id)) {
+        return;
+    }
+    const configKey = getColumnVisibilityConfigKey.call(this);
+
+    try {
+        host.setConfig(configKey, map);
+    } catch (error) {
+        addAttributeToken(this, ATTRIBUTE_ERRORMESSAGE, String(error));
+    }
 }
 
 /**
  * @private
  */
 function initEventHandler() {
-	const self = this;
-
-	self[columnBarElementSymbol].attachObserver(
-		new Observer((e) => {
-			updateHeaderFromColumnBar.call(self);
-			updateGrid.call(self);
-			updateConfigColumnBar.call(self);
-		}),
-	);
-
-	self[gridHeadersElementSymbol].addEventListener("click", function (event) {
-		let element = null;
-		const datasource = self[datasourceLinkedElementSymbol];
-		if (!datasource) {
-			return;
-		}
-
-		element = findTargetElementFromEvent(event, ATTRIBUTE_DATATABLE_SORTABLE);
-		if (element) {
-			const index = element.parentNode.getAttribute(ATTRIBUTE_DATATABLE_INDEX);
-			const headers = self.getOption("headers");
-
-			event.preventDefault();
-
-			headers[index].changeDirection();
-
-			queueMicrotask(function () {
-				/** hotfix, normally this should be done via the updater, no idea why this is not possible. */
-				element.setAttribute(
-					ATTRIBUTE_DATATABLE_SORTABLE,
-					`${headers[index].field} ${headers[index].direction}`,
-				);
-
-				storeOrderStatement.call(self, true);
-			});
-		}
-	});
+    const self = this;
+
+    const quoteOpenChar = this.getOption("copy.quoteOpen");
+    const quoteCloseChar = this.getOption("copy.quoteClose");
+    const delimiterChar = this.getOption("copy.delimiter");
+    const rowBreak = this.getOption("copy.rowBreak");
+
+    self[columnBarElementSymbol].attachObserver(
+        new Observer((e) => {
+            updateHeaderFromColumnBar.call(self);
+            updateGrid.call(self);
+            updateConfigColumnBar.call(self);
+        }),
+    );
+
+    self[gridHeadersElementSymbol].addEventListener("click", function (event) {
+        let element = null;
+        const datasource = self[datasourceLinkedElementSymbol];
+        if (!datasource) {
+            return;
+        }
+
+        element = findTargetElementFromEvent(event, ATTRIBUTE_DATATABLE_SORTABLE);
+        if (element) {
+            const index = element.parentNode.getAttribute(ATTRIBUTE_DATATABLE_INDEX);
+            const headers = self.getOption("headers");
+
+            event.preventDefault();
+
+            headers[index].changeDirection();
+
+            queueMicrotask(function () {
+                /** hotfix, normally this should be done via the updater, no idea why this is not possible. */
+                element.setAttribute(
+                    ATTRIBUTE_DATATABLE_SORTABLE,
+                    `${headers[index].field} ${headers[index].direction}`,
+                );
+
+                storeOrderStatement.call(self, true);
+            });
+        }
+    });
+
+
+    const eventHandlerDoubleClickCopyToClipboard = (event) => {
+        const element = findTargetElementFromEvent(event, "data-monster-head");
+        if (element) {
+
+
+            let text = "";
+
+            if (event.shiftKey) {
+                const index = element.getAttribute("data-monster-insert-reference");
+                if (index) {
+                    const cols = self.getGridElements(`[data-monster-insert-reference="${index}"]`);
+
+                    const colTexts = []
+                    for (let i = 0; i < cols.length; i++) {
+                        const col = cols[i];
+
+                        if (col.querySelector("monster-button-bar") || col.querySelector("monster-button")) {
+                            continue;
+                        }
+
+                        if (col.textContent) {
+                            colTexts.push(quoteOpenChar+col.textContent.trim()+quoteCloseChar);
+                        }
+                    }
+
+                    text = colTexts.join(delimiterChar);
+
+                }
+
+
+            } else {
+                if (element.querySelector("monster-button-bar") || element.querySelector("monster-button")) {
+                    return;
+                }
+
+                text = element.textContent.trim();
+
+            }
+
+            if (getWindow().navigator.clipboard && text) {
+                getWindow().navigator.clipboard.writeText(text).then(
+                    () => {
+                    },
+                    (err) => {
+                    }
+                );
+            }
+        }
+    }
+
+    if (self.getOption("features.doubleClickCopyToClipboard")) {
+        self[gridElementSymbol].addEventListener("dblclick", eventHandlerDoubleClickCopyToClipboard);
+    }
+
+    if (self.getOption("features.copyAll") && this[copyAllElementSymbol]) {
+        this[copyAllElementSymbol].addEventListener("click", (event) => {
+            event.preventDefault();
+
+            const table = [];
+            let currentRow = [];
+            let currentIndex= null;
+            
+            const cols = self.getGridElements(`[data-monster-insert-reference]`);
+            const rowIndexes = new Map();
+            cols.forEach((col) => {
+                const index = col.getAttribute("data-monster-insert-reference");
+                rowIndexes.set(index, true);
+            });
+
+            rowIndexes.forEach((value, key) => {
+                const cols = self.getGridElements(`[data-monster-insert-reference="${key}"]`);
+
+                for (let i = 0; i < cols.length; i++) {
+                    const col = cols[i];
+                    
+                    if (col.querySelector("monster-button-bar") || col.querySelector("monster-button")) {
+                        continue;
+                    }
+                    
+                    if (col.textContent) {
+                        currentRow.push(quoteOpenChar+col.textContent.trim()+quoteCloseChar);
+                    }
+                }
+                
+                if(currentRow.length > 0) {
+                    table.push(currentRow);
+                }
+                currentRow = [];
+            });
+            
+            if(table.length > 0) {
+                const text = table.map(row => row.join(delimiterChar)).join(rowBreak);
+                if (getWindow().navigator.clipboard && text) {
+                    getWindow().navigator.clipboard.writeText(text).then(
+                        () => {
+                        },
+                        (err) => {
+                        }
+                    );
+                }
+            }
+            
+        });
+
+
+    }
+
+
+
 }
 
 /**
  * @private
  */
 function initGridAndStructs(hostConfig, headerOrderMap) {
-	const rowID = this.getOption("templateMapping.row-key");
-
-	if (!this[gridElementSymbol]) {
-		throw new Error("no grid element is defined");
-	}
-
-	let template;
-	getSlottedElements.call(this).forEach((e) => {
-		if (e instanceof HTMLTemplateElement && e.id === rowID) {
-			template = e;
-		}
-	});
-
-	if (!template) {
-		throw new Error("no template is defined");
-	}
-
-	const rowCount = template.content.children.length;
-
-	const headers = [];
-
-	for (let i = 0; i < rowCount; i++) {
-		let hClass = "";
-		const row = template.content.children[i];
-
-		let mode = "";
-		if (row.hasAttribute(ATTRIBUTE_DATATABLE_MODE)) {
-			mode = row.getAttribute(ATTRIBUTE_DATATABLE_MODE);
-		}
-
-		let grid = row.getAttribute(ATTRIBUTE_DATATABLE_GRID_TEMPLATE);
-		if (!grid || grid === "" || grid === "auto") {
-			grid = "minmax(0, 1fr)";
-		}
-
-		let label = "";
-		let labelKey = "";
-
-		if (row.hasAttribute(ATTRIBUTE_DATATABLE_HEAD)) {
-			label = row.getAttribute(ATTRIBUTE_DATATABLE_HEAD);
-			labelKey = label;
-
-			try {
-				if (label.startsWith("i18n:")) {
-					label = label.substring(5, label.length);
-					label = getDocumentTranslations().getText(label, label);
-				}
-			} catch (e) {
-				label = "i18n error " + label;
-			}
-		}
-
-		if (!label) {
-			label = i + 1 + "";
-			mode = ATTRIBUTE_DATATABLE_MODE_FIXED;
-			labelKey = label;
-		}
-
-		if (isObject(hostConfig) && hostConfig.hasOwnProperty(label)) {
-			if (hostConfig[label] === false) {
-				mode = ATTRIBUTE_DATATABLE_MODE_HIDDEN;
-			} else {
-				mode = ATTRIBUTE_DATATABLE_MODE_VISIBLE;
-			}
-		}
-
-		let align = "";
-		if (row.hasAttribute(ATTRIBUTE_DATATABLE_ALIGN)) {
-			align = row.getAttribute(ATTRIBUTE_DATATABLE_ALIGN);
-		}
-
-		switch (align) {
-			case "center":
-				hClass = "flex-center";
-				break;
-			case "end":
-				hClass = "flex-end";
-				break;
-			case "start":
-				hClass = "flex-start";
-				break;
-			default:
-				hClass = "flex-start";
-		}
-
-		let field = "";
-		let direction = DIRECTION_NONE;
-		if (row.hasAttribute(ATTRIBUTE_DATATABLE_SORTABLE)) {
-			field = row.getAttribute(ATTRIBUTE_DATATABLE_SORTABLE).trim();
-			const parts = field.split(" ").map((item) => item.trim());
-			field = parts[0];
-
-			if (headerOrderMap.has(field)) {
-				direction = headerOrderMap.get(field);
-			} else if (
-				parts.length === 2 &&
-				[DIRECTION_ASC, DIRECTION_DESC].indexOf(parts[1]) !== -1
-			) {
-				direction = parts[1];
-			}
-		}
-
-		if (mode === ATTRIBUTE_DATATABLE_MODE_HIDDEN) {
-			hClass += " hidden";
-		}
-
-		const header = new Header();
-		header.setInternals({
-			field: field,
-			label: label,
-			classes: hClass,
-			index: i,
-			mode: mode,
-			grid: grid,
-			labelKey: labelKey,
-			direction: direction,
-		});
-
-		headers.push(header);
-	}
-
-	this.setOption("headers", headers);
-	queueMicrotask(() => {
-		storeOrderStatement.call(this, this.getOption("features.autoInit"));
-	});
+    const rowID = this.getOption("templateMapping.row-key");
+
+    if (!this[gridElementSymbol]) {
+        throw new Error("no grid element is defined");
+    }
+
+    let template;
+    getSlottedElements.call(this).forEach((e) => {
+        if (e instanceof HTMLTemplateElement && e.id === rowID) {
+            template = e;
+        }
+    });
+
+    if (!template) {
+        throw new Error("no template is defined");
+    }
+
+    const rowCount = template.content.children.length;
+
+    const headers = [];
+
+    for (let i = 0; i < rowCount; i++) {
+        let hClass = "";
+        const row = template.content.children[i];
+
+        let mode = "";
+        if (row.hasAttribute(ATTRIBUTE_DATATABLE_MODE)) {
+            mode = row.getAttribute(ATTRIBUTE_DATATABLE_MODE);
+        }
+
+        let grid = row.getAttribute(ATTRIBUTE_DATATABLE_GRID_TEMPLATE);
+        if (!grid || grid === "" || grid === "auto") {
+            grid = "minmax(0, 1fr)";
+        }
+
+        let label = "";
+        let labelKey = "";
+
+        if (row.hasAttribute(ATTRIBUTE_DATATABLE_HEAD)) {
+            label = row.getAttribute(ATTRIBUTE_DATATABLE_HEAD);
+            labelKey = label;
+
+            try {
+                if (label.startsWith("i18n:")) {
+                    label = label.substring(5, label.length);
+                    label = getDocumentTranslations().getText(label, label);
+                }
+            } catch (e) {
+                label = "i18n error " + label;
+            }
+        }
+
+        if (!label) {
+            label = i + 1 + "";
+            mode = ATTRIBUTE_DATATABLE_MODE_FIXED;
+            labelKey = label;
+        }
+
+        if (isObject(hostConfig) && hostConfig.hasOwnProperty(label)) {
+            if (hostConfig[label] === false) {
+                mode = ATTRIBUTE_DATATABLE_MODE_HIDDEN;
+            } else {
+                mode = ATTRIBUTE_DATATABLE_MODE_VISIBLE;
+            }
+        }
+
+        let align = "";
+        if (row.hasAttribute(ATTRIBUTE_DATATABLE_ALIGN)) {
+            align = row.getAttribute(ATTRIBUTE_DATATABLE_ALIGN);
+        }
+
+        switch (align) {
+            case "center":
+                hClass = "flex-center";
+                break;
+            case "end":
+                hClass = "flex-end";
+                break;
+            case "start":
+                hClass = "flex-start";
+                break;
+            default:
+                hClass = "flex-start";
+        }
+
+        let field = "";
+        let direction = DIRECTION_NONE;
+        if (row.hasAttribute(ATTRIBUTE_DATATABLE_SORTABLE)) {
+            field = row.getAttribute(ATTRIBUTE_DATATABLE_SORTABLE).trim();
+            const parts = field.split(" ").map((item) => item.trim());
+            field = parts[0];
+
+            if (headerOrderMap.has(field)) {
+                direction = headerOrderMap.get(field);
+            } else if (
+                parts.length === 2 &&
+                [DIRECTION_ASC, DIRECTION_DESC].indexOf(parts[1]) !== -1
+            ) {
+                direction = parts[1];
+            }
+        }
+
+        if (mode === ATTRIBUTE_DATATABLE_MODE_HIDDEN) {
+            hClass += " hidden";
+        }
+
+        const header = new Header();
+        header.setInternals({
+            field: field,
+            label: label,
+            classes: hClass,
+            index: i,
+            mode: mode,
+            grid: grid,
+            labelKey: labelKey,
+            direction: direction,
+        });
+
+        headers.push(header);
+    }
+
+    this.setOption("headers", headers);
+    queueMicrotask(() => {
+        storeOrderStatement.call(this, this.getOption("features.autoInit"));
+    });
 }
 
 /**
@@ -834,79 +967,79 @@ function initGridAndStructs(hostConfig, headerOrderMap) {
  * @return {string}
  */
 export function getStoredOrderConfigKey() {
-	return generateUniqueConfigKey("datatable", this?.id, "stored-order");
+    return generateUniqueConfigKey("datatable", this?.id, "stored-order");
 }
 
 /**
  * @private
  */
 function storeOrderStatement(doFetch) {
-	const headers = this.getOption("headers");
-	const statement = createOrderStatement(headers);
-	setDataSource.call(this, { orderBy: statement }, doFetch);
+    const headers = this.getOption("headers");
+    const statement = createOrderStatement(headers);
+    setDataSource.call(this, {orderBy: statement}, doFetch);
 
-	const host = findElementWithSelectorUpwards(this, "monster-host");
-	if (!(host && this.id)) {
-		return;
-	}
+    const host = findElementWithSelectorUpwards(this, "monster-host");
+    if (!(host && this.id)) {
+        return;
+    }
 
-	const configKey = getStoredOrderConfigKey.call(this);
+    const configKey = getStoredOrderConfigKey.call(this);
 
-	// statement explode with , and remove all empty
-	const list = statement.split(",").filter((item) => item.trim() !== "");
-	if (list.length === 0) {
-		return;
-	}
+    // statement explode with , and remove all empty
+    const list = statement.split(",").filter((item) => item.trim() !== "");
+    if (list.length === 0) {
+        return;
+    }
 
-	host.setConfig(configKey, list);
+    host.setConfig(configKey, list);
 }
 
 /**
  * @private
  */
 function updateGrid() {
-	if (!this[gridElementSymbol]) {
-		throw new Error("no grid element is defined");
-	}
-
-	let gridTemplateColumns = "";
-
-	const headers = this.getOption("headers");
-
-	let styles = "";
-
-	for (let i = 0; i < headers.length; i++) {
-		const header = headers[i];
-
-		if (header.mode === ATTRIBUTE_DATATABLE_MODE_HIDDEN) {
-			styles += `[data-monster-role=datatable]>[data-monster-head="${header.labelKey}"] { display: none; }\n`;
-			styles += `[data-monster-role=datatable-headers]>[data-monster-index="${header.index}"] { display: none; }\n`;
-		} else {
-			gridTemplateColumns += `${header.grid} `;
-		}
-	}
-
-	const sheet = new CSSStyleSheet();
-	if (styles !== "") sheet.replaceSync(styles);
-	this.shadowRoot.adoptedStyleSheets = [...DataTable.getCSSStyleSheet(), sheet];
-
-	const bodyWidth = this.parentNode.clientWidth;
-
-	const breakpoint = this.getOption("responsive.breakpoint");
-	this[dataControlElementSymbol].classList.toggle(
-		"small",
-		bodyWidth <= breakpoint,
-	);
-
-	if (bodyWidth > breakpoint) {
-		this[gridElementSymbol].style.gridTemplateColumns =
-			`${gridTemplateColumns}`;
-		this[gridHeadersElementSymbol].style.gridTemplateColumns =
-			`${gridTemplateColumns}`;
-	} else {
-		this[gridElementSymbol].style.gridTemplateColumns = "auto";
-		this[gridHeadersElementSymbol].style.gridTemplateColumns = "auto";
-	}
+    if (!this[gridElementSymbol]) {
+        throw new Error("no grid element is defined");
+    }
+
+    let gridTemplateColumns = "";
+
+    const headers = this.getOption("headers");
+
+    let styles = "";
+
+    for (let i = 0; i < headers.length; i++) {
+        const header = headers[i];
+
+        if (header.mode === ATTRIBUTE_DATATABLE_MODE_HIDDEN) {
+            styles += `[data-monster-role=datatable]>[data-monster-head="${header.labelKey}"] { display: none; }\n`;
+            styles += `[data-monster-role=datatable-headers]>[data-monster-index="${header.index}"] { display: none; }\n`;
+        } else {
+            gridTemplateColumns += `${header.grid} `;
+        }
+    }
+
+    const sheet = new CSSStyleSheet();
+    if (styles !== "") sheet.replaceSync(styles);
+    this.shadowRoot.adoptedStyleSheets = [...DataTable.getCSSStyleSheet(), sheet];
+
+    const bodyWidth = this.parentNode.clientWidth;
+
+    const breakpoint = this.getOption("responsive.breakpoint");
+    this[dataControlElementSymbol].classList.toggle(
+        "small",
+        bodyWidth <= breakpoint,
+    );
+
+    if (bodyWidth > breakpoint) {
+        this[gridElementSymbol].style.gridTemplateColumns =
+            `${gridTemplateColumns}`;
+        this[gridHeadersElementSymbol].style.gridTemplateColumns =
+            `${gridTemplateColumns}`;
+    } else {
+        this[gridElementSymbol].style.gridTemplateColumns = "auto";
+        this[gridHeadersElementSymbol].style.gridTemplateColumns = "auto";
+    }
 }
 
 /**
@@ -914,20 +1047,20 @@ function updateGrid() {
  * @param {Header[]} headers
  * @param {bool} doFetch
  */
-function setDataSource({ orderBy }, doFetch) {
-	const datasource = this[datasourceLinkedElementSymbol];
+function setDataSource({orderBy}, doFetch) {
+    const datasource = this[datasourceLinkedElementSymbol];
 
-	if (!datasource) {
-		return;
-	}
+    if (!datasource) {
+        return;
+    }
 
-	if (isFunction(datasource?.setParameters)) {
-		datasource.setParameters({ orderBy });
-	}
+    if (isFunction(datasource?.setParameters)) {
+        datasource.setParameters({orderBy});
+    }
 
-	if (doFetch !== false && isFunction(datasource?.fetch)) {
-		datasource.fetch();
-	}
+    if (doFetch !== false && isFunction(datasource?.fetch)) {
+        datasource.fetch();
+    }
 }
 
 /**
@@ -935,24 +1068,28 @@ function setDataSource({ orderBy }, doFetch) {
  * @return {DataTable}
  */
 function initControlReferences() {
-	if (!this.shadowRoot) {
-		throw new Error("no shadow-root is defined");
-	}
-
-	this[dataControlElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=control]",
-	);
-
-	this[gridElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=datatable]",
-	);
-	this[gridHeadersElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=datatable-headers]",
-	);
-	this[columnBarElementSymbol] =
-		this.shadowRoot.querySelector("monster-column-bar");
-
-	return this;
+    if (!this.shadowRoot) {
+        throw new Error("no shadow-root is defined");
+    }
+
+    this[dataControlElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=control]",
+    );
+
+    this[gridElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=datatable]",
+    );
+    this[gridHeadersElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=datatable-headers]",
+    );
+    this[columnBarElementSymbol] =
+        this.shadowRoot.querySelector("monster-column-bar");
+
+    this[copyAllElementSymbol] = this.shadowRoot.querySelector(
+         "[data-monster-role=copy-all]",
+     );
+
+    return this;
 }
 
 /**
@@ -962,22 +1099,22 @@ function initControlReferences() {
  * @throws {Error} the datasource could not be initialized
  */
 function initOptionsFromArguments() {
-	const options = {};
-	const selector = this.getAttribute(ATTRIBUTE_DATASOURCE_SELECTOR);
-
-	if (selector) {
-		options.datasource = { selector: selector };
-	}
-
-	const breakpoint = this.getAttribute(
-		ATTRIBUTE_DATATABLE_RESPONSIVE_BREAKPOINT,
-	);
-	if (breakpoint) {
-		options.responsive = {};
-		options.responsive.breakpoint = parseInt(breakpoint);
-	}
-
-	return options;
+    const options = {};
+    const selector = this.getAttribute(ATTRIBUTE_DATASOURCE_SELECTOR);
+
+    if (selector) {
+        options.datasource = {selector: selector};
+    }
+
+    const breakpoint = this.getAttribute(
+        ATTRIBUTE_DATATABLE_RESPONSIVE_BREAKPOINT,
+    );
+    if (breakpoint) {
+        options.responsive = {};
+        options.responsive.breakpoint = parseInt(breakpoint);
+    }
+
+    return options;
 }
 
 /**
@@ -985,7 +1122,7 @@ function initOptionsFromArguments() {
  * @return {string}
  */
 function getEmptyTemplate() {
-	return `<monster-state data-monster-role="empty-without-action">
+    return `<monster-state data-monster-role="empty-without-action">
     <div part="visual">
         <svg width="4rem" height="4rem" fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
             <path d="m21.5 22h-19c-1.378 0-2.5-1.121-2.5-2.5v-7c0-.07.015-.141.044-.205l3.969-8.82c.404-.896 1.299-1.475 2.28-1.475h11.414c.981 0 1.876.579 2.28 1.475l3.969 8.82c.029.064.044.135.044.205v7c0 1.379-1.122 2.5-2.5 2.5zm-20.5-9.393v6.893c0 .827.673 1.5 1.5 1.5h19c.827 0 1.5-.673 1.5-1.5v-6.893l-3.925-8.723c-.242-.536-.779-.884-1.368-.884h-11.414c-.589 0-1.126.348-1.368.885z"/>
@@ -1003,8 +1140,8 @@ function getEmptyTemplate() {
  * @return {string}
  */
 function getTemplate() {
-	// language=HTML
-	return `
+    // language=HTML
+    return `
         <div data-monster-role="control" part="control" data-monster-attributes="class path:classes.control">
             <template id="headers-row">
                 <div data-monster-attributes="class path:headers-row.classes,
@@ -1018,6 +1155,7 @@ function getTemplate() {
                     <slot name="filter"></slot>
                 </div>
                 <div class="bar">
+                    <a href="#" data-monster-attributes="class path:features.copyAll | ?::hidden" data-monster-role="copy-all" data-monster-replace="path:locale.copyAll">Copy all</a>
                     <monster-column-bar
                             data-monster-attributes="class path:features.settings | ?::hidden"></monster-column-bar>
                     <slot name="bar"></slot>