@absreim/react-bootstrap-data-grid-pro 2.4.0

package/grid/pipeline/useCombinedPipeline/useFilterStateStore.js

@@ -0,0 +1,57 @@
+import { useState } from "react";
+var generateEmptyFilterState = function (cols) {
+    var filterState = {};
+    cols.forEach(function (_a) {
+        var type = _a.type, name = _a.name;
+        switch (type) {
+            case "string": {
+                filterState[name] = {
+                    type: "string",
+                    enabled: false,
+                    scheme: "contains",
+                    searchString: "",
+                };
+                break;
+            }
+            case "number": {
+                filterState[name] = {
+                    type: "number",
+                    enabled: false,
+                    scheme: "greaterOrEqual",
+                    numValue: null,
+                };
+                break;
+            }
+            default: {
+                filterState[name] = {
+                    type: type,
+                    enabled: false,
+                    scheme: "startFrom",
+                    startDate: null,
+                };
+            }
+        }
+    });
+    return filterState;
+};
+var useFilterStateStore = function (filterModel, cols) {
+    // Initial states being from prop values means that should uncontrolled
+    // FilterModel starting values change, the changes will not take effect
+    // unless the Grid is remounted. The documentation for this and other
+    // uncontrolled features should indicate this fact and recommend using
+    // controlled modes if this behavior is unacceptable.
+    var _a = useState((filterModel === null || filterModel === void 0 ? void 0 : filterModel.tableFilterState) || generateEmptyFilterState(cols)), internalFilterState = _a[0], setInternalFilterState = _a[1];
+    if (!filterModel) {
+        return null;
+    }
+    return filterModel.type === "uncontrolled"
+        ? {
+            tableFilterState: internalFilterState,
+            setTableFilterState: setInternalFilterState,
+        }
+        : {
+            tableFilterState: filterModel.tableFilterState,
+            setTableFilterState: filterModel.setTableFilterState,
+        };
+};
+export default useFilterStateStore;

package/grid/pipeline/useCombinedPipeline/useSortedRows.d.ts

@@ -0,0 +1,10 @@
+import { ColDefBase, RowDef } from "../../types";
+import { SortColDef, TableSortModel } from "../../sorting/types";
+export interface SortedRowsOutput {
+    sortedRows: RowDef[];
+    sortingEnabled: boolean;
+    sortColDef: SortColDef | null | undefined;
+    setSortColDef: ((sortColDef: SortColDef | null) => void) | undefined;
+}
+declare const useSortedRows: (rows: RowDef[], cols: ColDefBase[], sortModel: TableSortModel | undefined) => SortedRowsOutput;
+export default useSortedRows;

package/grid/pipeline/useCombinedPipeline/useSortedRows.js

