gps-global-types 1.0.7 → 1.0.9

package/confused.js

@@ -0,0 +1,236 @@
+//var d3 = require('d3');//
+import { interpolateRgb } from 'd3-interpolate';
+import countryDict from '../static/coords.js'; // this file contains all facilities w corresponding countries as a dictionary
+const rainbow = ["ac9f9d", "beada1", "c0b7a6", "bcbbaa", "b8bfad", "a4c0b8", "9cbdbe", "97b6c2", "96acc1", "9ba5bb"]; //DO NOT DELETE
+import { isolateModel } from './isolate.model.tsx';
+import { toHex, dateToYMD } from '../helpers/reformatData.tsx';
+import Node from './node.model.tsx';
+import { colorFields, CustomDict, dateFields, dateKey, MSTGraph, MSTLegend, SnapshotType } from 'gps-global-types/mst.types.tsx';
+import { NodeType } from 'gps-global-types/pie.types.tsx';
+import { EdgeType } from 'gps-global-types/link.types.tsx';
+import { ObjectId } from 'gps-global-types/global.types.tsx';
+
+interface graphProps {
+    name:string,
+    snapshotData:SnapshotType
+}
+// console.log('LBL fields', lblFields)
+export class Graph implements MSTGraph { //implements MSTGraph
+    name:string;
+    // scheme:string;
+    //colorCalendar:lol;
+
+    nodes:NodeType[] = [];
+    links:EdgeType[] = [];
+    legend:MSTLegend;
+    custom:CustomDict= {}
+    snapshotData:SnapshotType
+    latest = { armordCultureDate: new Date('1900-01-01'), isos: [], _id: [] };
+    missing: Record<string,any>[] = [] 
+    constructor(props:graphProps) {
+        this.name = props.name;
+        var tempLegend:Record<string, any> = {};
+        colorFields.forEach((c) => {
+            tempLegend[c] = new Set();
+        });
+        dateFields.forEach((d) => {
+            tempLegend[d] = 'date'; //[{color:'#e4f1f1',label:'freshest'}, {color:'#062a51',label:'most stale'}];;
+        });
+        tempLegend['custom color'] = [{ color: '#ffeeff', label: 'No custom file imported yet' }]; //before custom field is initialized
+        tempLegend.beforeAndAfter = 'beforeAndAfter';//changed this because otherwise the 'Most Recent' entry duplicates 
+        this.legend = tempLegend as MSTLegend
+        this.snapshotData = props.snapshotData ;
+
+    }
+
+    /**
+     * @summary populate included nodes with relevant sequencedIsolates data in a format d3tree.js can parse
+     * @param {isolateModel[]} isolateData
+     * @param {Object<ObjectId,ObjectId[]>} mappings parent id, baby ids
+     * @adescription HOWDY - if you AREN'T criminally obsessed with dicitonaries, this code will change that
+     */
+    buildNodes(mappings:Record<ObjectId,ObjectId[]>, isolateData:typeof isolateModel[]) {
+        var graphCalendar = {}; //used to determine color gradients after all dates have been collected 
+        dateFields.forEach((field) => {
+            graphCalendar[field] = []
+        })
+        /** maps matrix index to node 
+        * @type {Object<integer,Node>}
+         * 
+        */
+        var nodeDict = {}; //initialize with parent nodes omg obvi . u DUMB O.DUMBO MSCGEEE
+        var missingCount = 0; //keep track of the missing agenda
+        // isolateData.forEach((iso) => {
+        var i = 0;
+        while (i < isolateData.length) {
+            var id = isolateData[i]._id.toString();
+            // console.log(i, '...,', iso._id)
+            if (missingCount < this.missing.length) {
+                for (var m = this.missing.length - 1; m > -1; m--) { //backwards cuz splice is a dangerous beast
+                    var missId = this.missing[m];
+                    if (missId === id) {
+
+                        console.log(m, ' m/ss/ng ', missingCount, '!!!!', id, isolateData[i])
+                        this.missing.splice(m, 1);
+                        //ITS A MISSING NODE!!!!!!!!!!;
+                        missingCount++;
+
+                        this.missing.push(isolateData[i]);
+                        var deleted = isolateData.splice(i, 1);
+
+                        m = -1;
+                    }
+                }
+            }
+
+            var iso = isolateData[i]
+            if (isolateData[i]) {
+
+                iso._id = iso._id.toString();
+                var node;
+                var nodeId = mappings[iso._id];
+                //
+                var node = nodeDict[nodeId];
+
+                if (!node) {
+                    node = new Node();
+                    if (nodeId) {  //dad uninitialized
+                        node.id = nodeId;
+                    } else { //no dad
+                        node.id = iso._id.split(' ')[0];
+                    }
+                }
+                // iso.armordMrsnId = iso.mstMrsnId;
+                iso.armordCultureDate = iso.mstCultureDate;
+                node.nodeids.push(iso._id)
+                node.mrsnIds.push(iso.mrsnIds); //for custom
+                this.custom[iso._id] = { mrsnId: iso.mrsnId }; //estabish custom entry. mrsnId for csv unless hmm
+
+                //1. COLOR FIELDS + LEGEND
+                colorFields.forEach((field) => {
+                    if (field === 'country') {
+                        iso.country = countryDict[iso.armordFacility];
+                    }
+                    const value = toHex(iso[field])
+                    const isNotCustom = (field.includes('custom') == false);
+                    // console.log(isNotCustom, isNotCustom && this.snapshotData )
+                    if (isNotCustom) {
+                        this.legend[field].add(value + '&' + iso[field]); //add entry to legend
+                        node.populate(field, value);
+                        this.custom[iso._id][field] = value;
+                    } else if (this.snapshotData) {//populate initial snapshot colors
+                        const snapColor = this.snapshotData?.nodes[iso._id]?.color ? this.snapshotData.nodes[iso._id].color : 'grey'
+
+                        node.populate(field, snapColor);
+                        this.custom[iso._id][field] = snapColor
+                    }
+                });
+
+                //2. LBL FIELDS
+                lblFields.forEach((field) => {
+                    var isoField = iso[field.slice(0, -3)];
+                    if (field.match('custom') && this.snapshotData && this.snapshotData?.nodes[iso._id]) { //populate initial snapshot labels
+                        isoField = this.snapshotData?.nodes[iso._id]?.label //? this.snapshotData?.nodes[iso._id]?.label : 'grey' ;
+                        this.custom[iso._id][field] = this.snapshotData?.nodes[iso._id]?.label;
+                    }
+                    else if (!isoField) isoField = '-';
+                    if (field == 'noLabelLBL') node[field] = ' ';
+                    else node[field] += isoField + '&';
+                    this.custom[iso._id][field] = isoField;
+                });
+
+                // 3. DATE FIELDS
+                const nodeDate = new Date(iso.armordCultureDate);
+                if (nodeDate > new Date(this.latest.armordCultureDate)) this.latest = { armordCultureDate: nodeDate, isos: [iso] }; // parent_id: [node.id], armordMrsnId: [iso.armordMrsnId] 
+                else if (nodeDate.getTime() === this.latest.armordCultureDate.getTime()) {
+                    this.latest.isos.push(iso);
+                }
+                const nodeDateStr = dateToYMD(nodeDate);
+                const nodeYear = nodeDate.getFullYear();
+                const nodeMonth = nodeYear + '-' + nodeDate.getMonth();
+                const nodeQuarter = nodeYear + 'QTR' + ((nodeMonth <= 3) ? 1 : (nodeMonth <= 6) ? 2 : (nodeMonth <= 9) ? 3 : 4);
+
+
+                var fieldMap = { 'armordCultureDate': nodeDateStr, 'quarter': nodeQuarter, 'month': nodeMonth, 'year': nodeYear };
+                this.custom[iso._id] = { ...fieldMap, ...this.custom[iso._id] };
+                dateFields.forEach((field) => {
+                    node.populate(field, fieldMap[field]);
+                    graphCalendar[field].push(fieldMap[field]);
+                })
+                // 3.5 sneaky before and after array
+                node.dateArr.push(nodeDate);
+
+                // 4. dont FORGET THE HOVER !!!
+                node.hover = node.hover.concat(iso.tier1);
+
+                //ADD HER TO THE NODES
+                nodeDict[node.id] = node;
+                i++
+
+            }  //missing
+            //0. get mapping/ parent id of iso
+
+        }
+
+        // configure colorCalendar based on graphCalendar 
+        /**
+         * return a color based on its field and date
+         *  @type {Object<String,Object<Date,String>>} 
+         * */
+        var colorCalendar = {}
+        Object.entries(graphCalendar).forEach(([field, arr]) => { //gradient time light (recent) -> dark (oldest)
+            arr = arr.sort()
+            var temp = {};
+            const max = arr.length
+            var normal = function (x) { return (max < 2) ? 1 : (x) / (max - 1) }
+            var gradient = interpolateRgb('#e4f1f1', '#062a51');
+            arr.forEach((date, i) => {
+                temp[date] = gradient(normal(i));
+            })
+            colorCalendar[field] = temp;
+        });
+
+        this.latest._id = this.latest.isos.map(i => { return i._id });
+
+        Object.entries(nodeDict).forEach(([key, node]) => {
+            if (this.snapshotData && this.snapshotData?.transforms[key]) {//initialize node position if snapshot is included
+                node.x = this.snapshotData.transforms[key].x;
+                node.y = this.snapshotData.transforms[key].y;
+            }
+            node.hover = Array.from(new Set(node.hover)); //convert array of tier 1 alleles into a string of unique values
+            this.tier1s = this.tier1s.concat(node.hover)
+            node.hover = node.hover.reduce((prev, curr) => {
+                return prev + ', ' + curr;
+            }, '');
+            node.hover = node.hover.substring(2) //remove silly first comma
+
+            if (!this.snapshotData) node['custom color'] = { '#fff': 1 }; //initialize dummy customcolor
+            node.beforeAndAfter = [{ color: '#fff', value: 1 }]; //initialize dummy ColorField[] obj to avoid crashes (if beforeAndAfter is selected as initial color field, and before and Afte colors haven't been calculated yet, firefox convluses in a horrific spasm)
+        })
+        Object.entries(this.custom).forEach(([id, dict]) => {
+            dateFields.forEach((field) => {
+                this.custom[id][field] = colorCalendar[field][this.custom[id][field]]; //brain = gone ; goodbye
+            })
+        })
+        colorFields.forEach((field) => {
+            if (field.match('custom')) return
+            this.legend[field] = Array.from(this.legend[field]).map(v => {
+                var temp = {};
+                var clrLbl = v.split('&');
+                temp.color = clrLbl[0];
+                temp.label = clrLbl[1];
+                return temp;
+            })
+            // this.legend[field].push(JSON.parse(process.env.REACT_APP_MOST_RECENT_LEGEND))
+        });
+        this.nodes = Object.values(nodeDict);
+        this.latest.armordCultureDate = dateToYMD(this.latest.armordCultureDate);
+        this.colorCalendar = colorCalendar;
+        this.tier1s = Array.from(new Set(this.tier1s))
+
+    }
+
+}
+
+
+// export Graph //typedefs

