@neovici/cosmoz-omnitable 14.14.3 → 14.15.0

package/dist/lib/utils-amount.js

@@ -0,0 +1,99 @@
+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) => {
+    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(amount.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;
+//# sourceMappingURL=utils-amount.js.map

package/dist/lib/utils-data.d.ts

@@ -0,0 +1,8 @@
+export function valuesFrom(data: any, valuePath: any): any[] | undefined;
+export function defaultComputeSource({ externalValues, values, valuePath }: {
+    externalValues: any;
+    values: any;
+    valuePath: any;
+}, data: any): any;
+export function onItemChange(host: any, column: any, item: any, value: any): void;
+//# sourceMappingURL=utils-data.d.ts.map

package/dist/lib/utils-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-data.d.ts","sourceRoot":"","sources":["../../src/lib/utils-data.js"],"names":[],"mappings":"AAGO,yEAsCL;AAtCK;;;;mBAsCL;AAtCK,kFAsCL"}

package/dist/lib/utils-data.js

@@ -0,0 +1,28 @@
+import { get, set } from '@polymer/polymer/lib/utils/path';
+import { columnSymbol } from './use-dom-columns';
+export const valuesFrom = (data, valuePath) => Array.isArray(data)
+    ? data
+        .map((item) => get(item, valuePath))
+        .filter((value, index, self) => value != null && self.indexOf(value) === index)
+    : undefined, 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,
+    }));
+};
+//# sourceMappingURL=utils-data.js.map

package/dist/lib/utils-date.d.ts

