neo.mjs 6.17.2 → 6.18.1

package/src/calendar/view/week/Component.mjs

@@ -256,12 +256,11 @@ class Component extends BaseComponent {
      * @param {Boolean} [silent=false]
      */
     adjustTotalHeight(data, silent=false) {
-        let me          = this,
-            rowHeight   = data.rowHeight,
-            rowsPerItem = data.rowsPerItem,
-            height      = data.totalHeight - rowHeight,
-            i           = 0,
-            gradient    = [];
+        let me                       = this,
+            {rowHeight, rowsPerItem} = data,
+            height                   = data.totalHeight - rowHeight,
+            i                        = 0,
+            gradient                 = [];
 
         for (; i < rowsPerItem; i++) {
             gradient.push(
@@ -355,27 +354,24 @@ class Component extends BaseComponent {
      * @protected
      */
     afterSetEnableDrag(value, oldValue) {
-        let me = this;
-
-        if (value && !me.getPlugin({flag: 'dragdrop'})) {
+        if (value && !this.getPlugin('calendar-week-dragdrop')) {
             Promise.all([
                 import('./plugin/DragDrop.mjs'),
                 import('./plugin/EventResizable.mjs')
             ]).then(modules => {
-                let me      = this,
-                    plugins = me.plugins || [];
+                let me        = this,
+                    {appName} = me,
+                    plugins   = me.plugins || [];
 
                 plugins.push({
                     module : modules[0].default,
-                    appName: me.appName,
-                    flag   : 'dragdrop',
+                    appName,
                     ...me.pluginDragDropConfig
                 }, {
                     module       : modules[1].default,
-                    appName      : me.appName,
+                    appName,
                     delegationCls: 'neo-event',
                     directions   : ['b', 't'],
-                    flag         : 'resizable',
                     ...me.pluginEventResizableConfig
                 });
 
@@ -391,8 +387,8 @@ class Component extends BaseComponent {
      * @protected
      */
     afterSetEventBorder(value, oldValue) {
-        let me  = this,
-            cls = me.cls;
+        let me    = this,
+            {cls} = me;
 
         oldValue && NeoArray.remove(cls, `neo-event-border-${oldValue}`);
         value    && NeoArray.add(   cls, `neo-event-border-${value}`);
@@ -483,8 +479,8 @@ class Component extends BaseComponent {
      * @protected
      */
     afterSetShowWeekends(value, oldValue) {
-        let me  = this,
-            cls = me.cls;
+        let me    = this,
+            {cls} = me;
 
         NeoArray[value ? 'add' : 'remove'](cls, 'neo-show-weekends');
 
@@ -504,7 +500,7 @@ class Component extends BaseComponent {
      */
     afterSetTimeAxisPosition(value, oldValue) {
         let me                = this,
-            cls               = me.cls,
+            {cls}             = me,
             timeAxisContainer = me.getColumnTimeAxisContainer();
 
         NeoArray[value === 'end' ? 'add' : 'remove'](cls, 'neo-timeaxis-end');
@@ -681,17 +677,19 @@ class Component extends BaseComponent {
      */
     onEventDoubleClick(data) {
         if (this.data.events.enableEdit) {
-            !data.path[0].cls.includes('neo-event') && data.path.shift();
+            let {path} = data;
+
+            !path[0].cls.includes('neo-event') && path.shift();
 
             let me                 = this,
-                editEventContainer = me.owner.editEventContainer,
-                eventNode          = data.path[0],
+                {editEventContainer} = me.owner,
+                eventNode          = path[0],
                 eventVdom          = VDomUtil.findVdomChild(me.vdom, eventNode.id).vdom,
                 record             = me.eventStore.get(eventVdom.flag),
-                style              = editEventContainer.style;
+                {style}            = editEventContainer;
 
             Object.assign(style, {left: `${eventNode.rect.width + 15}px`, top: eventVdom.style.top});
-            editEventContainer.setSilent({parentId: data.path[1].id, record, style});
+            editEventContainer.setSilent({parentId: path[1].id, record, style});
             editEventContainer.render(true)
         }
     }
@@ -716,8 +714,7 @@ class Component extends BaseComponent {
      * @param {Object[]} data.path
      */
     onFocusChange(data) {
-        let oldPath = data.oldPath,
-            path    = data.path;
+        let {oldPath, path} = data;
 
         oldPath?.[0]?.cls.includes('neo-event') && Neo.applyDeltas(this.appName, {id: oldPath[0].id, cls: {remove: ['neo-focus']}});
         path   ?.[0]?.cls.includes('neo-event') && Neo.applyDeltas(this.appName, {id: path[0]   .id, cls: {add:    ['neo-focus']}})
@@ -742,15 +739,13 @@ class Component extends BaseComponent {
      */
     onWheel(data) {
         if (!this.isUpdating && Math.abs(data.deltaX) > Math.abs(data.deltaY)) {
-            let me              = this,
-                columns         = me.getColumnContainer(),
-                columnsBuffer   = me.columnsBuffer,
-                columnsVisible  = me.columnsVisible,
-                firstColumnDate = me.firstColumnDate,
-                header          = me.getHeaderContainer(),
-                i               = 0,
-                timeAxisWidth   = 50,
-                width           = data.clientWidth - timeAxisWidth,
+            let me                                               = this,
+                columns                                          = me.getColumnContainer(),
+                {columnsBuffer, columnsVisible, firstColumnDate} = me,
+                header                                           = me.getHeaderContainer(),
+                i                                                = 0,
+                timeAxisWidth                                    = 50,
+                width                                            = data.clientWidth - timeAxisWidth,
                 config, date, scrollValue;
 
             // console.log(data.scrollLeft, Math.round(data.scrollLeft / (data.clientWidth - timeAxisWidth) * 7));
@@ -838,17 +833,13 @@ class Component extends BaseComponent {
         if (!me.mounted) {
             me.needsEventUpdate = true
         } else {
-            let calendarStore     = me.calendarStore,
-                eventStore        = me.eventStore,
-                timeAxis          = me.timeAxis,
-                endTime           = timeAxis.getTime(me.endTime),
-                startTime         = timeAxis.getTime(me.startTime),
-                totalTime         = endTime - startTime,
-                date              = DateUtil.clone(me.firstColumnDate),
-                vdom              = me.vdom,
-                content           = me.getColumnContainer(),
-                j                 = startIndex,
-                showEventEndTime  = me.showEventEndTime,
+            let {calendarStore, eventStore, showEventEndTime, timeAxis, vdom} = me,
+                endTime   = timeAxis.getTime(me.endTime),
+                startTime = timeAxis.getTime(me.startTime),
+                totalTime = endTime - startTime,
+                date      = DateUtil.clone(me.firstColumnDate),
+                content   = me.getColumnContainer(),
+                j         = startIndex,
                 calendarRecord, column, dayRecords, duration, endDate, eventCls, eventIntervals, hasOverflow, height, i,
                 len, record, recordKey, startDate, startHours, top;
 
@@ -940,7 +931,7 @@ class Component extends BaseComponent {
                 date.setDate(date.getDate() + 1)
             }
 
-            me[silent ? '_vdom' : 'vdom'] = vdom
+            !silent && me.update()
         }
     }
 
@@ -949,13 +940,12 @@ class Component extends BaseComponent {
      * @param {Boolean} [silent=false]
      */
     updateHeader(create=false, silent=false) {
-        let me           = this,
-            date         = me.currentDate, // cloned
-            vdom         = me.vdom,
-            content      = me.getColumnContainer(),
-            header       = me.getHeaderContainer(),
-            i            = 0,
-            showWeekends = me.showWeekends,
+        let me             = this,
+            {showWeekends} = me,
+            date           = me.currentDate, // cloned
+            content        = me.getColumnContainer(),
+            header         = me.getHeaderContainer(),
+            i              = 0,
             columnCls, currentDate, currentDay, dateCls, headerId, removeDom;
 
         me.setFirstColumnDate(date);
@@ -998,13 +988,13 @@ class Component extends BaseComponent {
 
                 Object.assign(header.cn[i],       {id: headerId, removeDom});
                 Object.assign(header.cn[i].cn[0], {html: me.intlFormat_day.format(date), id: `${headerId}_day`});
-                Object.assign(header.cn[i].cn[1], {cls: dateCls, html: currentDate, id: `${headerId}_date`});
+                Object.assign(header.cn[i].cn[1], {cls: dateCls, html: currentDate, id: `${headerId}_date`})
             }
 
             date.setDate(date.getDate() + 1)
         }
 
-        me[silent ? '_vdom' : 'vdom'] = vdom
+        !silent && me.update()
     }
 }
 

package/src/calendar/view/week/EventDragZone.mjs

@@ -112,7 +112,7 @@ class EventDragZone extends DragZone {
      *
      */
     addBodyCursorCls() {
-        Neo.applyDeltas(this.appName, {id: 'document.body', cls: {add: ['neo-cursor-move']}});
+        Neo.applyDeltas(this.appName, {id: 'document.body', cls: {add: ['neo-cursor-move']}})
     }
 
     /**
@@ -123,13 +123,13 @@ class EventDragZone extends DragZone {
     adjustEndDate(date) {
         if (date.getHours() === 0 && date.getMinutes() === 0) {
             // if an event ends at 24:00, change it to 23:59 => otherwise the day increases by 1
-            date.setMinutes(date.getMinutes() - 1);
+            date.setMinutes(date.getMinutes() - 1)
         } else if (!(date.getHours() === 23 && date.getMinutes() === 59) && date.getMinutes() % this.intervalSize !== 0) {
             // otherwise switch non interval based values back
-            date.setMinutes(date.getMinutes() + 1);
+            date.setMinutes(date.getMinutes() + 1)
         }
 
-        return date;
+        return date
     }
 
     /**
@@ -149,7 +149,7 @@ class EventDragZone extends DragZone {
                     id      : me.dragProxy.id,
                     index   : 0,
                     parentId: value
-                });
+                })
             }
         }
     }
@@ -181,15 +181,15 @@ class EventDragZone extends DragZone {
         config.cls.push('neo-focus');
 
         if (component) {
-            config.cls.push(component.getTheme());
+            config.cls.push(component.getTheme())
         }
 
         if (clone.cls && !me.useProxyWrapper) {
-            config.cls.push(...clone.cls);
+            config.cls.push(...clone.cls)
         }
 
         if (me.addDragProxyCls) {
-            NeoArray.add(config.cls, me.dragProxyCls);
+            NeoArray.add(config.cls, me.dragProxyCls)
         }
 
         Object.assign(config.style, {
@@ -198,7 +198,7 @@ class EventDragZone extends DragZone {
             width : `${data.width}px`
         });
 
-        me.dragProxy = Neo.create(config);
+        me.dragProxy = Neo.create(config)
     }
 
     /**
@@ -209,14 +209,14 @@ class EventDragZone extends DragZone {
     dragEnd(data) {
         super.dragEnd(data);
 
-        let me     = this,
-            owner  = me.owner,
-            record = me.eventRecord,
+        let me      = this,
+            {owner} = me,
+            record  = me.eventRecord,
             endDate, startDate;
 
         if (me.keepStartDate) {
             endDate   = me.newEndDate;
-            startDate = me.newStartDate || record.startDate;
+            startDate = me.newStartDate || record.startDate
         } else {
             startDate = new Date(VDomUtil.findVdomChild(owner.vdom, me.proxyParentId).vdom.flag + 'T00:00:00.000Z');
             startDate.setHours(me.axisStartTime);
@@ -224,10 +224,10 @@ class EventDragZone extends DragZone {
 
             if (me.keepEndDate) {
                 endDate   = me.newEndDate   || record.endDate;
-                startDate = me.newStartDate || startDate;
+                startDate = me.newStartDate || startDate
             } else {
                 endDate = DateUtil.clone(startDate);
-                endDate.setMinutes(endDate.getMinutes() + me.eventDuration);
+                endDate.setMinutes(endDate.getMinutes() + me.eventDuration)
             }
         }
 
@@ -252,7 +252,7 @@ class EventDragZone extends DragZone {
         // see: https://github.com/neomjs/neo/issues/2392
 
         owner.getModel().getStore('events').doSort();
-        owner.updateEvents();
+        owner.updateEvents()
     }
 
     /**
@@ -260,20 +260,13 @@ class EventDragZone extends DragZone {
      */
     dragMove(data) {
         let me              = this,
-            axisEndTime     = me.axisEndTime,
-            axisStartTime   = me.axisStartTime,
-            columnHeight    = me.columnHeight,
-            eventDuration   = me.eventDuration,
+            {axisEndTime, axisStartTime, columnHeight, eventDuration, intervalSize, keepEndDate, keepStartDate, owner} = me,
             i               = 0,
-            intervalSize    = me.intervalSize,
-            keepEndDate     = me.keepEndDate,
-            keepStartDate   = me.keepStartDate,
             path            = data.targetPath,
             len             = path.length,
-            owner           = me.owner,
             record          = me.eventRecord,
             switchDirection = false,
-            timeAxis        = owner.timeAxis,
+            {timeAxis}      = owner,
             axisStartDate, currentInterval, deltas, duration, endDate, eventIntervals, height, intervalHeight,
             intervals, limitInterval, minimumEventIntervals, position, startDate, startInterval;
 
@@ -282,7 +275,7 @@ class EventDragZone extends DragZone {
                 for (; i < len; i++) {
                     if (path[i].cls.includes('neo-c-w-column')) {
                         me.proxyParentId = path[i].id;
-                        break;
+                        break
                     }
                 }
             }
@@ -304,7 +297,7 @@ class EventDragZone extends DragZone {
                     startDate.setHours(axisStartTime);
                     startDate.setMinutes(0);
 
-                    eventDuration = (endDate - startDate) / 60 / 1000; // duration in minutes
+                    eventDuration = (endDate - startDate) / 60 / 1000 // duration in minutes
                 }
             }
 
@@ -315,13 +308,13 @@ class EventDragZone extends DragZone {
                     endDate.setHours(axisEndTime);
                     endDate.setMinutes(0);
 
-                    eventDuration = (endDate - startDate) / 60 / 1000; // duration in minutes
+                    eventDuration = (endDate - startDate) / 60 / 1000 // duration in minutes
                 }
             }
 
             if (!keepEndDate) {
                 // events must not end after the last visible interval
-                currentInterval = Math.min(currentInterval, intervals - (eventDuration / intervalSize));
+                currentInterval = Math.min(currentInterval, intervals - (eventDuration / intervalSize))
             }
 
             deltas = [{
@@ -343,7 +336,7 @@ class EventDragZone extends DragZone {
                     if (me.enableResizingAcrossOppositeEdge) {
                         if (me.forceUpdate && currentInterval > limitInterval -minimumEventIntervals && currentInterval < limitInterval + minimumEventIntervals) {
                             // when we resize back to the original direction, keep the min interval until we snap back
-                            return;
+                            return
                         } else if (currentInterval >= limitInterval + minimumEventIntervals) {
                             switchDirection = true;
                             me.forceUpdate  = true;
@@ -360,15 +353,15 @@ class EventDragZone extends DragZone {
                             me.newStartDate = startDate;
 
                             duration = (endDate - startDate) / 60 / 60 / 1000; // duration in hours
-                            deltas[0].style.top = `calc(${limitInterval * intervalHeight / columnHeight * 100}% + 1px)`;
+                            deltas[0].style.top = `calc(${limitInterval * intervalHeight / columnHeight * 100}% + 1px)`
                         } else {
                             me.forceUpdate  = false;
-                            me.newStartDate = null;
+                            me.newStartDate = null
                         }
                     }
 
                     if (!switchDirection) {
-                        currentInterval = Math.min(currentInterval, limitInterval - minimumEventIntervals);
+                        currentInterval = Math.min(currentInterval, limitInterval - minimumEventIntervals)
                     }
 
                 } else if (keepStartDate) {
@@ -398,40 +391,40 @@ class EventDragZone extends DragZone {
                             position = (eventDuration / intervalSize + currentInterval) * intervalHeight; // snap to valid intervals
                             position = position / columnHeight * 100;
 
-                            deltas[0].style.top = `calc(${position}% + 1px)`;
+                            deltas[0].style.top = `calc(${position}% + 1px)`
                         } else if (me.forceUpdate && currentInterval < limitInterval + minimumEventIntervals) {
                             // when we resize back to the original direction, keep the min interval until we snap back
-                            return;
+                            return
                         } else if (me.forceUpdate && currentInterval >= limitInterval + minimumEventIntervals) {
                             if (me.currentInterval !== currentInterval) {
                                 me.forceUpdate  = false;
                                 me.newStartDate = null;
-                                deltas[0].style.top = `calc(${startInterval * intervalHeight / columnHeight * 100}% + 1px)`;
+                                deltas[0].style.top = `calc(${startInterval * intervalHeight / columnHeight * 100}% + 1px)`
                             }
                         }
                     }
 
                     if (!switchDirection) {
-                        currentInterval = Math.max(currentInterval, limitInterval + minimumEventIntervals);
+                        currentInterval = Math.max(currentInterval, limitInterval + minimumEventIntervals)
                     }
                 }
             }
 
             if (!keepStartDate) {
                 // events must not start before the first visible interval
-                currentInterval = Math.max(0, currentInterval);
+                currentInterval = Math.max(0, currentInterval)
             }
 
             if (me.currentInterval !== currentInterval) {
                 if (!switchDirection) {
                     if (!keepEndDate) {
                         endDate.setHours(axisStartTime);
-                        endDate.setMinutes(eventDuration + currentInterval * intervalSize);
+                        endDate.setMinutes(eventDuration + currentInterval * intervalSize)
                     }
 
                     if (keepStartDate) {
                         me.newEndDate = endDate;
-                        duration = (endDate - record.startDate) / 60 / 60 / 1000; // duration in hours
+                        duration = (endDate - record.startDate) / 60 / 60 / 1000 // duration in hours
                     } else {
                         startDate.setHours(axisStartTime);
                         startDate.setMinutes(currentInterval * intervalSize);
@@ -439,11 +432,11 @@ class EventDragZone extends DragZone {
                         position = currentInterval * intervalHeight; // snap to valid intervals
                         position = position / columnHeight * 100;
 
-                        deltas[0].style.top = `calc(${position}% + 1px)`;
+                        deltas[0].style.top = `calc(${position}% + 1px)`
                     }
 
                     if (keepEndDate) {
-                        duration = (record.endDate - startDate) / 60 / 60 / 1000; // duration in hours
+                        duration = (record.endDate - startDate) / 60 / 60 / 1000 // duration in hours
                     }
                 }
 
@@ -456,7 +449,7 @@ class EventDragZone extends DragZone {
 
                 if (keepEndDate || keepStartDate) {
                     height = Math.round(duration / (axisEndTime - axisStartTime) * 100 * 1000) / 1000;
-                    deltas[0].style.height = `calc(${height}% - 2px)`;
+                    deltas[0].style.height = `calc(${height}% - 2px)`
                 }
 
                 deltas.push({
@@ -475,7 +468,7 @@ class EventDragZone extends DragZone {
                                 cls: {add: ['neo-overflow']}
                             });
 
-                            me.hasOverflow = true;
+                            me.hasOverflow = true
                         }
                     } else if (me.hasOverflow) {
                         deltas.push({
@@ -483,14 +476,14 @@ class EventDragZone extends DragZone {
                             cls: {remove: ['neo-overflow']}
                         });
 
-                        me.hasOverflow = false;
+                        me.hasOverflow = false
                     }
 
-                    Neo.applyDeltas(me.appName, deltas);
+                    Neo.applyDeltas(me.appName, deltas)
                 }
             }
 
-            me.currentInterval = currentInterval;
+            me.currentInterval = currentInterval
         }
     }
 
@@ -524,15 +517,15 @@ class EventDragZone extends DragZone {
                 offsetY
             });
 
-            me.dragMove(data);
-        });
+            me.dragMove(data)
+        })
     }
 
     /**
      *
      */
     removeBodyCursorCls() {
-        Neo.applyDeltas(this.appName, {id: 'document.body', cls: {remove: ['neo-cursor-move']}});
+        Neo.applyDeltas(this.appName, {id: 'document.body', cls: {remove: ['neo-cursor-move']}})
     }
 }
 

package/src/calendar/view/week/TimeAxisComponent.mjs

@@ -68,7 +68,7 @@ class TimeAxisComponent extends Component {
         let me = this;
 
         me.createItems();
-        me.afterSetRowHeight(me.rowHeight, 0);
+        me.afterSetRowHeight(me.rowHeight, 0)
     }
 
     /**
@@ -83,10 +83,10 @@ class TimeAxisComponent extends Component {
 
             // todo: handle 24:00 as 23:59
             if (!value) {
-                me._endTime = '24:00';
+                me._endTime = '24:00'
             }
 
-            me.afterSetRowHeight(me.rowHeight, 0);
+            me.afterSetRowHeight(me.rowHeight, 0)
         }
     }
 
@@ -98,7 +98,7 @@ class TimeAxisComponent extends Component {
      */
     afterSetInterval(value, oldValue) {
         if (oldValue !== undefined) {
-            this.afterSetRowHeight(this.rowHeight, 0);
+            this.afterSetRowHeight(this.rowHeight, 0)
         }
     }
 
@@ -110,14 +110,13 @@ class TimeAxisComponent extends Component {
      */
     afterSetRowHeight(value, oldValue) {
         if (oldValue !== undefined && this.vdom.cn) {
-            let me          = this,
-                endTime     = me.getTime(me.endTime),
-                startTime   = me.getTime(me.startTime),
-                vdom        = me.vdom,
-                rowHeight   = me.rowHeight,
-                rowsPerItem = me.getRowsPerItem(),
-                itemHeight  = rowsPerItem * rowHeight + rowsPerItem, // rowsPerItem * 1px borders
-                totalHeight = rowHeight + ((endTime - startTime) * itemHeight),
+            let me                = this,
+                endTime           = me.getTime(me.endTime),
+                startTime         = me.getTime(me.startTime),
+                {rowHeight, vdom} = me,
+                rowsPerItem       = me.getRowsPerItem(),
+                itemHeight        = rowsPerItem * rowHeight + rowsPerItem, // rowsPerItem * 1px borders
+                totalHeight       = rowHeight + ((endTime - startTime) * itemHeight),
                 i, itemStyle;
 
             Object.assign(vdom.style, {
@@ -134,9 +133,9 @@ class TimeAxisComponent extends Component {
                 };
 
                 if (i === startTime) {
-                    itemStyle.marginTop = `${-2 - rowHeight * (rowsPerItem === 1 ? 0.5 : rowsPerItem === 2 ? 1 : 2)}px`;
+                    itemStyle.marginTop = `${-2 - rowHeight * (rowsPerItem === 1 ? 0.5 : rowsPerItem === 2 ? 1 : 2)}px`
                 } else {
-                    delete itemStyle.marginTop;
+                    delete itemStyle.marginTop
                 }
 
                 vdom.cn[i].style = itemStyle;
@@ -149,7 +148,7 @@ class TimeAxisComponent extends Component {
                 rowHeight,
                 rowsPerItem,
                 totalHeight
-            });
+            })
         }
     }
 
@@ -161,7 +160,7 @@ class TimeAxisComponent extends Component {
      */
     afterSetStartTime(value, oldValue) {
         if (oldValue !== undefined) {
-            this.afterSetRowHeight(this.rowHeight, 0);
+            this.afterSetRowHeight(this.rowHeight, 0)
         }
     }
 
@@ -172,14 +171,14 @@ class TimeAxisComponent extends Component {
      * @protected
      */
     beforeSetInterval(value, oldValue) {
-        return this.beforeSetEnumValue(value, oldValue, 'interval');
+        return this.beforeSetEnumValue(value, oldValue, 'interval')
     }
 
     /**
      *
      */
     createItems() {
-        let vdom = this.vdom,
+        let {vdom} = this,
             html, i;
 
         vdom.cn = [];
@@ -190,7 +189,7 @@ class TimeAxisComponent extends Component {
             vdom.cn.push({
                 cls  : ['neo-c-w-timeaxis-item'],
                 cn   : [{html: html}]
-            });
+            })
         }
     }
 
@@ -199,7 +198,8 @@ class TimeAxisComponent extends Component {
      * @returns {Number}
      */
     getRowsPerItem() {
-        return this.interval === 60 ? 1 : this.interval === 30 ? 2 : 4;
+        let {interval} = this;
+        return interval === 60 ? 1 : interval === 30 ? 2 : 4
     }
 
     /**
@@ -208,7 +208,7 @@ class TimeAxisComponent extends Component {
      * @returns {Number}
      */
     getTime(value) {
-        return value.split(':').map(Number)[0];
+        return value.split(':').map(Number)[0]
     }
 }