@@ -0,0 +1,58 @@
+import { useMemo, useState } from "react";
+var getTypeComparator = function (typeStr) {
+    if (typeStr === "date" || typeStr === "datetime") {
+        return function (a, b) { return a.valueOf() - b.valueOf(); };
+    }
+    if (typeStr === "number") {
+        return function (a, b) { return a - b; };
+    }
+    return function (a, b) {
+        if (a < b) {
+            return -1;
+        }
+        if (a > b) {
+            return 1;
+        }
+        return 0;
+    };
+};
+var getRowComparator = function (comparator, fieldName) {
+    return function (rowA, rowB) { return comparator(rowA.data[fieldName], rowB.data[fieldName]); };
+};
+var useSortedRows = function (rows, cols, sortModel) {
+    var _a = useState(((sortModel === null || sortModel === void 0 ? void 0 : sortModel.type) === "uncontrolled" && sortModel.initialSortColDef) ||
+        null), internalSortColDef = _a[0], setInternalSortColDef = _a[1];
+    var sortColDef = (sortModel === null || sortModel === void 0 ? void 0 : sortModel.type) === "uncontrolled"
+        ? internalSortColDef
+        : (sortModel === null || sortModel === void 0 ? void 0 : sortModel.sortColDef) || undefined;
+    var setSortColDef = (sortModel === null || sortModel === void 0 ? void 0 : sortModel.type) === "uncontrolled"
+        ? setInternalSortColDef
+        : (sortModel === null || sortModel === void 0 ? void 0 : sortModel.setSortColDef) || undefined;
+    var sortingEnabled = !!sortModel;
+    var sortedRows = useMemo(function () {
+        if (!sortColDef) {
+            return rows;
+        }
+        var sortFieldName = sortColDef.name;
+        var sortOrder = sortColDef.order;
+        var sortColIndex = cols.findIndex(function (_a) {
+            var name = _a.name;
+            return name === sortFieldName;
+        });
+        if (sortColIndex < 0) {
+            throw new Error("The sortModel for the grid specifies that the data should be sorted based on a column named ".concat(sortFieldName, ", but it was not found among the column definitions."));
+        }
+        var typeStr = cols[sortColIndex].type;
+        var ascComparator = getTypeComparator(typeStr);
+        var rowComparator = getRowComparator(ascComparator, sortFieldName);
+        if (sortOrder === "desc") {
+            var descComparator = function (a, b) {
+                return ascComparator(a, b) * -1;
+            };
+            rowComparator = getRowComparator(descComparator, sortFieldName);
+        }
+        return rows.slice().sort(rowComparator);
+    }, [sortColDef, cols, rows]);
+    return { sortedRows: sortedRows, sortingEnabled: sortingEnabled, sortColDef: sortColDef, setSortColDef: setSortColDef };
+};
+export default useSortedRows;

package/grid/pipeline/useGetInputStrSubmitCallback.d.ts

@@ -0,0 +1,5 @@
+import { ColDefBase, RowId } from "../types";
+import { EditModel } from "../editing/types";
+export type UseGetInputStrSubmitCallbackHook = ((id: RowId) => (inputStrs: string[]) => void) | undefined;
+declare const useGetInputStrSubmitCallback: (editModel: EditModel | undefined, cols: ColDefBase[]) => UseGetInputStrSubmitCallbackHook;
+export default useGetInputStrSubmitCallback;

package/grid/pipeline/useGetInputStrSubmitCallback.js

@@ -0,0 +1,13 @@
+import inputStrsToRowData from "../editing/inputStrsToRowData";
+var useGetInputStrSubmitCallback = function (editModel, cols) {
+    var getInputStrSubmitCallback = editModel &&
+        (function (id) {
+            var idSpecificCallback = editModel.getUpdateCallback(id);
+            return function (inputStrs) {
+                var rowData = inputStrsToRowData(cols, inputStrs);
+                idSpecificCallback(rowData);
+            };
+        });
+    return getInputStrSubmitCallback;
+};
+export default useGetInputStrSubmitCallback;

package/grid/pipeline/useGridSelectionFns.d.ts

@@ -0,0 +1,16 @@
+import { RowDef, RowId } from "../types";
+import { MouseEventHandler } from "react";
+import { SelectionInfo, SelectModel } from "../selection/types";
+import { SelectionInputModel } from "../selection/SelectionInput";
+export interface UseGridSelectionFnsHook {
+    selectedSet: Set<RowId>;
+    rowsAreSelectable: boolean | undefined;
+    selectionInfo: SelectionInfo | null;
+    selectAllOnClick: () => void;
+    getSelectHandler: (index: RowId) => () => void;
+    getSelectInputModel: (id: RowId, selectModel: SelectModel) => SelectionInputModel;
+    getRowClickHandler: (index: RowId) => MouseEventHandler<HTMLTableRowElement>;
+    getAriaSelectedValue: (id: RowId) => "true" | "false" | undefined;
+}
+declare const useGridSelectionFns: (selectModel: SelectModel | undefined, rows: RowDef[]) => UseGridSelectionFnsHook;
+export default useGridSelectionFns;

package/grid/pipeline/useGridSelectionFns.js

