@neovici/cosmoz-omnitable 7.2.1 → 8.0.0-beta.1

package/lib/utils-date.js

@@ -0,0 +1,204 @@
+import { toLocalISOString } from '@neovici/cosmoz-utils/lib/date';
+import { get } from '@polymer/polymer/lib/utils/path';
+import { toNumber } from './utils-number';
+
+export const
+
+
+	/**
+	 * Calculates the local timezone offset and formats it to ISO Timezone string.
+	 * @param	 {String} localISOString an ISO date string
+	 * @return {String}								 the ISO timezone
+	 */
+	getTimezoneString = localISOString => {
+		const off = -new Date(localISOString).getTimezoneOffset() / 60;
+		return (off < 0 ? '-' : '+') + ['0', Math.abs(off)].join('').substr(-2) + ':00';
+	},
+
+	/**
+	* Computes the local timezone and adds it to a local ISO string
+	* @param	{String} localISOString an ISO date string, without timezone info
+	* @return {String}								an ISO date string, with timezone info
+	*/
+	getAbsoluteISOString = localISOString => {
+		// Most browsers use local timezone when no timezone is specified
+		// but Safari uses UTC, so we set it implicitly
+		// TODO: Consider removing this when/if Safari handles local timezone correctly
+		if (localISOString.length === 19) {
+			return localISOString + getTimezoneString(localISOString);
+		}
+		return localISOString;
+	},
+
+	parseDate = value => {
+		if (value == null || value === '') {
+			return;
+		}
+
+		// convert value to Date
+		let date = value;
+		if (!(date instanceof Date)) {
+			// if the value is an ISO string, make sure that it has an explicit timezone
+			if (typeof value === 'string') {
+				date = getAbsoluteISOString(date);
+			}
+
+			date = new Date(date);
+		}
+
+		if (Number.isNaN(date.getTime())) {
+			return null;
+		}
+
+		return date;
+	},
+
+	/**
+	 * Get comparable number from date
+	 *
+	 * @param	 {Object} item			 Item to be processed
+	 * @param	 {String} valuePath	 Property path
+	 * @returns {Number|void} Valid value or void
+	 */
+	getComparableValue = (item, valuePath) => {
+		if (item == null) {
+			return;
+		}
+		let value = item;
+		if (valuePath != null) {
+			value = get(item, valuePath);
+		}
+		value = parseDate(value);
+
+		if (value == null) {
+			return;
+		}
+		return toNumber(value.getTime());
+	},
+
+	/**
+	 * Converts an value to date optionaly limiting it.
+	 *
+	 * @param	 {Date|String} value	 Value to convert to date
+	 * @param	 {Date|String} limit	 Value used to limit the date
+	 * @param	 {Function} limitFunc	 Function used to limit the date (Math.min|Math.max)
+	 * @returns {Date|void} Value converted to date optionaly limitated
+	 */
+	toDate = (value, limit, limitFunc) => { // eslint-disable-line max-statements
+		const date = parseDate(value);
+
+		if (date == null) {
+			return null;
+		}
+
+		if (limitFunc == null || limit == null) {
+			return date;
+		}
+
+		const lDate = toDate(limit);
+		if (lDate == null) {
+			return date;
+		}
+
+		const comparableDate = getComparableValue(date),
+			comparableLDate = getComparableValue(lDate),
+			limitedValue = limitFunc(comparableDate, comparableLDate);
+		return limitedValue === comparableDate ? date : lDate;
+	},
+
+	renderValue = (value, formatter) => {
+		if (formatter == null) {
+			return;
+		}
+		const date = toDate(value);
+		if (date == null) {
+			return;
+		}
+		return formatter.format(date);
+	},
+
+	formatters = {},
+	getFormatter = locale => {
+		const key = locale || '';
+
+		if (formatters[key]) {
+			return formatters[key];
+		}
+
+		formatters[key] = new Intl.DateTimeFormat(locale || undefined);
+
+		return formatters[key];
+	},
+
+	getString = ({ valuePath, locale }, item) => {
+		let value = get(item, valuePath);
+		if (value === undefined) {
+			return '';
+		}
+		value = toDate(value);
+		if (value === null) {
+			return 'Invalid Date';
+		}
+		return renderValue(value, getFormatter(locale));
+	},
+
+	toInputString = value => {
+		const date = toDate(value);
+		if (date == null) {
+			return null;
+		}
+		return toLocalISOString(date).slice(0, 10);
+	},
+
+	getInputString = ({ valuePath }, item) => toInputString(get(item, valuePath)),
+
+	fromInputString = (value, property) => {
+		const date = toDate(value);
+		if (date == null) {
+			return;
+		}
+		if (property === 'min') {
+			date.setHours(0, 0, 0, 0);
+		}
+		if (property === 'max') {
+			date.setHours(23, 59, 59);
+		}
+		return date;
+	},
+
+	toHashString = value => {
+		const string = toInputString(value);
+		if (string == null) {
+			return '';
+		}
+		return string;
+	},
+
+	toXlsxValue = ({ valuePath }, item) => {
+		if (!valuePath) {
+			return '';
+		}
+		const date = toDate(get(item, valuePath));
+		if (!date) {
+			return '';
+		}
+		const localDate = toDate(toLocalISOString(date));
+		localDate.setHours(0, 0, 0, 0);
+		return localDate;
+	},
+
+	applySingleFilter = (column, filter) => item => {
+		const value = getComparableValue(item, column.valuePath, column);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue(filter, 'min', column),
+			max = getComparableValue(filter, 'max', column);
+
+		return !(value < min || value > max);
+	};
+
+

