vaporous 0.0.4 → 0.0.6

package/Vaporous.js

@@ -14,7 +14,6 @@ const styles = fs.readFileSync(__dirname + '/styles.css')
 const Papa = require('papaparse')
 
 // These globals allow us to write functions from the HTML page directly without needing to stringify
-class google { }
 const document = {}
 
 const keyFromEvent = (event, bys) => bys.map(i => event[i.bySplit]).join('|')
@@ -35,7 +34,7 @@ const _sort = (order, data, ...keys) => {
 
 class Vaporous {
 
-    constructor() {
+    constructor({ loggers } = {}) {
         this.events = [];
         this.visualisations = [];
         this.visualisationData = []
@@ -44,9 +43,50 @@ class Vaporous {
 
         this.savedMethods = {}
         this.checkpoints = {}
+
+        this.loggers = loggers
+        this.perf = null
+        this.totalTime = 0
+    }
+
+    manageEntry() {
+        if (this.loggers?.perf) {
+            const [, , method, ...origination] = new Error().stack.split('\n')
+            const invokedMethod = method.match(/Vaporous.(.+?) /)
+
+            let orig = origination.find(orig => {
+                const originator = orig.split("/").at(-1)
+                return !originator.includes("Vaporous")
+            })
+
+            orig = orig.split("/").at(-1)
+            const logLine = "(" + orig + " BEGIN " + invokedMethod[1]
+            this.loggers.perf('info', logLine)
+            this.perf = { time: new Date().valueOf(), logLine }
+        }
+    }
+
+    manageExit() {
+        if (this.loggers?.perf) {
+            let { logLine, time } = this.perf;
+            const executionTime = new Date() - time
+            this.totalTime += executionTime
+
+            const match = logLine.match(/^.*?BEGIN/);
+            const prepend = "END"
+            if (match) {
+                const toReplace = match[0]; // the matched substring
+                const spaces = " ".repeat(toReplace.length - prepend.length); // same length, all spaces
+                logLine = spaces + prepend + logLine.replace(toReplace, "");
+            }
+
+            this.loggers.perf('info', logLine + " (" + executionTime + "ms)")
+        }
+        return this
     }
 
     method(operation, name, options) {
+        if (operation != 'retrieve') this.manageEntry()
         const operations = {
             create: () => {
                 this.savedMethods[name] = options
@@ -61,70 +101,91 @@ class Vaporous {
 
 
         operations[operation]()
-        return this
+        if (operation !== 'retrieve') return this.manageExit()
+        return this;
+    }
+
+    filterIntoCheckpoint(checkpointName, funct, { disableCloning = false, destroy = true } = {}) {
+        this.manageEntry()
+        const dataCheckpoint = this.events.filter(funct)
+        this._checkpoint('create', checkpointName, dataCheckpoint, { disableCloning })
+        if (destroy) this.events = this.events.filter(event => !funct(event))
+        return this.manageExit()
     }
 
     filter(...args) {
+        this.manageEntry()
         this.events = this.events.filter(...args)
-        return this
+        return this.manageExit()
     }
 
     append(entities) {
+        this.manageEntry()
         this.events = this.events.concat(entities)
-        return this;
+        return this.manageExit()
     }
 
     eval(modifier) {
+        this.manageEntry()
         this.events.forEach(event => {
             const vals = modifier(event)
             if (vals) Object.assign(event, vals)
         })
-        return this;
+        return this.manageExit()
     }
 
-    table(modifier) {
+    _table(modifier) {
         this.events = this.events.map(event => {
             const vals = modifier(event)
             return vals;
         })
-        return this;
+    }
+    table(modifier) {
+        this.manageEntry()
+        this._table(modifier)
+        return this.manageExit()
     }
 
     rename(...entities) {
+        this.manageEntry()
         this.events.forEach(event => {
             entities.forEach(([from, to]) => {
                 event[to] = event[from]
                 delete event[from]
             })
         })
-        return this;
+        return this.manageExit()
     }
 
     parseTime(value, customFormat) {
+        this.manageEntry()
         this.events.forEach(event => {
             event[value] = dayjs(event[value], customFormat).valueOf()
         })
-        return this;
+        return this.manageExit()
     }
 
     bin(value, span) {
+        this.manageEntry()
         this.events.forEach(event => {
             event[value] = Math.floor(event[value] / span) * span
         })
-        return this;
+        return this.manageExit()
     }
 
     fileScan(directory) {
+        this.manageEntry()
         const items = fs.readdirSync(directory)
         this.events = items.map(item => {
             return {
                 _fileInput: path.resolve(directory, item)
             }
         })
-        return this;
+        return this.manageExit()
     }
 
     async csvLoad(parser) {
+        this.manageEntry()
         const tasks = this.events.map(obj => {
             const content = []
 
@@ -137,24 +198,35 @@ class Vaporous {
                     step: (row) => {
                         try {
                             const event = parser(row)
-                            if (event !== null) content.push(event)
+                            if (event !== null) {
+                                if (event instanceof Array) {
+                                    event.forEach(item => {
+                                        item._fileInput = obj._fileInput
+                                        content.push(item)
+                                    })
+                                } else {
+                                    event._fileInput = obj._fileInput
+                                    content.push(event)
+                                }
+                            }
                         } catch (err) {
                             reject(err)
                         }
                     },
                     complete: () => {
-                        obj._raw = content
-                        resolve(this)
+                        resolve(content)
                     }
                 })
             })
         })
 
-        await Promise.all(tasks)
-        return this;
+        const payloads = await Promise.all(tasks)
+        this.events = payloads
+        return this.manageExit()
     }
 
     async fileLoad(delim, parser) {
+        this.manageEntry()
         const tasks = this.events.map(obj => {
             const content = []
 
@@ -164,24 +236,34 @@ class Vaporous {
                     .on('data', line => {
                         try {
                             const event = parser(line)
-                            if (event !== null) content.push(event)
+                            if (!event) return;
+
+                            if (event instanceof Array) {
+                                event.forEach(item => {
+                                    item._fileInput = obj._fileInput
+                                    content.push(item)
+                                })
+                            } else {
+                                if (!event._fileInput) event._fileInput = obj._fileInput
+                                content.push(event)
+                            }
                         } catch (err) {
                             throw err;
                         }
 
                     })
                     .on('end', () => {
-                        obj._raw = content;
-                        resolve(this)
+                        resolve(content)
                     })
             })
         })
 
-        await Promise.all(tasks)
-        return this;
+        this.events = await Promise.all(tasks)
+        return this.manageExit()
     }
 
     output(...args) {
+        this.manageEntry()
         if (args.length) {
             console.log(this.events.map(event => {
                 return args.map(item => event[item])
@@ -190,28 +272,13 @@ class Vaporous {
             console.log(this.events)
         }
 
-        return this;
+        return this.manageExit()
     }
 
-    flatten() {
-        const arraySize = this.events.reduce((acc, obj) => acc + obj._raw.length, 0)
-        let flattened = new Array(arraySize)
-        let i = 0
-
-        this.events.forEach(obj => {
-            const raws = obj._raw
-            delete obj._raw
-
-            raws.forEach(event => {
-                flattened[i++] = {
-                    ...obj,
-                    _raw: event,
-                }
-            })
-
-        })
-        this.events = flattened;
-        return this;
+    flatten(depth = 1) {
+        this.manageEntry()
+        this.events = this.events.flat(depth)
+        return this.manageExit()
     }
 
     _stats(args, events) {
@@ -268,11 +335,13 @@ class Vaporous {
     }
 
     stats(...args) {
+        this.manageEntry()
         this.events = this._stats(args, this.events).arr
-        return this;
+        return this.manageExit()
     }
 
     eventstats(...args) {
+        this.manageEntry()
         const stats = this._stats(args, this.events)
 
         this.events.forEach(event => {
@@ -281,10 +350,10 @@ class Vaporous {
             Object.assign(event, stats.map[key])
         })
 
-        return this
+        return this.manageExit()
     }
 
-    streamstats(...args) {
+    _streamstats(...args) {
         const backwardIterate = (event, i, by, maxBoundary = 0) => {
             let backwardIndex = 0
             const thisKey = keyFromEvent(event, by)
@@ -332,28 +401,38 @@ class Vaporous {
             delete event._streamstats
         })
 
-        return this;
+        return this
+    }
+
+    streamstats(...args) {
+        this.manageEntry()
+        this._streamstats(...args)
+        return this.manageExit()
     }
 
     delta(field, remapField, ...bys) {
-        this.streamstats(new Aggregation(field, 'range', remapField), new Window(2), ...bys)
-        return this;
+        this.manageEntry()
+        this._streamstats(new Aggregation(field, 'range', remapField), new Window(2), ...bys)
+        return this.manageExit()
     }
 
     sort(order, ...keys) {
+        this.manageEntry()
         this.events = _sort(order, this.events, ...keys)
-        return this;
+        return this.manageExit()
     }
 
     assert(funct) {
+        this.manageEntry()
         const expect = (funct) => { if (!funct) throw new Error('Assertion failed') }
         this.events.forEach((event, i) => {
             funct(event, i, { expect })
         })
-        return this;
+        return this.manageExit()
     }
 
-    build(name, type, { tab = 'Default', columns = 2, y2, y1Type, y2Type, y1Stacked, y2Stacked, sortX = 'asc', xTicks = false, trellisAxis = "shared" } = {}) {
+    build(name, type, { tab = 'Default', columns = 2, y2, y1Type, y2Type, y1Stacked, y2Stacked, sortX = 'asc', xTicks = false, trellisAxis = "shared", legend } = {}) {
+        this.manageEntry()
 
         const visualisationOptions = { tab, columns }
 
@@ -372,6 +451,9 @@ class Vaporous {
 
             return y2Mapped
         }
+
+        const xPrimary = this.graphFlags.at(-1).xPrimary
+
         const graphData = this.events.map((trellis, i) => {
             if (type === 'Table') {
                 return trellis;
@@ -379,12 +461,13 @@ class Vaporous {
 
             const dataOptions = {}
 
-            // For every event in this trellis restructure to chart.js
-            if (sortX) trellis = _sort(sortX, trellis, '_time')
-
             const trellisName = this.graphFlags.at(-1).trellisName?.[i] || ""
             const columnDefinitions = this.graphFlags.at(-1).columnDefinitions[i]
 
+            // For every event in this trellis restructure to chart.js
+            if (sortX) trellis = _sort(sortX, trellis, xPrimary)
+
+
             trellis.forEach(event => {
                 columnDefinitions.forEach(prop => {
                     if (!dataOptions[prop]) dataOptions[prop] = []
@@ -403,12 +486,12 @@ class Vaporous {
             })
 
 
-            const _time = dataOptions._time
-            delete dataOptions._time
+            const primary = dataOptions[xPrimary]
+            delete dataOptions[xPrimary]
 
             let y2WasMapped = false
             const data = {
-                labels: _time,
+                labels: primary,
                 datasets: Object.keys(dataOptions).map(data => {
                     const y2Mapped = isY2(data)
                     if (y2Mapped) y2WasMapped = y2Mapped
@@ -468,6 +551,7 @@ class Vaporous {
                     responsive: true,
                     plugins: {
                         legend: {
+                            display: legend || true,
                             position: 'bottom',
                         },
                         title: {
@@ -484,7 +568,7 @@ class Vaporous {
             graphData.forEach(trellisGraph => {
                 Object.keys(bounds).forEach(bound => {
                     let axis = isY2(bound) ? 'y2' : 'y'
-                    if (bound === '_time') axis = 'x';
+                    if (bound === xPrimary) axis = 'x';
 
                     const thisAxis = trellisGraph.options.scales[axis]
                     const { min, max } = bounds[bound]
@@ -511,22 +595,28 @@ class Vaporous {
             this.tabs = this.tabs.sort((a, b) => a.localeCompare(b))
         }
 
-        return this;
+        return this.manageExit()
     }
 
-    checkpoint(operation, name) {
-
+    _checkpoint(operation, name, data, { disableCloning }) {
         const operations = {
-            create: () => this.checkpoints[name] = structuredClone(this.events),
-            retrieve: () => this.events = structuredClone(this.checkpoints[name]),
+            create: () => this.checkpoints[name] = disableCloning ? data : structuredClone(data),
+            retrieve: () => this.events = disableCloning ? this.checkpoints[name] : structuredClone(this.checkpoints[name]),
             delete: () => delete this.checkpoints[name]
         }
 
         operations[operation]()
-        return this;
+        return this
+    }
+
+    checkpoint(operation, name, { disableCloning } = {}) {
+        this.manageEntry()
+        this._checkpoint(operation, name, this.events, { disableCloning })
+        return this.manageExit()
     }
 
     mvexpand(target) {
+        this.manageEntry()
         const arr = []
         this.events.forEach(event => {
             if (!event[target]) return arr.push(event)
@@ -540,38 +630,45 @@ class Vaporous {
         })
 
         this.events = arr
-        return this;
+        return this.manageExit()
     }
 
     writeFile(title) {
+        this.manageEntry()
         fs.writeFileSync('./' + title, JSON.stringify(this.events))
-        return this;
+        return this.manageExit()
     }
 
     toGraph(x, y, series, trellis = false) {
 
+        this.manageEntry()
         if (!(y instanceof Array)) y = [y]
+        if (!(x instanceof Array)) x = [x]
 
         const yAggregations = y.map(item => [
             new Aggregation(item, 'list', item),
         ]).flat()
 
-        this.stats(
+        const xBy = x.map(x => new By(x))
+
+        this.events = this._stats([
             ...yAggregations,
             new Aggregation(series, 'list', series),
             new Aggregation(trellis, 'values', 'trellis'),
-            new By(x), trellis ? new By(trellis) : null
-        )
+            ...xBy, trellis ? new By(trellis) : null], this.events
+        ).arr
 
         const trellisMap = {}, columnDefinitions = {}
 
-        this.table(event => {
-            const _time = event[x]
-            if (_time === null || _time === undefined) throw new Error(`To graph operation with params ${x}, ${y.join(',')} looks corrupt. x value resolves to null - the graph will not render`)
+        this._table(event => {
             const obj = {
-                _time
+                [x[0]]: event[x[0]]
             }
 
+            x.forEach(item => {
+                obj[item] = event[item]
+            })
+
             event[series].forEach((series, i) => {
                 y.forEach(item => {
                     let name;
@@ -605,30 +702,33 @@ class Vaporous {
             return obj
         })
 
-        const graphFlags = {}
+        const graphFlags = {
+            xPrimary: x[0]
+        }
 
         if (trellis) {
             graphFlags.trellis = true;
             graphFlags.trellisName = Object.keys(trellisMap)
             graphFlags.columnDefinitions = Object.keys(trellisMap).map(tval => {
-                const adjColumns = ['_time']
-                Object.keys(columnDefinitions[tval]).forEach(col => (col !== '_time') ? adjColumns.push(col) : null)
+                const adjColumns = [x[0]]
+                Object.keys(columnDefinitions[tval]).forEach(col => (col !== x[0]) ? adjColumns.push(col) : null)
                 return adjColumns
             })
             this.events = Object.keys(trellisMap).map(tval => trellisMap[tval])
         } else {
-            const adjColumns = ['_time']
-            Object.keys(columnDefinitions).forEach(col => (col !== '_time') ? adjColumns.push(col) : null)
+            const adjColumns = [x[0]]
+            Object.keys(columnDefinitions).forEach(col => (col !== x[0]) ? adjColumns.push(col) : null)
 
             this.events = [this.events]
             graphFlags.columnDefinitions = [adjColumns]
         }
 
         this.graphFlags.push(graphFlags)
-        return this;
+        return this.manageExit()
     }
 
     render(location = './Vaporous_generation.html') {
+        this.manageEntry()
         const classSafe = (name) => name.replace(/[^a-zA-Z0-9]/g, "_")
 
         const createElement = (name, type, visualisationOptions, eventData, { trellis, trellisName = "" }) => {
@@ -719,8 +819,9 @@ class Vaporous {
   </body>
 </html>
         `)
-
         console.log('File ouput created ', path.resolve(filePath))
+        if (this.totalTime) console.log("File completed in " + this.totalTime)
+        return this.manageExit()
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vaporous",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Transition data to different structured states for analytical processing",
   "main": "Vaporous.js",
   "scripts": {
@@ -13,4 +13,4 @@
     "papaparse": "^5.5.3",
     "split2": "^4.2.0"
   }
-}
+}

package/styles.css

@@ -61,7 +61,7 @@ body {
     flex-wrap: wrap;
     padding: 0px;
     gap: 8px;
-    justify-content: space-between;
+    justify-content: flex-start;
 }
 
 .parentHolder {