dt-toolbox 5.0.0 → 7.0.0

package/src/lib/assemble.js

@@ -1,45 +0,0 @@
-function assemble ( dependencies, me ) {
-            const     
-                      { structure, value } = me._select
-                    , listIndex            = new Set ()
-                    , countObjects         = new Set ()
-                    , firstRow              = [ 'array', 0 ]
-                    ;
-                let small = value.reduce ( (res, k) => {
-                                            let num = parseInt ( k.split ( '/' )[1] );
-                                            listIndex.add ( num )
-                                            if ( num < res )   res = num
-                                            return res
-                                    }, 100000 )
-                // small -> id of first object with primitive values
-                me._select.structure = structure.reduce ( (res,item) => {   // Build structure of selection
-                                                    let 
-                                                          ix = item[1]
-                                                        , inScope = ( ix >= small )
-                                                        ;
-                                                    if ( inScope && listIndex.has(ix)   ) {
-                                                                    res.push ([...item])
-                                                                    countObjects.add ( ix )
-                                                        }
-                                                    return res
-                                            }, [ firstRow ]   )
-
-                if ( listIndex.has(0) )   me._select.structure.splice ( 1, 1 )
-                if ( countObjects.size > 1 ) {   // Selection has more than one object. Connect objects to root element
-                            let countIx = 0;
-                            countObjects.forEach ( i => {
-                                        let rec = me._select.structure[0];
-                                        if ( i != 0 )   rec.push ( [i, countIx++])
-                                    })
-                    }
-                else {   // Data comes from a single source. Use that source object as 'root'.
-                            me._select.structure.splice ( 0, 1 )
-                    }
-                return me
-} // assemble func..
-
-
-
-export default assemble
-
-

package/src/lib/attach.js

@@ -1,20 +0,0 @@
-function attach ( dependencies, me ) {
-    const
-         { convert, location } = dependencies
-       , mainData  = convert.to ( 'midFlat', dependencies, [ me.structure, me.value ]   )
-       , { result }  = me._select
-       ;
-    if ( !result )   return me
-    for ( let k in result ) {
-                const newKey = k.replace ( 'root', location )
-                if ( mainData[newKey] )  mainData[newKey] = { ...mainData[newKey],...result[k] } // Merge two objects
-                else                     mainData[newKey] = { ...result[k]}
-        } // for k
-    return convert.from ( 'midFlat').toFlat ( dependencies, mainData )
-} // attach func.
-
-
-
-export default attach
-
-

package/src/lib/block.js

@@ -1,33 +0,0 @@
-function block ( dependencies, me ) {
-/**
- *  Selects deeper structure 'array' or 'object' 
- */
-    const 
-            { type } = dependencies
-          , keys     = Object.keys ( me.value )
-          ;
-    let selectedIDs = me.structure.reduce ( (res,row) => {
-                                  let rowType = row[0];
-                                  if ( rowType != type )   return res
-                                  if ( row.length == 2 )   res.push ( row[1] )
-                                  return res
-                          },[])
-    me._select.value = keys.filter ( key => {
-                                let objectID = parseInt ( key.split('/')[1]);
-                                return selectedIDs.includes ( objectID )
-                            })
-    // Prepare structure as array of objects and update selected keys
-    me._select.structure = [[ 'array', 0 ]]
-    selectedIDs.forEach ( (id,i) => {
-                      let localType = me.structure[id][0];
-                      me._select.structure[0].push ( [id, i])
-                      me._select.structure.push ( [localType, id])
-              })
-    return me
-} // block func.
-
-
-
-export default block
-
-

package/src/lib/combine.js

@@ -1,38 +0,0 @@
-function combine ( dependencies, main, addData ) {
-    // ***   Modify combine
-                const
-                      { convert, modifier, walk } = dependencies 
-                    , mainData = convert.to ( 'midFlat', dependencies, [main.structure, main.value])
-                    , update   = convert.to ( 'midFlat', dependencies, [addData.structure, addData.value] )
-                    , keyList = Object.keys ( update )
-                    ;
-                let result;
-                main._error = main._error.concat ( addData._error )
-                result = keyList.reduce ( (res,k) => {
-                                                    let 
-                                                          check = k.split('/').pop()
-                                                        , rootKeys = Object.keys(res['root'])
-                                                        ;
-                                                    if ( check !='root' && res[k] ) {
-                                                            let up = {}
-                                                            up[k] = {...update[k]}
-                                                            return modifier ['combineShallow'] ( res, up )
-                                                        }
-                                                    if ( check!='root' && rootKeys.includes(check) ) {  
-                                                                let up = {};
-                                                                up[k] = {...update[k]}
-                                                                return modifier['combineShallow'] ( res, up)
-                                                        }
-                                                    else        return modifier['combineShallow'] ( res, { root: {...update[k]}} )
-                                        }, mainData )   
-                let [structure, value ] = convert.from ( 'midFlat').toFlat ( dependencies, result )
-                main.structure = walk ({ data:structure })
-                main.value = value
-                return main
-    } // combine func.
-        
-
-
-export default combine
-
-

