pixuireactcomponents 1.2.0 → 1.2.1

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

@@ -1,121 +0,0 @@
-import * as _hooks from '../../hooks';
-import * as preact from '../../src';
-import { JSXInternal } from '../../src/jsx';
-import * as _Suspense from './suspense';
-
-// export default React;
-export = React;
-export as namespace React;
-declare namespace React {
-	// Export JSX
-	export import JSX = JSXInternal;
-
-	// Hooks
-	export import CreateHandle = _hooks.CreateHandle;
-	export import EffectCallback = _hooks.EffectCallback;
-	export import Inputs = _hooks.Inputs;
-	export import PropRef = _hooks.PropRef;
-	export import Reducer = _hooks.Reducer;
-	export import Ref = _hooks.Ref;
-	export import StateUpdater = _hooks.StateUpdater;
-	export import useCallback = _hooks.useCallback;
-	export import useContext = _hooks.useContext;
-	export import useDebugValue = _hooks.useDebugValue;
-	export import useEffect = _hooks.useEffect;
-	export import useImperativeHandle = _hooks.useImperativeHandle;
-	export import useLayoutEffect = _hooks.useLayoutEffect;
-	export import useMemo = _hooks.useMemo;
-	export import useReducer = _hooks.useReducer;
-	export import useRef = _hooks.useRef;
-	export import useState = _hooks.useState;
-
-	// Preact Defaults
-	export import Component = preact.Component;
-	export import FunctionComponent = preact.FunctionComponent;
-	export import FC = preact.FunctionComponent;
-	export import createContext = preact.createContext;
-	export import createRef = preact.createRef;
-	export import Fragment = preact.Fragment;
-	export import createElement = preact.createElement;
-	export import cloneElement = preact.cloneElement;
-
-	// Suspense
-	export import Suspense = _Suspense.Suspense;
-	export import lazy = _Suspense.lazy;
-
-	// Compat
-	export const version: string;
-
-	export function createPortal(
-		vnode: preact.VNode,
-		container: Element
-	): preact.VNode<any>;
-
-	export function render(
-		vnode: preact.VNode<any>,
-		parent: Element,
-		callback?: () => void
-	): Component | null;
-
-	export function hydrate(
-		vnode: preact.VNode<any>,
-		parent: Element,
-		callback?: () => void
-	): Component | null;
-
-	export function unmountComponentAtNode(
-		container: Element | Document | ShadowRoot | DocumentFragment
-	): boolean;
-
-	export function createFactory(
-		type: preact.VNode<any>['type']
-	): (
-		props?: any,
-		...children: preact.ComponentChildren[]
-	) => preact.VNode<any>;
-	export function isValidElement(element: any): boolean;
-	export function findDOMNode(component: preact.Component): Element | null;
-
-	export abstract class PureComponent<P = {}, S = {}> extends preact.Component<
-		P,
-		S
-	> {
-		isPureReactComponent: boolean;
-	}
-
-	export function memo<C extends preact.FunctionalComponent<any>>(
-		component: C,
-		comparer?: (
-			prev: preact.ComponentProps<C>,
-			next: preact.ComponentProps<C>
-		) => boolean
-	): C;
-
-	export interface ForwardFn<P = {}, T = any> {
-		(props: P, ref: Ref<T>): preact.ComponentChild;
-		displayName?: string;
-	}
-
-	export function forwardRef<R, P = {}>(
-		fn: ForwardFn<P, R>
-	): preact.FunctionalComponent<P>;
-
-	export function unstable_batchedUpdates(
-		callback: (arg?: any) => void,
-		arg?: any
-	): void;
-
-	export const Children: {
-		map<T extends preact.ComponentChild, R>(
-			children: T | T[],
-			fn: (child: T, i: number) => R
-		): R[];
-		forEach<T extends preact.ComponentChild>(
-			children: T | T[],
-			fn: (child: T, i: number) => void
-		): void;
-		count: (children: preact.ComponentChildren) => number;
-		only: (children: preact.ComponentChildren) => preact.ComponentChild;
-		toArray: (children: preact.ComponentChildren) => preact.VNode<{}>[];
-	};
-}

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

