dt-toolbox 4.0.9 → 6.0.0

package/src/convertors/tuples.js

@@ -0,0 +1,171 @@
+'use strict'
+
+
+
+function toFlat ( dependencies, d ) {   // Converts data to 'dt' model
+        const 
+              { walk } = dependencies ()
+            , indexes = {}
+            , buffer = {root:[]}
+            , dt = []
+            ;
+                        function readKey ( k ) {
+                                    let name, crumbs, key;
+                                    if ( k == 'root' ) {
+                                                name= 'root'
+                                                crumbs = 'root'
+                                                key = null
+                                                return [ name, crumbs, key ]
+                                        }
+
+                                    const splited = k.split ( '/' )
+                                    if ( splited.length === 2 ) {
+                                            name =  'root'
+                                            crumbs = 'root'
+                                            key = splited.pop ()
+                                        }
+                                    if ( splited.length > 2 ) {
+                                            key = splited.pop ()
+                                            name = splited.pop ()
+                                            if ( splited.length === 0 )   crumbs = `root/${name}`
+                                            else                          crumbs = `${splited.join('/')}/${name}`
+                                        }
+                                    return [ name, crumbs, key ]
+                            } // readKey func.
+
+
+
+                        function makeContainers ( k ) {
+                                    if ( k === 'root' ) return
+                                    const ar = k.split ( '/' );
+                                    ar.pop ()
+                                    const container = ar.join ( '/' );
+                                    if ( !buffer[container] )   buffer[container] = []
+                                    if ( container.includes('/') )   makeContainers(container)
+                            } // makeContainers func.
+
+
+
+        d.forEach ( tupleRow => {
+                        const [ k, v ] = tupleRow
+                            , key = ( k === 'root') ? 'root' : `root/${k}`
+                            ;
+                        if ( buffer[key] )   buffer[key].push ( v )
+                        else                 buffer[key] = [ v ]
+                        makeContainers ( key )
+            }) // d forEach
+
+                        
+        
+    // Setup containers only objects/arrays
+    let bufferEntries = Object.entries ( buffer ).sort();
+    const containers = { root:'object' }
+    bufferEntries.forEach ( ([k,v]) => {
+                    if ( k === 'root' )   return
+                    const 
+                            arr = k.split('/')
+                            , el = arr.pop ()
+                            , parent = arr.join ( '/' )
+                            , notArray = (containers[parent] === 'array') ? false : true
+                            ;
+                    if ( notArray && !isNaN(el) )   containers[parent] = 'array'
+                    if ( v.length === 0         )   containers[k] = 'object'
+            })
+
+
+    
+    // Fill the data
+    bufferEntries = Object.entries ( buffer ).sort();
+    bufferEntries.forEach ( ([ k, v]) => {
+                    const 
+                          [ name, crumbs, key ] = readKey ( k )
+                        , isContainer = (v.length === 0) ? true : false
+                        , isProp = (v.length === 1) ? true : false
+                        ;
+                    let line, structure;
+
+                    if ( isContainer ) {
+                                if ( indexes[`${crumbs}/${key}`] )   return
+                                if ( key == null ) { // case 'root'
+                                            structure = (containers['root'] === 'object') ? {} : [] 
+                                            line = [ 'root', structure, 'root', []]
+                                            indexes['root'] = line
+                                            dt.push ( line )
+                                            return
+                                    }
+                                
+                                structure = ( containers[`${crumbs}/${key}`] === 'object' ) ? {} : [];
+                                line = [ key, structure, `${crumbs}/${key}`, [] ]
+                                indexes[`${crumbs}/${key}`] = line
+                                dt.push ( line )
+                                return
+                        }
+                    
+                    if ( !isProp ) {   // arrays with values 
+                                line = [ key, v, `${crumbs}/${key}`, []]
+                                indexes [`${crumbs}/${key}`] = line
+                                dt.push ( line )
+                                return
+                        }
+                    
+                    if ( indexes[`${crumbs}`] )  indexes[crumbs][1][key] = v[0]
+                    else {
+                                const obj = {}
+                                obj[key] = v[0]
+                                line = [ name, obj, crumbs, []]
+                                indexes[crumbs] = line
+                                dt.push ( line )
+                        }
+            }) // buffEntries forEach
+                
+        // Setup edges
+        dt.reverse ()
+        dt.forEach ( line => {
+                        const 
+                              [ name, flatData, breadcrumbs ] = line
+                            , parentCrumbs = breadcrumbs.replace ( `/${name}`, '' )
+                            , l = indexes[parentCrumbs]
+                            ;
+                        if ( parentCrumbs === breadcrumbs )   return                        
+                        if ( l )   l[3].push ( breadcrumbs )
+                }) // revDT
+        dt.reverse ()
+        const copy = walk ({ data : d });
+        return [ copy, indexes, dt ]
+    } // toFlat func.
+
+
+
+
+
+function toType ( dt ) {   // Converts data to tuples
+        let result = [];
+        dt.forEach ( line => {
+                    const 
+                          [ name, flatData, breadcrumbs ] = line
+                        , isArray = flatData instanceof Array ? true : false
+                        // , result = []
+                        ;
+                    let nakedBread = '';
+                    if ( name !== 'root' )    nakedBread = breadcrumbs.replace ( `root/`, '' )
+
+                    if ( isArray ) {
+                                if ( nakedBread.length == 0 )   result.push (['root', el])
+                                else   flatData.forEach ( el => result.push ([nakedBread, el]))
+                                return
+                        }
+                    
+                    const scan = Object.entries ( flatData )
+                    scan.forEach ( ([k, v]) => {
+                                        if ( nakedBread.length == 0 )   result.push ([k, v])
+                                        else                            result.push ([`${nakedBread}/${k}`, v])
+                            })
+            }) // forEach line
+        return result
+} // toType func.
+
+
+
+export default { toFlat, toType }
+
+