package/src/lib/deep.js

@@ -1,23 +0,0 @@
-function deep ( dependencies, me ) {
-    const { help, num, direction } = dependencies
-    let 
-          usedNumbers = []
-        , selectedKeys = [ ...me._select.value ]
-        , levels = help.objectsByLevel ( me.structure )
-        ;
-    levels.forEach ( (level,i) => {
-              let condition = (direction == 'more') ? ( i >= num ) : ( i <= num );
-              if ( condition )   usedNumbers = usedNumbers.concat ( level )
-        })
-    me._select.value = selectedKeys.filter ( key => {
-                              let objectID = parseInt (key.split('/')[1]);
-                              return usedNumbers.includes ( objectID )
-                          })
-    return me
-} // deep func.
-
-
-
-export default deep
-
-

package/src/lib/find.js

@@ -1,36 +0,0 @@
-function find ( dependencies, me ) {
-    // * Find if string exists in value attribute name.
-  let 
-        searchDefault = 'root'
-      , deepDefault = 9999
-      , deepMax
-      , keys = Object.keys ( me.value )
-      , { help, deep, search, walk } = dependencies
-      , longKeys = help.toBreadcrumbKeys ( keys, me.structure )
-      ;
-             
-      search = search || searchDefault
-      deep = (deep == null) ? deepDefault : deep
-      deep =  deep + 1 // because we add default wrapper 'root'
-      deepMax = search.split('/').length + deep
-
-      let collection = longKeys
-                          .filter ( el => el.match (search) )
-                          .reduce ( (res, el) => {
-                                                      let 
-                                                            index  = longKeys.indexOf(el)
-                                                          , elDeep = el.split('/').length
-                                                          ;
-                                                      if ( elDeep <= deepMax )   res.push(keys[index])
-                                                      return res
-                                          },[] )
-      me._select.value     = help.updateSelection ( me._select.value,  collection )
-      me._select.structure = walk ({ data : me.structure })
-      return me
-} // find func.
-
-
-
-export default find
-
-

package/src/lib/folder.js

@@ -1,42 +0,0 @@
-function folder ( dependencies, me ) {
-    const { help, prop, walk, where } = dependencies;
-    let 
-          usedNumbers = []
-        , selectedKeys = []
-        , result = []
-        ;
-    if ( prop == 'root' )   usedNumbers.push ( 0 )
-    me.structure.forEach ( row => {   // Find if structures
-    row.forEach ( (item,i) => {
-                  if ( i > 1 ) {
-                        let [id, name] = item;
-                        if ( name==prop )   usedNumbers.push(id)
-                    }
-        })})
-
-    selectedKeys = usedNumbers.reduce ( (res,number) => {
-                                for (let key in me.value ) {
-                                            let splited = key.split('/');
-                                            if ( splited[1] == number )   res.push ( key )
-                                    }
-                                return res
-                          },[])
-    if ( where ) { // TODO: Still not tested. May be 'where' should receive (key,value)
-          result = usedNumbers.reduce ( (res, number) => {
-                                let [localObject, localKeysSelection] = help.filterObject ( number, selectedKeys, me.value )
-                                let success = where ( localObject )
-                                if ( success )   res.push ( ...localKeysSelection )
-                                return res
-                        },[])
-        } // if where
-    else  result = selectedKeys
-    me._select.value     = help.updateSelection ( me._select.value, result )
-    me._select.structure = walk ({ data:me.structure })
-    return me
-} // folder func.
-
-
-
-export default folder
-
-

package/src/lib/index.js

