create-jen-app 1.2.2 → 1.2.4

package/templates/static/node_modules/preact/src/create-element.js

@@ -1,97 +0,0 @@
-import { slice } from './util';
-import options from './options';
-import { NULL, UNDEFINED } from './constants';
-
-let vnodeId = 0;
-
-/**
- * Create an virtual node (used for JSX)
- * @param {import('./internal').VNode["type"]} type The node name or Component constructor for this
- * virtual node
- * @param {object | null | undefined} [props] The properties of the virtual node
- * @param {Array<import('.').ComponentChildren>} [children] The children of the
- * virtual node
- * @returns {import('./internal').VNode}
- */
-export function createElement(type, props, children) {
-	let normalizedProps = {},
-		key,
-		ref,
-		i;
-	for (i in props) {
-		if (i == 'key') key = props[i];
-		else if (i == 'ref') ref = props[i];
-		else normalizedProps[i] = props[i];
-	}
-
-	if (arguments.length > 2) {
-		normalizedProps.children =
-			arguments.length > 3 ? slice.call(arguments, 2) : children;
-	}
-
-	// If a Component VNode, check for and apply defaultProps
-	// Note: type may be undefined in development, must never error here.
-	if (typeof type == 'function' && type.defaultProps != NULL) {
-		for (i in type.defaultProps) {
-			if (normalizedProps[i] === UNDEFINED) {
-				normalizedProps[i] = type.defaultProps[i];
-			}
-		}
-	}
-
-	return createVNode(type, normalizedProps, key, ref, NULL);
-}
-
-/**
- * Create a VNode (used internally by Preact)
- * @param {import('./internal').VNode["type"]} type The node name or Component
- * Constructor for this virtual node
- * @param {object | string | number | null} props The properties of this virtual node.
- * If this virtual node represents a text node, this is the text of the node (string or number).
- * @param {string | number | null} key The key for this virtual node, used when
- * diffing it against its children
- * @param {import('./internal').VNode["ref"]} ref The ref property that will
- * receive a reference to its created child
- * @returns {import('./internal').VNode}
- */
-export function createVNode(type, props, key, ref, original) {
-	// V8 seems to be better at detecting type shapes if the object is allocated from the same call site
-	// Do not inline into createElement and coerceToVNode!
-	/** @type {import('./internal').VNode} */
-	const vnode = {
-		type,
-		props,
-		key,
-		ref,
-		_children: NULL,
-		_parent: NULL,
-		_depth: 0,
-		_dom: NULL,
-		_component: NULL,
-		constructor: UNDEFINED,
-		_original: original == NULL ? ++vnodeId : original,
-		_index: -1,
-		_flags: 0
-	};
-
-	// Only invoke the vnode hook if this was *not* a direct copy:
-	if (original == NULL && options.vnode != NULL) options.vnode(vnode);
-
-	return vnode;
-}
-
-export function createRef() {
-	return { current: NULL };
-}
-
-export function Fragment(props) {
-	return props.children;
-}
-
-/**
- * Check if a the argument is a valid Preact VNode.
- * @param {*} vnode
- * @returns {vnode is VNode}
- */
-export const isValidElement = vnode =>
-	vnode != NULL && vnode.constructor === UNDEFINED;

package/templates/static/node_modules/preact/src/diff/catch-error.js

@@ -1,46 +0,0 @@
-import { NULL } from '../constants';
-
-/**
- * Find the closest error boundary to a thrown error and call it
- * @param {object} error The thrown value
- * @param {import('../internal').VNode} vnode The vnode that threw the error that was caught (except
- * for unmounting when this parameter is the highest parent that was being
- * unmounted)
- * @param {import('../internal').VNode} [oldVNode]
- * @param {import('../internal').ErrorInfo} [errorInfo]
- */
-export function _catchError(error, vnode, oldVNode, errorInfo) {
-	/** @type {import('../internal').Component} */
-	let component,
-		/** @type {import('../internal').ComponentType} */
-		ctor,
-		/** @type {boolean} */
-		handled;
-
-	for (; (vnode = vnode._parent); ) {
-		if ((component = vnode._component) && !component._processingException) {
-			try {
-				ctor = component.constructor;
-
-				if (ctor && ctor.getDerivedStateFromError != NULL) {
-					component.setState(ctor.getDerivedStateFromError(error));
-					handled = component._dirty;
-				}
-
-				if (component.componentDidCatch != NULL) {
-					component.componentDidCatch(error, errorInfo || {});
-					handled = component._dirty;
-				}
-
-				// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.
-				if (handled) {
-					return (component._pendingError = component);
-				}
-			} catch (e) {
-				error = e;
-			}
-		}
-	}
-
-	throw error;
-}

