@neovici/cosmoz-utils 4.0.0-beta.2 → 5.1.0

package/dist/hooks/use-promise.js

@@ -0,0 +1,42 @@
+import { useReducer, useEffect } from 'haunted';
+import { reduce, action } from '../reduce';
+const states = {
+    pending: 'pending',
+    rejected: 'rejected',
+    resolved: 'resolved'
+}, initial = {
+    error: undefined,
+    result: undefined,
+    state: states.pending
+}, pending = action(states.pending), resolved = action(states.resolved, result => ({ result })), rejected = action(states.rejected, error => ({ error })), reducer = reduce(initial, [
+    [pending, () => ({
+            error: undefined,
+            result: undefined,
+            state: states.pending
+        })],
+    [resolved, (state, { result }) => ({
+            error: undefined,
+            result,
+            state: states.resolved
+        })],
+    [rejected, (state, { error }) => ({
+            error,
+            result: undefined,
+            state: states.rejected
+        })]
+]);
+export const usePromise = promise => {
+    const [{ error, result, state }, dispatch] = useReducer(reducer, initial);
+    useEffect(() => {
+        if (!promise) {
+            return;
+        }
+        let canceled = false;
+        dispatch(pending());
+        promise.then(result => !canceled && dispatch(resolved(result)), error => !canceled && dispatch(rejected(error)));
+        return () => {
+            canceled = true;
+        };
+    }, [promise]);
+    return [result, error, state];
+};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Creates a mixin with the specified functions applied to the superclass
+ *
+ * ```js
+ * import { mixin, Money } from '@neovici/cosmoz-utils';
+ * import { isEmpty } from '@neovici/cosmoz-utils/template';
+ * import { isoDate } from '@neovici/cosmoz-utils/date';
+ *
+ * class DemoMoneyHelper extends mixin({isEmpty, isoDate, ...Money}, PolymerElement) {
+ * ```
+ *
+ * @mixinFunction
+ * @demo demo/index.html
+ * @param  {object} helpers   the functions to add to the class
+ * @param  {class} superclass the class to extend
+ * @return {class}            a new class
+ */
+import { hauntedPolymer, Constructor } from './haunted-polymer';
+declare const mixin: <H, S extends object>(helpers: H, superclass: Constructor<S>) => {
+    new (...args: any[]): {};
+};
+import * as Template from './template';
+import * as DateUtils from './date';
+import * as Money from './money';
+export { hauntedPolymer, Template, DateUtils, mixin, Money, DateUtils as Date };
+export * from './tagged';

package/{index.js → dist/index.js}

@@ -15,30 +15,20 @@
  * @param  {class} superclass the class to extend
  * @return {class}            a new class
  */
+import { hauntedPolymer } from './haunted-polymer';
 const mixin = (helpers, superclass) => {
-	/**
-	 * @polymer
-	 * @mixinClass
-	 */
-	const MixedElement = class extends superclass {};
-	Object.assign(MixedElement.prototype, helpers);
-	return MixedElement;
+    /**
+     * @polymer
+     * @mixinClass
+     */
+    const MixedElement = class extends superclass {
+    };
+    Object.assign(MixedElement.prototype, helpers);
+    return MixedElement;
 };
-
-import * as Template from './lib/template';
-import * as DateUtils from './lib/date';
-import * as Money from './lib/money';
-
-import { hauntedPolymer } from './lib/haunted-polymer';
-
+import * as Template from './template';
+import * as DateUtils from './date';
+import * as Money from './money';
 // TODO remove deprecated Date export [issue #34]
-export {
-	hauntedPolymer,
-	Template,
-	DateUtils,
-	mixin,
-	Money,
-	DateUtils as Date
-};
-
-export * from './lib/tagged';
+export { hauntedPolymer, Template, DateUtils, mixin, Money, DateUtils as Date };
+export * from './tagged';

package/dist/money.d.ts

