solarite 0.5.2 → 0.7.1

package/src/udomdiff.js

@@ -1,176 +0,0 @@
-/**
- * ISC License
- *
- * Copyright (c) 2020, Andrea Giammarchi, @WebReflection
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
- * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-/**
- * @param {Node} parentNode The container where children live
- * @param {Node[]} a The list of current/live children
- * @param {Node[]} b The list of future children
- * @param {(entry: Node, action: number) => Node} get
- * The callback invoked per each entry related DOM operation.
- * @param {Node} [before] The optional node used as anchor to insert before.
- * @returns {Node[]} The same list of future children.
- */
-const udomdiff = (parentNode, a, b, before) => {
-	const bLength = b.length;
-	let aEnd = a.length;
-	let bEnd = bLength;
-	let aStart = 0;
-	let bStart = 0;
-	let map = null;
-	while (aStart < aEnd || bStart < bEnd) {
-		// append head, tail, or nodes in between: fast path
-		if (aEnd === aStart) {
-			// we could be in a situation where the rest of nodes that
-			// need to be added are not at the end, and in such case
-			// the node to `insertBefore`, if the index is more than 0
-			// must be retrieved, otherwise it's gonna be the first item.
-			const node = bEnd < bLength
-				? (bStart
-					? (b[bStart - 1].nextSibling)
-					: b[bEnd - bStart])
-				: before;
-			while (bStart < bEnd) {
-				let bNode = b[bStart++];
-				parentNode.insertBefore(bNode, node);
-			}
-		}
-		// remove head or tail: fast path
-		else if (bEnd === bStart) {
-			while (aStart < aEnd) {
-				// remove the node only if it's unknown or not live
-				let aNode = a[aStart];
-				if (!map || !map.has(aNode)) {
-					parentNode.removeChild(aNode);
-				}
-				aStart++;
-			}
-		}
-		// same node: fast path
-		else if (a[aStart] === b[bStart]) {
-			aStart++;
-			bStart++;
-		}
-		// same tail: fast path
-		else if (a[aEnd - 1] === b[bEnd - 1]) {
-			aEnd--;
-			bEnd--;
-		}
-			// The once here single last swap "fast path" has been removed in v1.1.0
-			// https://github.com/WebReflection/udomdiff/blob/single-final-swap/esm/index.js#L69-L85
-		// reverse swap: also fast path
-		else if (
-			a[aStart] === b[bEnd - 1] &&
-			b[bStart] === a[aEnd - 1]
-		) {
-			// this is a "shrink" operation that could happen in these cases:
-			// [1, 2, 3, 4, 5]
-			// [1, 4, 3, 2, 5]
-			// or asymmetric too
-			// [1, 2, 3, 4, 5]
-			// [1, 2, 3, 5, 6, 4]
-			const node = a[--aEnd].nextSibling;
-
-
-			let a2 = b[bStart++];
-			let b2 = a[aStart++];
-			parentNode.insertBefore(
-				a2,
-				b2.nextSibling
-			);
-
-			let bNode = b[--bEnd];
-			parentNode.insertBefore(bNode, node);
-
-			// mark the future index as identical (yeah, it's dirty, but cheap 👍)
-			// The main reason to do this, is that when a[aEnd] will be reached,
-			// the loop will likely be on the fast path, as identical to b[bEnd].
-			// In the best case scenario, the next loop will skip the tail,
-			// but in the worst one, this node will be considered as already
-			// processed, bailing out pretty quickly from the map index check
-			a[aEnd] = b[bEnd];
-		}
-		// map based fallback, "slow" path
-		else {
-			// the map requires an O(bEnd - bStart) operation once
-			// to store all future nodes indexes for later purposes.
-			// In the worst case scenario, this is a full O(N) cost,
-			// and such scenario happens at least when all nodes are different,
-			// but also if both first and last items of the lists are different
-			if (!map) {
-				map = new Map;
-				let i = bStart;
-				while (i < bEnd)
-					map.set(b[i], i++);
-			}
-			// if it's a future node, hence it needs some handling
-			if (map.has(a[aStart])) {
-				// grab the index of such node, 'cause it might have been processed
-				const index = map.get(a[aStart]);
-				// if it's not already processed, look on demand for the next LCS
-				if (bStart < index && index < bEnd) {
-					let i = aStart;
-					// counts the amount of nodes that are the same in the future
-					let sequence = 1;
-					while (++i < aEnd && i < bEnd && map.get(a[i]) === (index + sequence))
-						sequence++;
-					// effort decision here: if the sequence is longer than replaces
-					// needed to reach such sequence, which would brings again this loop
-					// to the fast path, prepend the difference before a sequence,
-					// and move only the future list index forward, so that aStart
-					// and bStart will be aligned again, hence on the fast path.
-					// An example considering aStart and bStart are both 0:
-					// a: [1, 2, 3, 4]
-					// b: [7, 1, 2, 3, 6]
-					// this would place 7 before 1 and, from that time on, 1, 2, and 3
-					// will be processed at zero cost
-					if (sequence > (index - bStart)) {
-						const node = a[aStart];
-						while (bStart < index) {
-							let bNode = b[bStart++];
-							parentNode.insertBefore(bNode, node);
-						}
-					}
-						// if the effort wasn't good enough, fallback to a replace,
-						// moving both source and target indexes forward, hoping that some
-					// similar node will be found later on, to go back to the fast path
-					else {
-						let aNode = a[aStart++]
-						let bNode = b[bStart++]
-						parentNode.replaceChild(
-							bNode,
-							aNode
-						);
-					}
-				}
-				// otherwise move the source forward, 'cause there's nothing to do
-				else
-					aStart++;
-			}
-				// this node has no meaning in the future list, so it's more than safe
-				// to remove it, and check the next live node out instead, meaning
-			// that only the live list index should be forwarded
-			else {
-				let aNode = a[aStart++];
-				parentNode.removeChild(aNode);
-			}
-		}
-	}
-	return b;
-};
-
-export default udomdiff;

