@lexriver/dome 1.2.18 → 1.4.1

package/out/LongestCommonSubsequence.js

@@ -1,164 +1,164 @@
-export var LongestCommonSubsequence;
-(function (LongestCommonSubsequence) {
-    // https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequence
-    function getLongestCommonSubsequence(set1, set2) {
-        // Init LCS matrix.
-        const lcsMatrix = Array(set2.length + 1).fill(null).map(() => Array(set1.length + 1).fill(null));
-        // Fill first row with zeros.
-        for (let columnIndex = 0; columnIndex <= set1.length; columnIndex += 1) {
-            lcsMatrix[0][columnIndex] = 0;
-        }
-        // Fill first column with zeros.
-        for (let rowIndex = 0; rowIndex <= set2.length; rowIndex += 1) {
-            lcsMatrix[rowIndex][0] = 0;
-        }
-        // Fill rest of the column that correspond to each of two strings.
-        for (let rowIndex = 1; rowIndex <= set2.length; rowIndex += 1) {
-            for (let columnIndex = 1; columnIndex <= set1.length; columnIndex += 1) {
-                if (set1[columnIndex - 1] === set2[rowIndex - 1]) {
-                    lcsMatrix[rowIndex][columnIndex] = lcsMatrix[rowIndex - 1][columnIndex - 1] + 1;
-                }
-                else {
-                    lcsMatrix[rowIndex][columnIndex] = Math.max(lcsMatrix[rowIndex - 1][columnIndex], lcsMatrix[rowIndex][columnIndex - 1]);
-                }
-            }
-        }
-        // Calculate LCS based on LCS matrix.
-        if (!lcsMatrix[set2.length][set1.length]) {
-            // If the length of largest common string is zero then return empty string.
-            return [''];
-        }
-        const longestSequence = [];
-        let columnIndex = set1.length;
-        let rowIndex = set2.length;
-        while (columnIndex > 0 || rowIndex > 0) {
-            if (set1[columnIndex - 1] === set2[rowIndex - 1]) {
-                // Move by diagonal left-top.
-                longestSequence.unshift(set1[columnIndex - 1]);
-                columnIndex -= 1;
-                rowIndex -= 1;
-            }
-            else if (lcsMatrix[rowIndex][columnIndex] === lcsMatrix[rowIndex][columnIndex - 1]) {
-                // Move left.
-                columnIndex -= 1;
-            }
-            else {
-                // Move up.
-                rowIndex -= 1;
-            }
-        }
-        return longestSequence;
-    }
-    LongestCommonSubsequence.getLongestCommonSubsequence = getLongestCommonSubsequence;
-    function getPatch({ oldArray, newArray, onRemove, onAdd }) {
-        const lcsArray = getLongestCommonSubsequence(oldArray, newArray);
-        let countOfOperations = 0;
-        // console.log('oldArray=', oldArray.join(' '))
-        // console.log('newArray=', newArray.join(' '))
-        // console.log('lcsArray=', lcsArray.join(' '))
-        // old:   A B B B C
-        // new: X X B B B B C
-        // lcs:     B B B C
-        //let lcsStartIndexForOld = 0
-        //let lcsStartIndexForNew = 0
-        let lcsIndex = 0;
-        //let newIndex = 0
-        for (let oldIndex = 0; oldIndex < oldArray.length; oldIndex++) {
-            let oldItem = oldArray[oldIndex];
-            //let oldItemInLcs = itemInArray(oldItem, lcsArray, lcsStartIndexForOld)
-            let oldItemInLcs = lcsArray[lcsIndex] == oldItem;
-            //console.log('oldIndex=', oldIndex, 'oldItem=', oldItem, 'in LCS=', oldItemInLcs)
-            if (oldItemInLcs) {
-                //lcsStartIndexForOld++
-                lcsIndex++;
-                // so we must keep this element
-                //continue
-            }
-            else {
-                onRemove(oldIndex - countOfOperations, oldItem);
-                //indexForOperation++
-                countOfOperations++;
-            }
-        }
-        lcsIndex = 0;
-        for (let newIndex = 0; newIndex < newArray.length; newIndex++) {
-            let newItem = newArray[newIndex];
-            //let newItemInLcs = itemInArray(newItem, lcsArray, lcsStartIndexForNew)
-            let newItemInLcs = lcsArray[lcsIndex] == newItem;
-            if (newItemInLcs) {
-                lcsIndex++;
-                //lcsStartIndexForNew++
-                //keep
-            }
-            else {
-                onAdd(newIndex, newItem);
-                countOfOperations++;
-            }
-        }
-        return countOfOperations;
-    }
-    LongestCommonSubsequence.getPatch = getPatch;
-    function getPatchOrdered({ oldArray, newArray, onRemove, onAdd }) {
-        const lcsArray = getLongestCommonSubsequence(oldArray, newArray);
-        //let countOfOperations = 0
-        // console.log('oldArray=', oldArray.join(' '))
-        // console.log('newArray=', newArray.join(' '))
-        // console.log('lcsArray=', lcsArray.join(' '))
-        // old:   A B B B C
-        // new: X X B B B B C
-        // lcs:     B B B C
-        let lcsIndexForOld = 0;
-        let lcsIndexForNew = 0;
-        //let lcsIndex = 0
-        let oldIndex = 0;
-        let newIndex = 0;
-        let countOfRemoveOperations = 0;
-        let countOfAddOperations = 0;
-        let indexForOperation = 0;
-        while (oldIndex < oldArray.length || newIndex < newArray.length) {
-            while (oldIndex < oldArray.length) {
-                let oldItem = oldArray[oldIndex];
-                //let oldItemInLcs = itemInArray(oldItem, lcsArray, lcsStartIndexForOld)
-                let oldItemInLcs = lcsArray[lcsIndexForOld] == oldItem;
-                //console.log('oldItem', oldIndex, oldItem, oldItemInLcs)
-                if (oldItemInLcs) {
-                    //lcsStartIndexForNew++
-                    //lcsStartIndexForOld++
-                    lcsIndexForOld++;
-                    //indexForOperation++
-                    oldIndex++;
-                    break;
-                }
-                else {
-                    //onRemove(oldIndex-countOfRemoveOperations, oldItem)
-                    onRemove(indexForOperation, oldItem);
-                    countOfRemoveOperations++;
-                    oldIndex++;
-                }
-            }
-            while (newIndex < newArray.length) {
-                let newItem = newArray[newIndex];
-                //let newItemInLcs = itemInArray(newItem, lcsArray, lcsStartIndexForNew)
-                let newItemInLcs = lcsArray[lcsIndexForNew] == newItem;
-                //console.log('newItem', oldIndex, newItem, newItemInLcs)
-                if (newItemInLcs) {
-                    //lcsStartIndexForNew++
-                    lcsIndexForNew++;
-                    indexForOperation++;
-                    newIndex++;
-                    break;
-                }
-                else {
-                    onAdd(indexForOperation, newItem);
-                    indexForOperation++;
-                    countOfAddOperations++;
-                    newIndex++;
-                }
-            }
-        }
-        // console.log('countOf(+)operations', countOfAddOperations)
-        // console.log('countOf(-)operations', countOfRemoveOperations)
-        return countOfAddOperations + countOfRemoveOperations;
-    }
-    LongestCommonSubsequence.getPatchOrdered = getPatchOrdered;
-})(LongestCommonSubsequence || (LongestCommonSubsequence = {}));
+export var LongestCommonSubsequence;
+(function (LongestCommonSubsequence) {
+    // https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequence
+    function getLongestCommonSubsequence(set1, set2) {
+        // Init LCS matrix.
+        const lcsMatrix = Array(set2.length + 1).fill(null).map(() => Array(set1.length + 1).fill(null));
+        // Fill first row with zeros.
+        for (let columnIndex = 0; columnIndex <= set1.length; columnIndex += 1) {
+            lcsMatrix[0][columnIndex] = 0;
+        }
+        // Fill first column with zeros.
+        for (let rowIndex = 0; rowIndex <= set2.length; rowIndex += 1) {
+            lcsMatrix[rowIndex][0] = 0;
+        }
+        // Fill rest of the column that correspond to each of two strings.
+        for (let rowIndex = 1; rowIndex <= set2.length; rowIndex += 1) {
+            for (let columnIndex = 1; columnIndex <= set1.length; columnIndex += 1) {
+                if (set1[columnIndex - 1] === set2[rowIndex - 1]) {
+                    lcsMatrix[rowIndex][columnIndex] = lcsMatrix[rowIndex - 1][columnIndex - 1] + 1;
+                }
+                else {
+                    lcsMatrix[rowIndex][columnIndex] = Math.max(lcsMatrix[rowIndex - 1][columnIndex], lcsMatrix[rowIndex][columnIndex - 1]);
+                }
+            }
+        }
+        // Calculate LCS based on LCS matrix.
+        if (!lcsMatrix[set2.length][set1.length]) {
+            // If the length of largest common string is zero then return empty string.
+            return [''];
+        }
+        const longestSequence = [];
+        let columnIndex = set1.length;
+        let rowIndex = set2.length;
+        while (columnIndex > 0 || rowIndex > 0) {
+            if (set1[columnIndex - 1] === set2[rowIndex - 1]) {
+                // Move by diagonal left-top.
+                longestSequence.unshift(set1[columnIndex - 1]);
+                columnIndex -= 1;
+                rowIndex -= 1;
+            }
+            else if (lcsMatrix[rowIndex][columnIndex] === lcsMatrix[rowIndex][columnIndex - 1]) {
+                // Move left.
+                columnIndex -= 1;
+            }
+            else {
+                // Move up.
+                rowIndex -= 1;
+            }
+        }
+        return longestSequence;
+    }
+    LongestCommonSubsequence.getLongestCommonSubsequence = getLongestCommonSubsequence;
+    function getPatch({ oldArray, newArray, onRemove, onAdd }) {
+        const lcsArray = getLongestCommonSubsequence(oldArray, newArray);
+        let countOfOperations = 0;
+        // console.log('oldArray=', oldArray.join(' '))
+        // console.log('newArray=', newArray.join(' '))
+        // console.log('lcsArray=', lcsArray.join(' '))
+        // old:   A B B B C
+        // new: X X B B B B C
+        // lcs:     B B B C
+        //let lcsStartIndexForOld = 0
+        //let lcsStartIndexForNew = 0
+        let lcsIndex = 0;
+        //let newIndex = 0
+        for (let oldIndex = 0; oldIndex < oldArray.length; oldIndex++) {
+            let oldItem = oldArray[oldIndex];
+            //let oldItemInLcs = itemInArray(oldItem, lcsArray, lcsStartIndexForOld)
+            let oldItemInLcs = lcsArray[lcsIndex] == oldItem;
+            //console.log('oldIndex=', oldIndex, 'oldItem=', oldItem, 'in LCS=', oldItemInLcs)
+            if (oldItemInLcs) {
+                //lcsStartIndexForOld++
+                lcsIndex++;
+                // so we must keep this element
+                //continue
+            }
+            else {
+                onRemove(oldIndex - countOfOperations, oldItem);
+                //indexForOperation++
+                countOfOperations++;
+            }
+        }
+        lcsIndex = 0;
+        for (let newIndex = 0; newIndex < newArray.length; newIndex++) {
+            let newItem = newArray[newIndex];
+            //let newItemInLcs = itemInArray(newItem, lcsArray, lcsStartIndexForNew)
+            let newItemInLcs = lcsArray[lcsIndex] == newItem;
+            if (newItemInLcs) {
+                lcsIndex++;
+                //lcsStartIndexForNew++
+                //keep
+            }
+            else {
+                onAdd(newIndex, newItem);
+                countOfOperations++;
+            }
+        }
+        return countOfOperations;
+    }
+    LongestCommonSubsequence.getPatch = getPatch;
+    function getPatchOrdered({ oldArray, newArray, onRemove, onAdd }) {
+        const lcsArray = getLongestCommonSubsequence(oldArray, newArray);
+        //let countOfOperations = 0
+        // console.log('oldArray=', oldArray.join(' '))
+        // console.log('newArray=', newArray.join(' '))
+        // console.log('lcsArray=', lcsArray.join(' '))
+        // old:   A B B B C
+        // new: X X B B B B C
+        // lcs:     B B B C
+        let lcsIndexForOld = 0;
+        let lcsIndexForNew = 0;
+        //let lcsIndex = 0
+        let oldIndex = 0;
+        let newIndex = 0;
+        let countOfRemoveOperations = 0;
+        let countOfAddOperations = 0;
+        let indexForOperation = 0;
+        while (oldIndex < oldArray.length || newIndex < newArray.length) {
+            while (oldIndex < oldArray.length) {
+                let oldItem = oldArray[oldIndex];
+                //let oldItemInLcs = itemInArray(oldItem, lcsArray, lcsStartIndexForOld)
+                let oldItemInLcs = lcsArray[lcsIndexForOld] == oldItem;
+                //console.log('oldItem', oldIndex, oldItem, oldItemInLcs)
+                if (oldItemInLcs) {
+                    //lcsStartIndexForNew++
+                    //lcsStartIndexForOld++
+                    lcsIndexForOld++;
+                    //indexForOperation++
+                    oldIndex++;
+                    break;
+                }
+                else {
+                    //onRemove(oldIndex-countOfRemoveOperations, oldItem)
+                    onRemove(indexForOperation, oldItem);
+                    countOfRemoveOperations++;
+                    oldIndex++;
+                }
+            }
+            while (newIndex < newArray.length) {
+                let newItem = newArray[newIndex];
+                //let newItemInLcs = itemInArray(newItem, lcsArray, lcsStartIndexForNew)
+                let newItemInLcs = lcsArray[lcsIndexForNew] == newItem;
+                //console.log('newItem', oldIndex, newItem, newItemInLcs)
+                if (newItemInLcs) {
+                    //lcsStartIndexForNew++
+                    lcsIndexForNew++;
+                    indexForOperation++;
+                    newIndex++;
+                    break;
+                }
+                else {
+                    onAdd(indexForOperation, newItem);
+                    indexForOperation++;
+                    countOfAddOperations++;
+                    newIndex++;
+                }
+            }
+        }
+        // console.log('countOf(+)operations', countOfAddOperations)
+        // console.log('countOf(-)operations', countOfRemoveOperations)
+        return countOfAddOperations + countOfRemoveOperations;
+    }
+    LongestCommonSubsequence.getPatchOrdered = getPatchOrdered;
+})(LongestCommonSubsequence || (LongestCommonSubsequence = {}));