@@ -1,159 +0,0 @@
-import {
-	createElement,
-	render as preactRender,
-	cloneElement as preactCloneElement,
-	createRef,
-	Component,
-	createContext,
-	Fragment
-} from 'preact';
-import {
-	useState,
-	useReducer,
-	useEffect,
-	useLayoutEffect,
-	useRef,
-	useImperativeHandle,
-	useMemo,
-	useCallback,
-	useContext,
-	useDebugValue
-} from 'preact/hooks';
-import { PureComponent } from './PureComponent';
-import { memo } from './memo';
-import { forwardRef } from './forwardRef';
-import { Children } from './Children';
-import { Suspense, lazy } from './suspense';
-import { SuspenseList } from './suspense-list';
-import { createPortal } from './portals';
-import { hydrate, render, REACT_ELEMENT_TYPE } from './render';
-
-const version = '16.8.0'; // trick libraries to think we are react
-
-/**
- * Legacy version of createElement.
- * @param {import('./internal').VNode["type"]} type The node name or Component constructor
- */
-function createFactory(type) {
-	return createElement.bind(null, type);
-}
-
-/**
- * Check if the passed element is a valid (p)react node.
- * @param {*} element The element to check
- * @returns {boolean}
- */
-function isValidElement(element) {
-	return !!element && element.$$typeof === REACT_ELEMENT_TYPE;
-}
-
-/**
- * Wrap `cloneElement` to abort if the passed element is not a valid element and apply
- * all vnode normalizations.
- * @param {import('./internal').VNode} element The vnode to clone
- * @param {object} props Props to add when cloning
- * @param {Array<import('./internal').ComponentChildren>} rest Optional component children
- */
-function cloneElement(element) {
-	if (!isValidElement(element)) return element;
-	return preactCloneElement.apply(null, arguments);
-}
-
-/**
- * Remove a component tree from the DOM, including state and event handlers.
- * @param {import('./internal').PreactElement} container
- * @returns {boolean}
- */
-function unmountComponentAtNode(container) {
-	if (container._children) {
-		preactRender(null, container);
-		return true;
-	}
-	return false;
-}
-
-/**
- * Get the matching DOM node for a component
- * @param {import('./internal').Component} component
- * @returns {import('./internal').PreactElement | null}
- */
-function findDOMNode(component) {
-	return (
-		(component &&
-			(component.base || (component.nodeType === 1 && component))) ||
-		null
-	);
-}
-
-/**
- * Deprecated way to control batched rendering inside the reconciler, but we
- * already schedule in batches inside our rendering code
- * @template Arg
- * @param {(arg: Arg) => void} callback function that triggers the updated
- * @param {Arg} [arg] Optional argument that can be passed to the callback
- */
-// eslint-disable-next-line camelcase
-const unstable_batchedUpdates = (callback, arg) => callback(arg);
-
-export * from 'preact/hooks';
-export {
-	version,
-	Children,
-	render,
-	hydrate,
-	unmountComponentAtNode,
-	createPortal,
-	createElement,
-	createContext,
-	createFactory,
-	cloneElement,
-	createRef,
-	Fragment,
-	isValidElement,
-	findDOMNode,
-	Component,
-	PureComponent,
-	memo,
-	forwardRef,
-	// eslint-disable-next-line camelcase
-	unstable_batchedUpdates,
-	Suspense,
-	SuspenseList,
-	lazy
-};
-
-// React copies the named exports to the default one.
-export default {
-	useState,
-	useReducer,
-	useEffect,
-	useLayoutEffect,
-	useRef,
-	useImperativeHandle,
-	useMemo,
-	useCallback,
-	useContext,
-	useDebugValue,
-	version,
-	Children,
-	render,
-	hydrate: render,
-	unmountComponentAtNode,
-	createPortal,
-	createElement,
-	createContext,
-	createFactory,
-	cloneElement,
-	createRef,
-	Fragment,
-	isValidElement,
-	findDOMNode,
-	Component,
-	PureComponent,
-	memo,
-	forwardRef,
-	unstable_batchedUpdates,
-	Suspense,
-	SuspenseList,
-	lazy
-};

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

