kempo-ui 0.0.28 → 0.0.30

package/src/components/tableControls/Edit.js

@@ -3,9 +3,7 @@ import { html, css } from '../../lit-all.min.js';
 import '../Icon.js';
 
 export default class Edit extends TableControl {
-	/*
-		Properties
-	*/
+	/* Properties */
 	static properties = {
 		isEditing: { type: Boolean }
 	};

package/src/components/tableControls/HiddenCount.js

@@ -2,9 +2,7 @@ import TableControl from './TableControl.js';
 import { html } from '../../lit-all.min.js';
 
 export default class HiddenCount extends TableControl {
-	/*
-		Properties
-	*/
+	/* Properties */
 	static properties = {
 		hiddenCount: { type: Number }
 	};

package/src/components/tableControls/Search.js

@@ -3,9 +3,7 @@ import { html } from '../../lit-all.min.js';
 import debounce from '../../utils/debounce.js';
 
 export default class Search extends TableControl {
-	/*
-		Properties
-	*/
+	/* Properties */
 	static properties = {
 		searchTerm: { type: String }
 	};

package/src/components/tableControls/TableControl.js

@@ -2,9 +2,7 @@ import ShadowComponent from '../ShadowComponent.js';
 import { html, css } from '../../lit-all.min.js';
 
 export default class TableControl extends ShadowComponent {
-	/*
-		Properties
-	*/
+	/* Properties */
 	static properties = {
 		maxWidth: { type: Number, reflect: true, attribute: 'max-width' }
 	};

package/src/utils/cookie.js

@@ -0,0 +1,20 @@
+export const saveCookie = (name, value, minutes = 30 * 24 * 60, path = '/') => {
+  const expires = new Date(Date.now() + minutes * 60 * 1000);
+  document.cookie = `${name}=${value};expires=${expires.toUTCString()};path=${path}`;
+};
+
+export const getCookie = (name) => {
+  const cookies = document.cookie.split(';').map(cookie => cookie.trim().split('='));
+  const cookie = cookies.find(cookie => cookie[0] === name);
+  return cookie ? cookie[1] : null;
+};
+
+export const deleteCookie = (name) => {
+  document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/`;
+};
+
+export default {
+  saveCookie,
+  getCookie,
+  deleteCookie
+};

package/src/utils/object.js

@@ -0,0 +1,198 @@
+import { typeOf } from './type.js';
+
+export const toJson = (obj) => {
+	return JSON.stringify(obj, (key, value) => {
+		if (key !== '' && value === obj) {
+			return '<<Circular Reference>>';
+		} else if (typeof(Element) !== 'undefined' && value instanceof Element) {
+			return value.outerHTML;
+		} else if(typeOf(value) === 'function'){
+			return `<<Function ${key}>>`;
+		}
+		return value;
+	});
+};
+
+export const flattenObject = (
+	obj,
+	maxDepth = 100,
+	prevDepth = 0,
+	parentKeys = []
+) => {
+	const thisDepth = prevDepth + 1;
+	if (obj === null) return {};
+	return Object.keys(obj).reduce((o, k) => {
+		const v = obj[k];
+		const key = [...parentKeys, k].join('.');
+		if (typeOf(Element) !== 'undefined' && v instanceof Element) {
+			return {
+				...o,
+				[key]: v.outerHTML
+			};
+		} else if (v === null) {
+			return {
+				...o,
+				[key]: null
+			};
+		} else if (typeof v === 'object') {
+			if (maxDepth <= thisDepth) {
+				return {
+					...o,
+					[key]: '<<Max Depth Reached>>'
+				};
+			} else {
+				return {
+					...o,
+					...flattenObject(v, maxDepth, thisDepth, [...parentKeys, k])
+				};
+			}
+		} else {
+			return {
+				...o,
+				[key]: v
+			};
+		}
+	}, {});
+};
+
+export const flattenedObjects = (...objects) => objects.map(o=>flattenObject(o));
+
+export const objectSummary = (object, maxLength = 100) => {
+	if (typeof object === 'object') {
+		const flatObject = flattenObject(object);
+		const kvp = []; // key value pairs
+		Object.keys(flatObject).forEach((key) => {
+			kvp.push(`${key} = ${objectSummary(flatObject[key])}`);
+		});
+		return kvp.join(', ').substring(0, maxLength);
+	} else {
+		return `${object}`.substring(0, maxLength);
+	}
+};
+
+export const clone = (obj) => {
+	const type = typeof obj;
+	const Element =
+		typeof window === 'undefined' ? class Element {} : window.Element; // So this can run in Node
+	if (obj instanceof Element) {
+		return obj.outerHTML;
+	} else if (obj === null) {
+		return null;
+	} else if (
+		['string', 'number', 'boolean', 'undefined', 'bigint'].includes(type)
+	) {
+		return obj;
+	} else if (type === 'symbol') {
+		return '<<SYMBOL>>';
+	} else if (type === 'function') {
+		return '<<function>>';
+	} else if (obj instanceof Array) {
+		return obj.map((item) => clone(item));
+	} else if (type === 'object') {
+		return Object.keys(obj).reduce((r, k) => {
+			return {
+				...r,
+				[k]: clone(obj[k])
+			};
+		}, {});
+	} else {
+		return obj;
+	}
+};
+
+export const equalObjs = (...objs) => {
+	if (objs.length < 2) return true;
+	const first = toJson(objs[0]);
+	for (let i = 1; i < objs.length; i++) {
+		if (first !== toJson(objs[i])) return false;
+	}
+	return true;
+};
+
+const pruneVar = (value) => {
+	if (typeof value === 'undefined') {
+		return [undefined, true];
+	} else if (typeof value === 'string') {
+		return [value, value === ''];
+	} else if (value instanceof Array) {
+		return [value, value.length === 0];
+	} else if (value === null) {
+		return [value, false];
+	} else if (typeof value === 'object') {
+		// eslint-disable-next-line no-use-before-define
+		return pruneObject(value);
+	}
+	return [value, false];
+};
+const pruneObject = (object) => {
+	const results = {};
+	Object.keys(object).forEach((key) => {
+		const [pruned, isBlank] = pruneVar(object[key]);
+		if (!isBlank) {
+			results[key] = pruned;
+		}
+	});
+	return [results, Object.keys(results).length === 0];
+};
+export const prune = (object) => {
+	return pruneObject(object)[0]
+}
+export const getAllKeys = (...objects) => [...new Set(objects.map(o => Object.keys(o)).flat())];
+export const getDifferencesKeys = (...objects) => {
+	return getAllKeys(...objects)
+		.map(k => new Set(objects.map(o => o[k])).size !== 1 ? k : null)
+		.filter(k => k !== null);
+}
+export const diff = (obj1, obj2) => {
+  const result = {};
+
+  function compareValues(path, value1, value2) {
+    if (Array.isArray(value1) && Array.isArray(value2)) {
+      if (value1.length !== value2.length || !value1.every((v, i) => v === value2[i])) {
+        result[path.join('.')] = { newValue: value1, oldValue: value2 };
+      }
+    } else if (typeof value1 === 'object' && typeof value2 === 'object') {
+      compareObjects([...path], value1, value2);
+    } else if (value1 !== value2) {
+      result[path.join('.')] = { newValue: value1, oldValue: value2 };
+    }
+  }
+
+  function compareObjects(path, obj1, obj2) {
+    for (const key in obj1) {
+      if (obj1.hasOwnProperty(key)) {
+        const value1 = obj1[key];
+        const value2 = obj2[key];
+
+        compareValues([...path, key], value1, value2);
+      }
+    }
+  }
+
+  compareObjects([], obj1, obj2);
+  return result;
+}
+
+export const mapObject = (obj, func) => {
+  return Object.entries(obj).reduce((newObj, [key, value]) => {
+    const [newKey, newValue] = func(key, value);
+    newObj[newKey] = newValue;
+    return newObj;
+  }, {});
+}
+
+export default {
+	toJson,
+	flattenObject,
+	flattenedObjects,
+	objectSummary,
+	clone,
+	equalObjs,
+	pruneVar,
+	pruneObject,
+	prune,
+	getAllKeys,
+	getDifferencesKeys,
+	diff,
+	mapObject
+};

package/src/utils/string.js

@@ -0,0 +1,74 @@
+export const camelToDash = (str) => str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+export const dashToCamel = (str) => str.replace(/-([a-z])/g, (_, group) => group.toUpperCase());
+export const isCamelCase = (str) => /[a-z][A-Z]/.test(str);
+export const getCase = (str) => {
+  if(isCamelCase(str)){
+    return {
+      camel: str,
+      dash: camelToDash(str)
+    }
+  } else {
+    return {
+      camel: dashToCamel(str),
+      dash: str
+    }
+  }
+}
+export const escapeHTML = str => str.replace(/[&<>"'/]/g, match => {
+  switch (match) {
+    case '&':
+      return '&amp;';
+    case '<':
+      return '&lt;';
+    case '>':
+      return '&gt;';
+    case '"':
+      return '&quot;';
+    case "'":
+      return '&#39;';
+    case '/':
+      return '&#x2F;';
+    default:
+      return match;
+  }
+});
+export const unescapeHTML = str => str.replace(/&amp;|&lt;|&gt;|&quot;|&#39;|&#x2F;/g, match => {
+  switch (match) {
+    case '&amp;':
+      return '&';
+    case '&lt;':
+      return '<';
+    case '&gt;':
+      return '>';
+    case '&quot;':
+      return '"';
+    case '&#39;':
+      return "'";
+    case '&#x2F;':
+      return '/';
+    default:
+      return match;
+  }
+
+});
+export const trim = (str, chars) => str.replace(new RegExp(`^[${chars}]+|[${chars}]+$`, 'g'), '');
+export const compoundKey = keys => trim(keys.join('.'), '.');
+export const toTitleCase = str =>
+  str
+    .replace(/([A-Z])/g, ' $1')
+    .split(/[\s_-]+/)
+    .filter(word => word.length > 0)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ');
+
+export default {
+  camelToDash,
+  dashToCamel,
+  isCamelCase,
+  getCase,
+  escapeHTML,
+  unescapeHTML,
+  trim,
+  compoundKey,
+  toTitleCase
+};

package/src/utils/type.js

@@ -0,0 +1,13 @@
+export const typeOf = value => {
+	if(value === null) return 'null';
+	else if(value instanceof Array) return 'array';
+	else if(typeof(Element) !== 'undefined' && value instanceof Element) return  'element';
+	else return typeof(value);
+}
+
+export const isType = (value, type) => typeOf(value) === type;
+
+export default {
+	typeOf,
+	isType
+};

package/src/utils/wait.js

@@ -0,0 +1,18 @@
+const wait = (ms) => new Promise(resolve=>new Timeout(resolve,ms));
+const waitFrmaes = (frameCount = 1) => {
+  return new Promise((resolve) => {
+    let frames = 0;
+
+    function frameHandler() {
+      frames++;
+
+      if (frames >= frameCount) {
+        resolve();
+      } else {
+        requestAnimationFrame(frameHandler);
+      }
+    }
+
+    requestAnimationFrame(frameHandler);
+  });
+};

package/dist/utils/toTitleCase.js

@@ -1 +0,0 @@
-const toTitleCase=e=>e.replace(/([A-Z])/g," $1").split(/[\s_-]+/).filter(e=>e.length>0).map(e=>e.charAt(0).toUpperCase()+e.slice(1).toLowerCase()).join(" ");export default toTitleCase;

package/docs/src/utils/toTitleCase.js

@@ -1 +0,0 @@
-const toTitleCase=e=>e.replace(/([A-Z])/g," $1").split(/[\s_-]+/).filter(e=>e.length>0).map(e=>e.charAt(0).toUpperCase()+e.slice(1).toLowerCase()).join(" ");export default toTitleCase;

package/src/utils/toTitleCase.js

@@ -1,9 +0,0 @@
-const toTitleCase = str =>
-  str
-    .replace(/([A-Z])/g, ' $1')
-    .split(/[\s_-]+/)
-    .filter(word => word.length > 0)
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join(' ');
-
-export default toTitleCase;