dt-toolbox 7.3.0 → 7.4.0

package/Changelog.md

@@ -2,6 +2,12 @@
 
 
 
+### 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;

package/README.md

@@ -2,6 +2,12 @@
 
 ![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)
+
 
 
 
@@ -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.3.0",
+  "version": "7.4.0",
   "license": "MIT",
   "author": "Peter Naydenov",
   "keywords": [

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/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

@@ -23,6 +23,47 @@ const INIT_DATA_TYPES = [
 
 
 
+/**
+* @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 )
@@ -61,11 +110,19 @@ const mainLib = {
                                                 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;
@@ -73,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 )
@@ -85,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 )
@@ -99,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