@@ -0,0 +1,131 @@
+import { useCallback, useId, useMemo } from "react";
+import isSubset from "../util/isSubset";
+var useGridSelectionFns = function (selectModel, rows) {
+    var selectionExists = useMemo(function () {
+        if (!selectModel) {
+            return false;
+        }
+        if (selectModel.type === "single") {
+            return selectModel.selected !== null;
+        }
+        return selectModel.selected.length > 0;
+    }, [selectModel]);
+    var selectAllOnClick = useCallback(function () {
+        if (!selectModel) {
+            return;
+        }
+        if (selectionExists && selectModel.type === "single") {
+            selectModel.setSelected(null);
+            return;
+        }
+        if (selectionExists && selectModel.type === "multi") {
+            selectModel.setSelected([]);
+            return;
+        }
+        if (!selectionExists && selectModel.type === "multi") {
+            var allRowIndices = rows.map(function (_, index) { return index; });
+            selectModel.setSelected(allRowIndices);
+        }
+        // Button should be disabled in the case of selectionExists &&
+        // selectModel.type === "single", so function execution should never get
+        // to this point.
+    }, [rows, selectModel, selectionExists]);
+    var getSelectHandler = function (index) { return function () {
+        if (!selectModel) {
+            return;
+        }
+        if (selectModel.type === "single") {
+            selectModel.setSelected(index);
+            return;
+        }
+        selectModel.setSelected(selectModel.selected.concat(index));
+    }; };
+    var getDeselectHandler = function (index) { return function () {
+        if (!selectModel || selectModel.type === "single") {
+            return;
+        }
+        selectModel.setSelected(selectModel.selected.filter(function (num) { return num !== index; }));
+    }; };
+    // used to group radio buttons for selection
+    var gridId = useId();
+    var getSelectInputModel = function (id, selectModel) {
+        if (selectModel.type === "single") {
+            return {
+                type: "radio",
+                name: selectModel.groupName || gridId,
+            };
+        }
+        return {
+            type: "checkbox",
+            deselectCallback: getDeselectHandler(id),
+        };
+    };
+    var selectedSet = useMemo(function () {
+        var set = new Set();
+        if (selectModel && selectModel.type === "multi") {
+            selectModel.selected.forEach(function (value) { return set.add(value); });
+        }
+        if (selectModel &&
+            selectModel.type === "single" &&
+            selectModel.selected !== null) {
+            set.add(selectModel.selected);
+        }
+        return set;
+    }, [selectModel]);
+    var rowsAreSelectable = selectModel && selectModel.mode !== "column";
+    var selectionInfo = useMemo(function () {
+        if (!selectModel) {
+            return null;
+        }
+        if (selectModel.type === "single") {
+            return {
+                selectType: "single",
+                existingSelection: selectionExists,
+            };
+        }
+        var getMultiExistingSelection = function (selectionExists, rows) {
+            var rowIndices = rows.map(function (_, index) { return index; });
+            // Note that isFullSelection is true if there are no rows at all. In that case, the return value of this function
+            // should be "none", not "full".
+            var isFullSelection = isSubset(rowIndices, selectModel.selected);
+            if (!selectionExists) {
+                return "none";
+            }
+            if (isFullSelection) {
+                return "full";
+            }
+            return "partial";
+        };
+        return {
+            selectType: "multi",
+            existingSelection: getMultiExistingSelection(selectionExists, rows),
+        };
+    }, [selectModel, selectionExists, rows]);
+    var getRowClickHandler = function (index) { return function () {
+        if (!rowsAreSelectable) {
+            return;
+        }
+        if (selectedSet.has(index)) {
+            getDeselectHandler(index)();
+            return;
+        }
+        getSelectHandler(index)();
+    }; };
+    var getAriaSelectedValue = function (id) {
+        if (!selectModel) {
+            return undefined;
+        }
+        return String(selectedSet.has(id));
+    };
+    return {
+        selectedSet: selectedSet,
+        rowsAreSelectable: rowsAreSelectable,
+        selectionInfo: selectionInfo,
+        selectAllOnClick: selectAllOnClick,
+        getSelectHandler: getSelectHandler,
+        getSelectInputModel: getSelectInputModel,
+        getRowClickHandler: getRowClickHandler,
+        getAriaSelectedValue: getAriaSelectedValue,
+    };
+};
+export default useGridSelectionFns;

package/grid/pipeline/useUnwrappedGridStyles.d.ts