@@ -1,56 +0,0 @@
-'use strict'
-
-import find       from './find.js'
-import parent    from './parent.js'
-import block     from './block.js'
-import deep      from './deep.js'
-import folder    from './folder.js'
-import modify    from './modify.js'
-import transform from './transform.js'
-import attach    from './attach.js'
-import combine   from './combine.js'
-import assemble  from './assemble.js'
-import purify    from './purify.js'
-
-
-
-const dtlib = {
-
-      loadLong ( dependencies, flatData ) {
-                let { structure, value } = flatData;
-                return dtlib._loadData ( dependencies, structure, value )
-        } // loadLong func.
-
-    , loadShort ( dependencies, flatData ) {
-                let [structure, value] = flatData;
-                return dtlib._loadData ( dependencies, structure, value )
-        } // loadShort func.
-
-    , _loadData ( dependencies, structure, value ) {
-                const { simpleDT, walk } = dependencies;
-                let res = simpleDT ();
-                res.structure = walk ({ data : structure })
-                for ( const k in value ) {
-                          res.value[k] = value[k]
-                    }
-                return res
-        } // loadData
-
-    , modify
-    , find
-    , parent
-    , folder
-    , deep
-    , block
-    , transform
-    , attach
-    , combine
-    , assemble
-    , purify
-} // dtlib
-
-
-
-export default dtlib
-
-

package/src/lib/modify.js

@@ -1,22 +0,0 @@
-function modify ( dependencies, main, addData ) {
-    // ***   Modify add | update | overwrite | insert | append | prepend | combine
-            const
-                  { action, convert, modifier, walk } = dependencies 
-                , mainData = convert.to ( 'midFlat', dependencies, [main.structure, main.value])
-                , update   = convert.to ( 'midFlat', dependencies, [addData.structure, addData.value] )
-                ;
-            let result;
-            main._error = main._error.concat ( addData._error )
-            result = modifier[action] ( mainData, update )
-
-            let [structure, value ] = convert.from ( 'midFlat').toFlat ( dependencies, result )
-            main.structure = walk ({ data : structure })
-            main.value = value
-            return main
-} // modify func.
-
-
-
-export default modify
-
-

package/src/lib/parent.js

@@ -1,51 +0,0 @@
-function parent ( dependencies, me ) {
-    const { help, prop, walk, where } = dependencies;
-    let 
-          usedNumbers = []
-        , selectedKeys = []
-        , result
-        ;
-    for (let key in me.value ) {   // Collect used parent object(ids) from value
-            let splited = key.split('/');
-            if ( splited[2] == prop )   usedNumbers.push ( splited[1] )
-        }
-    function findUsedNumbers ({ value:obj, breadcrumbs }) {
-                    if ( breadcrumbs === 'root' )   return obj  // Ignore top object
-                    let isRow = typeof obj[0] == 'string';      // Ignore row objects
-                    if ( isRow                  )   return obj                  
-                    let [ location, name ] = obj;               // Here are only property descriptions
-                    if ( name === prop )    usedNumbers.push ( location )
-                    return null
-        }
-    walk ({ 
-            data : me.structure,
-            objectCallback :  findUsedNumbers
-        })
-    
-    selectedKeys = usedNumbers.reduce ( (res,location) => {   // Collect props of used parent objects
-                                for (let key in me.value ) {
-                                            let objectID = key.split('/')[1];
-                                            if ( objectID == location )   res.push ( key )
-                                    }
-                                return res
-                            },[] )
-                            
-    if ( where ) {   // Apply where fn if is defined
-            result = usedNumbers.reduce ( (res, number) => {
-                                let [localObject, localKeysSelection] = help.filterObject ( number, selectedKeys, me.value )
-                                let success = where ( localObject )
-                                if ( success )   res.push ( ...localKeysSelection )
-                                return res
-                            },[])
-        } // if where
-    else    result = selectedKeys
-    me._select.value     = help.updateSelection ( me._select.value, result )
-    me._select.structure = walk ({ data : me.structure })
-    return me
-} // parent func.
-
-
-
-export default parent
-
-

package/src/lib/purify.js

@@ -1,37 +0,0 @@
-function purify ( dependencies, me ) {
-    const     
-              { structure, value } = me._select
-            , structReverse = structure.reverse ()
-            ;
-    let objectIndexes = value.reduce ( (res,item) => {
-                                                let num = parseInt (item.split ( '/' )[1]);
-                                                if ( !res.includes( num) )   res.push ( num )
-                                                return res
-                                        },[]);
-            
-    me._select.structure = structReverse.reduce ( (res, strObject ) => {
-                                                let 
-                                                    [ type, item, ...nums ] = strObject
-                                                    , ln = strObject.length
-                                                    , updated = [ type, item ]
-                                                    ;
-                                                if ( ln == 2 && !objectIndexes.includes(item) )   return res
-                                                nums.forEach ( x => {
-                                                            let id = x[0];
-                                                            if ( objectIndexes.includes(id) ) {  
-                                                                        updated.push ( [...x] )
-                                                                        if ( !objectIndexes.includes(item) )   objectIndexes.push ( item )
-                                                                }
-                                                        })
-                                                if ( !objectIndexes.includes(item) )   return res
-                                                res.push ( [...updated] )
-                                                return res
-                                        },[]).reverse ()
-    return me
-} // assemble func..
-
-
-
-export default purify
-
-