package/lib/utils-datetime.js

@@ -0,0 +1,71 @@
+import { toLocalISOString } from '@neovici/cosmoz-utils/lib/date';
+import { get } from '@polymer/polymer/lib/utils/path';
+import { renderValue, toDate } from './utils-date';
+
+export const
+
+	formatters = {},
+	getFormatter = locale => {
+		const key = locale || '';
+
+		if (formatters[key]) {
+			return formatters[key];
+		}
+
+		const timeFormatOption = {
+			year: 'numeric',
+			month: 'numeric',
+			day: 'numeric',
+			hour: 'numeric',
+			minute: 'numeric'
+		};
+
+		formatters[key] = new Intl.DateTimeFormat(locale || undefined, timeFormatOption);
+
+		return formatters[key];
+	},
+
+	getString = ({ valuePath, locale }, item) => {
+		const value = toDate(get(item, valuePath));
+		if (value === undefined) {
+			return '';
+		}
+		if (value === null) {
+			return 'Invalid Date';
+		}
+		return renderValue(value, getFormatter(locale));
+	},
+
+	toXlsxValue = ({ valuePath }, item) => {
+		if (!valuePath) {
+			return '';
+		}
+		return get(item, valuePath);
+	},
+
+	toHashString = value => {
+		const date = toDate(value);
+		if (date == null) {
+			return '';
+		}
+		//Use utc in hash
+		return date.toISOString().slice(0, 19).replace(/:/gu, '.');
+	},
+
+	fromHashString = value => {
+		if (value == null || value === '') {
+			return;
+		}
+		//Parse utc from hash string
+		return toDate(value.replace(/\./gu, ':') + 'Z');
+	},
+
+	toInputString = value => {
+		const date = toDate(value);
+		if (date == null) {
+			return null;
+		}
+		return toLocalISOString(date).slice(0, 19);
+	},
+
+	getInputString = ({ valuePath }, item) => toInputString(get(item, valuePath));

package/lib/utils-number.js