@@ -0,0 +1,7 @@
+import { AdditionalComponentsStyleModel, StyleModel, TableStyleModel } from "../styling/types";
+export interface UseUnwrappedGridStylesHook {
+    unwrappedTableModel: Required<TableStyleModel>;
+    unwrappedAdditionalStyleModel: Required<AdditionalComponentsStyleModel>;
+}
+declare const UseUnwrappedGridStyles: (styleModel: StyleModel | undefined) => UseUnwrappedGridStylesHook;
+export default UseUnwrappedGridStyles;

package/grid/pipeline/useUnwrappedGridStyles.js

@@ -0,0 +1,17 @@
+import { useMemo } from "react";
+import { unwrapAdditionalComponentsStyleModel, unwrapTableStyleModel, } from "../styling/styleModelUnwrappers";
+var UseUnwrappedGridStyles = function (styleModel) {
+    // To give the developer the ability to specify between removing existing styles
+    // and simply adding additional ones, we should migrate off of this "unwrapped"
+    // design over time and instead apply logic based on the original params that
+    // can be undefined.
+    var unwrappedTableModel = useMemo(function () { return unwrapTableStyleModel(styleModel === null || styleModel === void 0 ? void 0 : styleModel.mainTableStyleModel); }, [styleModel === null || styleModel === void 0 ? void 0 : styleModel.mainTableStyleModel]);
+    var unwrappedAdditionalStyleModel = useMemo(function () {
+        return unwrapAdditionalComponentsStyleModel(styleModel === null || styleModel === void 0 ? void 0 : styleModel.additionalComponentsStyleModel);
+    }, [styleModel === null || styleModel === void 0 ? void 0 : styleModel.additionalComponentsStyleModel]);
+    return {
+        unwrappedTableModel: unwrappedTableModel,
+        unwrappedAdditionalStyleModel: unwrappedAdditionalStyleModel,
+    };
+};
+export default UseUnwrappedGridStyles;

package/grid/selection/SelectAllHeaderCell.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties, FC } from "react";
+import { SelectionInfo } from "./types";
+interface SelectAllHeaderCellProps {
+    onClick: () => void;
+    selectionInfo: SelectionInfo;
+    totalRows: number;
+    additionalClasses?: string[];
+    style?: CSSProperties;
+}
+declare const SelectAllHeaderCell: FC<SelectAllHeaderCellProps>;
+export default SelectAllHeaderCell;

package/grid/selection/SelectAllHeaderCell.js

@@ -0,0 +1,55 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import classNames from "classnames";
+var getCheckboxState = function (selectionInfo, noRows) {
+    var disabledState = {
+        indeterminate: false,
+        checked: false,
+        disabled: true,
+        description: "Select all (disabled)",
+    };
+    if (noRows) {
+        return disabledState;
+    }
+    var existingSelection = selectionInfo.existingSelection;
+    if (existingSelection === "full") {
+        return {
+            indeterminate: false,
+            checked: true,
+            disabled: false,
+            description: "Deselect all rows",
+        };
+    }
+    if (existingSelection === true || existingSelection === "partial") {
+        return {
+            indeterminate: true,
+            checked: true,
+            disabled: false,
+            description: "Deselect all rows",
+        };
+    }
+    if (existingSelection === "none") {
+        return {
+            indeterminate: false,
+            checked: false,
+            disabled: false,
+            description: "Select all rows",
+        };
+    }
+    // single select mode and none selected
+    return disabledState;
+};
+var SelectAllHeaderCell = function (_a) {
+    var onClick = _a.onClick, selectionInfo = _a.selectionInfo, totalRows = _a.totalRows, additionalClasses = _a.additionalClasses, style = _a.style;
+    var noRows = totalRows === 0;
+    var _b = getCheckboxState(selectionInfo, noRows), indeterminate = _b.indeterminate, checked = _b.checked, disabled = _b.disabled, description = _b.description;
+    var ref = useRef(null);
+    useEffect(function () {
+        ref.current.indeterminate = indeterminate;
+    }, [indeterminate]);
+    return (_jsx("th", { style: style, "aria-colindex": 1, title: description, "aria-description": description, className: classNames({
+            "btn-primary": !additionalClasses || additionalClasses.length === 0,
+        }, additionalClasses || []), children: _jsx("input", { type: "checkbox", checked: checked, ref: ref, disabled: disabled, "aria-label": description, onChange: onClick }) }));
+};
+export default SelectAllHeaderCell;