package/src/lib/transform.js

@@ -1,55 +0,0 @@
-function transform ( dependencies, [structure, value] ) {
-    // *** Transformer for 'flat' object. Reverse object key and values, or get only keys/values
-          let 
-                { modify, empty } = dependencies
-              , keyList = Object.keys ( value )
-              , result
-              ;
-          switch ( modify  ) {
-                     case 'reverse':
-                                      result = keyList.reduce ( (res,item) => {
-                                                                      let 
-                                                                            arr = item.split ( '/' )
-                                                                          , onlyNumbers = /^[0-9]+$/
-                                                                          , pureKey = ( arr[2].match(onlyNumbers) ) ? parseInt(arr[2]) : arr[2]
-                                                                          , val = value[item]
-                                                                          ;
-                                                                      res[`root/${arr[1]}/${val}`] = pureKey
-                                                                      return res
-                                                     }, {} )
-                                      break
-                     case 'key':
-                     case 'keys':
-                                      result = keyList.reduce ( (res,key,i) => {
-                                                                      let 
-                                                                            arr = key.split ( '/' )
-                                                                          , k = `root/0/${i}`
-                                                                          ;
-                                                                      res[k] = arr[2]
-                                                                      return res
-                                                     }, {} )
-                                      structure = [ [ 'array', 0 ]]
-                                      break
-                     case 'value' :
-                     case 'values':
-                                      result = keyList.reduce ( (res,k,i) => {
-                                                            let 
-                                                                  item = value [k]
-                                                                , key = `root/0/${i}`
-                                                                ;
-                                                            res[key] = item
-                                                            return res
-                                                      }, empty() )
-                                      structure = [ [ 'array', 0 ] ]
-                                      break
-                     default:
-                                      result = empty ()
-               } //   switch instructions
-               return [structure, result]
-    } // transform func.
-
-
-
-export default transform
-
-

package/src/modifiers/add.js

@@ -1,18 +0,0 @@
-function add ( mainData, update ) {
-    for (const updateKey in update ) {
-                let   selectObject =   mainData[updateKey];
-                if ( !selectObject )   mainData[updateKey] = { ...update[updateKey] }
-                else {
-                            for (let prop in update[updateKey]) {
-                                            if ( !mainData[updateKey][prop] )   mainData[updateKey][prop] = update[updateKey][prop]
-                                    }
-                    }
-        }
-    return mainData
-} // add func.
-
-
-
-export default add
-
-

package/src/modifiers/append.js

@@ -1,18 +0,0 @@
-function append ( mainData, update ) {
-    // *** Concatinate values for duplicated props.
-             for (const updateKey in update ) {
-                     if ( mainData[updateKey] ) {
-                                 for (let prop in update[updateKey]) {
-                                                 if ( mainData[updateKey][prop] )   mainData[updateKey][prop] += update[updateKey][prop]
-                                                 else                               mainData[updateKey][prop]  = update[updateKey][prop]
-                                         }
-                         }
-                 }
-             return mainData
-    } // append func.
-
-
-
-export default append
-
-

package/src/modifiers/combineShallow.js

