@lexriver/dome 2.0.1 → 2.0.3

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
-
-    }
-
-}

package/src/index.mts

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

package/src/temp-test.mts

@@ -1,23 +0,0 @@
-import { LongestCommonSubsequence } from "./LongestCommonSubsequence.mjs"
-
-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/tsconfig.json

@@ -1,59 +0,0 @@
-{
-    "compilerOptions": {
-        /* Basic Options */
-        //"target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
-        // "target": "es5",
-        //"target":"ESNext",
-        "target": "ESNext",
-        "moduleResolution": "NodeNext",
-        "module": "NodeNext",
-        //"module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
-        // "lib": [],                             /* Specify library files to be included in the compilation. */
-        // "allowJs": true,                       /* Allow javascript files to be compiled. */
-        // "checkJs": true,                       /* Report errors in .js files. */
-        // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-        "declaration": true, /* Generates corresponding '.d.ts' file. */
-        // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
-        // "sourceMap": true,                     /* Generates corresponding '.map' file. */
-        // "outFile": "./",                       /* Concatenate and emit output to single file. */
-        "outDir": "./out", /* Redirect output structure to the directory. */
-        // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
-        // "composite": true,                     /* Enable project compilation */
-        // "removeComments": true,                /* Do not emit comments to output. */
-        // "noEmit": true,                        /* Do not emit outputs. */
-        // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
-        "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-        // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-        /* Strict Type-Checking Options */
-        "strict": true, /* Enable all strict type-checking options. */
-        "noImplicitAny": false, /* Raise error on expressions and declarations with an implied 'any' type. */
-        // "strictNullChecks": true,              /* Enable strict null checks. */
-        // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
-        // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
-        // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
-        // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
-        /* Additional Checks */
-        // "noUnusedLocals": true,                /* Report errors on unused locals. */
-        // "noUnusedParameters": true,            /* Report errors on unused parameters. */
-        // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
-        // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-        /* Module Resolution Options */
-        // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-        // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
-        // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-        // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
-        // "typeRoots": [],                       /* List of folders to include type definitions from. */
-        // "types": [],                           /* Type declaration files to be included in compilation. */
-        // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-        "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-        // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
-        /* Source Map Options */
-        // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-        // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
-        // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
-        // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-        /* Experimental Options */
-        // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
-        // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
-    },
-}

package/vitest.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-    test:{
-        exclude: [
-            './out/**',
-            './node_modules/**'
-        ]
-    }
-})