package/src/flatData/connect.js

@@ -0,0 +1,50 @@
+'use strict'
+
+
+function connect ( selectionIx ) {
+return function connect ( list ) {
+            list.forEach ( item => {
+                        let arr = item.split ( '/' )
+                        const 
+                               child = arr.pop ()
+                             , parent = arr.pop ()
+                            , line = selectionIx[parent]
+                            , childLine = selectionIx[child]
+                            ;
+                            
+                        if ( !childLine     )   return this
+                        if ( !line          )   return this
+                        if ( line[1][child] )   return this
+
+                        let breadcrumbs = `${line[2]}/${child}`;
+
+                        updateBreadcrumbs ( selectionIx , child, breadcrumbs )
+                        if ( line[3].includes(breadcrumbs) )   return this
+                        line[3].push ( breadcrumbs )
+                        return this
+                })
+}} // connect func.
+
+
+
+function updateBreadcrumbs ( selectionIx, child, bread ) {
+        const 
+              childLine = selectionIx[child]
+            , oldBread = childLine [2]
+            ;
+
+        childLine[2] = bread
+        selectionIx[oldBread] = childLine
+
+        childLine[3].forEach ( (br,i) => {
+                        const search = new RegExp (`^${oldBread}\/`);
+                        const brUpdate = br.replace ( search, `${bread}/` );
+                        updateBreadcrumbs ( selectionIx[br], br, brUpdate )
+                })
+} // updateBreadcrumbs func.
+
+
+
+export default connect
+
+

package/src/flatData/export.js