package/out/index.d.ts

@@ -1,12 +1,12 @@
-export * from './Dome';
-export * from './DomeManipulator';
-export * from '@lexriver/observable';
-export * from './DomeComponent';
-export * from './DomeRouter';
-export * from './AnimatedArray';
-export * from './AnimatedTable';
-export * from './AnimatedText';
-export * from '@lexriver/async';
-export * from '@lexriver/observable';
-export * from '@lexriver/type-event';
-export * from '@lexriver/data-types';
+export * from './Dome';
+export * from './DomeManipulator';
+export * from '@lexriver/observable';
+export * from './DomeComponent';
+export * from './DomeRouter';
+export * from './AnimatedArray';
+export * from './AnimatedTable';
+export * from './AnimatedText';
+export * from '@lexriver/async';
+export * from '@lexriver/observable';
+export * from '@lexriver/type-event';
+export * from '@lexriver/data-types';

package/out/index.js

@@ -1,14 +1,14 @@
-export * from './Dome';
-export * from './DomeManipulator';
-export * from '@lexriver/observable';
-export * from './DomeComponent';
-//export * from './DomeEventDispatcher.ts.old'
-export * from './DomeRouter';
-export * from './AnimatedArray';
-export * from './AnimatedTable';
-export * from './AnimatedText';
-//export { Observable } from 'lex-observable' //?
-export * from '@lexriver/async';
-export * from '@lexriver/observable';
-export * from '@lexriver/type-event';
-export * from '@lexriver/data-types';
+export * from './Dome';
+export * from './DomeManipulator';
+export * from '@lexriver/observable';
+export * from './DomeComponent';
+//export * from './DomeEventDispatcher.ts.old'
+export * from './DomeRouter';
+export * from './AnimatedArray';
+export * from './AnimatedTable';
+export * from './AnimatedText';
+//export { Observable } from 'lex-observable' //?
+export * from '@lexriver/async';
+export * from '@lexriver/observable';
+export * from '@lexriver/type-event';
+export * from '@lexriver/data-types';

