@lexriver/dome 2.0.2 → 2.0.4

package/src/DomeRouter.mts

@@ -1,287 +0,0 @@
-import { DomeManipulator } from "./DomeManipulator.mjs"
-
-// const filename = '[DomeRouter]'
-
-export type RouteAction = (
-    params:{[key:string]:string|number}, 
-    url:string,
-    scrollToPreviousPositionAsync:()=>Promise<void>,
-    query:{[key:string]:string}
-    ) => void|Promise<void>
-
-interface Route{
-    routeSlices:string[]
-    exactMatch:boolean
-    action:RouteAction
-}
-
-interface HistoryUrl{
-    url:string
-    scroll:number
-}
-
-export namespace DomeRouter {
-    const historyUrls:HistoryUrl[] = []
-    const scrollPositionByUrl = new Map<string, number>()
-    export let maxHistoryUrlsCount:number = 20
-    const allRoutes:Route[] = []
-    let onNotFoundAction:(()=>void)|undefined = undefined
-
-    window.addEventListener('popstate', async (e) => {
-        // on go back/forward
-        //console.log(filename, 'window.popstate event', e, 'historyUrls=', historyUrls)
-        const url = window.location.pathname
-        await executeAsync(url, getScrollPositionForUrl(url) )
-        
-        await DomeManipulator.scrollToAsync({
-            pxFromTop: getScrollPositionForUrl(window.location.pathname)
-        })
-    })
-
-    function getScrollPositionForUrl(url:string){
-        return scrollPositionByUrl.get(url) ?? 0
-    }
-
-    function saveScrollPositionForUrl(url:string){
-        scrollPositionByUrl.set(url, DomeManipulator.getCurrentScrollPosition())
-    }
-
-    function saveScrollPositionForCurrentUrl(){
-        scrollPositionByUrl.set(getCurrentUrl(), DomeManipulator.getCurrentScrollPosition())
-    }
-
-    export function navigate(url:string){
-        addUrlToHistory(getCurrentUrl())
-        saveScrollPositionForCurrentUrl()
-        window.history.pushState(null, '', url)
-        executeAsync(url, 0)
-        DomeManipulator.scrollToTop()
-        // historyUrls.push()
-    }
-
-    export function goBack(){
-        window.history.go(-1)
-    }
-
-    export function goForward(){
-        window.history.go(+1)
-    }
-
-    export function changeUrl(url:string){
-        window.history.replaceState(null, '', url)
-        // if(historyUrls.length>0){
-        //     historyUrls[historyUrls.length-1].url = url
-        // }
-    }
-
-    function addUrlToHistory(url:string){
-        historyUrls.push({url, scroll: 0})
-        while(historyUrls.length>maxHistoryUrlsCount){
-            historyUrls.shift()
-        }
-
-        // save scroll position to previous url
-        if(historyUrls.length>1){
-            historyUrls[historyUrls.length-2].scroll = DomeManipulator.getCurrentScrollPosition()
-        }
-
-        // console.log('adding url to history', url)
-        // console.log('historyUrls=', historyUrls)
-    }
-
-      
-
-    export function getCurrentUrl(){
-        return window.location.pathname
-        // return historyUrls.length>0?historyUrls[historyUrls.length-1]:window.location.pathname
-    }
-
-    /**
-     * get previous page url navigated by router
-     * @param previousPageIndex 0=previousPage, 1=previousPage-1, etc
-     */
-    export function getPreviousPageUrl(previousPageIndex:number=0):string|undefined{
-        //if(historyUrls.length==0) return undefined
-        let index = historyUrls.length-2-previousPageIndex
-        if(index >= 0 && index < historyUrls.length) return historyUrls[index].url
-        return undefined
-    }
-
-    // export function reloadCurrentPage(addToHistory:boolean = false){
-    //     const url = window.location.pathname
-    //     if(addToHistory) addUrlToHistory(url)
-    //     executeAsync(url, getScrollPositionForUrl(url)) // TODO: check
-    // }
-
-    export function resolveUrl(url:string = window.location.pathname, addToHistory = true){
-        if(addToHistory) addUrlToHistory(window.location.pathname)
-        executeAsync(url, getScrollPositionForUrl(url))
-    }
-
-    export function onRoute(route:string, exactMatch:boolean, action:RouteAction){
-        if(route[0] !== '/') throw new Error('Please provide correct route. route='+route)
-        let routeSlices = getRouteSlices(route)
-        allRoutes.push({routeSlices, exactMatch, action})
-    }
-
-    function getRouteSlices(route:string){
-        //return route.split('/').filter(x => x.length>0).map(x => decodeURIComponent(x))
-        return route.split('/').map(x => decodeURIComponent(x))
-    }
-
-    export function onNotFound(action:()=>void){
-        onNotFoundAction = action
-    }
-
-    /**
-     * Check if url matched route.
-     *   example: /get-product/445345, /get-product/:productId, true ==> Map([productId:445345])
-     *   example: /get-product/123, /another-route, true ==> undefined
-     *   example: /articles, /articles, true ==> Map()
-     *   example: /articles/some-article, /articles, false ==> Map()
-     * @param url 
-     * @param route 
-     * @param exactMatch 
-     */
-    export function checkUrlMatchRouteAndGetParameters(url:string, route:string, exactMatch:boolean = true):Object|undefined{
-        // this function is purely for export
-        
-        const urlSlices = getRouteSlices(url)
-        const routeSlices = getRouteSlices(route)
-        if(exactMatch && routeSlices.length !== urlSlices.length) return undefined
-        // all routeSlices must match for !exactMatch
-        //const extractedParameters = new Map<string,string>()
-        const extractedParameters = {}
-        for(let i=0;i<routeSlices.length;i++){
-            let cRouteSlice = routeSlices[i]
-            let cUrlSlice = urlSlices[i] // could be undefined
-            //console.info('\t\t cRouteSlice=', cRouteSlice, 'cUrlSlice=', cUrlSlice)
-
-            if(cRouteSlice.startsWith(':')){
-                // we have a param name
-                if(cUrlSlice === undefined){
-                    return undefined
-                }
-
-                const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice)
-                extractedParameters[name] = value
-
-
-            } else {
-                // no param name
-                if(cRouteSlice !== cUrlSlice){
-                    return undefined
-                }
-            }
-        }
-        return extractedParameters
-    }
-
-    /**
-     * parse name with type or without type
-     * :quantity
-     * :quantity<number>
-     * :quantity<float>
-     * :quantity<int>
-     * 
-     * @param name string that starts with `:`
-     * @param value string that contains value
-     */
-    function parseToNameAndValue(name:string, value:string):[string,string|number]{
-        if(!name) throw new Error('no name')
-        
-        // parse name with type
-        // :quantity<number>
-        // :lat<float>
-        // :count<int>
-        const haveMatch = name.match(/:(.+)<(.+)>/)
-        if(haveMatch){
-            const paramName = haveMatch[1]
-            const paramType = haveMatch[2].toLowerCase()
-            if(paramType == 'int'){
-                return [paramName, parseInt(value)]
-                
-            } else if(paramType == 'float'){
-                return [paramName, parseFloat(value)]
-
-            } else if(paramType == 'number'){
-                return [paramName, Number(value)]
-
-            } else {
-                return [paramName, value]
-            }
-        } else {
-            return [name.substring(1), value]
-        }
-
-    }
-
-    function parseQueryString(search:string):{[key:string]:string}{
-        const query:{[key:string]:string} = {}
-        if(!search || search[0] !== '?') return query
-        const params = new URLSearchParams(search.substring(1))
-        for(const [key, value] of params.entries()){
-            query[key] = value
-        }
-        return query
-    }
-
-    async function executeAsync(url:string = window.location.pathname, scrollToPosition:number){
-        const queryString = window.location.search
-        const query = parseQueryString(queryString)
-        url = url.split('?')[0]  // Strip query params
-        //const url = window.location.pathname
-        const urlSlices = getRouteSlices(url)
-        // urlSlices = show, category, 345
-        let countOfFoundRoutes = 0
-        for(let route of allRoutes){
-            //console.info('\t route=', route.routeSlices, route.exactMatch)
-            // route.routeSlices = show, category, :categoryId
-            if(route.exactMatch && route.routeSlices.length != urlSlices.length) continue
-
-            // all routeSlices must match for !exactMatch
-            let matched:boolean = true
-            //let extractedParameters = new Map<string,string>()
-            const extractedParameters = {}
-            for(let i=0;i<route.routeSlices.length;i++){
-                let cRouteSlice = route.routeSlices[i]
-                let cUrlSlice = urlSlices[i] // could be undefined
-                //console.info('\t\t cRouteSlice=', cRouteSlice, 'cUrlSlice=', cUrlSlice)
-
-                if(cRouteSlice && typeof cRouteSlice === 'string' && cRouteSlice.startsWith(':')){
-                    // we have a param name
-                    if(cUrlSlice === undefined){
-                        matched = false
-                        continue
-                    }
-                    // we have some variable, save it
-                    const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice)
-                    extractedParameters[name] = value
-
-                } else {
-                    // no param name
-                    if(cRouteSlice !== cUrlSlice){
-                        matched = false
-                        continue
-                    }
-                }
-            }
-            if(matched){
-                countOfFoundRoutes++
-                //console.log('DomeRouter', 'executeAsync', url, route, extractedParameters)
-                await route.action(extractedParameters, url, async () => {
-                    await DomeManipulator.scrollToAsync({
-                        pxFromTop: scrollToPosition
-                    })
-                }, query)
-            }
-        }
-        if(countOfFoundRoutes==0 && onNotFoundAction){
-            //console.log('DomeRouter', 'onNotFoundAction()')
-            onNotFoundAction()
-        }
-    }
-}
-
-
-

package/src/LongestCommonSubsequence.mts

@@ -1,201 +0,0 @@
-export module LongestCommonSubsequence {
-    // https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sets/longest-common-subsequence
-    export function getLongestCommonSubsequence(set1: string[], set2: string[]) {
-        // 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:string[] = [];
-        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;
-    }
-
-    export function getPatch({ oldArray, newArray, onRemove, onAdd }: { 
-        oldArray: string[]
-        newArray: string[] 
-        onRemove: (index: number, item: string) => void
-        onAdd: (index: number, item: string) => void
-    }){
-        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
-
-        
-    }
-
-    export function getPatchOrdered({ oldArray, newArray, onRemove, onAdd }: { 
-        oldArray: string[]
-        newArray: string[] 
-        onRemove: (index: number, item: string) => void
-        onAdd: (index: number, item: string) => void
-    }){
-
-        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
-
-    }
-
-}