dt-toolbox 4.0.9 → 6.0.0

package/src/convertors/index.js

@@ -1,47 +1,34 @@
 'use strict'
 
-const 
-     breadcrumbs = require ( './breadcrumbs' )
-   , std         = require ( './standard'    )
-   , midFlat     = require ( './midflat'      )
-   ;
+import std     from './standard.js'
+import midFlat from './midflat.js'
+import tuples  from './tuples.js'
 
 
 
 const selectConvertorFrom = 
         ( type ) => 
         ( dependencies, inData ) => {
-                    let 
-                          { help } = dependencies
-                        , vBuffer = []   // keep values during key's sanitize procedure
-                        , rawKeys
-                        , keyList
-                        , rawValue
-                        ;
                     switch ( type ) {
                                 case 'std'     :
                                 case 'standard':
                                                   return   std.toFlat ( dependencies, inData )
                                 case 'tuple'   :
                                 case 'tuples'  :
-                                                  inData = help.tuplesToBradcrumbs ( dependencies, inData )
+                                                  return tuples.toFlat ( dependencies, inData )
                                 case 'breadcrumb'  :
                                 case 'breadcrumbs' :
-                                                  rawKeys  = Object.keys ( inData )
-                                                  vBuffer  = rawKeys.map ( k => inData[k] )
-                                                  keyList  = help.sanitizeFlatKeys ( rawKeys )
-                                                  rawValue = help.zipObject ( keyList, vBuffer )
-                                                  return   breadcrumbs.toFlat ( dependencies, rawValue )
+                                                  const br = Object.entries ( inData );
+                                                  return tuples.toFlat ( dependencies, br )
                                 case 'file'    :
                                 case 'files'   :
-                                                  rawKeys = inData.map ( el => {  // extract keys from files
-                                                                        let arr = el.split('/');
-                                                                        vBuffer.push ( arr.pop() )
-                                                                        return arr.join ( '/' )
-                                                                })
-                                                  keyList  = help.sanitizeFlatKeys ( rawKeys )
-                                                  rawValue = help.zipObject ( keyList, vBuffer )
-                                                  return   breadcrumbs.toFlat ( dependencies, rawValue )
+                                                  const tups = inData.map ( el => {
+                                                                                let ar = el.split ( '/' );
+                                                                                if ( ar.length === 1 )  ar = [ 'root'].concat(ar)
+                                                                                const v = ar.pop ()
+                                                                                return [ ar.join('/'), v ]
+                                                                        })
+                                                  return tuples.toFlat ( dependencies, tups )
                                 case 'midFlat' :
                                                   return midFlat.toFlat ( dependencies, inData )
                             }
@@ -61,29 +48,49 @@ function from ( type ) {   // convert from something to flat...
 
 
 function to ( type, dependencies, inData ) {   // convert from flat to 'data-type'...
-        const { help } = dependencies;
+        const 
+              breadcrumbs = {}
+            , check = new Set()
+            , extend = new Set()
+            ;
+        let tups, count = 0;
         switch ( type ) {
             case 'std' :
             case 'standard':
-                             return std.toType ( dependencies, inData )
+                             return std.toType ( inData )
             case 'midFlat' : 
-                             return midFlat.toType ( dependencies, inData )
+                             return midFlat.toType ( inData )
             case 'tuple':
             case 'tuples':
-                            let breadData = breadcrumbs.toType ( dependencies, inData )
-                            return help.reduceTuples ( dependencies, breadData )
+                            return tuples.toType ( inData )
+            case 'files':
+                           tups = tuples.toType ( inData );
+                           return tups.map ( ([k,v]) => `${k}/${v}`)
             case 'breadcrumb' :
             case 'breadcrumbs':
-                             return breadcrumbs.toType ( dependencies,inData )
+                           let current;
+                           tups = tuples.toType ( inData )
+                           tups.forEach ( ([k,v]) => check.has(k) ? extend.add(k) : check.add(k)  )
+                           tups.forEach ( ([k,v]) => {
+                                                if ( extend.has(k) ) {
+                                                        if ( current !== k ) {
+                                                                        current = k
+                                                                        count = 0
+                                                            }
+                                                        let key = `${k}/${count}`;
+                                                        breadcrumbs[key] = v
+                                                        count++
+                                                    }
+                                                else {
+                                                        breadcrumbs[k] = v
+                                                    }
+                                        })
+                           return breadcrumbs
             } //switch type
     } // to func.
 
 
 
-
-
-module.exports = { from, to }
-
-
+export default { from, to }
 
 

package/src/convertors/midflat.js

@@ -2,151 +2,95 @@
 
 
 
-function toFlat ( dependencies, d ) {   // Converts data to shortFlat
-        if ( Object.keys(d).length === 0 ) {
-                let 
-                      structure = [ [ 'object', 0 ]   ]
-                    , value = {}
-                    ;
-                return [ structure, value ]
-          }
-        let 
-              structure = []
-            , value     = {}
-            , { help }  = dependencies
-            , keyList   = Object            // Provides keys in order: from larger to shorter 
-                                .keys ( d )
-                                .map ( x => x.trim().replace(/\/$/,'').split('/')  )
-                                .sort ( (a,b) => b.length - a.length   )
-            , tProps    = {}                // { objectLocation<string> : childObjectNames<set> }
-            , structRaw = [ 'root' ]        // objectLocation strings
-            , propDone  = []
+function toFlat ( dependencies, d ) {   // Converts data to 'dt' model
+        const 
+              entries = Object.entries ( d )
+            , { walk } = dependencies ()
+            , indexes = {}
+            , dt = []
+            , containers = {}
+            , buffer = {}
             ;
-
-        keyList.forEach ( keyArr => {   // Setup our temp structures: tProps and structRaw
-                                keyArr.forEach ( (k,i) => {
-                                                let parent = keyArr.slice( 0, i ).join ( '/' );
-                                                if ( !parent         )   return
-                                                if ( !tProps[parent] ) { 
-                                                        tProps[parent] = new Set()
-                                                        structRaw.push ( parent )
-                                                        }
-                                                tProps[parent].add ( k )
-                                        })
+                        function findContainers ( br ) {
+                                        if ( !containers[br] )   containers[br] = 'object'
+                                        const arr = br.split ( '/' );
+                                        if ( arr.length == 1 )   return
+                                        arr.pop ()
+                                        if ( arr.length == 1 )   return
+                                        findContainers ( arr.join('/') )
+                                } // findContainers func.
+
+                        function checkData ( br, midData ) {
+                                        const k = Object.keys ( midData );
+                                        k.forEach ( key => {
+                                                        if ( !isNaN(key) )   containers[br] = 'array'
+                                                })
+                                } // checkData func.
+
+        entries.forEach ( ([br, midData]) => {
+                        if ( !br.startsWith('root') )   br = `root/${br}`
+                        findContainers ( br )
+                        checkData ( br, midData )
+                        buffer[br] = midData
                 })
 
-        Array.from ( structRaw.reduce ((res,ls)=> {   // Add flat objects paths
-                                                res.add ( ls )
-                                                let flatList;
-                                                const spot = tProps[ls];
-                                                if ( spot == null )   return res
-                                                flatList = Array.from ( spot )
-                                                flatList.forEach ( el => res.add ( `${ls}/${el}` )   )
-                                                return res
-                                }, new Set()   )
-                )
-             .sort ()
-             .forEach ( (path,i) => {   // Build the structure rows    
-                                                let position;
-                                                if ( !structure[i]       ) {  
-                                                                structure[i] = [ 'object', i ]
-                                                                propDone [i] = path
-                                                        }
-                                                if ( propDone[i]  )   path = propDone[i]
-                                                if ( path == null )   return
-
-                                                const flatList = tProps[path];
-                                                if ( !flatList ) return
-                                                
-                                                let 
-                                                          flat = Array.from(flatList)
-                                                        , isArray = help.hasNumbers ( flat )
-                                                        ;
-                                                if ( isArray )   structure[i][0] = 'array'
-
-                                                flatList.forEach ( name => {
-                                                                position = structure.length
-                                                                propDone[position] = `${path}/${name}`
-                                                                structure.push ( ['object' , position])
-                                                        })
-                        })
-
-        propDone.forEach ( (k,i) => {   // Setup values
-                                let 
-                                     keyList = Object.keys ( d[k] ).map ( k => k.trim().replace (/\/$/,'')   )   // Prevents key to end on empty-space or '/'
-                                   , isArray = help.hasNumbers ( keyList )
-                                   , kSplit  = k.split ( '/' )
-                                   , kProp  
-                                   , breadcrumbs
-                                   ;
-
-                                kProp = kSplit.pop()
-                                breadcrumbs = kSplit.join('/')
-
-                                let ix = propDone.indexOf (breadcrumbs);
-                                if ( ix >= 0 )   structure[ix].push ( [i, kProp] )
-                                if ( isArray )   structure[i][0] = 'array'
-
-                                propDone [i] = k
-                                for (let el in d[k] ) {
-                                                let val = d[k][el];
-                                                if ( val === '_fake$$$' )   return   // Remove fake data generated from 'toType' function
-                                                value [`root/${i}/${el}` ] = val
+        // Add containers to other data in buffer. Modify the data according the container type
+        const containerEntries = Object.entries ( containers );
+        containerEntries.forEach ( ([ k, t]) => {
+                        if ( buffer[k] === 'object' )   return
+                        if ( buffer[k] ) {
+                                const isArray = buffer[k] instanceof Array;
+                                if ( t === 'array' && !isArray ) {
+                                                const list = Object.values ( buffer[k] )
+                                                buffer[k] = list
                                         }
-            }) // keys foreach
-        return [ structure, value ]
+                                return
+                            }
+                        const structure = ( t === 'object' ) ? {} : [];
+                        buffer[k] = structure
+                }) // containerEntries forEach
+
+        const bufferEntries = Object.entries ( buffer ).sort();
+        bufferEntries.forEach ( ([ breadcrumbs, flatData]) => {
+                        const 
+                              name = breadcrumbs.split ( '/' ).pop ()
+                            , parent = breadcrumbs.replace ( `/${name}`, '' )
+                            , dcopy  = flatData instanceof Array ? [...flatData] : {...flatData}
+                            , line = [ name, dcopy, breadcrumbs, [] ]
+                            ;
+                        
+                        indexes[breadcrumbs] = line
+                        dt.push ( line )
+                        if ( breadcrumbs === 'root' )   return
+                        if ( !parent                )   return
+                        if ( indexes[parent] )   indexes[parent][3].push ( breadcrumbs )
+                }) // forEach entry
+
+        const copy = walk ({ data : d })
+        return [ copy, indexes, dt ]
     } // toFlat func.
 
 
 
-
-
-function toType ( dependencies, [structure, value] ) {   // Converts data to midFlat
-          let
-              result = { 'root': {} }
-            , keys   = {'0':'root'}
-            , activeKey
-            ;
-        structure.forEach ( (row,i) => {   // Define relation between structure number and midkeys. Var 'keys'.
-                        if ( keys[i] != null )   activeKey = keys[i]
-                        else                     activeKey = 'root'
-
-                        row.forEach ( (el,j) => {   // Collect all defined sub structures
-                                        if ( j < 2 )   return
-                                        let 
-                                            [ objNumber, objName ] = el
-                                           , midKey = `${activeKey}/${objName}`
-                                           ;
-                                        result [ midKey  ] = {}
-                                        keys [ objNumber ] = midKey
-                                })
-                })
-        let 
-              valueKeys = Object.keys ( value )
-            , valueCheck = new Set ()
-            ;
-        for (let k of valueKeys ) {    // Organize values per midFlat object
-                        let 
-                              [ , n ,prop ] = k.split ( '/' )
-                            , midKey = keys[n]
-                            ;
-                        valueCheck.add(n)
-                        result[midKey][prop] = value[k]
-                    }
-        structure.forEach ( row => {   // Set a fake value into array objects. Preserve 'array' during midflat operations
-                        let 
-                              [ type, n, ...objects ] = row
-                            ,  midKey     = keys [ n ]
-                            , noValue = !valueCheck.has(n.toString())
-                            , hasNoObjects = !( objects.length > 0 )
-                            ;
-                        if ( type === 'array' && noValue && hasNoObjects )   result[midKey]['-1'] = '_fake$$$'
-                })
+function toType ( dt ) {   // Converts data to midFlat
+        const result = {};
+        dt.forEach ( line => {
+                    const 
+                          [ , flatData, breadcrumbs ] = line
+                        , isEmpty = (Object.keys ( flatData ).length === 0)
+                        ;
+                    if ( isEmpty )   return
+                    const 
+                          br = breadcrumbs.replace ( 'root/', '' )
+                        , d = flatData instanceof Array ? [...flatData] : {...flatData}
+                        ;
+                    result [br] = d
+            }) // forEach line
         return result
 } // toType func.
 
 
 
-module.exports = { toFlat, toType }
+export default { toFlat, toType }
 
 

package/src/convertors/standard.js

@@ -2,59 +2,51 @@
 
 
 
-function toFlat ( dependencies, d ) {
-            let 
-                  value       = dependencies.empty ()
-                , { help, walk } = dependencies
-                , { findType    } = help
-                , structure = []
-                , objectCounter = 0
-                , currentObjectID = 0  // In use for values in keyCalls function 
-                , objectIndex = {}     // Map breadcrumb -> structure row number
-                ;
-
-            function objectCalls ({value:obj, breadcrumbs }) {
-                      let 
-                          location = breadcrumbs.split ( '/' )
-                        , objectName = location.pop()
-                        ;
-
-                      structure.push ( [findType(obj), objectCounter])
-                      objectIndex[breadcrumbs] = objectCounter
-                      currentObjectID = objectCounter
-                     
-                      let 
-                          hostName = location.join ( '/' )
-                        , hostID   = objectIndex[hostName]
-                        ;
-                        
-                      if ( hostID >= 0 )   structure[hostID].push ([objectCounter, objectName])
-                         
-                      objectCounter++
-                      return obj
-                } // objectCalls func.
-
-            function keyCalls ({ value:v, key:k, breadcrumbs }) {
-                      const location = breadcrumbs.split('/');
-                      location.pop ()
-                      const 
-                            hostName = location.join ( '/' )
-                          , hostID = objectIndex [ hostName ]
-                          ;
-                      value[`root/${hostID}/${k}`] = v
-                      return v
-                } // keyCalls func.
-
-            structure.push ([ findType(d), objectCounter++ ])
-            objectIndex["root"] = 0
-
-            walk ({ 
-                    data : d, 
-                    keyCallback : keyCalls, 
-                    objectCallback : objectCalls 
-                })
-                
-            return [ structure, value ]
+function toFlat ( dependencies, d ) {   // Convert data to 'dt' model
+        const dataType = d instanceof Array ? [] : {}
+        const
+              { walk } = dependencies ()
+            , dt = [
+                  //  Store record line positions:
+                  //    0      1        2          3    
+                  // [ name, data , breadcrumbs, edges ] 
+                    [ 'root', dataType, 'root', [] ]
+                ]
+            , index = { 'root' : dt[0] }
+            , dtDATA = 1   // Const: Flat data object in store record line;
+            , dtEDGES = 3  // Const: Edges in store record line;
+            ;
+
+        function objCallbackFn ({ value, key, breadcrumbs }) {
+                        const 
+                              isArray = value instanceof Array ? true : false
+                            , dataType = isArray ? [] : {}
+                            , objectName = key
+                            , search = new RegExp (  `\/${key}$` )
+                            , parentName = breadcrumbs.replace ( search, '' )
+                            , newObject = [ objectName, dataType, breadcrumbs, [] ]
+                            ;
+                        index[ parentName][dtEDGES].push ( breadcrumbs )
+                        dt.push ( newObject )
+                        index [ breadcrumbs ] = dt.at(-1)
+                        return value
+                } // objCallbackFn
+
+        function keyCallbackFn ({ value, key, breadcrumbs }) {
+                        const
+                              search = new RegExp (  `\/${key}$` )
+                            , parentName = breadcrumbs.replace ( search, '' )
+                            ; 
+                        index [parentName][dtDATA][key] = value
+                        return value
+                } // keyCallbackFn
+
+        const copy = walk ({
+                              data : d
+                            , keyCallback    : keyCallbackFn
+                            , objectCallback : objCallbackFn 
+                        })
+            return [ { root:copy }, index, dt ]   
     } // getFlat func.
 
 
@@ -66,39 +58,23 @@ function toFlat ( dependencies, d ) {
 
 
 
-function toType ( dependencies, [ structure, value ]) {
+function toType ( dt ) {
             let 
-                keys = Object.keys ( value )
-              , resultObjects = []
-              , resultMap = {}
-              ;
-
-            structure.forEach ( ([type, id, ...items]) => {   // Create data-structures
-                                    let local;
-                                    if ( type == 'array' )   local = []
-                                    else                     local = {}
-                                    
-                                    let selectedKeys = keys.filter ( k => k.includes(`root/${id}/`));
-                                    selectedKeys.forEach ( k => {   // Fill with primitive data
-                                                            let 
-                                                                  arr      = k.split ( '/' )
-                                                                , propName = arr [arr.length-1]
-                                                                ;
-                                                            local [propName]  = value[k]
-                                                    })
-                                    resultMap [id] = resultObjects.length
-                                    resultObjects.push ( local )
-                            })
-                            
-            structure.forEach ( ([ , id, ...items]) => {  // Conect data-structures
-                                    items.forEach ( ([link, propName]) => {
-                                                    link = Number(link) || link;
-                                                    let location = resultMap[link];
-                                                    resultObjects[id][propName] = resultObjects[ location ]
-                                            })
-                            })
-                            
-            return resultObjects[0]
+                  result = {}
+                , revDT = dt.reverse ()
+                ;
+            revDT.forEach ( ([ name, d, breadcrumbs, edges ]) => {
+                        const copy = d instanceof Array ? [...d] : {...d};
+                        
+                        result[breadcrumbs] = copy
+                        edges.forEach ( edge => {
+                                        if ( result[edge] ) {
+                                                const name = edge.replace (`${breadcrumbs}/`, '' );
+                                                result[breadcrumbs][name] = result[edge]
+                                            }  
+                                })
+                    })
+            return result['root']
     } // toType func.
 
 
@@ -113,6 +89,5 @@ function toType ( dependencies, [ structure, value ]) {
 
 
 
-module.exports = { toFlat, toType }
-
+export default { toFlat, toType }