package/src/unused/FastLookupArray.js

@@ -1,54 +0,0 @@
-/**
- * partialUpdate test is 20% slower when using this, even before I override any methods!*/
-export default class FastLookupArray extends Array {
-	constructor() {
-		super(...arguments)
-		this.indexMap = new Map(); // You can replace with WeakMap() but ensure only objects are added.
-
-	}
-
-	push(item) { // doesn't support pushing multiple
-		if (!this.indexMap.has(item)) {
-			this[this.length] = item;
-			this.indexMap.set(item, this.length - 1);
-		}
-	}
-
-	indexOf(item) {
-		return this.indexMap.get(item) || -1;
-	}
-
-	remove(item) {
-		const index = this.indexOf(item);
-		if (index !== -1) {
-			this.splice(index, 1);
-			this.indexMap.delete(item);
-
-			// Adjust the map indices for the items after the removed one
-			for (let i = index; i < this.length; i++)
-				this.indexMap.set(this[i], i);
-		}
-	}
-
-	insertBefore(referenceItem, newItem) {
-		const refIndex = this.indexOf(referenceItem);
-		if (refIndex !== -1) {
-			this.splice(refIndex, 0, newItem);
-			this.indexMap.set(newItem, refIndex);
-
-			// Adjust the map indices for the items after the inserted one
-			for (let i = refIndex + 1; i < this.length; i++)
-				this.indexMap.set(this[i], i);
-		}
-	}
-
-	set(index, item) {
-		const currentItem = this[index];
-		if (currentItem !== undefined)
-			this.indexMap.delete(currentItem);
-		this[index] = item;
-		this.indexMap.set(item, index);
-	}
-
-	// TODO: Override splice?
-}

package/src/unused/Hashes.js

