dt-toolbox 5.0.0 → 7.0.0

package/src/flatData/setupFilter.js

@@ -0,0 +1,21 @@
+'use strict'
+
+function setupFilter ( flatStorage, filterFn, filtering, getFilterNames ) {
+return function setupFilter ( name, fn ) {
+        const 
+              filterNames = getFilterNames ()
+            , [,, flatData ] = flatStorage
+            ;
+        if ( filterNames.includes( name )) {
+                    console.error ( `Filter name "${name}" is already defined` )
+                    return this
+            }
+        filterFn[name] = fn
+        flatData.forEach ( line => filtering ( name, line ))
+}} // setupFilter func.
+
+
+
+export default setupFilter
+
+

package/src/flatData/use.js

@@ -0,0 +1,16 @@
+'use strict'
+
+
+
+function use ( flatIO ) {
+return function use ( name ) {
+        const filter = flatIO.getFilters()[name];
+        if ( filter )   flatIO.setupScanList ( filter )
+        return this
+}} // use func.
+
+
+
+export default use
+
+

package/src/flatObject/copy.js

@@ -0,0 +1,19 @@
+'use strict'
+
+
+
+function copy ( dependencies, flatIO ) {
+return function copy ( name = 'root' ) {
+        const 
+               c = flatIO.getCopy (name)
+            ,  { walk } = dependencies ()
+            ;            
+        if ( !c )   return null
+        return walk ({ data : c })
+}} // copy func.
+
+
+
+export default copy
+
+

package/src/flatObject/export.js

@@ -0,0 +1,13 @@
+'use strict'
+
+
+
+function ex ( dependencies, flatIO ) {
+        return name => flatIO.export ( name )
+}
+
+
+
+export default ex
+
+

package/src/flatObject/index.js

@@ -0,0 +1,55 @@
+'use strict'
+
+
+
+import insert      from './insert.js'
+import ex          from './export.js'
+import copy        from './copy.js'
+import model       from './model.js'
+import query       from './query.js'
+import setupFilter from './setupFilter.js'
+
+
+
+function flatObject ( dependencies, d ) {
+        const 
+              { flatData } = dependencies ()
+            , [ flatIO, flatStore ]   = flatData ( dependencies, d )
+            , objectAPI = {
+                    // I/O Operations
+                      insertSegment : insert ( dependencies, flatIO )         // Extends available data with new data segment;
+                    , export : ex     ( dependencies, flatIO )                // Returns flat data;
+                    , copy   : copy   ( dependencies, flatIO )                // Creates deep copy of original data
+                    , model  : model  ( dependencies, flatIO, flatStore )      // Arrange data according specific data-model. Model should come as a function;
+                    , query  : query  ( dependencies, flatIO, flatStore )      // Request, and evaluate data. Returns a new flat object;
+                    , setupFilter : setupFilter ( flatIO )                    // Functions should filter content according some criteria. Generated indexes will help for data search in
+                    , listSegments  : () =>  {
+                                    const ix = Object.keys ( flatIO.getIndexes() );
+                                    return ix.reduce ( (res,item) => {
+                                                              if ( item.includes('/') )   return res
+                                                              res.push ( item )
+                                                              return res
+                                                        }, [] )
+                                }
+                    , index  : n => {
+                                        if ( n == null )   return null
+                                        let r  = flatIO.getLine(n)
+                                        if ( r ) {
+                                              let [ name, d, breadcrumbs, links ] = r;
+                                              let copy;
+                                              if ( d instanceof Array )   copy = [...d ]
+                                              else                        copy = {...d }
+                                              return [ name, copy, breadcrumbs, [...links] ]
+                                          }
+                                        else return null
+                                  } // index
+                }
+            ;
+        return objectAPI
+    } // flatObject func.
+
+
+
+export default flatObject
+
+

package/src/flatObject/insert.js

@@ -0,0 +1,38 @@
+'use strict'
+
+function insert ( dependencies, flatIO ) {
+return function insert ( name, inData ) {
+            const { convert, isDTO, isDTM, walk } = dependencies();
+            let d, copy;
+
+            if ( isDTO(inData) ) {
+                        d    = inData.export ()
+                        copy = inData.copy ()
+                        
+               }
+            else if ( isDTM(inData) ) {
+                        d = walk ({ data : inData })
+                        copy = walk ({ data : inData })
+                }
+            else {
+                        [ copy,, d ] = convert.from ( 'std' ).toFlat ( dependencies, inData )
+                        console.warn ( 'A non "dt-object" data segment was inserted. Autoconverted to "dt-object".' )
+                }
+            
+            const search = new RegExp ( `^root\/` );
+            d.forEach ( line => {   // Word 'root' should be changed to the argument 'name'.
+                        if ( line[0] === line[2] ) {  
+                                line[0] = name
+                                line[2] = name
+                            }
+                        line[2] = line[2].replace ( search, `${name}/` )
+                        line[3].forEach ( (edge,i) => line[3][i] = edge.replace ( search, `${name}/` )   )
+                })
+            flatIO.insert ( [copy,,d])
+}} // insert func.
+
+
+
+export default insert
+
+

package/src/flatObject/model.js

@@ -0,0 +1,32 @@
+'use strict'
+
+
+
+function model ( dependencies, flatIO ,flatStore ) {
+return function model () {
+    const 
+          [ fn, ...args ] = arguments
+        , { as } = fn ( flatStore, ...args ) || {}
+        , { convert } = dependencies ()
+        , selection = flatIO.getSelection ()
+        , data = ( selection.length === 0 ) ? flatIO.export() : selection
+        , CONVERTOR_NAMES = [ 'standard', 'std', 'midFlat', 'tuple', 'tuples', 'breadcrumb', 'breadcrumbs' ]
+        , hasConvertor = as ? CONVERTOR_NAMES.includes ( as ) : false
+        ;
+
+    let result;
+    if ( as && !hasConvertor ) {
+                console.error ( `Model '${as}' is unknown data-model.` )
+                return null
+        }
+    if ( as )   result = convert.to ( as, dependencies, data )
+    else        result = data
+    flatIO.reset ()
+    return result
+}} // model func.
+
+
+
+export default model
+
+

package/src/flatObject/query.js

@@ -0,0 +1,24 @@
+'use strict'
+
+
+
+function query ( dependencies, flatIO ,flatStore ) {
+return function query () {
+    const 
+          { main } = dependencies ()
+        , { load } = main ()
+        , [ fn, ...args ] = arguments
+        ;
+    
+    fn ( flatStore, ...args )
+    const result = flatIO.getSelection ();
+    flatIO.reset ()
+    if ( result.length === 0 )   return this
+    return load ( result )
+}} // query func.
+
+
+
+export default query
+
+

package/src/flatObject/setupFilter.js

@@ -0,0 +1,12 @@
+'use strict'
+
+
+function setupFilter ( flatIO ) {
+    return ( name, filterFn )  => flatIO.setupFilter ( name, filterFn )
+} // setupFilter func.
+
+
+
+export default setupFilter
+
+