@@ -0,0 +1,46 @@
+'use struct'
+
+function ex ( flatStorage ) {
+return function ex ( name ) {
+        const [ , indexes, flatData ] = flatStorage;
+
+        if ( name && !indexes[name] )   return []
+        if ( !name ) {
+                const exportCopy = []
+                flatData.forEach ( line => {
+                                    const 
+                                          [ lnName, data, breadcrumbs, edges ] = line
+                                        , dataChange = ( data instanceof Array ) ? [ ...data] : { ...data }
+                                        ;
+                                    exportCopy.push ([ lnName, dataChange, breadcrumbs, [...edges] ])
+
+                        })
+                return exportCopy
+            }
+
+        // If existing name:
+        const selection = [];
+        flatData.forEach ( line => {
+                    const 
+                          [ lnName, data, breadcrumbs, edges ] = line
+                        , search = new RegExp ( `^${name}\/`)
+                        ;
+                    if ( breadcrumbs === name || breadcrumbs.match(search) ) {
+                            let 
+                                  nameChange = ( lnName === breadcrumbs ) ? 'root' : lnName
+                                , dataChange = ( data instanceof Array ) ? [ ...data ] : { ...data }
+                                , breadcrumbsChange = ( breadcrumbs.includes('/') ) ? breadcrumbs.replace ( search, 'root/' ) : 'root'
+                                , edgesChange = edges.map ( edge => edge.replace ( search, 'root/'))
+                                ;
+                            selection.push ([ nameChange, dataChange, breadcrumbsChange, edgesChange ])
+                        }
+
+            })
+        return selection
+}}
+
+
+
+export default ex
+
+

package/src/flatData/filters/list.js

@@ -0,0 +1,11 @@
+'use strict'
+
+function list ({flatData}) {
+    if ( flatData instanceof Array )   return true
+    return false
+} // list func.
+
+
+export default list
+
+

package/src/flatData/filters/listObject.js

@@ -0,0 +1,13 @@
+'use strict'
+
+function listObject ({name,flatData}) {
+    if ( flatData instanceof Array )   return false
+    if ( !isNaN(name)             )   return true
+    return false
+} // listObject func.
+
+
+
+export default listObject
+
+

package/src/flatData/filters/object.js

@@ -0,0 +1,12 @@
+'use strict'
+
+function object ({flatData}) {
+        if ( flatData instanceof Array )   return false
+        return true
+} // object func.
+
+
+
+export default object
+
+

package/src/flatData/filters/root.js

@@ -0,0 +1,12 @@
+'use strict'
+
+function root ({name,breadcrumbs}) {
+    if ( name === breadcrumbs )   return true
+    return false
+} // root func.
+
+
+
+export default root
+
+

package/src/flatData/find.js

@@ -0,0 +1,20 @@
+'use strict'
+
+
+
+function find ( flatIO ) {
+return function find ( name ) {
+        const list = [];
+        flatIO.getScanList().forEach ( line => {
+                        const lnName = line[0];
+                        if ( lnName === name )   list.push( line ) 
+                })
+        flatIO.setupScanList ( list )
+        return this
+}} // find func.
+
+
+
+export default find
+
+

package/src/flatData/from.js

@@ -0,0 +1,33 @@
+'use strict'
+
+
+function fr ( flatIO ) {
+return function fr ( breadcrumbs ) {
+        const 
+              indexes = flatIO.getIndexes ()
+            , start   = indexes[breadcrumbs]
+            , list    = []
+            ;
+
+        if ( !start )   return this
+        list.push ( start )
+        findDeep ( indexes, list, start[3] )
+        flatIO.setupScanList ( list )
+        return this
+}} // fr func.
+
+
+function findDeep ( indexes, list, ls ) {
+    ls.forEach ( br => {
+                    const line = indexes[br];
+                    if ( !line )   return
+                    list.push ( line )
+                    findDeep ( indexes, list, line[3] )
+            })
+} // findDeep func.
+
+
+
+export default fr
+
+

package/src/flatData/get.js

@@ -0,0 +1,29 @@
+'use strict'
+
+/**
+ *  Find an object on specific route
+ * 
+ */
+
+
+
+function get ( flatIO ) {
+return function find ( name ) {
+        const list = [];
+        flatIO.getScanList().every ( line => {
+                        const loc = line[2];
+                        if ( loc === name ) {  
+                                list.push( line ) 
+                                return false
+                            }
+                        return true
+                })
+        flatIO.setupScanList ( list )
+        return this
+}} // get func.
+
+
+
+export default get
+
+

package/src/flatData/index.js