@@ -0,0 +1,25 @@
+export function getTimezoneString(localISOString: any): string;
+export function getAbsoluteISOString(localISOString: any): any;
+export function parseDate(value: any): any;
+export function getComparableValue({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function toDate(value: any, limit: any, limitFunc: any): any;
+export function renderValue(value: any, formatter: any): any;
+export const formatters: {};
+export function getFormatter(locale: any): any;
+export function getString({ valuePath, locale }: {
+    valuePath: any;
+    locale: any;
+}, item: any): any;
+export function toInputString(value: any): any;
+export function getInputString({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function fromInputString(value: any, property: any): any;
+export function toHashString(value: any): any;
+export function toXlsxValue({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function applySingleFilter(column: any, filter: any): (item: any) => boolean;
+//# sourceMappingURL=utils-date.d.ts.map

package/dist/lib/utils-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-date.d.ts","sourceRoot":"","sources":["../../src/lib/utils-date.js"],"names":[],"mappings":"AAIO,+DA6LL;AA7LK,+DA6LL;AA7LK,2CA6LL;AA7LK;;mBA6LL;AA7LK,oEA6LL;AA7LK,6DA6LL;AA7ED,4BAAe;AAhHT,+CA6LL;AA7LK;;;mBA6LL;AA7LK,+CA6LL;AA7LK;;mBA6LL;AA7LK,gEA6LL;AA7LK,8CA6LL;AA7LK;;mBA6LL;AA7LK,8DAkLmC,SAAI,aAW5C"}

package/dist/lib/utils-date.js

@@ -0,0 +1,161 @@
+import { toLocalISOString, ensureDate } from '@neovici/cosmoz-utils/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 = ensureDate(date);
+        if (!date) {
+            return null;
+        }
+    }
+    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) => {
+    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));
+    if (!localDate) {
+        return '';
+    }
+    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);
+};
+//# sourceMappingURL=utils-date.js.map

package/dist/lib/utils-datetime.d.ts

@@ -0,0 +1,16 @@
+export const formatters: {};
+export function getFormatter(locale: any): any;
+export function getString({ valuePath, locale }: {
+    valuePath: any;
+    locale: any;
+}, item: any): any;
+export function toXlsxValue({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function toHashString(value: any): any;
+export function fromHashString(value: any): any;
+export function toInputString(value: any): any;
+export function getInputString({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+//# sourceMappingURL=utils-datetime.d.ts.map

package/dist/lib/utils-datetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-datetime.d.ts","sourceRoot":"","sources":["../../src/lib/utils-datetime.js"],"names":[],"mappings":"AAIa,4BAAe;AAArB,+CA6DuE;AA7DvE;;;mBA6DuE;AA7DvE;;mBA6DuE;AA7DvE,8CA6DuE;AA7DvE,gDA6DuE;AA7DvE,+CA6DuE;AA7DvE;;mBA6DuE"}

package/dist/lib/utils-datetime.js

@@ -0,0 +1,52 @@
+import { toLocalISOString } from '@neovici/cosmoz-utils/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));
+//# sourceMappingURL=utils-datetime.js.map

package/dist/lib/utils-number.d.ts

@@ -0,0 +1,19 @@
+export function toNumber(value: any, limit: any, limitFunc: any): any;
+export function toInputString(value: any): any;
+export function getInputString({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function toHashString(value: any): any;
+export function getComparableValue({ valuePath, maximumFractionDigits }: {
+    valuePath: any;
+    maximumFractionDigits: any;
+}, item: any): any;
+export const makeFormatter: any;
+export function getString({ valuePath, locale, minimumFractionDigits, maximumFractionDigits }: {
+    valuePath: any;
+    locale: any;
+    minimumFractionDigits: any;
+    maximumFractionDigits: any;
+}, item: any): any;
+export function applySingleFilter(column: any, filter: any): (item: any) => boolean;
+//# sourceMappingURL=utils-number.d.ts.map

package/dist/lib/utils-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-number.d.ts","sourceRoot":"","sources":["../../src/lib/utils-number.js"],"names":[],"mappings":"AAGO,sEA2GL;AA3GK,+CA2GL;AA3GK;;mBA2GL;AA3GK,8CA2GL;AA3GK;;;mBA2GL;AA9CD,gCAaC;AA1EK;;;;;mBA2GL;AA3GK,8DAgGmC,SAAI,aAW5C"}

package/dist/lib/utils-number.js

@@ -0,0 +1,87 @@
+import { get } from '@polymer/polymer/lib/utils/path';
+import { memoooize } from '@neovici/cosmoz-utils/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);
+};
+//# sourceMappingURL=utils-number.js.map

package/dist/lib/utils-time.d.ts

@@ -0,0 +1,17 @@
+export const _fixedDate: "1970-01-01";
+export function toDate(value: any, limit: any, limitFunc: any): any;
+export const formatters: {};
+export function getFormatter(locale: any): any;
+export function getString({ valuePath, locale }: {
+    valuePath: any;
+    locale: any;
+}, item: any): any;
+export function toXlsxValue(column: any, item: any): any;
+export function toInputString(value: any): any;
+export function getComparableValue({ valuePath }: {
+    valuePath: any;
+}, item: any): any;
+export function applySingleFilter(column: any, filter: any): (item: any) => boolean;
+export function toHashString(value: any): any;
+export function fromHashString(value: any): any;
+//# sourceMappingURL=utils-time.d.ts.map

package/dist/lib/utils-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-time.d.ts","sourceRoot":"","sources":["../../src/lib/utils-time.js"],"names":[],"mappings":"AASa,yBAAa,YAAY,CAAA;AAA/B,oEAsGL;AAnFD,4BAAe;AAnBT,+CAsGL;AAtGK;;;mBAsGL;AAtGK,yDAsGL;AAtGK,+CAsGL;AAtGK;;mBAsGL;AAtGK,8DA4EmC,SAAI,aA0B5C;AAtGK,8CAsGL;AAtGK,gDAsGL"}

package/dist/lib/utils-time.js

@@ -0,0 +1,88 @@
+import { toLocalISOString } from '@neovici/cosmoz-utils/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');
+};
+//# sourceMappingURL=utils-time.js.map

package/dist/lib/utils.d.ts

@@ -0,0 +1,3 @@
+export function findLastIndex(array: any, predicate: any): any;
+export const indexSymbol: unique symbol;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.js"],"names":[],"mappings":"AAIO,+DAYN;AAhBD,wCAAoC"}

package/dist/lib/utils.js

@@ -0,0 +1,14 @@
+const indexSymbol = Symbol('index');
+export { indexSymbol };
+export const findLastIndex = (array, predicate) => {
+    if (Array.prototype.findLastIndex) {
+        return array.findLastIndex(predicate);
+    }
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (predicate(array[i], i, array)) {
+            return i;
+        }
+    }
+    return -1;
+};
+//# sourceMappingURL=utils.js.map

package/dist/ui-helpers/cosmoz-clear-button.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cosmoz-clear-button.d.ts.map

package/dist/ui-helpers/cosmoz-clear-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmoz-clear-button.d.ts","sourceRoot":"","sources":["../../src/ui-helpers/cosmoz-clear-button.js"],"names":[],"mappings":""}