dt-toolbox 7.2.0 → 7.4.0

package/Changelog.md

@@ -1,6 +1,22 @@
 ## Release History
 
 
+
+### 7.4.0 ( 2023-11-3)
+- [x] Types were added to the project;
+
+
+
+
+### 7.3.0 ( 2023-10-19 )
+- [x] Model function recognize a `dt-model` model. Result is equal to result of `export`;
+- [x] Model function recognize a `dt-object` model. Returns a new dt-object;
+- [x] Method `extractList` recognize a `dt-model` and `dt-object` models;
+- [x] Method `init` recognize a `dt-model` model. Result is equal to result of `load`;
+- [x] Update of @peter.naydenov/walk to version 4.2.0;
+
+
+
 ### 7.2.0 (2023-09-18)
 - [x] Convertors recognize HTML DOM nodes. Makes a copy by reference;
 - [x] Convertors recognize functions. Makes a copy by reference;

package/README.md

@@ -2,12 +2,18 @@
 
 ![version](https://img.shields.io/github/package-json/v/peterNaydenov/dt-toolbox)
 ![license](https://img.shields.io/github/license/peterNaydenov/dt-toolbox)
+![npm](https://img.shields.io/npm/dt/dt-toolbox)
+![issues](https://img.shields.io/github/issues/peterNaydenov/dt-toolbox)
+![language](https://img.shields.io/github/languages/top/peterNaydenov/dt-toolbox)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/peterNaydenov/dt-toolbox)
+![npm bundle size](https://img.shields.io/bundlephobia/min/dt-toolbox)
 
 
 
-## Last Updates
 
-After version 7.1.x `dt-object` api has a new method `extractList` that helps to extract a multiple segments or properties, defined as a list. Use '**options**'(the second argument) to define a model of extracted data if needed. Reed about `extractList` bellow.
+## Last Updates
+- After version 7.3.0 extractList options.as can receive a `dt-model` and `dt-object`;
+- After version 7.1.x `dt-object` api has a new method `extractList` that helps to extract a multiple segments or properties, defined as a list. Use '**options**'(the second argument) to define a model of extracted data if needed. Reed about `extractList` bellow.
 
 
 
@@ -543,7 +549,7 @@ const storage = dtbox.init ( first );   // first will become a root segment
 storage.insertSegment ( 'second', second );
 storage.insertSegment ( 'third', third );
 
-const [ a, b c, firstData, otherData ] = storage.extractList ( ['first', 'second', 'third', 'data', 'secondData' ], { type: 'std' } ));
+const [ a, b c, firstData, otherData ] = storage.extractList ( ['first', 'second', 'third', 'data', 'secondData' ], { as: 'std' } ));
 // a -> { name: 'first', data: 'first data' }
 // b -> { name: 'second', data: 'second data' }
 // c -> { name: 'third', data: 'third data' }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dt-toolbox",
   "description": "Data manipulation tool",
-  "version": "7.2.0",
+  "version": "7.4.0",
   "license": "MIT",
   "author": "Peter Naydenov",
   "keywords": [
@@ -28,11 +28,11 @@
   },
   "homepage": "https://github.com/PeterNaydenov/dt-toolbox#readme",
   "dependencies": {
-    "@peter.naydenov/walk": "4.1.0"
+    "@peter.naydenov/walk": "4.2.0"
   },
   "devDependencies": {
     "c8": "^8.0.1",
-    "chai": "^4.3.8",
+    "chai": "^4.3.10",
     "mocha": "^10.2.0"
   },
   "c8": {

package/src/convertors/index.js

@@ -50,14 +50,19 @@ function from ( type ) {   // convert from something to flat...
 function to ( type, dependencies, inData ) {   // convert from flat to 'data-type'...
         const 
               breadcrumbs = {}
+            , { walk } = dependencies ()
             , check = new Set()
             , extend = new Set()
             ;
         let tups, count = 0;
         switch ( type ) {
+            case 'flat':
+            case 'dt-model':
+                             return walk ({data:inData })
             case 'std' :
             case 'standard':
                              return std.toType ( inData )
+            case 'midflat'  :
             case 'midFlat' : 
                              return midFlat.toType ( inData )
             case 'tuple':

package/src/flatObject/extractList.js

@@ -7,6 +7,7 @@ return function extractList ( list, options ) {
             const 
                       root     = indexFn ( 'root' )
                     , { main:{load}, INIT_DATA_TYPES } = dependencies ()
+                    , asTypes = [ ...INIT_DATA_TYPES, 'dt-object' ]
                     ;
             let 
                   error = false
@@ -18,9 +19,9 @@ return function extractList ( list, options ) {
                             error = true
                             errorMsg = `Options should be an object and property "as" is required`
                         }
-                    if ( !error && !INIT_DATA_TYPES.includes(options.as) ) {  
+                    if ( !error && !asTypes.includes(options.as) ) {  
                             error = true
-                            errorMsg = `Invalid option "as" value: ${options.as}. Choose one of: std, standard, ''`
+                            errorMsg = `Invalid option "as" value: ${options.as}.`
                         }
                     if ( error )  throw new Error ( errorMsg )
                 }
@@ -34,7 +35,7 @@ return function extractList ( list, options ) {
                         .map ( item => {
                                             if ( item == null            )   return null
                                             if ( !(item instanceof Array))   return item
-                                            return options ? load(item).model(() => options ) : load(item)
+                                            return load(item).model(() => options )
                                         })
 }} // extractList func.
 

package/src/flatObject/index.js

@@ -21,7 +21,7 @@ function flatObject ( dependencies, d ) {
             , objectAPI = {
                     // I/O Operations
                       insertSegment : insert ( dependencies, flatIO )         // Extends available data with new data segment;
-                    , export : ex     ( dependencies, flatIO )                // Returns flat data;
+                    , export : ex     ( dependencies, flatIO )                // Returns a 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;

package/src/flatObject/model.js

@@ -9,7 +9,7 @@ return function model () {
       , selectionIx = {}
       ;
     const 
-          { convert, draft } = dependencies ()
+          { convert, draft, INIT_DATA_TYPES, main:{load} } = dependencies ()
         , draft_API = {
                           set     : draft.set ( selection, selectionIx )      // Selection: Creates a new row;
                         , connect : draft.connect ( selectionIx )             // Selection: Creates an edges among rows;
@@ -19,18 +19,19 @@ return function model () {
         , [ fn, ...args ] = arguments
         , { as } = fn ( {...flatStore,...draft_API}, ...args ) || {}
         , data = ( selection.length === 0 ) ? flatIO.export() : selection
-        , CONVERTOR_NAMES = [ 'standard', 'std', 'midFlat', 'tuple', 'tuples', 'breadcrumb', 'breadcrumbs', 'files', 'file' ]
-        , hasConvertor = as ? CONVERTOR_NAMES.includes ( as ) : false
+        , hasConvertor = as ? INIT_DATA_TYPES.includes ( as ) : false
         ;
 
     let result;
+    if ( as === 'dt-object'  ) {  
+                return load ( data )
+        }
     if ( as && !hasConvertor ) {
                 console.error ( `Model '${as}' is unknown data-model.` )
                 return null
         }
-        
     if ( as )   result = convert.to ( as, dependencies, data )
-    else        result = data
+    else        result = load ( data )
     flatIO.resetScan ()
     return result
 }} // model func.

package/src/flatObject/setupFilter.js

@@ -1,8 +1,9 @@
 'use strict'
 
-
 function setupFilter ( flatIO ) {
-    return ( name, filterFn )  => flatIO.setupFilter ( name, filterFn )
+return function setupFilter ( name, filterFn ) {
+        flatIO.setupFilter ( name, filterFn )
+}
 } // setupFilter func.
 
 

package/src/main.js

@@ -43,12 +43,16 @@ const { init, load, flating, converting, getWalk } =  mainLib;
 
 
 
+
+
+
+
 const dtbox = {
-              init : init
-            , load : load
-            , flat : flating
-            , convert : converting
-            , getWalk
+            init,
+            load, 
+            flat : flating, 
+            convert : converting,
+            getWalk
         } // dtbox func.
 
 

package/src/mainLib.js

@@ -16,13 +16,54 @@ const INIT_DATA_TYPES = [
                 , 'tuple', 'tuples'
                 , 'breadcrumb', 'breadcrumbs'
                 , 'file', 'files'
-                , 'midFlat'
-                , 'flat'
+                , 'midFlat', 'midflat'
+                , 'flat', 'dt-model'
             ]
     ;
 
 
 
+/**
+* @typedef {(number|string|boolean)} Primitives
+* @typedef {('std'|'tuples'|'breadcrumbs'|'files'|'midFlat'|'flat'|'dt-model')} DtmodelNames
+* @typedef {(filterName:string,fn:function)=>void} setupFilterFn
+* @typedef {(segmentName:string, segment:DTObject)=>void} insertSegmentFn
+* @typedef {(request:Array<string>,options:{as:DtmodelNames}=) => Array<RequestedModel>} extractListFn;
+* @typedef {(fn:queryFunction, ...args)=>DTObject} QueryFn
+* @typedef {(breadcrumbs:string) => dtLine } IndexFn
+*
+*
+*
+* @typedef {Object} DTObject
+* @property {insertSegmentFn} insertSegment - Extends available data with new data segment;
+* @property {(segmentName:string)=>Dtmodel} export - Returns a dt-model of the data;
+* @property {Function} copy - Creates deep copy of original data segment;
+* @property {Function} model - Arrange data according specific data-model. Model should come as a function;
+* @property {QueryFn} query - Request, and evaluate data. Returns a new flat object;
+* @property {setupFilterFn} setupFilter - Functions should filter content according some criteria. Generated indexes will help for data search in;
+* @property {Function} listSegments - Returns list of segments in flat data;
+* @property {IndexFn} index - Returns dt-line by breadcrumbs;
+* @property {extractListFn} extractList - Extracts list of data segments;
+*
+*
+*
+*
+*
+* @typedef {{0:string,1:(Array<Primitives>|Object<string,Primitives>),2:string,3:string[]}} Dtmodel - dt-model
+* @param Dtmodel[]0 - name of the dt-line;
+* @param Dtmodel[]1 - flat data;
+* @param Dtmodel[]2 - breadcrumbs of the dt-line;
+* @param Dtmodel[]3 - children breadcrumbs(edges);
+*
+*
+*
+* @typedef {Object} Initoptions
+* @description dtbox.init options
+* @property {string} [model='std'] model - data model according library's data models.(Look at the documentation)
+*/
+
+
+
 const mainLib = {
 
     dependencies () {
@@ -43,11 +84,19 @@ const mainLib = {
                                         }
                             , draft
                         }
-            } // dependencies func.
+            },   // dependencies func.
 
 
 
-    , init ( inData, options={} ) {
+/**
+ * @function init
+ * @description Create a dt-object from data source
+ * @param {(Array|Object)} inData - data source
+ * @param {Object} options - options {}
+ * @param {('std'|'tuples'|'breadcrumbs'|'files'|'midFlat'|'flat'|'dt-model')} options.model - model of the data source
+ * @returns {DTObject} - dt-object
+ */
+    init ( inData, options={} ) {
                     let 
                           defaultOptions = { model : 'std' }
                         , { model } = Object.assign ( {}, defaultOptions, options )
@@ -57,13 +106,23 @@ const mainLib = {
                             console.error ( `Can't understand your data-model: ${model}. Please, find what is possible on https://github.com/PeterNaydenov/dt-toolbox` )
                             return null
                         }
-                    const d  = convert.from(model).toFlat ( dependencies, inData );
+                    const d  = ['flat', 'dt-model'].includes ( model ) ? 
+                                                mainLib.load ( inData ) : 
+                                                convert.from ( model ).toFlat ( dependencies, inData );
                     return flatObject ( dependencies, d )
-            } // init func.
-
-
-
-    , load ( inData ) {
+            }, // init func.
+
+/**
+ * @function load
+ * @description Load data from dt-model
+ * @param {{0:string,1:(Array<Primitives>|Object<string,Primitives>),2:string,3:string[]}} inData - dt-model:
+ * @param inData[]0 - name of the dt-line;
+ * @param inData[]1 - flat data;
+ * @param inData[]2 - breadcrumbs of the dt-line;
+ * @param inData[]3 - children breadcrumbs(edges);
+ * @returns {DTObject} - dt-object
+ */
+    load ( inData ) {
                 const index = {};
                 inData.forEach ( line => {
                                         const [ , ,breadcrumbs ] = line;
@@ -71,11 +130,20 @@ const mainLib = {
                                 })
                 const copy = walk ({data: inData });
                 return flatObject ( mainLib.dependencies, [copy, index, inData ] )
-            } // load func.
+            }, // load func.
 
 
 
-    , flating ( inData, options={} ) {
+/**
+ * 
+ * @function flating
+ * @description Create a dt-model from data source
+ * @param {(Array|Object)} inData - data source. Object or array.
+ * @param {Object} options - options.
+ * @param {('std'|'tuples'|'breadcrumbs'|'files'|'midFlat'|'flat'|'dt-model')} options.model - model of the data source
+ * @returns {Dtmodel[]} - dt-model
+ */
+     flating ( inData, options={} ) {
                 let 
                        defaultOptions = { model : 'std' }
                     ,  { model } = Object.assign ( {}, defaultOptions, options )
@@ -83,11 +151,18 @@ const mainLib = {
                     if ( !INIT_DATA_TYPES.includes(model) )   return null
                     let [,,dt] = convert.from ('std').toFlat ( mainLib.dependencies, inData );
                     return dt
-            } // flating func.
-
-
-
-    , converting ( inData, options={} ) {
+            }, // flating func.
+
+/**
+ * @function converting
+ * @description Convert data from one model to another
+ * @param {Array|Object} inData - data source
+ * @param {Object} options
+ * @param {string} options.model - model of the data source
+ * @param {string} options.as - model to be converted to
+ * @returns {Array|Object} - converted data
+ */
+     converting ( inData, options={} ) {
                 let 
                        defaultOptions = { model : 'std', as: 'std' }
                     ,  { model, as } = Object.assign ( {}, defaultOptions, options )
@@ -97,11 +172,16 @@ const mainLib = {
                     let [,,dt] = convert.from ('std').toFlat ( mainLib.dependencies, inData );
 
                     return convert.to ( as, mainLib.dependencies, dt )
-            } // flating func.
+            }, // flating func.
+
 
 
-            
-    , getWalk : () => walk
+/**
+ * @function getWalk
+ * @description Extract the 'walk' (@peter.naydenov/walk) dependency from dt-toolbox library
+ * @returns {Function} - the 'walk' function
+ */
+    getWalk : () => walk
 
 } // mainLib