solarite 0.2.2 → 0.2.3

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "solarite",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Solarite is a small, fast, compilation-free JavaScript web component library that closely follows modern web standards.",
   "main": "dist/Solarite.js",
   "files": [
     "readme.md",
     "dist",
-    "src"    
+    "src/solarite",    
+    "src/util"    
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

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 "../solarite/hash.js";
-import Template from "../solarite/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');
-});
-
-

package/src/unused/InUseMap.js

@@ -1,98 +0,0 @@
-
-
-
-/**
- * An array that keeps track of how many elements are in-use.
- * In-use elements are always at the beginning of the array. */
-export class InUseArray extends Array {
-
-	/**
-	 * @type {int} Everything before this number is in-use. */
-	count = 0;
-
-
-	/**
-	 * Get a value and mark it as in-use.
-	 * @param val {undefined|*} Optional.  If set, find this specific value.  Otherwise find any value.
-	 * @return {undefined|*} The value that is now marked as in-use. */
-	use(val=undefined) {
-		if (val) {
-			// If val doesn't exist or is already in-use, return undefined.
-			let index = this.indexOf(val);
-			if (index === -1 || index < this.count)
-				return undefined;
-
-			// Swap the first available with val.
-			this[index] = this[this.count];
-			this[this.count] = val;
-			this.count++;
-			return val;
-		}
-
-		// Try to get last available.
-		else {
-			if (this.count >= this.length)
-				return undefined;
-			let result = this[this.count];
-			this.count++;
-			return result;
-		}
-	}
-
-	free() {
-		this.count = 0;
-	}
-
-	reset() {
-		this.length = 0;
-	}
-}
-
-/**
- *
- */
-export class InUseMap {
-
-	/** @type {Object<string, InUseArray>} */
-	data = {};
-
-	// Set a new value for a key
-	add(key, value) {
-		let data = this.data;
-		let array = data[key]
-		if (!array) {
-			array = new InUseArray();
-			data[key] = array;
-		}
-		array.push(value);
-	}
-
-	// Get all values for a key
-	getAll(key) {
-		return this.data[key] || [];
-	}
-
-	// Find a value matching the given key, mark it as inUse, and return it.
-	use(key, val=undefined) {
-		return this.data[key]?.use(val) || undefined
-	}
-
-	// temporary
-	delete(key, val=undefined) {
-		return this.data[key]?.use(val) || undefined
-	}
-
-	freeAll() {
-		for (let key in this.data)
-			this.data[key].free();
-	}
-
-	hasValue(val) {
-		let data = this.data;
-		let names = [];
-		for (let name in data)
-			if (data[name].includes(val))
-				names.push(name)
-		return names;
-	}
-}

package/src/unused/LinkedList.js

@@ -1,117 +0,0 @@
-export default class LinkedList {
-
-	constructor(input) {
-		this.head = null;
-		this.tail = null;
-		this.map = new Map();
-
-		if (Array.isArray(input)) {
-			input.forEach(val => this.push(val));
-		} else if (input instanceof LinkedList) {
-			for (let val of input) {
-				this.push(val);
-			}
-		}
-	}
-
-	push(value) {
-		if (!this.head) {
-			this.head = value;
-			this.tail = value;
-			return;
-		}
-
-		this.map.set(value, { prev: this.tail, next: null });
-		this.map.set(this.tail, { ...this.map.get(this.tail), next: value });
-		this.tail = value;
-	}
-
-	unshift(value) {
-		if (!this.head) {
-			this.push(value);
-			return;
-		}
-
-		this.map.set(value, { prev: null, next: this.head });
-		this.map.set(this.head, { ...this.map.get(this.head), prev: value });
-		this.head = value;
-	}
-
-	shift() {
-		if (!this.head) return;
-
-		const secondNode = this.map.get(this.head).next;
-
-		if (secondNode) {
-			this.map.set(secondNode, { ...this.map.get(secondNode), prev: null });
-		} else {
-			this.tail = null;
-		}
-
-		this.head = secondNode;
-	}
-
-	pop() {
-		if (!this.tail) return;
-
-		const penultimate = this.map.get(this.tail).prev;
-
-		if (penultimate) {
-			this.map.set(penultimate, { ...this.map.get(penultimate), next: null });
-		} else {
-			this.head = null;
-		}
-
-		this.tail = penultimate;
-	}
-
-	*[Symbol.iterator]() {
-		let currentNode = this.head;
-
-		while (currentNode) {
-			yield currentNode;
-			const mapData = this.map.get(currentNode);
-			currentNode = mapData ? mapData.next : null;
-		}
-	}
-
-	slice(start, end) {
-		const newList = new LinkedList();
-		let currentNode = start;
-
-		while (currentNode && currentNode !== end) {
-			newList.push(currentNode);
-			currentNode = this.map.get(currentNode).next;
-		}
-		if (end) {
-			newList.push(end);
-		}
-
-		return newList;
-	}
-
-
-	splice(start, end, newList) {
-		// TODO: assert items in newList aren't already in our list.
-
-		const firstNewNode = newList instanceof LinkedList ? newList.head : newList[0];
-		const lastNewNode = newList instanceof LinkedList ? newList.tail : newList[newList.length - 1];
-
-		if (firstNewNode) {
-			this.map.set(start, { ...this.map.get(start), next: firstNewNode });
-			this.map.set(firstNewNode, { ...this.map.get(firstNewNode), prev: start });
-		}
-
-		const afterEnd = end ? this.map.get(end).next : null;
-		if (lastNewNode) {
-			this.map.set(lastNewNode, { ...this.map.get(lastNewNode), next: afterEnd });
-			if (afterEnd) {
-				this.map.set(afterEnd, { ...this.map.get(afterEnd), prev: lastNewNode });
-			} else {
-				this.tail = lastNewNode;
-			}
-		} else if (afterEnd) {
-			this.map.set(afterEnd, { ...this.map.get(afterEnd), prev: start });
-		}
-	}
-}