@@ -1,45 +0,0 @@
-import {
-	Component as PreactComponent,
-	VNode as PreactVNode,
-	FunctionalComponent as PreactFunctionalComponent
-} from '../../src/internal';
-import { SuspenseProps } from './suspense';
-
-export { ComponentChildren } from '../..';
-
-export { PreactElement } from '../../src/internal';
-
-export interface Component<P = {}, S = {}> extends PreactComponent<P, S> {
-	isReactComponent?: object;
-	isPureReactComponent?: true;
-	_patchedLifecycles?: true;
-
-	_childDidSuspend?(
-		error: Promise<void>,
-		suspendingComponent: Component<any, any>
-	): void;
-	_suspendedComponentWillUnmount?(): void;
-}
-
-export interface FunctionalComponent<P = {}>
-	extends PreactFunctionalComponent<P> {
-	shouldComponentUpdate?(nextProps: Readonly<P>): boolean;
-	_forwarded?: boolean;
-	_patchedLifecycles?: true;
-}
-
-export interface VNode<T = any> extends PreactVNode<T> {
-	$$typeof?: symbol | string;
-	preactCompatNormalized?: boolean;
-}
-
-export interface SuspenseState {
-	_suspended?: null | VNode<any>;
-}
-
-export interface SuspenseComponent
-	extends PreactComponent<SuspenseProps, SuspenseState> {
-	_pendingSuspensionCount: number;
-	_suspenders: Component[];
-	_detachOnNextRender: null | VNode<any>;
-}

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

@@ -1,34 +0,0 @@
-import { createElement } from 'preact';
-import { shallowDiffers, assign } from './util';
-
-/**
- * Memoize a component, so that it only updates when the props actually have
- * changed. This was previously known as `React.pure`.
- * @param {import('./internal').FunctionalComponent} c functional component
- * @param {(prev: object, next: object) => boolean} [comparer] Custom equality function
- * @returns {import('./internal').FunctionalComponent}
- */
-export function memo(c, comparer) {
-	function shouldUpdate(nextProps) {
-		let ref = this.props.ref;
-		let updateRef = ref == nextProps.ref;
-		if (!updateRef && ref) {
-			ref.call ? ref(null) : (ref.current = null);
-		}
-
-		if (!comparer) {
-			return shallowDiffers(this.props, nextProps);
-		}
-
-		return !comparer(this.props, nextProps) || !updateRef;
-	}
-
-	function Memoed(props) {
-		this.shouldComponentUpdate = shouldUpdate;
-		return createElement(c, assign({}, props));
-	}
-	Memoed.prototype.isReactComponent = true;
-	Memoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';
-	Memoed._forwarded = true;
-	return Memoed;
-}

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