@@ -0,0 +1,47 @@
+export interface Amount {
+    amount: number;
+    currency: string;
+}
+declare const 
+/**
+ * Determine if a constant or a variable is an amount.
+ * @param {object} potentialAmount Potential amount.
+ * @returns {boolean} Whether the potential amount is a valid amount object with amount and currency.
+ */
+isAmount: (potentialAmount: unknown) => potentialAmount is Amount, 
+/**
+ * Render an amount with decimal separator and currency symbol.
+ * @param	 {object} money Money with amount property and optionally currency property.
+ * @param	{void|string} locale Locale to format the amount in.
+ * @return {string} Formatted amount.
+ */
+renderAmount: (money: Amount | null, locale?: string) => string | undefined, 
+/**
+ * Alias for renderAmount(money). Render an amount with decimal separator and currency symbol.
+ * @param	 {object} money Money with amount property and optionally currency property.
+ * @return {string} Formatted amount.
+ */
+renderMoney: (money: Amount | null, locale?: string) => string | undefined, 
+/**
+ * Render an amount with decimal separator but without currency symbol.
+ * @param	 {object} money Money with amount property and optionally currency property.
+ * @param	{void|string} locale Locale to format the amount in.
+ * @return {string} Formatted number.
+ */
+renderNumberAmount: (money: Amount, locale?: string) => string, 
+/**
+ * Round a number to a given precision.
+ * @param	 {string} number Number with decimals to round.
+ * @param	 {number} precision Number of decimals to round amount to.
+ * @return {number} Rounded number.
+ */
+round: (number: number | string, precision: number) => number, 
+/**
+ * Compare amounts.
+ * @param {object} amount1 Amount 1.
+ * @param {object} amount2 Amount 2.
+ * @param {number} precision Decimal precision, defaults to 2 decimals.
+ * @returns {boolean} Whether the amounts are equal regarding amount to the specified precision and the currency.
+ */
+amountEquals: <T1, T2>(amount1: T1, amount2: T2, precision?: number) => boolean;
+export { isAmount, renderAmount, renderMoney, renderNumberAmount, round, amountEquals, };

package/dist/money.js

@@ -0,0 +1,86 @@
+const CURRENCY_FORMATTERS = {}, NUMBER_FORMATTERS = {}, _getCurrencyFormatter = function (currency, locale, currencyDisplay = 'code') {
+    if (currency == null) {
+        return;
+    }
+    const key = currency.toUpperCase() + (locale || '');
+    if (CURRENCY_FORMATTERS[key] == null) {
+        CURRENCY_FORMATTERS[key] = new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency,
+            currencyDisplay,
+        });
+    }
+    return CURRENCY_FORMATTERS[key];
+}, 
+/**
+ * Determine if a constant or a variable is an amount.
+ * @param {object} potentialAmount Potential amount.
+ * @returns {boolean} Whether the potential amount is a valid amount object with amount and currency.
+ */
+isAmount = (potentialAmount) => potentialAmount != null &&
+    typeof potentialAmount === 'object' &&
+    typeof potentialAmount.amount === 'number' &&
+    typeof potentialAmount.currency === 'string' &&
+    potentialAmount.currency.length === 3, 
+/**
+ * Render an amount with decimal separator and currency symbol.
+ * @param	 {object} money Money with amount property and optionally currency property.
+ * @param	{void|string} locale Locale to format the amount in.
+ * @return {string} Formatted amount.
+ */
+renderAmount = (money, locale) => {
+    if (money?.amount == null) {
+        return;
+    }
+    const formatter = _getCurrencyFormatter(money.currency, locale);
+    if (formatter == null) {
+        return;
+    }
+    return formatter.format(money.amount);
+}, 
+/**
+ * Alias for renderAmount(money). Render an amount with decimal separator and currency symbol.
+ * @param	 {object} money Money with amount property and optionally currency property.
+ * @return {string} Formatted amount.
+ */
+renderMoney = renderAmount, 
+/**
+ * Render an amount with decimal separator but without currency symbol.
+ * @param	 {object} money Money with amount property and optionally currency property.
+ * @param	{void|string} locale Locale to format the amount in.
+ * @return {string} Formatted number.
+ */
+renderNumberAmount = (money, locale) => {
+    const key = locale || '0';
+    if (NUMBER_FORMATTERS[key] == null) {
+        NUMBER_FORMATTERS[key] = new Intl.NumberFormat(locale, {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2,
+        });
+    }
+    return NUMBER_FORMATTERS[key].format(money.amount);
+}, 
+/**
+ * Round a number to a given precision.
+ * @param	 {string} number Number with decimals to round.
+ * @param	 {number} precision Number of decimals to round amount to.
+ * @return {number} Rounded number.
+ */
+round = (number, precision) => {
+    const fixed = Number(Math.round(Number(number + 'e' + precision)) + 'e-' + precision).toFixed(precision);
+    return parseFloat(fixed);
+}, 
+/**
+ * Compare amounts.
+ * @param {object} amount1 Amount 1.
+ * @param {object} amount2 Amount 2.
+ * @param {number} precision Decimal precision, defaults to 2 decimals.
+ * @returns {boolean} Whether the amounts are equal regarding amount to the specified precision and the currency.
+ */
+amountEquals = (amount1, amount2, precision = 2) => {
+    return (isAmount(amount1) &&
+        isAmount(amount2) &&
+        round(amount1.amount, precision) === round(amount2.amount, precision) &&
+        amount1.currency === amount2.currency);
+};
+export { isAmount, renderAmount, renderMoney, renderNumberAmount, round, amountEquals, };