@@ -0,0 +1,112 @@
+
+import { get } from '@polymer/polymer/lib/utils/path';
+import { memoooize } from './memoize';
+
+export const
+	/**
+	 * Converts a value to number optionaly limiting it.
+	 *
+	 * @param	 {Number|*} value	 The value to convert to number
+	 * @param	 {Number|*} limit	 The value used to limit the number
+	 * @param	 {Function} limitFunc	 The function used to limit the number (Math.min|Math.max)
+	 * @returns {Number|void}		 Value converted to Number or void
+	 */
+	toNumber = (value, limit, limitFunc) => {
+		if (value == null || value === '') {
+			return;
+		}
+		const number = typeof value === 'number' ? value : Number(value);
+		if (Number.isNaN(number)) {
+			return;
+		}
+		if (limitFunc == null || limit == null) {
+			return number;
+		}
+		const lNumber = toNumber(limit);
+		if (lNumber == null) {
+			return number;
+		}
+		return limitFunc(number, lNumber);
+	},
+
+	toInputString = value => {
+		const val = toNumber(value);
+		if (val == null) {
+			return null;
+		}
+		return val.toString();
+	},
+
+	getInputString = ({ valuePath }, item) => {
+		const value = toNumber(get(item, valuePath));
+		return toInputString(value);
+	},
+
+	toHashString = value => {
+		const string = toInputString(value);
+		if (string == null) {
+			return '';
+		}
+		return string;
+	},
+
+	getComparableValue = (item, valuePath, { maximumFractionDigits } = {}) => {
+		if (item == null) {
+			return;
+		}
+		let value = item;
+		if (valuePath != null) {
+			value = get(item, valuePath);
+		}
+		value = toNumber(value);
+		if (value == null) {
+			return;
+		}
+
+		if (maximumFractionDigits !== null) {
+			return toNumber(value.toFixed(maximumFractionDigits));
+		}
+		return value;
+	},
+
+	makeFormatter = memoooize((locale, minimumFractionDigits, maximumFractionDigits) => {
+		const options = {
+			localeMatcher: 'best fit' // chrome expects this when using custom options
+		};
+		if (minimumFractionDigits !== null) {
+			options.minimumFractionDigits = minimumFractionDigits;
+		}
+		if (maximumFractionDigits !== null) {
+			options.maximumFractionDigits = maximumFractionDigits;
+		}
+		return new Intl.NumberFormat(locale || undefined, options);
+	}),
+
+	getString = ({ valuePath, locale, minimumFractionDigits, maximumFractionDigits }, item) => {
+		const value = get(item, valuePath);
+
+		if (value == null) {
+			return '';
+		}
+
+		const number = toNumber(value);
+		if (number == null) {
+			return;
+		}
+		const formatter = makeFormatter(locale, minimumFractionDigits, maximumFractionDigits);
+		return formatter.format(number);
+	},
+
+	applySingleFilter = (column, filter) => item => {
+		const value = getComparableValue(item, column.valuePath, column);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue(filter, 'min', column),
+			max = getComparableValue(filter, 'max', column);
+
+		return !(value < min || value > max);
+	};

package/lib/utils-time.js

