@neovici/cosmoz-omnitable 7.2.0 → 8.0.0-beta.10

package/lib/utils-amount.js

@@ -0,0 +1,147 @@
+import { get } from '@polymer/polymer/lib/utils/path';
+import { toNumber } from './utils-number';
+
+export const
+	/**
+	 * Converts a value to an amount object optionaly limiting it.
+	 *
+	 * @param {Object} rates The rates
+	 * @param {Object} value The value to convert to number
+	 * @param {Object} limit The value used to limit the number
+	 * @param {Function} limitFunc The function used to limit the number (Math.min|Math.max)
+	 * @returns {Object|void} Value converted to Number or void
+	 */
+	toAmount = (rates = {}, value, limit, limitFunc) => { // eslint-disable-line max-statements
+		if (value == null || value === '') {
+			return;
+		}
+
+		if (typeof value !== 'object' || value.currency == null || value.currency === '') {
+			return null;
+		}
+
+		const number = toNumber(value.amount);
+		if (number == null || Number.isNaN(number)) {
+			return null;
+		}
+		const amount = {
+			currency: value.currency,
+			amount: number
+		};
+
+		if (limitFunc == null || limit == null) {
+			return amount;
+		}
+		const lAmount = toAmount(rates, limit);
+		if (lAmount == null) {
+			return amount;
+		}
+
+		// calculate value and limit amounts with rates
+		const
+			valAmount = amount.amount * (rates[amount.currency] || 1),
+			limAmount = lAmount.amount * (rates[lAmount.currency] || 1),
+			lNumber = toNumber(valAmount, limAmount, limitFunc);
+		return lNumber === valAmount ? amount : lAmount;
+	},
+
+	getComparableValue = ({ valuePath, rates }, item) => {
+		if (item == null) {
+			return;
+		}
+
+		let value = item;
+
+		if (valuePath != null) {
+			value = get(item, valuePath);
+		}
+		value = toAmount(rates, value);
+
+		if (value == null) {
+			return;
+		}
+		const amount = toNumber(value.amount);
+
+		if (rates == null) {
+			return amount;
+		}
+
+		return amount * (rates[value.currency] || 1);
+	},
+
+	applySingleFilter = (column, filter) => item => {
+		const value = getComparableValue(column, item);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue({ ...column, valuePath: 'min' }, filter),
+			max = getComparableValue({ ...column, valuePath: 'max' }, filter);
+
+		return !(value < min || value > max);
+	},
+
+	formatters = {},
+	getFormatter = (currency, locale) => {
+		const id = locale ? locale : '',
+			key = currency + id || '';
+
+		if (formatters[key]) {
+			return formatters[key];
+		}
+
+		formatters[key] = new Intl.NumberFormat(locale || undefined, {
+			style: 'currency',
+			currency
+		});
+
+		return formatters[key];
+	},
+
+	renderValue = (rates, value, locale) => {
+		const amount = toAmount(rates, value);
+		if (amount == null) {
+			return '';
+		}
+		return getFormatter(amount.currency, locale)
+			.format(value.amount);
+	},
+
+
+	getString = ({ valuePath, rates, locale }, item) => {
+		const value = toAmount(rates, get(item, valuePath));
+		if (value === undefined) {
+			return '';
+		}
+		if (value === null) {
+			return 'Invalid value';
+		}
+		return renderValue(rates, value, locale);
+	},
+
+	toHashString = value => {
+		if (!value) {
+			return '';
+		}
+		return value.amount + value.currency;
+	},
+
+	fromHashString = value => {
+		if (value == null || value === '') {
+			return;
+		}
+		const params = value.match(/^(-?[\d]+)([\D]+?)$/iu);
+		if (!Array.isArray(params) || params.length < 0) {
+			return null;
+		}
+		return {
+			amount: params[1],
+			currency: params[2]
+		};
+	},
+
+	getCurrency = ({ valuePath }, item) => get(item, valuePath)?.currency,
+
+	getInputString = ({ valuePath }, item) => get(item, valuePath)?.amount;

package/lib/utils-data.js

@@ -0,0 +1,41 @@
+import { get, set } from '@polymer/polymer/lib/utils/path';
+import { columnSymbol } from './use-dom-columns';
+
+export const
+	valuesFrom = (data, valuePath) => data
+		?.map(item => get(item, valuePath))
+		.filter((value, index, self) =>
+			value != null && self.indexOf(value) === index
+		),
+
+	defaultComputeSource = ({ externalValues, values, valuePath }, data) =>
+		externalValues || typeof values === 'function'
+			? values
+			: valuesFrom(data, valuePath),
+
+	onItemChange = (host, column, item, value) => {
+		const
+			{ valuePath } = column,
+			oldValue = get(item, valuePath);
+
+		if (value === oldValue) {
+			return;
+		}
+
+		set(item, valuePath, value);
+
+		const
+			change = {
+				item,
+				valuePath,
+				value,
+				oldValue,
+				column: column[columnSymbol]
+			};
+
+		host.dispatchEvent(new CustomEvent('column-item-changed', {
+			bubbles: true,
+			composed: true,
+			detail: change
+		}));
+	};

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	 {String} valuePath	 Property path
+	 * @param	 {Object} item			 Item to be processed
+	 * @returns {Number|void} Valid value or void
+	 */
+	getComparableValue = ({ valuePath }, item) => {
+		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(column, item);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue({ ...column, valuePath: 'min' }, filter),
+			max = getComparableValue({ ...column, valuePath: 'max' }, filter);
+
+		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 = ({ valuePath, maximumFractionDigits }, item) => {
+		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(column, item);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue({ ...column, valuePath: 'min' }, filter),
+			max = getComparableValue({ ...column, valuePath: 'max' }, filter);
+
+		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 = ({ valuePath }, item) => {
+		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(column, item);
+
+		if (value == null) {
+			return false;
+		}
+
+		const
+			min = getComparableValue({ ...column, valuePath: 'min' }, filter),
+			max = getComparableValue({ ...column, valuePath: 'max' }, filter);
+
+		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.0",
+	"version": "8.0.0-beta.10",
 	"description": "[![Build Status](https://travis-ci.org/Neovici/cosmoz-omnitable.svg?branch=master)](https://travis-ci.org/Neovici/cosmoz-omnitable)",
 	"keywords": [
 		"web-components"
@@ -64,7 +64,6 @@
 		"@polymer/iron-icons": "^3.0.0",
 		"@polymer/iron-label": "^3.0.0",
 		"@polymer/paper-button": "^3.0.0",
-		"@polymer/paper-checkbox": "^3.0.0",
 		"@polymer/paper-dropdown-menu": "^3.2.0",
 		"@polymer/paper-icon-button": "^3.0.0",
 		"@polymer/paper-input": "^3.2.0",

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]);
-};