package/dist/object.d.ts

@@ -0,0 +1,21 @@
+import { identity } from './function';
+declare type Rec<K extends PropertyKey = PropertyKey, V = any> = Record<K, V>;
+export declare function prop(): typeof identity;
+export declare function prop(a: '' | null | false | undefined | 0): typeof identity;
+export declare function prop<K extends PropertyKey>(key: K): <O extends Rec<K>>(obj: O) => O[K];
+export declare const strProp: <K extends PropertyKey>(key: K) => <O extends Rec<K, any>>(o: O) => string;
+export declare const transform: <K extends string, V, RK extends PropertyKey, RV>(obj: Record<K, V>, trans: (entries: [Extract<K, string>, V][]) => Iterable<readonly [RK, RV]>) => { [key in RK]: RV; };
+export declare const omit: <K extends PropertyKey>(keys: K[]) => <T extends Rec<PropertyKey, any>>(obj: T) => { [key in Exclude<keyof T, K>]: T[key]; };
+export declare const props: <K extends PropertyKey>(keys: K[]) => <T extends Rec<PropertyKey, any>>(obj: T) => { [key in K & keyof T]: T[key]; };
+declare type Merge<T1, T2> = {
+    [key in Exclude<keyof T1, keyof T2>]: T1[key];
+} & {
+    [key in Exclude<keyof T2, keyof T1>]: T2[key];
+} & {
+    [key in keyof T1 & keyof T2]: T1 extends Rec ? T2 extends Rec ? Merge<T1[key], T2[key]> : T2[key] : T2[key];
+};
+export declare const isObject: (obj: unknown) => obj is object;
+export declare function merge<T1, T2, T3>(a1: T1, a2: T2, a3: T3): Merge<Merge<T1, T2>, T3>;
+export declare function merge<T1, T2>(a1: T1, b2: T2): Merge<T1, T2>;
+export declare function merge(...objs: Rec[]): Rec;
+export {};

package/dist/object.js

@@ -0,0 +1,56 @@
+/* eslint-disable func-style, no-use-before-define, import/group-exports */
+import { identity } from './function';
+export function prop(key) {
+    if (!key) {
+        return identity;
+    }
+    return (obj) => obj[key];
+}
+export const strProp = (key) => {
+    const p = prop(key);
+    return (o) => {
+        if (typeof o === 'string') {
+            return o;
+        }
+        return p(o)?.toString() || '';
+    };
+};
+export const transform = (obj, trans) => Object.fromEntries(trans(Object.entries(obj)));
+export const omit = (keys) => (obj) => {
+    const ret = {};
+    for (const key in obj) {
+        if (!keys.includes(key)) {
+            ret[key] = obj[key];
+        }
+    }
+    return ret;
+};
+export const props = (keys) => (obj) => {
+    const ret = {};
+    for (const key in obj) {
+        if (keys.includes(key)) {
+            ret[key] = obj[key];
+        }
+    }
+    return ret;
+};
+export const isObject = (obj) => obj != null && typeof obj === 'object' && obj.constructor === Object;
+export function merge(...objs) {
+    return objs.reduce((acc, obj) => {
+        if (obj == null) {
+            return acc;
+        }
+        for (const key of Object.keys(obj)) {
+            if (isObject(obj[key]) && isObject(acc[key])) {
+                Object.assign(acc[key], merge(acc[key], obj[key]));
+            }
+            else if (Array.isArray(acc[key]) && Array.isArray(obj[key])) {
+                acc[key] = acc[key].concat(obj[key]);
+            }
+            else {
+                acc[key] = obj[key];
+            }
+        }
+        return acc;
+    }, {});
+}