@@ -0,0 +1,115 @@
+import { toLocalISOString } from '@neovici/cosmoz-utils/lib/date';
+import { get } from '@polymer/polymer/lib/utils/path';
+import { getAbsoluteISOString, renderValue, toDate as superToDate } from './utils-date';
+import { toNumber } from './utils-number';
+
+export const
+
+	_fixedDate = '1970-01-01',
+
+	/**
+	 * Converts time to date optionaly limiting it.
+	 *
+	 * @param	 {Date|Number} value	 Date or Timestamp ( miliseconds since property _fixedDate ) to be converted
+	 * @param	 {Date|Number} limit	 Optional value to limit the date.
+	 * @param	 {Function} limitFunc	 Function used to limit the date (Math.min|Math.max)
+	 * @returns {Date|void}					 Value converted to date optionaly limitated
+	 */
+	toDate = (value, limit, limitFunc) => {
+		// Most browsers use local timezone when no timezone is specified
+		// but Safari uses UTC, so we set it implicitly
+		// TODO: Consider removing this when/if Safari handles local timezone correctly
+		const date = typeof value === 'string' && value.length > 3 && value.length <= 9
+			? getAbsoluteISOString(_fixedDate + 'T' + value)
+			: value;
+		return superToDate(date, limit, limitFunc);
+	},
+
+	formatters = {},
+	getFormatter = locale => {
+		const key = locale || '';
+
+		if (formatters[key]) {
+			return formatters[key];
+		}
+
+		const timeFormatOption = {
+			hour: 'numeric',
+			minute: 'numeric',
+			second: 'numeric'
+		};
+		formatters[key] = new Intl.DateTimeFormat(locale || undefined, timeFormatOption);
+
+		return formatters[key];
+	},
+	getString = ({ valuePath, locale }, item) => {
+		const value = toDate(get(item, valuePath));
+		if (value === undefined) {
+			return '';
+		}
+		if (value === null) {
+			return 'Invalid Date';
+		}
+		return renderValue(value, getFormatter(locale));
+	},
+
+	toXlsxValue = (column, item) => {
+		if (!column.valuePath) {
+			return '';
+		}
+		return getString(column, item);
+	},
+	toInputString = value => {
+		const date = toDate(value);
+		if (date == null) {
+			return null;
+		}
+		return toLocalISOString(date).slice(11, 19);
+	},
+
+	getComparableValue = (item, valuePath) => {
+		if (item == null) {
+			return;
+		}
+		let value = toInputString(valuePath == null ? item : get(item, valuePath));
+		if (value == null) {
+			return;
+		}
+		value = toDate(getAbsoluteISOString(_fixedDate + 'T' + value));
+		if (value == null) {
+			return;
+		}
+		return toNumber(value.getTime());
+	},
+
+	applySingleFilter = (column, filter) => item => {
+		const value = getComparableValue(item, column.valuePath, column);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue(filter, 'min', column),
+			max = getComparableValue(filter, 'max', column);
+
+		return !(value < min || value > max);
+	},
+
+	toHashString = value => {
+		const date = toDate(value);
+		if (date == null) {
+			return '';
+		}
+		//Use utc in hash
+		return date.toISOString().slice(11, 19).replace(/:/gu, '.');
+	},
+
+	fromHashString = value => {
+		if (value == null || value === '') {
+			return;
+		}
+		//Parse utc from hash string
+		return toDate(value.replace(/\./gu, ':') + 'Z');
+	};
+

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@neovici/cosmoz-omnitable",
-	"version": "7.2.1",
+	"version": "8.0.0-beta.1",
 	"description": "[![Build Status](https://travis-ci.org/Neovici/cosmoz-omnitable.svg?branch=master)](https://travis-ci.org/Neovici/cosmoz-omnitable)",
 	"keywords": [
 		"web-components"

package/lib/use-force-render.js

@@ -1,8 +0,0 @@
-import {
-	useState, useCallback
-} from 'haunted';
-
-export const useForceRender = () => {
-	const [, setState] = useState(0);
-	return useCallback(() => setState(state => state + 1), [setState]);
-};

package/lib/use-render-on-column-updates.js

@@ -1,18 +0,0 @@
-import { useEffect } from 'haunted';
-import { useForceRender } from './use-force-render';
-
-export const useRenderOnColumnUpdates = columns => {
-	const render = useForceRender();
-
-	useEffect(() => {
-		if (columns == null) {
-			return;
-		}
-
-		// NOTE: this re-renders *all* of the cells when any column prop changes
-		// re-rendering costs around 2ms, so we can ignore this for now
-		// TODO: revisit this after haunted migration
-		columns.forEach(column => column.addEventListener('cosmoz-column-prop-changed', render));
-		return () => columns.forEach(column => column.removeEventListener('cosmoz-column-prop-changed', render));
-	}, [columns, render]);
-};