pixuireactcomponents 1.2.0 → 1.2.1

package/lib/preact/compat/src/suspense-list.js

@@ -1,127 +0,0 @@
-import { Component, toChildArray } from 'preact';
-import { suspended } from './suspense.js';
-
-// Indexes to linked list nodes (nodes are stored as arrays to save bytes).
-const SUSPENDED_COUNT = 0;
-const RESOLVED_COUNT = 1;
-const NEXT_NODE = 2;
-
-// Having custom inheritance instead of a class here saves a lot of bytes.
-export function SuspenseList() {
-	this._next = null;
-	this._map = null;
-}
-
-// Mark one of child's earlier suspensions as resolved.
-// Some pending callbacks may become callable due to this
-// (e.g. the last suspended descendant gets resolved when
-// revealOrder === 'together'). Process those callbacks as well.
-const resolve = (list, child, node) => {
-	if (++node[RESOLVED_COUNT] === node[SUSPENDED_COUNT]) {
-		// The number a child (or any of its descendants) has been suspended
-		// matches the number of times it's been resolved. Therefore we
-		// mark the child as completely resolved by deleting it from ._map.
-		// This is used to figure out when *all* children have been completely
-		// resolved when revealOrder is 'together'.
-		list._map.delete(child);
-	}
-
-	// If revealOrder is falsy then we can do an early exit, as the
-	// callbacks won't get queued in the node anyway.
-	// If revealOrder is 'together' then also do an early exit
-	// if all suspended descendants have not yet been resolved.
-	if (
-		!list.props.revealOrder ||
-		(list.props.revealOrder[0] === 't' && list._map.size)
-	) {
-		return;
-	}
-
-	// Walk the currently suspended children in order, calling their
-	// stored callbacks on the way. Stop if we encounter a child that
-	// has not been completely resolved yet.
-	node = list._next;
-	while (node) {
-		while (node.length > 3) {
-			node.pop()();
-		}
-		if (node[RESOLVED_COUNT] < node[SUSPENDED_COUNT]) {
-			break;
-		}
-		list._next = node = node[NEXT_NODE];
-	}
-};
-
-// Things we do here to save some bytes but are not proper JS inheritance:
-// - call `new Component()` as the prototype
-// - do not set `Suspense.prototype.constructor` to `Suspense`
-SuspenseList.prototype = new Component();
-
-SuspenseList.prototype._suspended = function(child) {
-	const list = this;
-	const delegated = suspended(list._vnode);
-
-	let node = list._map.get(child);
-	node[SUSPENDED_COUNT]++;
-
-	return unsuspend => {
-		const wrappedUnsuspend = () => {
-			if (!list.props.revealOrder) {
-				// Special case the undefined (falsy) revealOrder, as there
-				// is no need to coordinate a specific order or unsuspends.
-				unsuspend();
-			} else {
-				node.push(unsuspend);
-				resolve(list, child, node);
-			}
-		};
-		if (delegated) {
-			delegated(wrappedUnsuspend);
-		} else {
-			wrappedUnsuspend();
-		}
-	};
-};
-
-SuspenseList.prototype.render = function(props) {
-	this._next = null;
-	this._map = new Map();
-
-	const children = toChildArray(props.children);
-	if (props.revealOrder && props.revealOrder[0] === 'b') {
-		// If order === 'backwards' (or, well, anything starting with a 'b')
-		// then flip the child list around so that the last child will be
-		// the first in the linked list.
-		children.reverse();
-	}
-	// Build the linked list. Iterate through the children in reverse order
-	// so that `_next` points to the first linked list node to be resolved.
-	for (let i = children.length; i--; ) {
-		// Create a new linked list node as an array of form:
-		// 	[suspended_count, resolved_count, next_node]
-		// where suspended_count and resolved_count are numeric counters for
-		// keeping track how many times a node has been suspended and resolved.
-		//
-		// Note that suspended_count starts from 1 instead of 0, so we can block
-		// processing callbacks until componentDidMount has been called. In a sense
-		// node is suspended at least until componentDidMount gets called!
-		//
-		// Pending callbacks are added to the end of the node:
-		// 	[suspended_count, resolved_count, next_node, callback_0, callback_1, ...]
-		this._map.set(children[i], (this._next = [1, 0, this._next]));
-	}
-	return props.children;
-};
-
-SuspenseList.prototype.componentDidUpdate = SuspenseList.prototype.componentDidMount = function() {
-	// Iterate through all children after mounting for two reasons:
-	// 1. As each node[SUSPENDED_COUNT] starts from 1, this iteration increases
-	//    each node[RELEASED_COUNT] by 1, therefore balancing the counters.
-	//    The nodes can now be completely consumed from the linked list.
-	// 2. Handle nodes that might have gotten resolved between render and
-	//    componentDidMount.
-	const list = this;
-	list._map.forEach((node, child) => {
-		resolve(list, child, node);
-	});
-};