package/grid/selection/SelectionInput.d.ts

@@ -0,0 +1,19 @@
+import { FC } from "react";
+export interface RadioSelectionInputModel {
+    type: "radio";
+    name: string;
+}
+export interface CheckboxSelectionInputModel {
+    type: "checkbox";
+    deselectCallback: () => void;
+    name?: string;
+}
+export type SelectionInputModel = RadioSelectionInputModel | CheckboxSelectionInputModel;
+export interface SelectionInputProps {
+    selected: boolean;
+    selectionInputModel: SelectionInputModel;
+    selectCallback: () => void;
+    additionalClasses?: string[];
+}
+declare const SelectionInput: FC<SelectionInputProps>;
+export default SelectionInput;

package/grid/selection/SelectionInput.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import classNames from "classnames";
+var SelectionInput = function (_a) {
+    var selectionInputModel = _a.selectionInputModel, selected = _a.selected, selectCallback = _a.selectCallback, additionalClasses = _a.additionalClasses;
+    var type = selectionInputModel.type;
+    var onChange = function (_a) {
+        var checked = _a.target.checked;
+        // theoretically, a radio button shouldn't become unchecked so the below
+        // check of the "type" variable is not needed except for narrowing the
+        // type of the "selectionInputModel"
+        if (!checked && type === "checkbox") {
+            selectionInputModel.deselectCallback();
+            return;
+        }
+        if (checked) {
+            selectCallback();
+        }
+    };
+    return (_jsx("input", { className: classNames(additionalClasses || []), "aria-label": "Input to select the current row", onClick: function (event) {
+            event.stopPropagation();
+        }, type: type, checked: selected, onChange: onChange, name: selectionInputModel.name }));
+};
+export default SelectionInput;

package/grid/selection/types.d.ts

@@ -0,0 +1,30 @@
+import { RowId } from "../types";
+export type SelectMode = "column" | "row" | "both";
+export type SelectType = "single" | "multi";
+interface BaseSelectModel {
+    mode: SelectMode;
+    selectColWidth?: number;
+}
+export type MultiSelectModel = BaseSelectModel & {
+    type: "multi";
+    selected: RowId[];
+    setSelected: (selected: RowId[]) => void;
+};
+export type SingleSelectModel = BaseSelectModel & {
+    type: "single";
+    selected: RowId | null;
+    setSelected: (selected: RowId | null) => void;
+    groupName?: string;
+};
+export type SelectModel = SingleSelectModel | MultiSelectModel;
+export type MultiExistingSelection = "full" | "partial" | "none";
+export interface SingleSelectionInfo {
+    selectType: "single";
+    existingSelection: boolean;
+}
+export interface MultiSelectionInfo {
+    selectType: "multi";
+    existingSelection: "full" | "partial" | "none";
+}
+export type SelectionInfo = SingleSelectionInfo | MultiSelectionInfo;
+export {};

package/grid/selection/types.js

@@ -0,0 +1,4 @@
+// Selected indices are based on the id of the input rows. If
+// filtered-out items are included in the 'selected' property, there will be a
+// visual indication to the user of that fact.
+export {};

package/grid/sorting/arrowPlaceholder.d.ts

@@ -0,0 +1,2 @@
+declare const arrowPlaceholder: import("react/jsx-runtime").JSX.Element;
+export default arrowPlaceholder;