@@ -1,85 +0,0 @@
-import { createElement, hydrate, render, _unmount } from 'preact';
-
-class ContextProvider {
-	getChildContext() {
-		return this.props.context;
-	}
-	render(props) {
-		return props.children;
-	}
-}
-
-/**
- * Portal component
- * @param {object | null | undefined} props
- */
-function Portal(props) {
-	let _this = this;
-	let container = props.container;
-	let wrap = createElement(
-		ContextProvider,
-		{ context: _this.context },
-		props.vnode
-	);
-
-	// When we change container we should clear our old container and
-	// indicate a new mount.
-	if (_this._container && _this._container !== container) {
-		if (_this._temp.parentNode) _this._container.removeChild(_this._temp);
-		_unmount(_this._wrap);
-		_this._hasMounted = false;
-	}
-
-	// When props.vnode is undefined/false/null we are dealing with some kind of
-	// conditional vnode. This should not trigger a render.
-	if (props.vnode) {
-		if (!_this._hasMounted) {
-			// Create a placeholder that we can use to insert into.
-			_this._temp = document.createTextNode('');
-			// Hydrate existing nodes to keep the dom intact, when rendering
-			// wrap into the container.
-			hydrate('', container);
-			// Append to the container (this matches React's behavior)
-			container.appendChild(_this._temp);
-			// At this point we have mounted and should set our container.
-			_this._hasMounted = true;
-			_this._container = container;
-			// Render our wrapping element into temp.
-			render(wrap, container, _this._temp);
-			_this._children = _this._temp._children;
-		} else {
-			// When we have mounted and the vnode is present it means the
-			// props have changed or a parent is triggering a rerender.
-			// This implies we only need to call render. But we need to keep
-			// the old tree around, otherwise will treat the vnodes as new and
-			// will wrongly call `componentDidMount` on them
-			container._children = _this._children;
-			render(wrap, container);
-			_this._children = container._children;
-		}
-	}
-	// When we come from a conditional render, on a mounted
-	// portal we should clear the DOM.
-	else if (_this._hasMounted) {
-		if (_this._temp.parentNode) _this._container.removeChild(_this._temp);
-		_unmount(_this._wrap);
-	}
-	// Set the wrapping element for future unmounting.
-	_this._wrap = wrap;
-
-	_this.componentWillUnmount = () => {
-		if (_this._temp.parentNode) _this._container.removeChild(_this._temp);
-		_unmount(_this._wrap);
-	};
-
-	return null;
-}
-
-/**
- * Create a `Portal` to continue rendering the vnode tree at a different DOM node
- * @param {import('./internal').VNode} vnode The vnode to render
- * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.
- */
-export function createPortal(vnode, container) {
-	return createElement(Portal, { vnode, container });
-}

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