package/mst.types.tsx

@@ -32,7 +32,7 @@ export type labelKey = typeof labelFields[number];
 
 
 
-type CustomDictEntry = Record<colorKey | dateKey, Color> | Record<labelKey, string>;
+type CustomDictEntry = Partial<Record<colorKey & dateKey, Color>> | Partial<Record<labelKey, string>>;
 export type CustomDict = Record<ObjectId, CustomDictEntry>
 
 
@@ -90,12 +90,13 @@ interface MSTResult {
     }
 }
 
-interface LegendBullet { //or custom upload data
+export interface LegendBullet { //or custom upload data
     color: Color,
     label: string
 }
 
-export type MSTLegend = Record<colorKey, LegendBullet[]> & Record<dateKey, 'date'> & { 'beforeAndAfter': [{ color: '#666666', label: 'Before ' }, { color: '#4a64aa', label: 'After ' }] }
+export type MSTLegend = Record<colorKey&'beforeAndAfter'&'custom color', LegendBullet[]> & Record<dateKey, 'date'>;
+// & { 'beforeAndAfter': [{ color: '#666666', label: 'Before ' }, { color: '#4a64aa', label: 'After ' }] }
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gps-global-types",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "types shared between front-end and back-end",
   "main": "index.js",
   "scripts": {

package/pie.types.tsx

@@ -1,5 +1,5 @@
 import type { BaseType, Selection, SimulationNodeDatum } from "d3";
-import type { ObjectId, Color, RegexMatchedString } from "./global.types.tsx"
+import type { ObjectId, Color, RegexMatchedString, mrsnId } from "./global.types.tsx"
 import type  { colorKey, dateKey, labelKey } from "./mst.types.tsx"
 
 export interface ColorField {//TYPES OF GRAPH FIELDS ColorField datefields become colorFields but require additional processing  
@@ -23,6 +23,7 @@ export interface ExtraNodeTypeFields extends SimulationNodeDatum {
     dateArr: DateType[], // array of armordCultureDates used for beforeAndAfter coloring
     hover?: string, // [=""] //unique fieldfields \/ \/ list seperated by ', ' (only tier1 alleles for now)
     nodeids: ObjectId[] // for selection logic between table and node=
+    mrsnIds:mrsnId[],
     x?: number,
     y?: number,
     fx?: number | null,