package/out/temp-test.d.ts

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

package/out/temp-test.js

@@ -1,20 +1,20 @@
-import { LongestCommonSubsequence } from "./LongestCommonSubsequence";
-let oldArray = "ABCD".split('');
-let newArray = "AXYZBCD345".split('');
-const countOfOperations = LongestCommonSubsequence.getPatchOrdered({
-    oldArray: [...oldArray],
-    newArray: newArray,
-    onRemove: (index, item) => {
-        console.log('-', item, index);
-        oldArray.splice(index, 1);
-    },
-    onAdd: (index, item) => {
-        console.log('+', item, index);
-        oldArray.splice(index, 0, item);
-    }
-});
-console.log('expecting equal', oldArray, newArray);
-console.log('countOfOperations=', countOfOperations);
-//expect(oldArray).toEqual(newArray)
-// console.log('result oldArray=', oldArray)
-// console.log('result nweArray=', newArray)
+import { LongestCommonSubsequence } from "./LongestCommonSubsequence";
+let oldArray = "ABCD".split('');
+let newArray = "AXYZBCD345".split('');
+const countOfOperations = LongestCommonSubsequence.getPatchOrdered({
+    oldArray: [...oldArray],
+    newArray: newArray,
+    onRemove: (index, item) => {
+        console.log('-', item, index);
+        oldArray.splice(index, 1);
+    },
+    onAdd: (index, item) => {
+        console.log('+', item, index);
+        oldArray.splice(index, 0, item);
+    }
+});
+console.log('expecting equal', oldArray, newArray);
+console.log('countOfOperations=', countOfOperations);
+//expect(oldArray).toEqual(newArray)
+// console.log('result oldArray=', oldArray)
+// console.log('result nweArray=', newArray)