package/lib/preact/compat/src/suspense.d.ts

@@ -1,15 +0,0 @@
-import { Component, ComponentChild } from '../../src';
-
-//
-// Suspense/lazy
-// -----------------------------------
-export function lazy<T>(loader: () => Promise<{ default: T }>): T;
-
-export interface SuspenseProps {
-	children?: preact.ComponentChildren;
-	fallback: preact.ComponentChildren;
-}
-
-export class Suspense extends Component<SuspenseProps> {
-	render(): ComponentChild;
-}

package/lib/preact/compat/src/suspense.js

@@ -1,165 +0,0 @@
-import { Component, createElement, options } from 'preact';
-import { assign } from './util';
-
-const oldCatchError = options._catchError;
-options._catchError = function(error, newVNode, oldVNode) {
-	if (error.then) {
-		/** @type {import('./internal').Component} */
-		let component;
-		let vnode = newVNode;
-
-		for (; (vnode = vnode._parent); ) {
-			if ((component = vnode._component) && component._childDidSuspend) {
-				// Don't call oldCatchError if we found a Suspense
-				return component._childDidSuspend(error, newVNode._component);
-			}
-		}
-	}
-	oldCatchError(error, newVNode, oldVNode);
-};
-
-function detachedClone(vnode) {
-	if (vnode) {
-		vnode = assign({}, vnode);
-		vnode._component = null;
-		vnode._children = vnode._children && vnode._children.map(detachedClone);
-	}
-	return vnode;
-}
-
-// having custom inheritance instead of a class here saves a lot of bytes
-export function Suspense() {
-	// we do not call super here to golf some bytes...
-	this._pendingSuspensionCount = 0;
-	this._suspenders = null;
-	this._detachOnNextRender = null;
-}
-
-// Things we do here to save some bytes but are not proper JS inheritance:
-// - call `new Component()` as the prototype
-// - do not set `Suspense.prototype.constructor` to `Suspense`
-Suspense.prototype = new Component();
-
-/**
- * @param {Promise} promise The thrown promise
- * @param {Component<any, any>} suspendingComponent The suspending component
- */
-Suspense.prototype._childDidSuspend = function(promise, suspendingComponent) {
-	/** @type {import('./internal').SuspenseComponent} */
-	const c = this;
-
-	if (c._suspenders == null) {
-		c._suspenders = [];
-	}
-	c._suspenders.push(suspendingComponent);
-
-	const resolve = suspended(c._vnode);
-
-	let resolved = false;
-	const onResolved = () => {
-		if (resolved) return;
-
-		resolved = true;
-
-		if (resolve) {
-			resolve(onSuspensionComplete);
-		} else {
-			onSuspensionComplete();
-		}
-	};
-
-	suspendingComponent._suspendedComponentWillUnmount =
-		suspendingComponent.componentWillUnmount;
-	suspendingComponent.componentWillUnmount = () => {
-		onResolved();
-
-		if (suspendingComponent._suspendedComponentWillUnmount) {
-			suspendingComponent._suspendedComponentWillUnmount();
-		}
-	};
-
-	const onSuspensionComplete = () => {
-		if (!--c._pendingSuspensionCount) {
-			c._vnode._children[0] = c.state._suspended;
-			c.setState({ _suspended: (c._detachOnNextRender = null) });
-
-			let suspended;
-			while ((suspended = c._suspenders.pop())) {
-				suspended.forceUpdate();
-			}
-		}
-	};
-
-	if (!c._pendingSuspensionCount++) {
-		c.setState({ _suspended: (c._detachOnNextRender = c._vnode._children[0]) });
-	}
-	promise.then(onResolved, onResolved);
-};
-
-Suspense.prototype.render = function(props, state) {
-	if (this._detachOnNextRender) {
-		this._vnode._children[0] = detachedClone(this._detachOnNextRender);
-		this._detachOnNextRender = null;
-	}
-
-	return [
-		createElement(Component, null, state._suspended ? null : props.children),
-		state._suspended && props.fallback
-	];
-};
-
-/**
- * Checks and calls the parent component's _suspended method, passing in the
- * suspended vnode. This is a way for a parent (e.g. SuspenseList) to get notified
- * that one of its children/descendants suspended.
- *
- * The parent MAY return a callback. The callback will get called when the
- * suspension resolves, notifying the parent of the fact.
- * Moreover, the callback gets function `unsuspend` as a parameter. The resolved
- * child descendant will not actually get unsuspended until `unsuspend` gets called.
- * This is a way for the parent to delay unsuspending.
- *
- * If the parent does not return a callback then the resolved vnode
- * gets unsuspended immediately when it resolves.
- *
- * @param {import('../src/internal').VNode} vnode
- * @returns {((unsuspend: () => void) => void)?}
- */
-export function suspended(vnode) {
-	let component = vnode._parent._component;
-	return component && component._suspended && component._suspended(vnode);
-}
-
-export function lazy(loader) {
-	let prom;
-	let component;
-	let error;
-
-	function Lazy(props) {
-		if (!prom) {
-			prom = loader();
-			prom.then(
-				exports => {
-					component = exports.default || exports;
-				},
-				e => {
-					error = e;
-				}
-			);
-		}
-
-		if (error) {
-			throw error;
-		}
-
-		if (!component) {
-			throw prom;
-		}
-
-		return createElement(component, props);
-	}
-
-	Lazy.displayName = 'Lazy';
-	Lazy._forwarded = true;
-	return Lazy;
-}