package/dist/promise.d.ts

@@ -0,0 +1,10 @@
+declare type Pfn<T> = (arg: T) => void;
+export declare class ManagedPromise<T> extends Promise<T> {
+    constructor(callback?: (resolve: Pfn<T>, reject: Pfn<T>) => void);
+}
+export declare const timeout$: (ms?: number) => Promise<unknown>;
+declare type Predicate<T extends Event> = (e: T) => boolean;
+export declare const event$: <E extends Event, P extends Predicate<E>>(target: EventTarget, type: string, predicate?: P | undefined, timeout?: number) => Promise<unknown>;
+export declare const limit$: <T extends [], P>(fn: (...args: T) => PromiseLike<P>, limit: number) => (...args: T) => Promise<P>;
+export declare const debounce$: <T extends [], P>(fn: (...args: T) => PromiseLike<P>, ms?: number) => (...args: T) => Promise<unknown>;
+export {};

package/dist/promise.js

@@ -0,0 +1,66 @@
+/* eslint-disable import/group-exports */
+export class ManagedPromise extends Promise {
+    constructor(callback) {
+        const handles = {};
+        super((resolve, reject) => Object.assign(handles, { resolve, reject }));
+        Object.assign(this, handles);
+        callback?.(handles.resolve, handles.reject);
+    }
+}
+export const timeout$ = (ms) => new Promise((res) => setTimeout(res, ms));
+export const event$ = (target, type, predicate, timeout = 300000) => new Promise((resolve, reject) => {
+    let handler;
+    const tid = setTimeout(() => {
+        target.removeEventListener(type, handler);
+        reject(new Error('Timeout out'));
+    }, timeout);
+    target.addEventListener(type, (handler = (e) => {
+        if (predicate == null || predicate(e)) {
+            target.removeEventListener(type, handler);
+            clearTimeout(tid);
+            resolve(e);
+        }
+    }));
+});
+export const limit$ = (fn, limit) => {
+    const state = {
+        queue: [],
+        pending: [],
+    }, process = () => {
+        if (state.queue.length === 0) {
+            return;
+        }
+        if (state.pending.length >= limit) {
+            return;
+        }
+        const task = state.queue.shift();
+        state.pending.push(task);
+        Promise.resolve(fn(...task.args))
+            .then(task.resolve, task.reject)
+            .then(() => {
+            state.pending.splice(state.pending.indexOf(task), 1);
+            process();
+        });
+    };
+    return (...args) => new Promise((resolve, reject) => {
+        state.queue.push({ args, resolve, reject });
+        process();
+    });
+};
+export const debounce$ = (fn, ms) => {
+    let timeoutId;
+    const pending = [];
+    return (...args) => new Promise((res, rej) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+            const currentPending = [...pending];
+            pending.length = 0;
+            Promise.resolve(fn(...args)).then((data) => {
+                currentPending.forEach(({ resolve }) => resolve(data));
+            }, (error) => {
+                currentPending.forEach(({ reject }) => reject(error));
+            });
+        }, ms);
+        pending.push({ resolve: res, reject: rej });
+    });
+};

package/dist/reduce/action.d.ts

@@ -0,0 +1,13 @@
+declare type Creator<T extends [], R extends object> = (...args: T) => R;
+export interface Action<T = unknown> {
+    type?: T;
+    toString: () => string;
+}
+declare const action: <T, A extends [], R extends object>(type: T, create?: Creator<A, R>) => ((...args: A) => R & {
+    type: T;
+    toString(): T;
+}) & {
+    type: T;
+    toString(): T;
+}, type: <T>(action: Action<T>) => string | T;
+export { action, type };