@@ -1,166 +0,0 @@
-import {
-	render as preactRender,
-	hydrate as preactHydrate,
-	options,
-	toChildArray,
-	Component
-} from 'preact';
-import { applyEventNormalization } from './events';
-
-const CAMEL_PROPS = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;
-
-// Some libraries like `react-virtualized` explicitly check for this.
-Component.prototype.isReactComponent = {};
-
-export const REACT_ELEMENT_TYPE =
-	(typeof Symbol != 'undefined' && Symbol.for && Symbol.for('react.element')) ||
-	0xeac7;
-
-/**
- * Proxy render() since React returns a Component reference.
- * @param {import('./internal').VNode} vnode VNode tree to render
- * @param {import('./internal').PreactElement} parent DOM node to render vnode tree into
- * @param {() => void} [callback] Optional callback that will be called after rendering
- * @returns {import('./internal').Component | null} The root component reference or null
- */
-export function render(vnode, parent, callback) {
-	// React destroys any existing DOM nodes, see #1727
-	// ...but only on the first render, see #1828
-	if (parent._children == null) {
-		while (parent.firstChild) {
-			parent.removeChild(parent.firstChild);
-		}
-	}
-
-	preactRender(vnode, parent);
-	if (typeof callback == 'function') callback();
-
-	return vnode ? vnode._component : null;
-}
-
-export function hydrate(vnode, parent, callback) {
-	preactHydrate(vnode, parent);
-	if (typeof callback == 'function') callback();
-
-	return vnode ? vnode._component : null;
-}
-
-let oldEventHook = options.event;
-options.event = e => {
-	if (oldEventHook) e = oldEventHook(e);
-	e.persist = () => {};
-	let stoppedPropagating = false,
-		defaultPrevented = false;
-
-	const origStopPropagation = e.stopPropagation;
-	e.stopPropagation = () => {
-		origStopPropagation.call(e);
-		stoppedPropagating = true;
-	};
-
-	const origPreventDefault = e.preventDefault;
-	e.preventDefault = () => {
-		origPreventDefault.call(e);
-		defaultPrevented = true;
-	};
-
-	e.isPropagationStopped = () => stoppedPropagating;
-	e.isDefaultPrevented = () => defaultPrevented;
-	return (e.nativeEvent = e);
-};
-
-// Patch in `UNSAFE_*` lifecycle hooks
-function setSafeDescriptor(proto, key) {
-	if (proto['UNSAFE_' + key] && !proto[key]) {
-		Object.defineProperty(proto, key, {
-			configurable: false,
-			get() {
-				return this['UNSAFE_' + key];
-			},
-			// This `set` is only used if a user sets a lifecycle like cWU
-			// after setting a lifecycle like UNSAFE_cWU. I doubt anyone
-			// actually does this in practice so not testing it
-			/* istanbul ignore next */
-			set(v) {
-				this['UNSAFE_' + key] = v;
-			}
-		});
-	}
-}
-
-let classNameDescriptor = {
-	configurable: true,
-	get() {
-		return this.class;
-	}
-};
-
-let oldVNodeHook = options.vnode;
-options.vnode = vnode => {
-	vnode.$$typeof = REACT_ELEMENT_TYPE;
-
-	let type = vnode.type;
-	let props = vnode.props;
-
-	if (type) {
-		// Alias `class` prop to `className` if available
-		if (props.class && props.class != props.className) {
-			classNameDescriptor.enumerable = 'className' in props;
-			if (props.className != null) props.class = props.className;
-			Object.defineProperty(props, 'className', classNameDescriptor);
-		}
-
-		// Apply DOM VNode compat
-		if (typeof type != 'function') {
-			// Apply defaultValue to value
-			if (props.defaultValue && props.value !== undefined) {
-				if (!props.value && props.value !== 0) {
-					props.value = props.defaultValue;
-				}
-				delete props.defaultValue;
-			}
-
-			// Add support for array select values: <select value={[]} />
-			if (Array.isArray(props.value) && props.multiple && type === 'select') {
-				toChildArray(props.children).forEach(child => {
-					if (props.value.indexOf(child.props.value) != -1) {
-						child.props.selected = true;
-					}
-				});
-				delete props.value;
-			}
-
-			// Normalize DOM vnode properties.
-			let shouldSanitize, attrs, i;
-			for (i in props) if ((shouldSanitize = CAMEL_PROPS.test(i))) break;
-			if (shouldSanitize) {
-				attrs = vnode.props = {};
-				for (i in props) {
-					attrs[
-						CAMEL_PROPS.test(i) ? i.replace(/[A-Z0-9]/, '-$&').toLowerCase() : i
-					] = props[i];
-				}
-			}
-		}
-
-		// Events
-		applyEventNormalization(vnode);
-
-		// Component base class compat
-		// We can't just patch the base component class, because components that use
-		// inheritance and are transpiled down to ES5 will overwrite our patched
-		// getters and setters. See #1941
-		if (
-			typeof type == 'function' &&
-			!type._patchedLifecycles &&
-			type.prototype
-		) {
-			setSafeDescriptor(type.prototype, 'componentWillMount');
-			setSafeDescriptor(type.prototype, 'componentWillReceiveProps');
-			setSafeDescriptor(type.prototype, 'componentWillUpdate');
-			type._patchedLifecycles = true;
-		}
-	}
-
-	if (oldVNodeHook) oldVNodeHook(vnode);
-};

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

@@ -1,14 +0,0 @@
-import { Component, ComponentChild } from '../../src';
-
-//
-// SuspenseList
-// -----------------------------------
-
-export interface SuspenseListProps {
-	children?: preact.ComponentChildren;
-	revealOrder?: 'forwards' | 'backwards' | 'together';
-}
-
-export class SuspenseList extends Component<SuspenseListProps> {
-	render(): ComponentChild;
-}