adore-datatable 2.0.0

package/src/style.css

@@ -0,0 +1,304 @@
+:root {
+    --dt-border-color: #d1d8dd;
+    --dt-primary-color: rgb(82, 146, 247);
+    --dt-light-bg: #f5f7fa;
+    --dt-light-red: #FD8B8B;
+    --dt-light-yellow: #fffce7;
+    --dt-orange: rgb(255, 160, 10);
+    --dt-text-color: #000000;
+    --dt-text-light: #dfe2e5;
+    --dt-spacer-1: 0.25rem;
+    --dt-spacer-2: 0.5rem;
+    --dt-spacer-3: 1rem;
+    --dt-border-radius: 3px;
+    --dt-cell-bg: #fff;
+    --dt-focus-border-width: 2px;
+    --dt-selection-highlight-color: var(--dt-light-yellow);
+    --dt-toast-message-border: none;
+    --dt-header-cell-bg: var(--dt-cell-bg);
+    --dt-no-data-message-width: 90px;
+}
+
+.datatable {
+    *, *::after, *::before {
+        box-sizing: border-box;
+    }
+}
+
+.datatable {
+    position: relative;
+    overflow: hidden;
+}
+
+.dt-scrollable {
+    height: 40vw;
+    overflow: auto;
+    border-top: 2px solid var(--dt-border-color);
+
+    &--highlight-all {
+        background-color: var(--dt-selection-highlight-color);
+    }
+
+    &__no-data {
+        text-align: center;
+        padding: var(--dt-spacer-3);
+        border-left: 1px solid var(--dt-border-color);
+        border-right: 1px solid var(--dt-border-color);
+        .no-data-message{
+            position: absolute;
+            top: 100px; 
+            left: 50px;
+            border: none;
+            width: var(--dt-no-data-message-width);
+    }
+    }
+}
+
+.dt-row {
+    display: flex;
+
+    &--highlight .dt-cell {
+        background-color: var(--dt-selection-highlight-color);
+    }
+
+    &--unhighlight .dt-cell {
+        background-color: var(--dt-cell-bg);
+    }
+
+    &--hide {
+        display: none;
+    }
+
+    &:last-child:not(.dt-row-filter) {
+        border-bottom: 1px solid var(--dt-border-color);
+    }
+}
+
+.dt-cell {
+    border: 1px solid var(--dt-border-color);
+    border-bottom: none;
+    border-right: none;
+    position: relative;
+    outline: none;
+    padding: 0;
+    background-color: var(--dt-cell-bg);
+    color: var(--dt-text-color);
+    /*
+     Fix for firefox and Edge
+     https://stackoverflow.com/a/16337203
+     firefox paints td background over border
+    */
+    background-clip: padding-box;
+    user-select: none;
+
+    &__content {
+        padding: var(--dt-spacer-2);
+        border: var(--dt-focus-border-width) solid transparent;
+        height: 100%;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+        overflow: hidden;
+    }
+
+    &__edit {
+        display: none;
+        padding: var(--dt-spacer-2);
+        background-color: var(--dt-cell-bg);
+        border: var(--dt-focus-border-width) solid var(--dt-orange);
+        z-index: 1;
+        height: 100%;
+    }
+
+    &__resize-handle {
+        opacity: 0;
+        position: absolute;
+        right: -3px;
+        top: 0;
+        width: 5px;
+        height: 100%;
+        cursor: col-resize;
+        z-index: 1;
+    }
+
+    &--editing &__content {
+        display: none;
+    }
+
+    &--editing &__edit {
+        display: block;
+    }
+
+    &--focus &__content {
+        border-color: var(--dt-primary-color);
+    }
+
+    &--highlight {
+        background-color: var(--dt-light-bg);
+    }
+
+    &--dragging {
+        background-color: var(--dt-light-bg);
+    }
+
+    &--header {
+        background-color: var(--dt-header-cell-bg);
+    }
+
+    &--header:last-child {
+        border-right: 1px solid var(--dt-border-color);
+    }
+
+    &--header &__content {
+        padding-right: var(--dt-spacer-3);
+        font-weight: bold;
+    }
+
+    &--header:hover .dt-dropdown__toggle {
+        opacity: 1;
+    }
+
+    &--tree-close {
+        .icon-open {
+            display: none;
+        }
+
+        .icon-close {
+            display: flex;
+        }
+    }
+
+    &:last-child {
+        border-right: 1px solid var(--dt-border-color);
+    }
+}
+
+.datatable[dir=rtl] .dt-cell__resize-handle {
+    right: unset;
+    left: -3px;
+}
+
+.icon-open, .icon-close {
+    width: 16px;
+    height: 16px;
+}
+
+.icon-open {
+    display: flex;
+}
+
+.icon-close {
+    display: none;
+}
+
+.dt-dropdown {
+    position: absolute;
+    right: 10px;
+    display: inline-flex;
+    vertical-align: top;
+    text-align: left;
+    font-weight: normal;
+    cursor: pointer;
+
+    &__toggle {
+        opacity: 0;
+        background-color: var(--dt-header-cell-bg);
+    }
+
+    &__list {
+        position: fixed;
+        min-width: 8rem;
+        z-index: 1;
+        cursor: pointer;
+        background-color: var(--dt-cell-bg);
+        border-radius: var(--dt-border-radius);
+        padding: var(--dt-spacer-2) 0;
+        box-shadow: 0 2px 3px rgba(10, 10, 10, 0.1), 0 0 0 1px rgba(10, 10, 10, 0.1);
+    }
+
+    &__list-item {
+        padding: var(--dt-spacer-2) var(--dt-spacer-3);
+
+        &:hover {
+            background-color: var(--dt-light-bg);
+        }
+    }
+
+    &--active &__list {
+        display: block;
+    }
+}
+
+.dt-tree-node {
+    display: flex;
+    align-items: center;
+    position: relative;
+
+    &__toggle {
+        display: inline-block;
+        cursor: pointer;
+        margin-right: 0.2rem;
+    }
+}
+
+.dt-toast {
+    position: absolute;
+    bottom: var(--dt-spacer-3);
+    left: 50%;
+    transform: translateX(-50%);
+
+    &__message {
+        display: inline-block;
+        background-color: rgba(0, 0, 0, 0.8);
+        color: var(--dt-text-light);
+        border-radius: var(--dt-border-radius);
+        padding: var(--dt-spacer-2) var(--dt-spacer-3);
+        border: var(--dt-toast-message-border);
+    }
+}
+
+.dt-input {
+    outline: none;
+    width: 100%;
+    border: none;
+    overflow: visible;
+    font-family: inherit;
+    font-size: inherit;
+    line-height: inherit;
+    background-color: inherit;
+    color: inherit;
+    margin: 0;
+    padding: 0;
+}
+
+.dt-freeze {
+    display: flex;
+    justify-content: center;
+    align-content: center;
+    position: absolute;
+    left: 0;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    background-color: var(--dt-light-bg);
+    opacity: 0.5;
+    font-size: 2em;
+
+    &__message {
+        position: absolute;
+        top: 50%;
+        transform: translateY(-50%);
+    }
+}
+
+.dt-paste-target {
+    position: fixed;
+    left: -999em;
+}
+
+.dt-hidden{
+    display: none;
+}
+
+body.dt-resize {
+    cursor: col-resize;
+}