package/lib/preact/compat/src/util.js

@@ -1,23 +0,0 @@
-/**
- * Assign properties from `props` to `obj`
- * @template O, P The obj and props types
- * @param {O} obj The object to copy properties to
- * @param {P} props The object to copy properties from
- * @returns {O & P}
- */
-export function assign(obj, props) {
-	for (let i in props) obj[i] = props[i];
-	return /** @type {O & P} */ (obj);
-}
-
-/**
- * Check if two objects have a different shape
- * @param {object} a
- * @param {object} b
- * @returns {boolean}
- */
-export function shallowDiffers(a, b) {
-	for (let i in a) if (i !== '__source' && !(i in b)) return true;
-	for (let i in b) if (i !== '__source' && a[i] !== b[i]) return true;
-	return false;
-}

package/lib/preact/hooks/src/index.d.ts

@@ -1,133 +0,0 @@
-import { PreactContext, Ref as PreactRef } from '../..';
-
-type Inputs = ReadonlyArray<unknown>;
-
-export type StateUpdater<S> = (value: S | ((prevState: S) => S)) => void;
-/**
- * Returns a stateful value, and a function to update it.
- * @param initialState The initial value (or a function that returns the initial value)
- */
-export function useState<S>(initialState: S | (() => S)): [S, StateUpdater<S>];
-
-export type Reducer<S, A> = (prevState: S, action: A) => S;
-/**
- * An alternative to `useState`.
- *
- * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
- * multiple sub-values. It also lets you optimize performance for components that trigger deep
- * updates because you can pass `dispatch` down instead of callbacks.
- * @param reducer Given the current state and an action, returns the new state
- * @param initialState The initial value to store as state
- */
-export function useReducer<S, A>(
-	reducer: Reducer<S, A>,
-	initialState: S
-): [S, (action: A) => void];
-
-/**
- * An alternative to `useState`.
- *
- * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
- * multiple sub-values. It also lets you optimize performance for components that trigger deep
- * updates because you can pass `dispatch` down instead of callbacks.
- * @param reducer Given the current state and an action, returns the new state
- * @param initialArg The initial argument to pass to the `init` function
- * @param init A function that, given the `initialArg`, returns the initial value to store as state
- */
-export function useReducer<S, A, I>(
-	reducer: Reducer<S, A>,
-	initialArg: I,
-	init: (arg: I) => S
-): [S, (action: A) => void];
-
-type PropRef<T> = { current?: T };
-type Ref<T> = { current: T };
-
-/**
- * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument
- * (`initialValue`). The returned object will persist for the full lifetime of the component.
- *
- * Note that `useRef()` is useful for more than the `ref` attribute. It’s handy for keeping any mutable
- * value around similar to how you’d use instance fields in classes.
- */
-export function useRef<T>(initialValue: T | null): Ref<T>;
-
-/**
- * `useRef` without an initial value is the special case handling `ref` props.
- * If you want a non prop-based, mutable ref, you can explicitly give it an initial value of undefined/null/etc.
- * You should explicitly set the type parameter for the expected ref value to either a DOM Element like `HTMLInputElement` or a `Component`
- */
-export function useRef<T = unknown>(): PropRef<T>;
-
-type EffectCallback = () => void | (() => void);
-/**
- * Accepts a function that contains imperative, possibly effectful code.
- * The effects run after browser paint, without blocking it.
- *
- * @param effect Imperative function that can return a cleanup function
- * @param inputs If present, effect will only activate if the values in the list change (using ===).
- */
-export function useEffect(effect: EffectCallback, inputs?: Inputs): void;
-
-type CreateHandle = () => object;
-
-/**
- * @param ref The ref that will be mutated
- * @param create The function that will be executed to get the value that will be attached to
- * ref.current
- * @param inputs If present, effect will only activate if the values in the list change (using ===).
- */
-export function useImperativeHandle<T, R extends T>(
-	ref: PreactRef<T>,
-	create: () => R,
-	inputs?: Inputs
-): void;
-
-/**
- * Accepts a function that contains imperative, possibly effectful code.
- * Use this to read layout from the DOM and synchronously re-render.
- * Updates scheduled inside `useLayoutEffect` will be flushed synchronously, after all DOM mutations but before the browser has a chance to paint.
- * Prefer the standard `useEffect` hook when possible to avoid blocking visual updates.
- *
- * @param effect Imperative function that can return a cleanup function
- * @param inputs If present, effect will only activate if the values in the list change (using ===).
- */
-export function useLayoutEffect(effect: EffectCallback, inputs?: Inputs): void;
-
-/**
- * Returns a memoized version of the callback that only changes if one of the `inputs`
- * has changed (using ===).
- */
-export function useCallback<T extends Function>(callback: T, inputs: Inputs): T;
-
-/**
- * Pass a factory function and an array of inputs.
- * useMemo will only recompute the memoized value when one of the inputs has changed.
- * This optimization helps to avoid expensive calculations on every render.
- * If no array is provided, a new value will be computed whenever a new function instance is passed as the first argument.
- */
-// for `inputs`, allow undefined, but don't make it optional as that is very likely a mistake
-export function useMemo<T>(factory: () => T, inputs: Inputs | undefined): T;
-
-/**
- * Returns the current context value, as given by the nearest context provider for the given context.
- * When the provider updates, this Hook will trigger a rerender with the latest context value.
- *
- * @param context The context you want to use
- */
-export function useContext<T>(context: PreactContext<T>): T;
-
-/**
- * Customize the displayed value in the devtools panel.
- *
- * @param value Custom hook name or object that is passed to formatter
- * @param formatter Formatter to modify value before sending it to the devtools
- */
-export function useDebugValue<T>(
-	value: T,
-	formatter?: (value: T) => string | number
-): void;
-
-export function useErrorBoundary(
-	callback?: (error: any) => Promise<void> | void
-): [any, () => void];