package/dist/reduce/action.js

@@ -0,0 +1,10 @@
+const action = (type, create = () => ({})) => {
+    const common = {
+        type,
+        toString() {
+            return type;
+        },
+    }, callable = (...args) => Object.assign(create(...args), common);
+    return Object.assign(callable, common);
+}, type = (action) => action.type || action.toString();
+export { action, type };

package/dist/reduce/index.js

@@ -0,0 +1,2 @@
+export * from './action';
+export * from './reduce';

package/dist/reduce/reduce.d.ts

@@ -0,0 +1 @@
+export function reduce(initial: any, handle: any): (state: any, action: any) => any;

package/dist/reduce/reduce.js

@@ -0,0 +1,12 @@
+import { type } from './action';
+const ensureArray = x => Array.isArray(x) ? x : [x], reduce = (initial, handle) => {
+    const handles = ensureArray(handle), handlers = (handles.every(Array.isArray) ? handles : [handles]).map(([actions, handle]) => ({
+        actions: ensureArray(actions).map(type),
+        handle
+    }));
+    return (state = initial, action) => {
+        const handler = handlers.find(h => h.actions.includes(type(action)));
+        return handler ? handler.handle(state, action) : state;
+    };
+};
+export { reduce };

package/dist/tag.d.ts

@@ -0,0 +1,23 @@
+export declare const 
+/**
+ * Dynamic component support for lit-html.
+ *
+ * Normally lit-html does not support interpolating the component tag, but we can trick it
+ * by calling the template function manually.
+ *
+ * NOTE: You can only use this function for interpolating a single tag and it must be the
+ * first interpolated value. If you need multiple components, you can do multiple interpolations.
+ *
+ * @example
+ *  tag`<${name} some=${param}/>`
+ *
+ * @example
+ * 	html`A: ${ tag`<${ aTag }/>` } - B: ${ tag`${ bTag }` }`
+ *
+ * @param   {string[]}     strings    The static strings.
+ * @param   {string}       component  The interpolated component name.
+ * @param   {any[]}        values     The interpolated values.
+ *
+ * @return  {TemplateResult}          The lit template result.
+ */
+tag: (strings: string[], component: string, ...values: unknown[]) => import("lit-html").TemplateResult<1>;

package/dist/tag.js

@@ -0,0 +1,28 @@
+import { html as htm } from 'haunted';
+const html = (arr, ...thru) => htm(Object.assign(arr, { raw: true }), ...thru);
+export const 
+/**
+ * Dynamic component support for lit-html.
+ *
+ * Normally lit-html does not support interpolating the component tag, but we can trick it
+ * by calling the template function manually.
+ *
+ * NOTE: You can only use this function for interpolating a single tag and it must be the
+ * first interpolated value. If you need multiple components, you can do multiple interpolations.
+ *
+ * @example
+ *  tag`<${name} some=${param}/>`
+ *
+ * @example
+ * 	html`A: ${ tag`<${ aTag }/>` } - B: ${ tag`${ bTag }` }`
+ *
+ * @param   {string[]}     strings    The static strings.
+ * @param   {string}       component  The interpolated component name.
+ * @param   {any[]}        values     The interpolated values.
+ *
+ * @return  {TemplateResult}          The lit template result.
+ */
+tag = (strings, component, ...values) => html([
+    strings[0] + component + strings[1],
+    ...strings.slice(2)
+], ...values);

package/dist/tagged.d.ts

@@ -0,0 +1 @@
+export declare const tagged: (strings: string[], ...values: string[]) => string;

package/dist/template.d.ts