@@ -1,119 +0,0 @@
-function combineShallow ( mainData, update ) {
-            let  
-                  mainKeys = Object.keys(mainData)
-                , updateKeys = Object.keys ( update )
-                , allKeys = [...mainKeys]
-                , result  = {root:{}}
-                , extraContent = {}
-                ;
-
-            for ( let key of updateKeys ) {
-                     if ( !allKeys.includes(key) )   allKeys.push ( key )
-               }
-
-            let sortedKeys = allKeys.sort ( (a,b) => b.split('/').length - a.split('/').length )
-
-            let duplicateNames = sortedKeys.reduce ( (res,key) => {
-                                              let
-                                                   mainObject   = mainData['root']
-                                                 , updateObject = update [key]
-                                                 , check  = key.split('/').pop ()
-                                                 , mainKeys = Object.keys ( mainObject )
-                                                 ;
-
-                                              if ( key!= 'root' && mainData[key] ) {   // key already has more than one value in mainData. Converted to object
-                                                      res.add ( check )
-                                                      if ( !extraContent[check] )   extraContent[check] = []
-                                                      extraContent[check] = Object.keys ( mainData[key] ).reduce ( (res,k) => {
-                                                                                                                  res.push ( mainData[key][k] )
-                                                                                                                  return res
-                                                                                                      }, extraContent[check])
-                                                }
-
-                                             if ( check!='root' && updateObject ) {  // key exists as object in updateObject
-                                                      res.add ( check )
-                                                      if (!extraContent[check])   extraContent[check] = []
-                                                      extraContent[check] = Object.keys ( updateObject ).reduce ( (res,k) => {
-                                                                                                                        res.push ( updateObject[k] )
-                                                                                                                        return res
-                                                                                                      }, extraContent[check])
-                                                }
-                                                  
-                                          
-                                             for ( let k in updateObject ) {
-                                                              if ( mainData[`root/${k}`] && updateObject[k] ) { 
-                                                                        res.add ( k )
-                                                                        if ( !extraContent[k] )   extraContent[k] = []
-                                                                        extraContent[k].push ( updateObject[k] )
-                                                                  }
-
-                                                              if ( mainObject[k] && updateObject[k]) {
-                                                                        res.add ( k )
-                                                                        if ( extraContent[k] )   extraContent[k].push ( updateObject[k] )
-                                                                        else                     extraContent [ k ] = [ mainObject[k], updateObject[k]]
-                                                                  }
-                                                      }
-                                              return res
-                                    }, new Set() )
-    
-            mainKeys.forEach ( key => {   // Insert mainKeys but ignore duplicates
-                                          let obj = mainData[key];
-                                          result[key] = {}
-                                          for ( let k in obj ) {
-                                                if ( !duplicateNames.has(k) )   result[key][k] = obj[k]
-                                              }
-               })   // forEach mainKeys
-
-            updateKeys.forEach ( key => {
-                                          let 
-                                               obj = update[key]
-                                             , updateKeyList = Object.keys ( obj )
-                                             , check = key.split ( '/' ).pop ()
-                                             ;
-                                          if ( duplicateNames.has(check) )   return
-                                          updateKeyList.forEach ( k => {
-                                                         let testKey = `root/${k}`;
-                                                         if ( result[testKey] ) {
-                                                                     let digitCount = _findDigitKeys ( result[testKey]);
-                                                                     if ( obj[k] === '_fake$$$' )   return
-                                                                     result[testKey][digitCount] = obj[k]
-                                                                     return
-                                                               }
-                                                         if ( !duplicateNames.has(k) ) {  
-                                                                     if ( obj[k] === '_fake$$$' )   return
-                                                                     result[key][k] = obj[k]
-                                                               }
-                                                })
-               })   // forEach updateKeys
-            
-            
-
-            for ( let k in extraContent ) {
-                        const resKey = `root/${k}`;
-
-                        result[resKey] = extraContent[k].reduce ( (res,item,i) => {
-                                    res[i] = item
-                                    return res
-                              },{})
-               }   // for extraContent               
-            return result
-    } // combineShallow func.
-
-
-
-
-
-function _findDigitKeys ( obj ) {
-      let count = 0;
-      for ( let k in obj ) {
-            let isDigit = isNaN ( parseInt(k)) ? false : true;
-            if ( isDigit )   count++
-         } // for obj
-      return count
-} // findDigitKeys func.
-
-
-
-export default combineShallow
-
-

package/src/modifiers/flatten.js

@@ -1,38 +0,0 @@
-import combineShallow from './combineShallow.js'
-const separator = ';';
-
-
-
-function flatten ( mainData ) {
-    
-    let keyList = Object
-                     .keys ( mainData )
-                     .filter ( x => x != 'root' );
-    let flatter =  keyList.reduce ( (res,k) => {
-                                let update = { 'root': {...mainData[k]} }
-                                return combineShallow ( res, update )
-                },{ 'root': {...mainData['root']}})
-
-    let flatterKeyList = Object
-                          .keys ( flatter )
-                          .filter ( x => x != 'root' );
-
-    return flatterKeyList.reduce ( (res,k) => {
-                            let 
-                                  key = k.split ('/')[1]
-                                , val = ''
-                                ;
-                            for ( let prop in flatter[k]) {
-                                    if ( val )   val += separator
-                                    val += flatter[k][prop]
-                                }
-                            res['root'][key] = val
-                            return res
-                    }, {'root':{...flatter['root']}})
-} //flatten func.
-
-
-
-export default flatten
-
-