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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@neovici/cosmoz-utils",
-	"version": "4.0.0-beta.2",
+	"version": "5.1.0",
 	"description": "Date, money and template management functions commonly needed in Cosmoz views.",
 	"keywords": [
 		"polymer",
@@ -16,12 +16,16 @@
 	},
 	"license": "Apache-2.0",
 	"author": "Neovici Development",
-	"main": "index.js",
+	"main": "dist/index.js",
 	"directories": {
 		"test": "test"
 	},
+	"files": [
+		"dist/"
+	],
 	"scripts": {
-		"lint": "eslint --cache --ext .js .",
+		"lint": "tsc && eslint --cache .",
+		"build": "tsc -p tsconfig.build.json",
 		"start": "wds",
 		"test": "wtr --coverage",
 		"test:watch": "wtr --watch",
@@ -41,14 +45,24 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"files": [
-		"lib/**/*.js"
-	],
 	"commitlint": {
 		"extends": [
 			"@commitlint/config-conventional"
 		]
 	},
+	"exports": {
+		".": "./dist/index.js",
+		"./object": "./dist/object.js",
+		"./function": "./dist/function.js",
+		"./array": "./dist/array.js",
+		"./promise": "./dist/promise.js",
+		"./tag": "./dist/tag.js",
+		"./reduce": "./dist/reduce/index.js",
+		"./elements": "./dist/elements/index.js",
+		"./elements/*": "./dist/elements/*.js",
+		"./directives/*": "./dist/directives/*.js",
+		"./hooks/*": "./dist/hooks/*.js"
+	},
 	"dependencies": {
 		"haunted": "^5.0.0"
 	},

package/lib/array.js

@@ -1,27 +0,0 @@
-import { identity } from './function';
-
-const array = arr => {
-		if (arr == null) {
-			return [];
-		}
-		if (Array.isArray(arr)) {
-			return arr;
-		}
-		if (typeof arr === 'string') {
-			return [arr];
-		}
-		if (typeof arr[Symbol.iterator] === 'function') {
-			return Array.from(arr);
-		}
-		return [arr];
-	},
-	without = (exclude, predicate = identity) => list => {
-		const excludes = array(exclude).map(predicate);
-		return array(list).filter(value => !excludes.includes(predicate(value)));
-	};
-
-
-export {
-	array,
-	without
-};

package/lib/date.js

@@ -1,176 +0,0 @@
-const
-	getValUnitDiff = (date1, date2) => {
-		const msDiff = date1.getTime() - date2.getTime(),
-			secDiff = msDiff / 1000,
-			minDiff = secDiff / 60,
-			hourDiff = minDiff / 60,
-			dayDiff = hourDiff / 24,
-			monthDiff = dayDiff / 30,
-			yearDiff = monthDiff / 12;
-		if (Math.abs(yearDiff) >= 1) {
-			return [yearDiff, 'year'];
-		}
-		if (Math.abs(monthDiff) >= 1) {
-			return [monthDiff, 'month'];
-		}
-		if (Math.abs(dayDiff) >= 1) {
-			return [dayDiff, 'day'];
-		}
-		if (Math.abs(hourDiff) >= 1) {
-			return [hourDiff, 'hour'];
-		}
-		if (Math.abs(minDiff) >= 1) {
-			return [minDiff, 'minute'];
-		}
-		return [secDiff, 'second'];
-	},
-	rules = { isoBasic: /^\d{4}-\d{2}-\d{2}$/ui },
-	parse = val => {
-		if (typeof val === 'string' && rules.isoBasic.test(val)) {
-			return new Date(`${ val }T00:00`);
-		}
-		return new Date(val);
-	},
-	/**
-	 * Validate a Date object or date string.
-	 * @param {date/string} date Date to check.
-	 * @return {date} Validated date or undefined on failure.
-	 */
-	ensureDate = date => {
-		if (date == null) {
-			return;
-		}
-		if (date instanceof Date && !isNaN(date)) {
-			return date;
-		}
-
-		const ensuredDate = parse(date);
-
-		if (ensuredDate instanceof Date && isNaN(ensuredDate)) {
-			return;
-		}
-		return ensuredDate;
-	},
-	/**
-	 * Format a date as an ISO-date - YYYY-MM-DD.
-	 * @param {date/string} date Date to be ISO formatted.
-	 * @return {string} ISO formatted date.
-	 */
-	isoDate = date => {
-		const d = ensureDate(date);
-		if (d == null) {
-			return '';
-		}
-		// Sweden uses ISO8601 human-readable
-		return d.toLocaleDateString('sv', {
-			year: 'numeric',
-			month: 'numeric',
-			day: 'numeric'
-		});
-	},
-
-	/**
-	 * Format a date with time as an ISO date with time - YYYY-MM-DD HH:mm:ss.
-	 * @param	 {date/string} date Date to be ISO formatted.
-	 * @return {string} ISO formatted date.
-	 */
-	isoDT = date => {
-		const d = ensureDate(date);
-		if (d == null) {
-			return '';
-		}
-		// Sweden uses ISO8601 human-readable
-		return d.toLocaleDateString('sv', {
-			year: 'numeric',
-			month: 'numeric',
-			day: 'numeric',
-			hour: 'numeric',
-			minute: 'numeric',
-			second: 'numeric'
-		});
-	},
-
-	/**
-	 * Check if date is in the past.
-	 * @param	 {date/string} date Date to check.
-	 * @return {boolean} Whether the date is in the past or not.
-	 */
-	pastDate = date => {
-		const d = ensureDate(date);
-		if (d == null) {
-			return;
-		}
-		return d.getTime() < Date.now();
-	},
-
-	/**
-	 * Get human readable string describing date's difference from now in the current locale language.
-	 * @param {date/string} date Date to check.
-	 * @param {string} locale Localized lang to return string in (undefined = browser)
-	 * @return {string}		Date representation string in the current locale language.
-	 */
-	timeago = (date, locale) => {
-		const d = ensureDate(date);
-		if (d == null) {
-			return '';
-		}
-		return new Intl.RelativeTimeFormat(locale, {
-			localeMatcher: 'best fit', // other values: "lookup"
-			numeric: 'auto', // other values: "auto"
-			style: 'long' // other values: "short" or "narrow"
-		}).format(...getValUnitDiff(d, new Date()));
-	},
-
-	/**
-	 * Alias for isoDate(date), format a date as an ISO-date - YYYY-MM-DD.
-	 * @param	 {date/string} date Date to be formatted.
-	 * @return {string} ISO formatted date.
-	 */
-	renderDate = isoDate,
-
-	pad = number => number < 10 ? '0' + number : number,
-
-	toLocalISOString = date => {
-		if (!(date instanceof Date)) {
-			return null;
-		}
-		return date.getFullYear() +
-			'-' + pad(date.getMonth() + 1) +
-			'-' + pad(date.getDate()) +
-			'T' + pad(date.getHours()) +
-			':' + pad(date.getMinutes()) +
-			':' + pad(date.getSeconds()) +
-			'.' + (date.getMilliseconds() / 1000).toFixed(3).slice(2, 5);
-	},
-
-	parseDate = str => {
-		const ts = Date.parse(str);
-		if (isNaN(ts)) {
-			return;
-		}
-		return new Date(ts);
-	},
-
-	inputDate = date => {
-		const d = ensureDate(date);
-		if (d == null) {
-			return;
-		}
-		return d.getFullYear() +
-			'-' + pad(d.getMonth() + 1) +
-			'-' + pad(d.getDate());
-
-	};
-
-export {
-	ensureDate,
-	isoDate,
-	isoDT,
-	pad,
-	pastDate,
-	renderDate,
-	toLocalISOString,
-	timeago,
-	parseDate,
-	inputDate
-};

package/lib/directives/lazy-until.js

@@ -1,163 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/* eslint-disable import/group-exports */
-import { noChange } from 'lit-html';
-import { directive } from 'lit-html/directive.js';
-import { isPrimitive } from 'lit-html/directive-helpers.js';
-import { AsyncDirective } from 'lit-html/async-directive.js';
-
-class PseudoWeakRef {
-  constructor(ref) {
-    this._ref = ref;
-  }
-  disconnect() {
-    this._ref = undefined;
-  }
-  reconnect(ref) {
-    this._ref = ref;
-  }
-  deref() {
-    return this._ref;
-  }
-}
-
-class Pauser {
-   _promise = undefined;
-   _resolve = undefined;
-  get() {
-    return this._promise;
-  }
-  pause() {
-    this._promise ??= new Promise((resolve) => (this._resolve = resolve));
-  }
-  resume() {
-    this._resolve?.();
-    this._promise = this._resolve = undefined;
-  }
-}
-
-const isPromise = (x) => {
-		return !isPrimitive(x) && typeof x.then === 'function';
-	},
-	// Effectively infinity, but a SMI.
-	_infinity = 0x3fffffff;
-
-export class UntilDirective extends AsyncDirective {
-	__lastRenderedIndex = _infinity;
-	__values = [];
-	__weakThis = new PseudoWeakRef(this);
-	__pauser = new Pauser();
-
-	render(...args) {
-		return args.find((x) => !isPromise(x)) ?? noChange;
-	}
-
-	// eslint-disable-next-line max-statements
-	update(_part, args) {
-		const previousValues = this.__values,
-			previousLength = previousValues.length;
-		this.__values = args;
-
-		const weakThis = this.__weakThis,
-			pauser = this.__pauser;
-
-		// If our initial render occurs while disconnected, ensure that the pauser
-		// and weakThis are in the disconnected state
-		if (!this.isConnected) {
-			this.disconnected();
-		}
-
-		for (let i = 0; i < args.length; i++) {
-			// If we've rendered a higher-priority value already, stop.
-			if (i > this.__lastRenderedIndex) {
-				break;
-			}
-
-			const value = args[i];
-
-			// Render non-Promise values immediately
-			if (!isPromise(value)) {
-				this.__lastRenderedIndex = i;
-				// Since a lower-priority value will never overwrite a higher-priority
-				// synchronous value, we can stop processing now.
-				return value;
-			}
-
-			// If this is a Promise we've already handled, skip it.
-			if (i < previousLength && value === previousValues[i]) {
-				continue;
-			}
-
-			// Note, the callback avoids closing over `this` so that the directive
-			// can be gc'ed before the promise resolves; instead `this` is retrieved
-			// from `weakThis`, which can break the hard reference in the closure when
-			// the directive disconnects
-			Promise.resolve(value).then(async (result) => {
-				// If we're disconnected, wait until we're (maybe) reconnected
-				// The while loop here handles the case that the connection state
-				// thrashes, causing the pauser to resume and then get re-paused
-				while (pauser.get()) {
-					await pauser.get();
-				}
-				// If the callback gets here and there is no `this`, it means that the
-				// directive has been disconnected and garbage collected and we don't
-				// need to do anything else
-				const _this = weakThis.deref();
-				if (_this !== undefined) {
-					const index = _this.__values.indexOf(value);
-					// If state.values doesn't contain the value, we've re-rendered without
-					// the value, so don't render it. Then, only render if the value is
-					// higher-priority than what's already been rendered.
-					if (index > -1 && index <= _this.__lastRenderedIndex) {
-						_this.__lastRenderedIndex = index;
-						_this.setValue(result);
-					}
-				}
-			});
-		}
-
-		return noChange;
-	}
-
-	disconnected() {
-		this.__weakThis.disconnect();
-		this.__pauser.pause();
-	}
-
-	reconnected() {
-		this.__weakThis.reconnect(this);
-		this.__pauser.resume();
-	}
-}
-
-/**
- * Renders one of a series of values, including Promises, to a Part.
- *
- * Values are rendered in priority order, with the first argument having the
- * highest priority and the last argument having the lowest priority. If a
- * value is a Promise, low-priority values will be rendered until it resolves.
- *
- * The priority of values can be used to create placeholder content for async
- * data. For example, a Promise with pending content can be the first,
- * highest-priority, argument, and a non_promise loading indicator template can
- * be used as the second, lower-priority, argument. The loading indicator will
- * render immediately, and the primary content will render when the Promise
- * resolves.
- *
- * Example:
- *
- * ```js
- * const content = fetch('./content.txt').then(r => r.text());
- * html`${until(content, html`<span>Loading...</span>`)}`
- * ```
- */
-export const lazyUntil = directive(UntilDirective);
-
-/**
- * The type of the class that powers this directive. Necessary for naming the
- * directive's return type.
- */
-// export type {UntilDirective};

package/lib/directives/measure.js

@@ -1,32 +0,0 @@
-import { nothing } from 'lit-html';
-import { Directive, directive } from 'lit-html/directive.js';
-import { array } from '../array';
-
-class MeasureDirective extends Directive {
-	render() {
-		return nothing;
-	}
-
-	update(part, [select, onMeasure]) {
-		this.measure(part.element, select, onMeasure);
-		return nothing;
-	}
-
-	measure(element, select, onMeasure) {
-		this._observer?.disconnect();
-		const elements = array(select(element)),
-			observer = (this._observer = new ResizeObserver((entries) => {
-				onMeasure(
-					entries
-						.sort(
-							(a, b) => elements.indexOf(a.target) - elements.indexOf(b.target)
-						)
-						.map((e) => e.contentRect)
-				);
-			}));
-		elements.forEach((el) => observer.observe(el));
-		return nothing;
-	}
-}
-
-export const measure = directive(MeasureDirective);

package/lib/directives/portal.js

@@ -1,65 +0,0 @@
-import { html, nothing, render } from 'lit-html';
-import { AsyncDirective, directive } from 'lit-html/async-directive.js';
-import {
-	setChildPartValue,
-	clearPart,
-	removePart,
-} from 'lit-html/directive-helpers.js';
-const createMarker = () => document.createComment(''),
-	ChildPart = render(nothing, new DocumentFragment()).constructor;
-
-/**
- * Helper element with a customizable disconnect behavior.
- */
-class DisconnectObserver extends HTMLElement {
-	disconnectedCallback() {
-		this.onDisconnect();
-	}
-}
-customElements.define('disconnect-observer', DisconnectObserver);
-
-class PortalDirective extends AsyncDirective {
-	render() {
-		return html`<disconnect-observer
-			.onDisconnect=${() => {
-				this.isConnected = false;
-				this.disconnected();
-			}}
-		></disconnect-observer>`;
-	}
-	update(part, [content, outlet = document.body]) {
-		this.updateOutlet(outlet, content);
-		return this.render();
-	}
-
-	updateOutlet(outlet, content) {
-		if (this._outlet !== outlet) {
-			this.clearOutlet();
-		}
-		this._outlet = outlet;
-		const part = (this._op ??= new ChildPart(
-			outlet.appendChild(createMarker()),
-			outlet.appendChild(createMarker())
-		));
-		setChildPartValue(part, (this.content = content));
-	}
-
-	clearOutlet() {
-		const part = this._op;
-		if (!part) {
-			return;
-		}
-		clearPart(part);
-		removePart(part);
-		this._op = undefined;
-	}
-
-	disconnected() {
-		this.clearOutlet();
-	}
-	reconnected() {
-		this.updateOutlet(this._outlet, this._content);
-	}
-}
-
-export const portal = directive(PortalDirective);

package/lib/directives/spread-props.js

@@ -1,31 +0,0 @@
-import { nothing } from 'lit-html';
-import { Directive, directive } from 'lit-html/directive.js';
-
-const undefs = (prev, obj) => {
-	if (!prev || !obj) {
-		return;
-	}
-	const keys = Object.keys(obj);
-	return Object.fromEntries(
-		Object.keys(prev).flatMap((k) => (keys.includes(k) ? [] : [[k, undefined]]))
-	);
-};
-
-class SpreadPropsDirective extends Directive {
-	render() {
-		return nothing;
-	}
-
-	update(part, [props]) {
-		if (this._props !== props) {
-			Object.assign(
-				part.element,
-				undefs(this._props, props),
-				(this._props = props)
-			);
-		}
-		return nothing;
-	}
-}
-
-export const spreadProps = directive(SpreadPropsDirective);

package/lib/function.js

@@ -1,21 +0,0 @@
-const
-	constant = v => () => v,
-	constTrue = constant(true),
-	constUndefined = constant(),
-	noop = constUndefined,
-	identity = obj => obj,
-	or = (...fns) => (...args) => fns.reduce((res, fn) => res || fn(...args), false),
-	once = (fn, check = constTrue) => {
-		let result; // eslint-disable-next-line no-return-assign
-		return (...args) => result ??= check(args) ? fn(...args) : undefined;
-	};
-
-export {
-	constant,
-	constTrue,
-	constUndefined,
-	noop,
-	identity,
-	once,
-	or
-};

package/lib/haunted-polymer.js

@@ -1,93 +0,0 @@
-import {
-	BaseScheduler, render
-} from 'haunted';
-
-class Scheduler extends BaseScheduler {
-	constructor(renderer, host, commitCallback) {
-		super(renderer, host);
-		this._commit = commitCallback;
-	}
-
-	commit(result) {
-		this._commit(result);
-	}
-}
-
-/**
- * Creates a mixin that mixes a haunted hook with a polymer component.
- *
- * @param {String} outputPath The property where the result of the hook will be stored (deprecated)
- * @param {Function} hook A haunted hook
- * @returns {Function} The mixin
- */
-export const hauntedPolymer = (outputPath, hook) => base => {
-	const hasOutputPath = hook !== undefined,
-		_hook = hasOutputPath ? hook : outputPath;
-
-	// TODO: drop outputPath support after all usages are fixed.
-	if (hasOutputPath) {
-		// eslint-disable-next-line no-console
-		console.warn('Haunted Polymer: use of outputPath is deprecated. Instead have the hook return an object with the keys being property names to update.');
-	}
-
-	return class extends base {
-		constructor() {
-			super();
-
-			this._scheduler = new Scheduler( // whenever the state is updated
-				() => _hook(this), // run the hook with the element as input
-				this, // using the element as state host
-				result => hasOutputPath ? this.set(outputPath, result) : this.setProperties(result) // and update the output path with the results
-			);
-		}
-
-		connectedCallback() {
-			super.connectedCallback();
-			this._scheduler.update();
-		}
-
-		disconnectedCallback() {
-			super.disconnectedCallback();
-			this._scheduler.teardown();
-		}
-
-		_propertiesChanged(currentProps, changedProps, oldProps) {
-			super._propertiesChanged(currentProps, changedProps, oldProps);
-
-			// skip haunted state update if the only thing that has changed is the hook output path
-			if (hasOutputPath && Object.keys(changedProps).length === 1 && changedProps[outputPath] != null) {
-				return;
-			}
-
-			// update haunted state only if a polymer prop has changed
-			if (this._onlyHauntedPropertiesChanged(changedProps)) {
-				return;
-			}
-
-			// trigger a haunted update loop
-			// do it in the next animation frame, so the current loop finishes processing first
-			cancelAnimationFrame(this._hauntedUpdateFrameHandle);
-			this._hauntedUpdateFrameHandle = requestAnimationFrame(() => this._scheduler.update());
-		}
-
-		_onlyHauntedPropertiesChanged(changedProps) {
-			const props = this.constructor.__properties;
-
-			if (Object.keys(changedProps)
-				.map(prop => prop.split('.')[0])
-				// props updated by haunted are not listed or have the `haunted` flag
-				.every(prop => props[prop] == null || props[prop].haunted)) {
-				return true;
-			}
-
-			return false;
-		}
-
-		renderLitTo(part, outlet) {
-			// render in the next animation frame to allow the haunted scheduler to finish processing the current state update
-			// otherwise hooks might be updated twice
-			cancelAnimationFrame(outlet.__renderAF);
-			outlet.__renderAF = requestAnimationFrame(() => render(typeof part === 'function' ? part() : part, outlet));
-		}
-	};
-};