package/package.json

@@ -2,7 +2,7 @@
     "type": "module",
     "sideEffects": false,
     "name": "@lexriver/dome",
-    "version": "1.2.18",
+    "version": "1.4.1",
     "description": "",
     "main": "out/index.js",
     "types": "out/index.d.ts",
@@ -17,6 +17,10 @@
         "DOM"
     ],
     "author": "LexRiver <LexRiver@gmail.com> (https://github.com/LexRiver/)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/LexRiver/dome.git"
+    },
     "license": "MIT",
     "devDependencies": {
         "@types/node": "^12.12.42",

package/src/AnimatedArray.ts

@@ -17,6 +17,8 @@ export class AnimatedArray<T>{
         getHtmlElement:(o:T)=>HTMLElement,
         animationShow?:Animation
         animationHide?:Animation
+        //renderEmptyList?:()=>HTMLElement
+        emptyList?:HTMLElement
     }){
         if(params.array && params.parentElement){
             this.update(params.array)
@@ -34,6 +36,15 @@ export class AnimatedArray<T>{
             return
         }
 
+        if(array.length == 0 && this.params.emptyList){
+            DomeManipulator.replaceAllChildrenAsync(parentElement, this.params.emptyList)    
+            return
+        }
+
+        if(array.length > 0 && this.params.emptyList){
+            DomeManipulator.removeElementAsync(this.params.emptyList, this.params.animationHide)
+        }
+
         //let arrayOfKeyToElement:KeyToElementPair[] = []
         let newArrayOfKeys = array.map((item:T) => this.params.getKey(item))
         let oldArrayOfKeys = this.arrayOfKeyToElement.map(x => x.key)

package/src/DomeManipulator.ts

@@ -201,6 +201,13 @@ export module DomeManipulator {
         return document.body.contains(el)
     }
 
+    export function isOnScreen(el:Element|undefined){
+        if(!el) return false
+        var rect = el.getBoundingClientRect()
+        var viewHeight = Math.max(document.documentElement.clientHeight, window.innerHeight)
+        return !(rect.bottom < 0 || rect.top - viewHeight >= 0)
+    }
+
     export async function addCssClassAsync(element: Element, cssClassName: string, removeAfterMs?:number) {
         if(element.nodeType !== Node.ELEMENT_NODE) return
         element.classList.add(cssClassName)
@@ -285,17 +292,18 @@ export module DomeManipulator {
     }
 
     export function scrollIntoView(element: Element, paddingFromTop:number = 100) {
-        const positionBefore = getCurrentScrollPosition()
+        if(isOnScreen(element)) {
+            return  // no need to scroll
+        }
+        //const positionBefore = getCurrentScrollPosition()
         //element.scrollIntoView({ behavior: 'smooth', block: 'nearest' })
         //const positionAfter = getCurrentScrollPosition()
         //console.log('before=', positionBefore, 'after=', positionAfter)
         let expectedPosition = element.getBoundingClientRect().top + window.pageYOffset;
-        if(expectedPosition>positionBefore){
-            expectedPosition += paddingFromTop
-        } else {
-            expectedPosition -= paddingFromTop
-        }
+        expectedPosition -= paddingFromTop
         window.scrollTo({top: expectedPosition, behavior: 'smooth'});
+
+        
         
     }