@@ -1,339 +0,0 @@
-import {getObjectId} from "../hash.js";
-import Template from "../Template.js";
-
-/**
- * Convert obj to a non-cyclic form that can be given to JSON.serialize.
- * This is useful for creating a string that represents a hash of all the deep values of an object.
- *
- * One instance of a node always has the same hash, even if its attributes/children have changed.
- *
- * TODO: Could memoize be faster if given an old version of the same object, and it only finds the differences?
- * Or if we inline getObjectId()
- *
- * @param obj {Object|Array|function|Node}
- * @param seenMap Used internally.
- * @param idCounter Used internally.
- * @returns {{}|*|string} */
-export function memoize(obj, seenMap = new Map(), idCounter = {value: 0}) {
-
-	// If obj is a Node, Element, or Window, we treat it specially
-	if (obj?.nodeType) { // Benchmarking shows this is faster than "instanceof Node"
-		let nodeId = getObjectId(obj);
-		return `&N:${nodeId}`;
-	}
-
-	// TODO: Should I instead use id's to keep track of functions?
-	let type = typeof obj
-
-	if (obj && type === 'object') {
-		if (seenMap.has(obj))
-			return `&O:${seenMap.get(obj)}`;
-
-		else {
-			seenMap.set(obj, idCounter.value++);
-			if (typeof obj.memoize === 'function')
-				return obj.memoize();
-
-			// We iterate through the keys of an object because an object may have changed since the last time we saw it.
-			const serializedObj = {};
-			for (let key in obj)
-				serializedObj[key] = memoize(obj[key], seenMap, idCounter);
-			return serializedObj;
-		}
-	} else if (type === 'function')
-		//return `&F:${obj}` // String version of function.  This version fails the loop.eventBindings test.
-		return `&F:${getObjectId(obj)}`; // Memory reference to function.  this makes it twice as slow!
-
-	else
-		return obj;
-}
-
-
-function fnv1a(...data) {
-	let hash = 0x811c9dc5; // FNV offset basis
-	for (let i = 0; i < data.length; i++) {
-		hash ^= data[i]; // XOR
-		hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24); // FNV prime multiplication
-	}
-	return hash >>> 0; // Convert to 32-bit unsigned integer
-}
-
-const FNV_PRIME_64 = BigInt("1099511628211");
-const OFFSET_BASIS_64 = BigInt("14695981039346656037");
-function fnv1a_64bit(...data) {
-	let hash = OFFSET_BASIS_64;
-	for (let i = 0; i < data.length; i++) {
-		hash ^= data[i]; // XOR
-		//	hash = BigInt.asUintN(64, hash*FNV_PRIME_64);
-	}
-	return hash;
-}
-
-
-// Faster than memoize
-export function hashObject(obj) {
-	let combinedData = (0);
-	if (obj === null)
-		return combinedData;
-
-	if (Array.isArray(obj)) {
-		for (let i=(0); i<obj.length; i++) {
-			let v = hashObject(obj[i])
-			combinedData = fnv1a(combinedData, i, v);
-		}
-	}
-
-	else if (typeof obj === 'object') {
-		let i = (0);
-		for (const key in obj) {
-			let k = getObjectId3(key)
-			let v = hashObject(obj[key])
-			combinedData = fnv1a(combinedData, i, k, v);
-			i++
-		}
-	}
-	else if (typeof obj === 'number')
-		return (obj)
-	else if (typeof obj === 'string')
-		return getObjectId3(obj)
-	else
-		return getObjectId2(obj);
-
-	return combinedData;
-}
-
-// TODO: Use this number instead as the high bits for getObjectId2?
-let lastObjectId2 = (1_010_101_101); // Big enough to not easily not collide with the space of unhashed numbers.
-let objectIds2 = new Map();
-
-export function getObjectId2(obj) {
-	let result = objectIds2.get(obj);
-	if (!result) {
-		result = (lastObjectId2++); // convert to string, store in result, then add 1 to lastObjectId.
-		objectIds2.set(obj, result)
-	}
-	return result;
-}
-
-
-let objectIds3 = {};
-
-export function getObjectId3(obj) {
-	// if (typeof obj === 'string') {
-	// 	let l = obj.length;
-	// 	if (l < 512) { // Faster than getObjectId3.  512 was picked randomly and has not been benchmarked.
-	// 		let result = 1;
-	// 		for (let i=0; i < l; i++)
-	// 			result ^= obj.charCodeAt(i) << (i%16);
-	// 		return result
-	// 	}
-	// }
-
-
-	let result = objectIds3[obj];
-	if (!result) {
-		result = (lastObjectId2++); // convert to string, store in result, then add 1 to lastObjectId.
-		objectIds3[obj] = result
-	}
-	return result;
-}
-
-
-let hash64Cache = new WeakMap();
-export {hash64Cache};
-
-// 25% slower than 32-bit version but still faster than memoize+JSON.stringify()
-// TODO: hardcoded hash values for true and false?
-export function hashObject64(obj) {
-	let resultLow = 0;
-	let resultHigh = 0;
-
-	if (obj instanceof Template)
-		obj = [obj.htmlId, ...obj.exprs]
-
-	if (obj === null)
-		return [0, 0];
-
-	else if (Array.isArray(obj)) {
-		let result
-		//  = hash64Cache.get(obj);
-		// if (!result) {
-		for (let i = (0); i < obj.length; i++) {
-			let [vLow, vHigh] = hashObject64(obj[i])
-			resultLow = fnv1a(resultLow, i, vLow)
-			resultHigh = fnv1a(resultHigh, vHigh)
-		}
-		result = [resultLow, resultHigh]
-		//	hash64Cache.set(obj, result)
-		//}
-		return result;
-	}
-
-	else if (typeof obj === 'object') {
-		let result
-		//  	= hash64Cache.get(obj);
-		// if (!result) {
-		let i = (0);
-		for (const key in obj) {
-			let k = getObjectId3(key)
-			let [vLow, vHigh] = hashObject64(obj[key])
-			resultLow = fnv1a(resultLow, i, vLow)
-			resultHigh = fnv1a(resultHigh, k, vHigh)
-			i++
-		}
-		result = [resultLow, resultHigh]
-		//	hash64Cache.set(obj, result)
-		//}
-
-		return result;
-	}
-	else if (typeof obj === 'number')
-		return [0, obj]
-	else if (typeof obj === 'string')
-		return [0, getObjectId3(obj)]
-	else
-		return [0, getObjectId2(obj)];
-}
-
-
-
-
-// Perforamnce varies greatly.
-export function memoize2(obj) {
-
-	if (obj === null)
-		return 'null';
-
-	switch (obj?.constructor) {
-		case Function:
-		case Node:
-			return getObjectId(obj);
-		case Array:
-			return '[' + obj.map(item => memoize2(item)) + ']'
-		case Object:
-			let result = '{';
-			for (let key in obj) {
-				//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
-				key = (key.includes(':')) ? JSON.stringify(key) : key;
-				result += `${key}:${memoize2(obj[key])}`
-			}
-			return result +'}';
-		default:
-			return JSON.stringify(obj);
-	}
-}
-
-// as fast as memoize2, or faster.
-export function memoize3(obj) {
-
-	if (obj === null)
-		return 'null';
-
-	let type = typeof obj;
-	if (Array.isArray(obj))
-		return '[' + obj.map(item => memoize2(item)) + ']'
-	if (obj instanceof Node || type === 'function')
-		return getObjectId(obj);
-	if (type=== 'object') {
-		let result = '{';
-		for (let key in obj) {
-			//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
-			key = (key.includes(':')) ? JSON.stringify(key) : key;
-			result += `${key}:${memoize2(obj[key])}`
-		}
-		return result +'}';
-	}
-	return JSON.stringify(obj);
-}
-
-
-
-
-// as fast as memoize2, or faster.
-export function memoize4(obj, seenMap=new Map(), idCounter={value: 0}) {
-	let result;
-	if (obj instanceof Template) {
-		if (obj.exprs.length === 1)
-			return obj.htmlId + '\f' + memoize4(obj.exprs[0]) // \f is the "Form feed" control character, unlikely to be usedin regular text.
-
-		let exprLength = obj.exprs.length;
-		result = new Array(exprLength + 1);
-		result[0] = obj.htmlId;
-		let exprs = obj.exprs;
-		for (let i = 0; i < exprLength; i++)
-			result[i + 1] = memoize4(exprs[i])
-	}
-
-	else if (obj === null)
-		result = 'null';
-
-	else if (Array.isArray(obj)) {
-		if (seenMap.has(obj))
-			result = `&A${seenMap.get(obj)}`;
-		else {
-			seenMap.set(obj, idCounter.value++);
-			result = '[' + obj.map(item => memoize2(item)) + ']'
-		}
-	}
-	else if (obj instanceof Node || typeof obj === 'function')
-		result = getObjectId(obj);
-
-	else if (typeof obj=== 'object') {
-		if (seenMap.has(obj))
-			result = `&O${seenMap.get(obj)}`;
-
-		else {
-			seenMap.set(obj, idCounter.value++);
-
-			// // String contact approach.
-			// result = '{';
-			// for (let key in obj) {
-			// 	//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
-			// 	key = (key.includes(':')) ? JSON.stringify(key) : key;
-			// 	result += `${key}:${memoize2(obj[key])}`
-			// }
-			// result = result + '}';
-
-			// Buffer approach.  Seems slightly faster.
-			let keys = Object.keys(obj);
-			let buffer = new Array(keys.length) + 2;
-			buffer[0] = '{'
-			buffer[buffer.length-1] = '}'
-			let idx = 1;
-			for (let key of keys) {
-				//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
-				key = (key.includes(':')) ? JSON.stringify(key) : key;
-				buffer[idx] = `${key}:${memoize2(obj[key])},`
-				idx++;
-			}
-			result = buffer.join('');
-		}
-	}
-	else
-		result = JSON.stringify(obj);
-
-
-	return result;
-}
-
-
-
-
-
-// Takes half as long as just calling JSON.serialize!
-function containsFunction(obj) {
-	// Base case: if the object itself is a function
-	let type = typeof obj;
-	if (type === 'function') {
-		return true;
-	}
-
-	// If the object is an object or array, recursively search its properties
-	if (type === 'object' && obj !== null)
-		for (let key in obj)
-			if (containsFunction(obj[key]))
-				return true;
-
-	// If none of the properties are functions, return false
-	return false;
-}