@@ -0,0 +1,101 @@
+'use strict'
+
+import insert      from './insert.js'
+import ex          from './export.js'
+import setupFilter from './setupFilter.js'
+
+import set from './set.js'
+import connect from './connect.js'
+import save from './save.js'
+import push from './push.js'
+
+import fr   from './from.js'
+import use  from './use.js'
+import find  from './find.js'
+import like from './like.js'
+import look from './look.js'
+import get  from './get.js'
+
+
+// Default filters
+import list       from './filters/list.js'
+import listObject from './filters/listObject.js'
+import object     from './filters/object.js'
+import root       from './filters/root.js'
+
+function flatData ( dependencies, d ) {
+          const 
+              [ copy, indexes, flatData ] = d
+            , flatStorage = [ copy, indexes, flatData ]
+            , filters =  {} // { filterName : [selected flat items] }
+            , filterFn = { list, listObject, object, root } // { filter functions}
+            ;
+
+        let 
+              selection = []          // Place for building a query/model result;
+            , selectionIx = {}
+            , scanList  = flatData     // Where 'look' function will be executed;
+            ;
+            
+        const  
+                getFilterNames = () => Object.keys ( filterFn )
+              , filtering = ( filterName, line ) => {
+                            if ( filterFn[filterName] ) {
+                                                  const [ name, flatData, breadcrumbs, edges ] = line;
+                                                  if ( !filters[filterName]   )   filters[filterName] = []
+                                                  if ( filterFn[filterName]({name, flatData, breadcrumbs, edges}) ) {
+                                                            const item = indexes[breadcrumbs];
+                                                            filters[filterName].push ( item )
+                                                      }
+                                }
+                      }
+              ;
+  
+        // Apply default filters
+        const filterNames = getFilterNames ();
+        filterNames.forEach ( name => flatData.forEach ( line => filtering(name, line)   ))
+
+        const 
+              flatIO_API = {
+                          insert  : insert ( flatStorage, filtering, getFilterNames )                     // Insert a new rows to existing flatData;
+                        , export  : ex ( flatStorage )                                                   // Exports a copy of flatData;
+                        , getCopy : name => ( copy[name] ) ? copy[name] : null 
+                        , getSelection  : () => selection
+                        , getSelectionIx : () => selectionIx
+                        , getIndexes    : () => indexes
+                        , getLine       : k => indexes[k] ? indexes[k] : null
+                        , getFilters    : () => filters
+                        , getScanList   : () => scanList
+                        , setupScanList : l =>  scanList = l
+                        , setupFilter : setupFilter ( flatStorage, filterFn, filtering, getFilterNames )   // Add and apply a new filter function to flatData;
+                        , reset         : () => {  selection = [], scanList = flatData    }              // Removes 'selection' and reset the scanList to use all flatData;
+                        , resetScan     : () => { scanList = flatData }
+                    }
+            , flatStoreSelection_API = {
+                          set     : set ( selection, selectionIx )      // Selection: Creates a new row;
+                        , connect : connect ( selectionIx )             // Selection: Creates an edges among rows;
+                        , save    : save ( selectionIx )                // Selection: Sets property+value in specified selection row;
+                        , push    : push ( selectionIx )                // Selection: Adds a new value to selection row if data is an array structure;
+                  }
+            , flatStore_API = {
+                          set     : flatStoreSelection_API.set  
+                        , connect : flatStoreSelection_API.connect
+                        , save    : flatStoreSelection_API.save
+                        , push    : flatStoreSelection_API.push
+                        
+                        , from : fr ( flatIO_API )                               // Scan: Scan deeper from object;
+                        , use  : use ( flatIO_API )                              // Scan: Use filter to select objects to scan;
+                        , get  : get ( flatIO_API )                              // Scan: Take a single object with specific breadcrumbs;
+                        , find  : find ( flatIO_API  )                             // Scan: String search for exact object name;
+                        , like : like ( flatIO_API )                             // Scan: String search in object name;
+                        , look : look ( flatIO_API )     // Scan: Executes on each object property in the selection list;
+                    }
+            ;
+        return [ flatIO_API , flatStore_API ]
+  } // flatData func.
+
+
+
+export default flatData
+
+

package/src/flatData/insert.js

