@neovici/cosmoz-utils 3.27.0 → 3.29.1

package/lib/directives/lazy-until.js

@@ -0,0 +1,87 @@
+/* eslint-disable max-statements */
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+import { isPrimitive } from 'lit-html/lib/parts';
+import { directive } from 'lit-html';
+const _state = new WeakMap(),
+	// Effectively infinity, but a SMI.
+	_infinity = 0x7fffffff;
+/**
+  * Renders one of a series of values, including Promises, to a Part.
+  *
+  * This is a variant of until, which never falls back to lower priority values.
+  * Already rendered content is re-used, even when called with new Promises.
+  *
+  * 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:
+  *
+  *     const content = fetch('./content.txt').then(r => r.text());
+  *     html`${until(content, html`<span>Loading...</span>`)}`
+  */
+export const lazyUntil = directive((...args) => part => {
+	let state = _state.get(part);
+	if (state === undefined) {
+		state = {
+			lastRenderedIndex: _infinity,
+			values: []
+		};
+		_state.set(part, state);
+	}
+	const previousValues = state.values,
+		previousLength = previousValues.length;
+	state.values = args;
+	for (let i = 0; i < args.length; i++) {
+		// If we've rendered a higher-priority value already, stop.
+		if (i > state.lastRenderedIndex) {
+			break;
+		}
+
+		const value = args[i];
+		// Render non-Promise values immediately
+		if (isPrimitive(value) || typeof value.then !== 'function') {
+			part.setValue(value);
+			state.lastRenderedIndex = i;
+			// Since a lower-priority value will never overwrite a higher-priority
+			// synchronous value, we can stop processing now.
+			break;
+		}
+		// If this is a Promise we've already handled, skip it.
+		if (i < previousLength && value === previousValues[i]) {
+			continue;
+		}
+
+		Promise.resolve(value).then(resolvedValue => {
+			const index = state.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 <= state.lastRenderedIndex) {
+				state.lastRenderedIndex = index;
+				part.setValue(resolvedValue);
+				part.commit();
+			}
+		});
+	}
+});
+

package/lib/haunted-polymer.js

@@ -87,7 +87,7 @@ export const hauntedPolymer = (outputPath, hook) => base => {
 			// 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(part, outlet));
+			outlet.__renderAF = requestAnimationFrame(() => render(typeof part === 'function' ? part() : part, outlet));
 		}
 	};
 };

package/lib/object.js

@@ -3,7 +3,7 @@ import { identity } from './function';
 export const prop = key => key && (object => object[key]) || identity,
 	strProp = key => {
 		const p = prop(key);
-		return o => p(o)?.toString() || '';
+		return o => typeof o === 'string' ? o : p(o)?.toString() || '';
 	},
 	isObject = obj => Object.prototype.toString.call(obj) === '[object Object]',
 	merge = (...objs) => objs.reduce((acc, obj) => {

package/lib/promise.js

@@ -1,4 +1,14 @@
-export const timeout$ = ms => new Promise(res => setTimeout(res, ms)),
+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);
+	}
+}
+
+
+const timeout$ = ms => new Promise(res => setTimeout(res, ms)),
 	event$ = (target, type, predicate = () => true, timeout = 300000) =>
 		new Promise((resolve, reject) => {
 			let handler;
@@ -68,3 +78,11 @@ export const timeout$ = ms => new Promise(res => setTimeout(res, ms)),
 				pending.push({ resolve: res, reject: rej });
 			});
 	};
+
+export {
+	ManagedPromise,
+	timeout$,
+	event$,
+	limit$,
+	debounce$
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@neovici/cosmoz-utils",
-	"version": "3.27.0",
+	"version": "3.29.1",
 	"description": "Date, money and template management functions commonly needed in Cosmoz views.",
 	"keywords": [
 		"polymer",