package/src/style.js

@@ -0,0 +1,379 @@
+import $ from './dom';
+import {
+    camelCaseToDash,
+    linkProperties,
+    throttle
+} from './utils';
+
+export default class Style {
+    constructor(instance) {
+        this.instance = instance;
+
+        linkProperties(this, this.instance, [
+            'options', 'datamanager', 'columnmanager',
+            'header', 'footer', 'bodyScrollable', 'datatableWrapper',
+            'getColumn', 'bodyRenderer'
+        ]);
+
+        this.scopeClass = 'dt-instance-' + instance.constructor.instances;
+        instance.datatableWrapper.classList.add(this.scopeClass);
+
+        const styleEl = document.createElement('style');
+        instance.wrapper.insertBefore(styleEl, instance.datatableWrapper);
+        this.styleEl = styleEl;
+
+        this.bindResizeWindow();
+        this.bindScrollHeader();
+    }
+
+    get stylesheet() {
+        return this.styleEl.sheet;
+    }
+
+    bindResizeWindow() {
+        this.onWindowResize = this.onWindowResize.bind(this);
+        this.onWindowResize = throttle(this.onWindowResize, 300);
+
+        if (this.options.layout === 'fluid') {
+            $.on(window, 'resize', this.onWindowResize);
+        }
+    }
+
+    bindScrollHeader() {
+        this._settingHeaderPosition = false;
+
+        $.on(this.bodyScrollable, 'scroll', (e) => {
+            if (this._settingHeaderPosition) return;
+
+            this._settingHeaderPosition = true;
+
+            requestAnimationFrame(() => {
+                const left = -e.target.scrollLeft;
+
+                $.style(this.header, {
+                    transform: `translateX(${left}px)`
+                });
+                $.style(this.footer, {
+                    transform: `translateX(${left}px)`
+                });
+                this._settingHeaderPosition = false;
+                if (this.instance.noData) {
+                    $.style($('.no-data-message'), {
+                        left: `${this.instance.wrapper.clientWidth / 2 - (left)}px`
+                    });
+                }
+                this._settingHeaderPosition = false;
+            });
+        });
+    }
+
+    onWindowResize() {
+        this.distributeRemainingWidth();
+        this.refreshColumnWidth();
+        this.setBodyStyle();
+    }
+
+    destroy() {
+        this.styleEl.remove();
+        $.off(window, 'resize', this.onWindowResize);
+    }
+
+    setStyle(selector, styleObject) {
+        if (selector.includes(',')) {
+            selector.split(',')
+                .map(s => s.trim())
+                .forEach(selector => {
+                    this.setStyle(selector, styleObject);
+                });
+            return;
+        }
+
+        selector = selector.trim();
+        if (!selector) return;
+
+        this._styleRulesMap = this._styleRulesMap || {};
+        const prefixedSelector = this._getPrefixedSelector(selector);
+
+        if (this._styleRulesMap[prefixedSelector]) {
+            this.removeStyle(selector);
+
+            // merge with old styleobject
+            styleObject = Object.assign({}, this._styleRulesMap[prefixedSelector], styleObject);
+        }
+
+        const styleString = this._getRuleString(styleObject);
+        const ruleString = `${prefixedSelector} { ${styleString} }`;
+
+        this._styleRulesMap[prefixedSelector] = styleObject;
+        this.stylesheet.insertRule(ruleString);
+    }
+
+    removeStyle(selector) {
+        if (selector.includes(',')) {
+            selector.split(',')
+                .map(s => s.trim())
+                .forEach(selector => {
+                    this.removeStyle(selector);
+                });
+            return;
+        }
+
+        selector = selector.trim();
+        if (!selector) return;
+
+        // find and remove
+        const prefixedSelector = this._getPrefixedSelector(selector);
+        const index = Array.from(this.stylesheet.cssRules)
+            .findIndex(rule => rule.selectorText === prefixedSelector);
+
+        if (index === -1) return;
+        this.stylesheet.deleteRule(index);
+    }
+
+    _getPrefixedSelector(selector) {
+        return `.${this.scopeClass} ${selector}`;
+    }
+
+    _getRuleString(styleObject) {
+        return Object.keys(styleObject)
+            .map(prop => {
+                let dashed = prop;
+                if (!prop.includes('-')) {
+                    dashed = camelCaseToDash(prop);
+                }
+                return `${dashed}:${styleObject[prop]};`;
+            })
+            .join('');
+    }
+
+    setDimensions() {
+        this.setCellHeight();
+        this.setupMinWidth();
+        this.setupNaturalColumnWidth();
+        this.setupColumnWidth();
+        this.distributeRemainingWidth();
+        this.setColumnStyle();
+        this.setBodyStyle();
+    }
+
+    setCellHeight() {
+        this.setStyle('.dt-cell', {
+            height: this.options.cellHeight + 'px'
+        });
+    }
+
+    setupMinWidth() {
+        $.each('.dt-cell--header', this.header).map(col => {
+            const { colIndex } = $.data(col);
+            const column = this.getColumn(colIndex);
+
+            if (!column.minWidth) {
+                const width = $.style($('.dt-cell__content', col), 'width');
+                // only set this once
+                column.minWidth = width;
+            }
+        });
+    }
+
+    setupNaturalColumnWidth() {
+        if (!$('.dt-row')) return;
+
+        $.each('.dt-row-header .dt-cell', this.header).map($headerCell => {
+            const { colIndex } = $.data($headerCell);
+            const column = this.datamanager.getColumn(colIndex);
+            let width = $.style($('.dt-cell__content', $headerCell), 'width');
+            if (typeof width === 'number' && width >= this.options.minimumColumnWidth) {
+                column.naturalWidth = width;
+            } else {
+                column.naturalWidth = this.options.minimumColumnWidth;
+            }
+        });
+
+        // set initial width as naturally calculated by table's first row
+        $.each('.dt-row-0 .dt-cell', this.bodyScrollable).map($cell => {
+            const {
+                colIndex
+            } = $.data($cell);
+            const column = this.datamanager.getColumn(colIndex);
+
+            let naturalWidth = $.style($('.dt-cell__content', $cell), 'width');
+
+            if (typeof naturalWidth === 'number' && naturalWidth >= column.naturalWidth) {
+                column.naturalWidth = naturalWidth;
+            } else {
+                column.naturalWidth = column.naturalWidth;
+            }
+        });
+    }
+
+    setupColumnWidth() {
+        if (this.options.layout === 'ratio') {
+            let totalWidth = $.style(this.datatableWrapper, 'width');
+
+            if (this.options.serialNoColumn) {
+                const rowIndexColumn = this.datamanager.getColumnById('_rowIndex');
+                totalWidth = totalWidth - rowIndexColumn.width - 1;
+            }
+
+            if (this.options.checkboxColumn) {
+                const rowIndexColumn = this.datamanager.getColumnById('_checkbox');
+                totalWidth = totalWidth - rowIndexColumn.width - 1;
+            }
+
+            const totalParts = this.datamanager.getColumns()
+                .map(column => {
+                    if (column.id === '_rowIndex' || column.id === '_checkbox') {
+                        return 0;
+                    }
+                    if (!column.width) {
+                        column.width = 1;
+                    }
+                    column.ratioWidth = parseInt(column.width, 10);
+                    return column.ratioWidth;
+                })
+                .reduce((a, c) => a + c);
+
+            const onePart = totalWidth / totalParts;
+
+            this.datamanager.getColumns()
+                .map(column => {
+                    if (column.id === '_rowIndex' || column.id === '_checkbox') return;
+                    column.width = Math.floor(onePart * column.ratioWidth) - 1;
+                });
+        } else {
+            this.datamanager.getColumns()
+                .map(column => {
+                    if (!column.width) {
+                        column.width = column.naturalWidth;
+                    }
+                    if (column.id === '_rowIndex') {
+                        column.width = this.getRowIndexColumnWidth();
+                    }
+                    if (column.width < this.options.minimumColumnWidth) {
+                        column.width = this.options.minimumColumnWidth;
+                    }
+                });
+        }
+    }
+
+    distributeRemainingWidth() {
+        if (this.options.layout !== 'fluid') return;
+
+        const wrapperWidth = $.style(this.instance.datatableWrapper, 'width');
+        let firstRow = $('.dt-row', this.bodyScrollable);
+        let firstRowWidth = wrapperWidth;
+        if (!firstRow) {
+            let headerRow = $('.dt-row', this.instance.header);
+            let cellWidths = Array.from(headerRow.children)
+                .map(cell => cell.offsetWidth);
+            firstRowWidth = cellWidths.reduce((sum, a) => sum + a, 0);
+        } else {
+            firstRowWidth = $.style(firstRow, 'width');
+        }
+        const resizableColumns = this.datamanager.getColumns().filter(col => col.resizable);
+        const deltaWidth = (wrapperWidth - firstRowWidth) / resizableColumns.length;
+
+        resizableColumns.map(col => {
+            const width = $.style(this.getColumnHeaderElement(col.colIndex), 'width');
+            let finalWidth = Math.floor(width + deltaWidth) - 2;
+
+            this.datamanager.updateColumn(col.colIndex, {
+                width: finalWidth
+            });
+        });
+    }
+
+    setColumnStyle() {
+        // align columns
+        this.datamanager.getColumns()
+            .map(column => {
+                // alignment
+                if (!column.align) {
+                    column.align = 'left';
+                }
+                if (!['left', 'center', 'right'].includes(column.align)) {
+                    column.align = 'left';
+                }
+                this.setStyle(`.dt-cell--col-${column.colIndex}`, {
+                    'text-align': column.align
+                });
+
+                // width
+                this.columnmanager.setColumnHeaderWidth(column.colIndex);
+                this.columnmanager.setColumnWidth(column.colIndex);
+            });
+    }
+
+    refreshColumnWidth() {
+        this.datamanager.getColumns()
+            .map(column => {
+                this.columnmanager.setColumnHeaderWidth(column.colIndex);
+                this.columnmanager.setColumnWidth(column.colIndex);
+            });
+    }
+
+    setBodyStyle() {
+        const bodyWidth = $.style(this.datatableWrapper, 'width');
+        const firstRow = $('.dt-row', this.bodyScrollable);
+        if (!firstRow) return;
+        const rowWidth = $.style(firstRow, 'width');
+
+        let width = bodyWidth > rowWidth ? rowWidth + 10 : bodyWidth;
+        $.style(this.bodyScrollable, {
+            width: width + 'px'
+        });
+
+        // remove the body height, so that it resets to it's original
+        $.removeStyle(this.bodyScrollable, 'height');
+
+        // when there are less rows than the container
+        // adapt the container height
+        let bodyHeight = $.getStyle(this.bodyScrollable, 'height');
+        const scrollHeight = (this.bodyRenderer.hyperlist || {})._scrollHeight || Infinity;
+        const hasHorizontalOverflow = $.hasHorizontalOverflow(this.bodyScrollable);
+
+        let height;
+
+        if (scrollHeight < bodyHeight) {
+            height = scrollHeight;
+
+            // account for scrollbar size when
+            // there is horizontal overflow
+            if (hasHorizontalOverflow) {
+                height += $.scrollbarSize();
+            }
+
+            $.style(this.bodyScrollable, {
+                height: height + 'px'
+            });
+        }
+
+        const verticalOverflow = this.bodyScrollable.scrollHeight - this.bodyScrollable.offsetHeight;
+        if (verticalOverflow < $.scrollbarSize()) {
+            // if verticalOverflow is less than scrollbar size
+            // then most likely scrollbar is causing the scroll
+            // which is not needed
+            $.style(this.bodyScrollable, {
+                overflowY: 'hidden'
+            });
+        }
+
+        if (this.options.layout === 'fluid') {
+            $.style(this.bodyScrollable, {
+                overflowX: 'hidden'
+            });
+        }
+    }
+
+    getColumnHeaderElement(colIndex) {
+        colIndex = +colIndex;
+        if (colIndex < 0) return null;
+        return $(`.dt-cell--col-${colIndex}`, this.header);
+    }
+
+    getRowIndexColumnWidth() {
+        const rowCount = this.datamanager.getRowCount();
+        const padding = 22;
+        return $.measureTextWidth(rowCount + '') + padding;
+    }
+}

package/src/translationmanager.js

@@ -0,0 +1,30 @@
+import { format } from './utils';
+import getTranslations from './translations';
+
+export default class TranslationManager {
+    constructor(language) {
+        this.language = language;
+        this.translations = getTranslations();
+    }
+
+    addTranslations(translations) {
+        this.translations = Object.assign(this.translations, translations);
+    }
+
+    translate(sourceText, args) {
+        let translation = (this.translations[this.language] &&
+            this.translations[this.language][sourceText]) || sourceText;
+
+        if (typeof translation === 'object') {
+            translation = args && args.count ?
+                this.getPluralizedTranslation(translation, args.count) :
+                sourceText;
+        }
+
+        return format(translation, args || {});
+    }
+
+    getPluralizedTranslation(translations, count) {
+        return translations[count] || translations['default'];
+    }
+};