@@ -0,0 +1,47 @@
+export declare const abs: (x: number) => number, 
+/**
+ * Check if any of the arguments are true.
+ * @return {Boolean} Whether any of the function arguments are true or not.
+ */
+anyTrue: <T>(...args: T[]) => boolean, 
+/**
+ * Concatenate all arguments to a string.
+ * @return {string} Concatenated arguments.
+ */
+concat: <T>(...args: T[]) => string, 
+/**
+ * If iftrue argument is true, return result argument, otherwise return elseresult argument.
+ * @param {boolean} iftrue Codition for result
+ * @param {*} result Result when iftrue is true.
+ * @param {*} elseresult Result when iftrue is false.
+ * @return {boolean} result or elseresult depending on iftrue evaluation.
+ */
+ifElse: <T extends boolean, R, E>(iftrue: T, result: R, elseresult: E) => R | E, 
+/**
+ * Check if item argument exists in array argument.
+ * @param {*} item Item to search for in the array.
+ * @param {array} array Array to search.
+ * @return {boolean} Whether the item was found in array or not.
+ */
+inArray: <T>(item: T, array: T[]) => boolean, 
+/**
+ * Check equality of the arguments.
+ * @param {*} arg1 First argument to compare.
+ * @param {*} arg2 Second argument to compare
+ * @return {boolean} Whether the first and second arguments are equal or not.
+ */
+isEqual: <T>(arg1: T, arg2: T) => boolean, 
+/**
+ * Check if argument is undefined, null, empty Array list,
+ * empty String or 0 number (like length).
+ * @param	 {object}	 obj Argument to evaluate.
+ * @return {boolean}	Whether the argument is empty or not.
+ */
+isEmpty: <T>(obj: T) => boolean, 
+/**
+ * Formats a number using fixed-point notation.
+ * @param {number} number Number with decimals to be formatted.
+ * @param {number} fixval Number of decimals to use.
+ * @return {String} The number converted to string keep only fixval number of decimals, if number empty, returns empty string
+ */
+toFixed: <T>(number: T, fixval: number) => string;

package/dist/template.js

@@ -0,0 +1,66 @@
+export const abs = Math.abs, 
+/**
+ * Check if any of the arguments are true.
+ * @return {Boolean} Whether any of the function arguments are true or not.
+ */
+anyTrue = (...args) => args.some(arg => !!arg), 
+/**
+ * Concatenate all arguments to a string.
+ * @return {string} Concatenated arguments.
+ */
+concat = (...args) => args.join(''), 
+/**
+ * If iftrue argument is true, return result argument, otherwise return elseresult argument.
+ * @param {boolean} iftrue Codition for result
+ * @param {*} result Result when iftrue is true.
+ * @param {*} elseresult Result when iftrue is false.
+ * @return {boolean} result or elseresult depending on iftrue evaluation.
+ */
+ifElse = (iftrue, result, elseresult) => iftrue ? result : elseresult, 
+/**
+ * Check if item argument exists in array argument.
+ * @param {*} item Item to search for in the array.
+ * @param {array} array Array to search.
+ * @return {boolean} Whether the item was found in array or not.
+ */
+inArray = (item, array) => array.indexOf(item) > -1, 
+/**
+ * Check equality of the arguments.
+ * @param {*} arg1 First argument to compare.
+ * @param {*} arg2 Second argument to compare
+ * @return {boolean} Whether the first and second arguments are equal or not.
+ */
+isEqual = (arg1, arg2) => arg1 === arg2, 
+/**
+ * Check if argument is undefined, null, empty Array list,
+ * empty String or 0 number (like length).
+ * @param	 {object}	 obj Argument to evaluate.
+ * @return {boolean}	Whether the argument is empty or not.
+ */
+isEmpty = (obj) => {
+    if (obj === undefined || obj === null) {
+        return true;
+    }
+    if (Array.isArray(obj) && obj.length === 0) {
+        return true;
+    }
+    if (typeof obj === 'string' && obj.length === 0) {
+        return true;
+    }
+    if (typeof obj === 'number' && obj === 0) {
+        return true;
+    }
+    return false;
+}, 
+/**
+ * Formats a number using fixed-point notation.
+ * @param {number} number Number with decimals to be formatted.
+ * @param {number} fixval Number of decimals to use.
+ * @return {String} The number converted to string keep only fixval number of decimals, if number empty, returns empty string
+ */
+toFixed = (number, fixval) => {
+    if (typeof number !== 'number') {
+        return '';
+    }
+    return number.toFixed(fixval);
+};