package/grid/sorting/arrowPlaceholder.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Temporary solution to prevent column widths from changing when hovering over
+// columns with a mouse.
+// More ideal permanent solution would be to fix column widths based on preset
+// values.
+var arrowPlaceholder = (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentColor", viewBox: "0 0 16 16", children: [_jsx("title", { children: "(not being sorted)" }), _jsx("desc", { children: "Empty transparent square for styling purposes" })] }));
+export default arrowPlaceholder;

package/grid/sorting/downArrow.d.ts

@@ -0,0 +1,2 @@
+declare const downArrow: import("react/jsx-runtime").JSX.Element;
+export default downArrow;

package/grid/sorting/downArrow.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+var downArrow = (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentColor", viewBox: "0 0 16 16", children: [_jsx("title", { children: "(sorted descending)" }), _jsx("desc", { children: "Down arrow indicating that the column is being sorted in an descending manner" }), _jsx("path", { fillRule: "evenodd", d: "M8 1a.5.5 0 0 1 .5.5v11.793l3.146-3.147a.5.5 0 0 1 .708.708l-4 4a.5.5 0 0 1-.708 0l-4-4a.5.5 0 0 1 .708-.708L7.5 13.293V1.5A.5.5 0 0 1 8 1" })] }));
+export default downArrow;

package/grid/sorting/types.d.ts

@@ -0,0 +1,19 @@
+export type SortOrder = "asc" | "desc";
+export interface SortColDef {
+    name: string;
+    order: SortOrder;
+}
+export interface ColSortModel {
+    sortOrder: SortOrder | null;
+    setSortOrder: (order: SortOrder | null) => void;
+}
+export interface ControlledTableSortModel {
+    type?: "controlled";
+    sortColDef: SortColDef | null;
+    setSortColDef: (sortColDef: SortColDef | null) => void;
+}
+export interface UncontrolledTableSortModel {
+    type: "uncontrolled";
+    initialSortColDef: SortColDef | null;
+}
+export type TableSortModel = ControlledTableSortModel | UncontrolledTableSortModel;

package/grid/sorting/types.js

@@ -0,0 +1 @@
+export {};

package/grid/sorting/upArrow.d.ts

@@ -0,0 +1,2 @@
+declare const upArrow: (grayed: boolean) => import("react/jsx-runtime").JSX.Element;
+export default upArrow;

package/grid/sorting/upArrow.js

@@ -0,0 +1,13 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import classNames from "classnames";
+var upArrow = function (grayed) { return (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentColor", className: classNames(__spreadArray([], (grayed ? ["text-body-secondary"] : []), true)), viewBox: "0 0 16 16", children: [!grayed && (_jsxs(_Fragment, { children: [_jsx("title", { children: "(sorted ascending)" }), _jsx("desc", { children: "Up arrow indicating that the column is being sorted in an ascending manner" })] })), _jsx("path", { fillRule: "evenodd", d: "M8 15a.5.5 0 0 0 .5-.5V2.707l3.146 3.147a.5.5 0 0 0 .708-.708l-4-4a.5.5 0 0 0-.708 0l-4 4a.5.5 0 1 0 .708.708L7.5 2.707V14.5a.5.5 0 0 0 .5.5" })] })); };
+export default upArrow;

package/grid/styling/styleModelUnwrappers.d.ts

@@ -0,0 +1,4 @@
+import { AdditionalComponentsStyleModel, FilterInputTableStyleModel, TableStyleModel } from "./types";
+export declare const unwrapTableStyleModel: (tableStyleModel: TableStyleModel | undefined) => Required<TableStyleModel>;
+export declare const unwrapFilterInputTableStyleModel: (filterTableStyleModel: FilterInputTableStyleModel | undefined) => Required<FilterInputTableStyleModel>;
+export declare const unwrapAdditionalComponentsStyleModel: (styleModel: AdditionalComponentsStyleModel | undefined) => Required<AdditionalComponentsStyleModel>;

package/grid/styling/styleModelUnwrappers.js

@@ -0,0 +1,58 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var unwrapSharedStyleModel = function (sharedStyleModel) { return ({
+    table: (sharedStyleModel === null || sharedStyleModel === void 0 ? void 0 : sharedStyleModel.table) || [],
+    tbody: (sharedStyleModel === null || sharedStyleModel === void 0 ? void 0 : sharedStyleModel.tbody) || [],
+    thead: (sharedStyleModel === null || sharedStyleModel === void 0 ? void 0 : sharedStyleModel.thead) || [],
+    theadTr: (sharedStyleModel === null || sharedStyleModel === void 0 ? void 0 : sharedStyleModel.theadTr) || [],
+    theadTh: (sharedStyleModel === null || sharedStyleModel === void 0 ? void 0 : sharedStyleModel.theadTh) ? sharedStyleModel.theadTh : function () { return []; },
+    caption: (sharedStyleModel === null || sharedStyleModel === void 0 ? void 0 : sharedStyleModel.caption) || [],
+}); };
+export var unwrapTableStyleModel = function (tableStyleModel) { return (__assign(__assign({}, unwrapSharedStyleModel(tableStyleModel)), { tbodyTr: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.tbodyTr) ? tableStyleModel.tbodyTr : function () { return []; }, tbodyTd: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.tbodyTd) ? tableStyleModel.tbodyTd : function () { return []; }, tbodyTdInput: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.tbodyTdInput)
+        ? tableStyleModel.tbodyTdInput
+        : function () { return []; }, editColTh: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.editColTh) || [], editColTd: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.editColTd) ? tableStyleModel.editColTd : function () { return []; }, editCancelButton: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.editCancelButton)
+        ? tableStyleModel.editCancelButton
+        : function () { return []; }, editDeleteButton: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.editDeleteButton)
+        ? tableStyleModel.editDeleteButton
+        : function () { return []; }, editSaveButton: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.editSaveButton)
+        ? tableStyleModel.editSaveButton
+        : function () { return []; }, editStartButton: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.editStartButton)
+        ? tableStyleModel.editStartButton
+        : function () { return []; }, rowSelectColTh: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.rowSelectColTh) || [], rowSelectColTd: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.rowSelectColTd)
+        ? tableStyleModel.rowSelectColTd
+        : function () { return []; }, rowSelectInput: (tableStyleModel === null || tableStyleModel === void 0 ? void 0 : tableStyleModel.rowSelectInput)
+        ? tableStyleModel.rowSelectInput
+        : function () { return []; } })); };
+export var unwrapFilterInputTableStyleModel = function (filterTableStyleModel) { return (__assign(__assign({}, unwrapSharedStyleModel(filterTableStyleModel)), { tbodyTr: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.tbodyTr)
+        ? filterTableStyleModel.tbodyTr
+        : function () { return []; }, tbodyTd: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.tbodyTd)
+        ? filterTableStyleModel.tbodyTd
+        : function () { return []; }, enablementInput: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.enablementInput)
+        ? filterTableStyleModel.enablementInput
+        : function () { return []; }, schemeSelectionInput: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.schemeSelectionInput)
+        ? filterTableStyleModel.schemeSelectionInput
+        : function () { return []; }, searchStringInput: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.searchStringInput)
+        ? filterTableStyleModel.searchStringInput
+        : function () { return []; }, numberInput: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.numberInput)
+        ? filterTableStyleModel.numberInput
+        : function () { return []; }, startDateInput: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.startDateInput)
+        ? filterTableStyleModel.startDateInput
+        : function () { return []; }, endDateInput: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.endDateInput)
+        ? filterTableStyleModel.endDateInput
+        : function () { return []; }, submitButton: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.submitButton) || [], form: (filterTableStyleModel === null || filterTableStyleModel === void 0 ? void 0 : filterTableStyleModel.form) || [] })); };
+export var unwrapAdditionalComponentsStyleModel = function (styleModel) { return ({
+    topLevelDiv: (styleModel === null || styleModel === void 0 ? void 0 : styleModel.topLevelDiv) || [],
+    filterInputsDiv: (styleModel === null || styleModel === void 0 ? void 0 : styleModel.filterInputsDiv) || [],
+    tableAndPaginationDiv: (styleModel === null || styleModel === void 0 ? void 0 : styleModel.tableAndPaginationDiv) || [],
+    filterUiToggleButton: (styleModel === null || styleModel === void 0 ? void 0 : styleModel.filterUiToggleButton) || [],
+    paginationUiDiv: (styleModel === null || styleModel === void 0 ? void 0 : styleModel.paginationUiDiv) || [],
+}); };