@@ -0,0 +1,24 @@
+'use strict'
+
+function insert ( flat, flitering, getFilterNames ) {
+return function insert ( d ) {
+    const 
+          [ copy,, flatData ] = d
+        , name = flatData[0][0]
+        , [ copies, indexes, flatStorage ] = flat
+        , filterNames = getFilterNames ()
+        ;
+    copies [ name ] = copy
+    flatData.forEach ( line => {
+                const [ ,, breadcrumbs ] = line;
+                indexes[breadcrumbs] = line
+                flatStorage.push ( line )
+                filterNames.forEach ( fname => flitering (fname, line )   )
+        })
+}} // insert func.
+
+
+
+export default insert
+
+

package/src/flatData/like.js

@@ -0,0 +1,24 @@
+'use strict'
+
+
+
+function like ( flatIO ) {
+return function like ( name ) {
+        const 
+                  list = []
+                , listNames = (name instanceof Array) ? name : [name]
+                ;
+
+        flatIO.getScanList().forEach ( line => {
+                        const lnName = line[0];
+                        listNames.forEach ( nm => { if ( lnName.includes(nm) )   list.push ( line )   })                        
+                })
+        flatIO.setupScanList ( list )
+        return this
+}} // like func.
+
+
+
+export default like
+
+

package/src/flatData/look.js

@@ -0,0 +1,49 @@
+'use strict'
+
+
+
+function look ( flatIO ) {
+return function look ( fn ) {
+    flatIO.getScanList().forEach ( line => {
+                        const 
+                              [ name, flatData, breadcrumbs, edges ] = line
+                            ,  isArray = flatData instanceof Array ? true : false
+                            ;
+
+                        const links = edges.map ( edge => { 
+                                                    let child = edge.replace ( `${breadcrumbs}/`, '')
+                                                    return [ name, child ]
+                                            })
+
+                        if ( isArray ) {
+                                if ( flatData.length === 0 )   empty([])
+                                else {
+                                        flatData.every ( (value,key) => {
+                                                    const callback = fn({ value, key, name, flatData, breadcrumbs, links });
+                                                    return ( callback === 'next' ) ? false : true 
+                                            })
+                                    }
+                            }
+                        else {
+                                const test = Object.entries(flatData);
+                                if ( test.length === 0 )   empty({})
+                                else {
+                                        test.every ( ([key, value]) => {
+                                                    const callback = fn ({ value, key, name, flatData, breadcrumbs, links });
+                                                    return ( callback === 'next' ) ? false : true 
+                                            })
+                                    }
+                                
+                            }
+                        function empty ( flatData ) {
+                                    fn ({ value:null, key:null, name, flatData, breadcrumbs, links, empty: true })
+                            } // empty func.
+                        flatIO.resetScan ()
+            })
+}} // look func.
+
+
+
+export default look
+
+

package/src/flatData/push.js

@@ -0,0 +1,19 @@
+'use strict'
+
+
+function push ( selectionIx ) {
+return function push ( target, val ) {
+        const line = selectionIx[target] ? selectionIx[target][1] : false;
+
+        if ( !line                     )   return this
+        if ( !(line instanceof Array)  )   return this
+        if ( typeof value === 'object' )   return this
+        line.push ( val )
+        return this
+}} // push func.
+
+
+
+export default push
+
+

package/src/flatData/save.js

@@ -0,0 +1,17 @@
+'use strict'
+
+
+function save ( selectionIx ) {
+return function save ( target, key, value ) {
+        const lineData = selectionIx[target] ? selectionIx[target][1] : false;
+        if ( !lineData     )   return this
+        if ( lineData[key] )   return this
+        lineData[key] = value
+        return this
+}} // save func.
+
+
+
+export default save
+
+

package/src/flatData/set.js

@@ -0,0 +1,26 @@
+'use strict'
+
+
+
+function set ( selection, selectionIx ) {
+return function set ( name, data ) {
+        const
+              isArray = ( data instanceof Array )
+            , newRecord = []
+            ;
+
+        newRecord.push (name)
+        if ( isArray )   newRecord.push ( [...data] )
+        else             newRecord.push ( {...data} )
+        newRecord.push ( name )
+        newRecord.push ( [] )
+        selection.push ( newRecord )
+        selectionIx[name] = newRecord
+        return this
+}} // set func.
+
+
+
+export default set
+
+