package/templates/static/node_modules/preact/src/diff/children.js

@@ -1,451 +0,0 @@
-import { diff, unmount, applyRef } from './index';
-import { createVNode, Fragment } from '../create-element';
-import {
-	EMPTY_OBJ,
-	EMPTY_ARR,
-	INSERT_VNODE,
-	MATCHED,
-	UNDEFINED,
-	NULL
-} from '../constants';
-import { isArray } from '../util';
-import { getDomSibling } from '../component';
-
-/**
- * @typedef {import('../internal').ComponentChildren} ComponentChildren
- * @typedef {import('../internal').Component} Component
- * @typedef {import('../internal').PreactElement} PreactElement
- * @typedef {import('../internal').VNode} VNode
- */
-
-/**
- * Diff the children of a virtual node
- * @param {PreactElement} parentDom The DOM element whose children are being
- * diffed
- * @param {ComponentChildren[]} renderResult
- * @param {VNode} newParentVNode The new virtual node whose children should be
- * diff'ed against oldParentVNode
- * @param {VNode} oldParentVNode The old virtual node whose children should be
- * diff'ed against newParentVNode
- * @param {object} globalContext The current context object - modified by
- * getChildContext
- * @param {string} namespace Current namespace of the DOM node (HTML, SVG, or MathML)
- * @param {Array<PreactElement>} excessDomChildren
- * @param {Array<Component>} commitQueue List of components which have callbacks
- * to invoke in commitRoot
- * @param {PreactElement} oldDom The current attached DOM element any new dom
- * elements should be placed around. Likely `null` on first render (except when
- * hydrating). Can be a sibling DOM element when diffing Fragments that have
- * siblings. In most cases, it starts out as `oldChildren[0]._dom`.
- * @param {boolean} isHydrating Whether or not we are in hydration
- * @param {any[]} refQueue an array of elements needed to invoke refs
- */
-export function diffChildren(
-	parentDom,
-	renderResult,
-	newParentVNode,
-	oldParentVNode,
-	globalContext,
-	namespace,
-	excessDomChildren,
-	commitQueue,
-	oldDom,
-	isHydrating,
-	refQueue
-) {
-	let i,
-		/** @type {VNode} */
-		oldVNode,
-		/** @type {VNode} */
-		childVNode,
-		/** @type {PreactElement} */
-		newDom,
-		/** @type {PreactElement} */
-		firstChildDom;
-
-	// This is a compression of oldParentVNode!=null && oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR
-	// as EMPTY_OBJ._children should be `undefined`.
-	/** @type {VNode[]} */
-	let oldChildren = (oldParentVNode && oldParentVNode._children) || EMPTY_ARR;
-
-	let newChildrenLength = renderResult.length;
-
-	oldDom = constructNewChildrenArray(
-		newParentVNode,
-		renderResult,
-		oldChildren,
-		oldDom,
-		newChildrenLength
-	);
-
-	for (i = 0; i < newChildrenLength; i++) {
-		childVNode = newParentVNode._children[i];
-		if (childVNode == NULL) continue;
-
-		// At this point, constructNewChildrenArray has assigned _index to be the
-		// matchingIndex for this VNode's oldVNode (or -1 if there is no oldVNode).
-		if (childVNode._index == -1) {
-			oldVNode = EMPTY_OBJ;
-		} else {
-			oldVNode = oldChildren[childVNode._index] || EMPTY_OBJ;
-		}
-
-		// Update childVNode._index to its final index
-		childVNode._index = i;
-
-		// Morph the old element into the new one, but don't append it to the dom yet
-		let result = diff(
-			parentDom,
-			childVNode,
-			oldVNode,
-			globalContext,
-			namespace,
-			excessDomChildren,
-			commitQueue,
-			oldDom,
-			isHydrating,
-			refQueue
-		);
-
-		// Adjust DOM nodes
-		newDom = childVNode._dom;
-		if (childVNode.ref && oldVNode.ref != childVNode.ref) {
-			if (oldVNode.ref) {
-				applyRef(oldVNode.ref, NULL, childVNode);
-			}
-			refQueue.push(
-				childVNode.ref,
-				childVNode._component || newDom,
-				childVNode
-			);
-		}
-
-		if (firstChildDom == NULL && newDom != NULL) {
-			firstChildDom = newDom;
-		}
-
-		let shouldPlace = !!(childVNode._flags & INSERT_VNODE);
-		if (shouldPlace || oldVNode._children === childVNode._children) {
-			oldDom = insert(childVNode, oldDom, parentDom, shouldPlace);
-		} else if (typeof childVNode.type == 'function' && result !== UNDEFINED) {
-			oldDom = result;
-		} else if (newDom) {
-			oldDom = newDom.nextSibling;
-		}
-
-		// Unset diffing flags
-		childVNode._flags &= ~(INSERT_VNODE | MATCHED);
-	}
-
-	newParentVNode._dom = firstChildDom;
-
-	return oldDom;
-}
-
-/**
- * @param {VNode} newParentVNode
- * @param {ComponentChildren[]} renderResult
- * @param {VNode[]} oldChildren
- */
-function constructNewChildrenArray(
-	newParentVNode,
-	renderResult,
-	oldChildren,
-	oldDom,
-	newChildrenLength
-) {
-	/** @type {number} */
-	let i;
-	/** @type {VNode} */
-	let childVNode;
-	/** @type {VNode} */
-	let oldVNode;
-
-	let oldChildrenLength = oldChildren.length,
-		remainingOldChildren = oldChildrenLength;
-
-	let skew = 0;
-
-	newParentVNode._children = new Array(newChildrenLength);
-	for (i = 0; i < newChildrenLength; i++) {
-		// @ts-expect-error We are reusing the childVNode variable to hold both the
-		// pre and post normalized childVNode
-		childVNode = renderResult[i];
-
-		if (
-			childVNode == NULL ||
-			typeof childVNode == 'boolean' ||
-			typeof childVNode == 'function'
-		) {
-			newParentVNode._children[i] = NULL;
-			continue;
-		}
-		// If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,
-		// or we are rendering a component (e.g. setState) copy the oldVNodes so it can have
-		// it's own DOM & etc. pointers
-		else if (
-			typeof childVNode == 'string' ||
-			typeof childVNode == 'number' ||
-			// eslint-disable-next-line valid-typeof
-			typeof childVNode == 'bigint' ||
-			childVNode.constructor == String
-		) {
-			childVNode = newParentVNode._children[i] = createVNode(
-				NULL,
-				childVNode,
-				NULL,
-				NULL,
-				NULL
-			);
-		} else if (isArray(childVNode)) {
-			childVNode = newParentVNode._children[i] = createVNode(
-				Fragment,
-				{ children: childVNode },
-				NULL,
-				NULL,
-				NULL
-			);
-		} else if (childVNode.constructor === UNDEFINED && childVNode._depth > 0) {
-			// VNode is already in use, clone it. This can happen in the following
-			// scenario:
-			//   const reuse = <div />
-			//   <div>{reuse}<span />{reuse}</div>
-			childVNode = newParentVNode._children[i] = createVNode(
-				childVNode.type,
-				childVNode.props,
-				childVNode.key,
-				childVNode.ref ? childVNode.ref : NULL,
-				childVNode._original
-			);
-		} else {
-			newParentVNode._children[i] = childVNode;
-		}
-
-		const skewedIndex = i + skew;
-		childVNode._parent = newParentVNode;
-		childVNode._depth = newParentVNode._depth + 1;
-
-		// Temporarily store the matchingIndex on the _index property so we can pull
-		// out the oldVNode in diffChildren. We'll override this to the VNode's
-		// final index after using this property to get the oldVNode
-		const matchingIndex = (childVNode._index = findMatchingIndex(
-			childVNode,
-			oldChildren,
-			skewedIndex,
-			remainingOldChildren
-		));
-
-		oldVNode = NULL;
-		if (matchingIndex != -1) {
-			oldVNode = oldChildren[matchingIndex];
-			remainingOldChildren--;
-			if (oldVNode) {
-				oldVNode._flags |= MATCHED;
-			}
-		}
-
-		// Here, we define isMounting for the purposes of the skew diffing
-		// algorithm. Nodes that are unsuspending are considered mounting and we detect
-		// this by checking if oldVNode._original == null
-		const isMounting = oldVNode == NULL || oldVNode._original == NULL;
-
-		if (isMounting) {
-			if (matchingIndex == -1) {
-				// When the array of children is growing we need to decrease the skew
-				// as we are adding a new element to the array.
-				// Example:
-				// [1, 2, 3] --> [0, 1, 2, 3]
-				// oldChildren   newChildren
-				//
-				// The new element is at index 0, so our skew is 0,
-				// we need to decrease the skew as we are adding a new element.
-				// The decrease will cause us to compare the element at position 1
-				// with value 1 with the element at position 0 with value 0.
-				//
-				// A linear concept is applied when the array is shrinking,
-				// if the length is unchanged we can assume that no skew
-				// changes are needed.
-				if (newChildrenLength > oldChildrenLength) {
-					skew--;
-				} else if (newChildrenLength < oldChildrenLength) {
-					skew++;
-				}
-			}
-
-			// If we are mounting a DOM VNode, mark it for insertion
-			if (typeof childVNode.type != 'function') {
-				childVNode._flags |= INSERT_VNODE;
-			}
-		} else if (matchingIndex != skewedIndex) {
-			// When we move elements around i.e. [0, 1, 2] --> [1, 0, 2]
-			// --> we diff 1, we find it at position 1 while our skewed index is 0 and our skew is 0
-			//     we set the skew to 1 as we found an offset.
-			// --> we diff 0, we find it at position 0 while our skewed index is at 2 and our skew is 1
-			//     this makes us increase the skew again.
-			// --> we diff 2, we find it at position 2 while our skewed index is at 4 and our skew is 2
-			//
-			// this becomes an optimization question where currently we see a 1 element offset as an insertion
-			// or deletion i.e. we optimize for [0, 1, 2] --> [9, 0, 1, 2]
-			// while a more than 1 offset we see as a swap.
-			// We could probably build heuristics for having an optimized course of action here as well, but
-			// might go at the cost of some bytes.
-			//
-			// If we wanted to optimize for i.e. only swaps we'd just do the last two code-branches and have
-			// only the first item be a re-scouting and all the others fall in their skewed counter-part.
-			// We could also further optimize for swaps
-			if (matchingIndex == skewedIndex - 1) {
-				skew--;
-			} else if (matchingIndex == skewedIndex + 1) {
-				skew++;
-			} else {
-				if (matchingIndex > skewedIndex) {
-					skew--;
-				} else {
-					skew++;
-				}
-
-				// Move this VNode's DOM if the original index (matchingIndex) doesn't
-				// match the new skew index (i + new skew)
-				// In the former two branches we know that it matches after skewing
-				childVNode._flags |= INSERT_VNODE;
-			}
-		}
-	}
-
-	// Remove remaining oldChildren if there are any. Loop forwards so that as we
-	// unmount DOM from the beginning of the oldChildren, we can adjust oldDom to
-	// point to the next child, which needs to be the first DOM node that won't be
-	// unmounted.
-	if (remainingOldChildren) {
-		for (i = 0; i < oldChildrenLength; i++) {
-			oldVNode = oldChildren[i];
-			if (oldVNode != NULL && (oldVNode._flags & MATCHED) == 0) {
-				if (oldVNode._dom == oldDom) {
-					oldDom = getDomSibling(oldVNode);
-				}
-
-				unmount(oldVNode, oldVNode);
-			}
-		}
-	}
-
-	return oldDom;
-}
-
-/**
- * @param {VNode} parentVNode
- * @param {PreactElement} oldDom
- * @param {PreactElement} parentDom
- * @param {boolean} shouldPlace
- * @returns {PreactElement}
- */
-function insert(parentVNode, oldDom, parentDom, shouldPlace) {
-	// Note: VNodes in nested suspended trees may be missing _children.
-
-	if (typeof parentVNode.type == 'function') {
-		let children = parentVNode._children;
-		for (let i = 0; children && i < children.length; i++) {
-			if (children[i]) {
-				// If we enter this code path on sCU bailout, where we copy
-				// oldVNode._children to newVNode._children, we need to update the old
-				// children's _parent pointer to point to the newVNode (parentVNode
-				// here).
-				children[i]._parent = parentVNode;
-				oldDom = insert(children[i], oldDom, parentDom, shouldPlace);
-			}
-		}
-
-		return oldDom;
-	} else if (parentVNode._dom != oldDom) {
-		if (shouldPlace) {
-			if (oldDom && parentVNode.type && !oldDom.parentNode) {
-				oldDom = getDomSibling(parentVNode);
-			}
-			parentDom.insertBefore(parentVNode._dom, oldDom || NULL);
-		}
-		oldDom = parentVNode._dom;
-	}
-
-	do {
-		oldDom = oldDom && oldDom.nextSibling;
-	} while (oldDom != NULL && oldDom.nodeType == 8);
-
-	return oldDom;
-}
-
-/**
- * Flatten and loop through the children of a virtual node
- * @param {ComponentChildren} children The unflattened children of a virtual
- * node
- * @returns {VNode[]}
- */
-export function toChildArray(children, out) {
-	out = out || [];
-	if (children == NULL || typeof children == 'boolean') {
-	} else if (isArray(children)) {
-		children.some(child => {
-			toChildArray(child, out);
-		});
-	} else {
-		out.push(children);
-	}
-	return out;
-}
-
-/**
- * @param {VNode} childVNode
- * @param {VNode[]} oldChildren
- * @param {number} skewedIndex
- * @param {number} remainingOldChildren
- * @returns {number}
- */
-function findMatchingIndex(
-	childVNode,
-	oldChildren,
-	skewedIndex,
-	remainingOldChildren
-) {
-	const key = childVNode.key;
-	const type = childVNode.type;
-	let oldVNode = oldChildren[skewedIndex];
-	const matched = oldVNode != NULL && (oldVNode._flags & MATCHED) == 0;
-
-	// We only need to perform a search if there are more children
-	// (remainingOldChildren) to search. However, if the oldVNode we just looked
-	// at skewedIndex was not already used in this diff, then there must be at
-	// least 1 other (so greater than 1) remainingOldChildren to attempt to match
-	// against. So the following condition checks that ensuring
-	// remainingOldChildren > 1 if the oldVNode is not already used/matched. Else
-	// if the oldVNode was null or matched, then there could needs to be at least
-	// 1 (aka `remainingOldChildren > 0`) children to find and compare against.
-	//
-	// If there is an unkeyed functional VNode, that isn't a built-in like our Fragment,
-	// we should not search as we risk re-using state of an unrelated VNode. (reverted for now)
-	let shouldSearch =
-		// (typeof type != 'function' || type === Fragment || key) &&
-		remainingOldChildren > (matched ? 1 : 0);
-
-	if (
-		(oldVNode === NULL && key == null) ||
-		(matched && key == oldVNode.key && type == oldVNode.type)
-	) {
-		return skewedIndex;
-	} else if (shouldSearch) {
-		let x = skewedIndex - 1;
-		let y = skewedIndex + 1;
-		while (x >= 0 || y < oldChildren.length) {
-			const childIndex = x >= 0 ? x-- : y++;
-			oldVNode = oldChildren[childIndex];
-			if (
-				oldVNode != NULL &&
-				(oldVNode._flags & MATCHED) == 0 &&
-				key == oldVNode.key &&
-				type == oldVNode.type
-			) {
-				return childIndex;
-			}
-		}
-	}
-
-	return -1;
-}