package/src/unused/InUse.test.js

@@ -1,92 +0,0 @@
-import {InUseArray, InUseMap} from "./InUseMap.js";
-import Testimony, {assert} from "../../tests/Testimony.js";
-
-Testimony.test('InUseArray.constructor', () => {
-	const arr = new InUseArray();
-	assert.eq(arr.count, 0, 'Initial count should be 0');
-	assert.eq(arr.length, 0, 'Initial length should be 0');
-});
-
-Testimony.test('InUseArray.use - with no value', () => {
-	const arr = new InUseArray(1, 2, 3);
-	const val = arr.use();
-	assert.eq(val, 1, 'Should return the first value');
-	assert.eq(arr.count, 1, 'Count should be incremented');
-});
-
-Testimony.test('InUseArray.use - with specific value', () => {
-	const arr = new InUseArray(1, 2, 3);
-	arr.count = 1; // Mark the first element as in-use
-	const val = arr.use(3);
-	assert.eq(val, 3, 'Should return the specified value');
-	assert.eq(arr.count, 2, 'Count should be incremented');
-	assert.eq(arr[1], 3, 'Value should be moved to the in-use section');
-	assert.eq(arr[2], 2, 'Remaining value should be in the available section');
-});
-
-Testimony.test('InUseArray.use', () => {
-	const arr = new InUseArray(1, 2, 3);
-	let val = arr.use(4);
-	assert.eq(val, undefined,'Should return undefined');
-	assert.eq(arr.use(), 1);
-	assert.eq(arr.use(3), 3);
-	assert.eq(arr.use(), 2);
-	assert.eq(arr.use(), undefined);
-});
-
-Testimony.test('InUseArray.use - all in use', () => {
-	const arr = new InUseArray(1, 2, 3);
-	arr.count = 3;
-	const val = arr.use();
-	assert.eq(val, undefined, 'Should return undefined');
-});
-
-Testimony.test('InUseArray.free', () => {
-	const arr = new InUseArray(1, 2, 3);
-	arr.count = 3;
-	arr.free();
-	assert.eq(arr.count, 0, 'Count should be reset to 0');
-});
-
-Testimony.test('InUseArray.reset', () => {
-	const arr = new InUseArray(1, 2, 3);
-	arr.reset();
-	assert.eq(arr.length, 0, 'Array should be empty');
-});
-
-
-
-
-Testimony.test('InUseMap.add', () => {
-	const map = new InUseMap();
-	map.add('key', 'value');
-	assert.eq(map.data['key'][0], 'value', 'Value should be added to the map');
-});
-
-Testimony.test('InUseMap.getAll', () => {
-	const map = new InUseMap();
-	map.add('key', 'value');
-	const values = map.getAll('key');
-	assert.eq(values.length, 1, 'Should return an array with one value');
-	assert.eq(values[0], 'value', 'Should return the correct value');
-});
-
-Testimony.test('InUseMap.use', () => {
-	const map = new InUseMap();
-	map.add('key', 'value');
-	let value = map.use('key');
-	assert.eq(value, 'value', 'Should return and mark the value as in-use');
-	value = map.use('key');
-	assert.eq(value, undefined, 'Should return and mark the value as in-use');
-});
-
-Testimony.test('InUseMap.hasValue', () => {
-	const map = new InUseMap();
-	map.add('key1', 'value1');
-	map.add('key2', 'value2');
-	const keys = map.hasValue('value1');
-	assert.eq(keys.length, 1, 'Should return an array with one key');
-	assert.eq(keys[0], 'key1', 'Should return the correct key');
-});
-
-