pixuireactcomponents 1.2.0 → 1.2.2

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

@@ -1,275 +0,0 @@
-export = preact;
-export as namespace preact;
-
-import { JSXInternal } from './jsx';
-
-import { JCSSProperties } from './jsx';
-export type CSSProperties = JCSSProperties ;
-
-declare namespace preact {
-	export import JSX = JSXInternal;
-
-	//
-	// Preact Virtual DOM
-	// -----------------------------------
-
-	interface VNode<P = {}> {
-		type: ComponentType<P> | string;
-		props: P & { children: ComponentChildren };
-		key: Key;
-		/**
-		 * ref is not guaranteed by React.ReactElement, for compatiblity reasons
-		 * with popular react libs we define it as optional too
-		 */
-		ref?: Ref<any> | null;
-		/**
-		 * The time this `vnode` started rendering. Will only be set when
-		 * the devtools are attached.
-		 * Default value: `0`
-		 */
-		startTime?: number;
-		/**
-		 * The time that the rendering of this `vnode` was completed. Will only be
-		 * set when the devtools are attached.
-		 * Default value: `-1`
-		 */
-		endTime?: number;
-	}
-
-	//
-	// Preact Component interface
-	// -----------------------------------
-
-	type Key = string | number | any;
-
-	type RefObject<T> = { current?: T | null };
-	type RefCallback<T> = (instance: T | null) => void;
-	type Ref<T> = RefObject<T> | RefCallback<T>;
-
-	type ComponentChild = VNode<any> | object | string | number | boolean | null | undefined;
-	type ComponentChildren = ComponentChild[] | ComponentChild;
-
-	interface Attributes {
-		key?: Key;
-		jsx?: boolean;
-	}
-
-	interface ClassAttributes<T> extends Attributes {
-		ref?: Ref<T>;
-	}
-
-	interface PreactDOMAttributes {
-		children?: ComponentChildren;
-		dangerouslySetInnerHTML?: {
-			__html: string;
-		};
-	}
-
-	type RenderableProps<P, RefType = any> = P &
-		Readonly<Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }>;
-
-	type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
-	type ComponentFactory<P = {}> = ComponentType<P>;
-
-	type ComponentProps<C extends ComponentType<any>> = C extends ComponentType<infer P> ? P : never;
-
-	interface FunctionComponent<P = {}> {
-		(props: RenderableProps<P>, context?: any): VNode<any> | null;
-		displayName?: string;
-		defaultProps?: Partial<P>;
-	}
-	interface FunctionalComponent<P = {}> extends FunctionComponent<P> {}
-
-	interface ComponentClass<P = {}, S = {}> {
-		new (props: P, context?: any): Component<P, S>;
-		displayName?: string;
-		defaultProps?: Partial<P>;
-		getDerivedStateFromProps?(props: Readonly<P>, state: Readonly<S>): Partial<S> | null;
-		getDerivedStateFromError?(error: any): Partial<S> | null;
-	}
-	interface ComponentConstructor<P = {}, S = {}> extends ComponentClass<P, S> {}
-
-	// Type alias for a component instance considered generally, whether stateless or stateful.
-	type AnyComponent<P = {}, S = {}> = FunctionComponent<P> | Component<P, S>;
-
-	interface Component<P = {}, S = {}> {
-		refs: { [key: string]: Component<any> | Element };
-		componentWillMount?(): void;
-		componentDidMount?(): void;
-		componentWillUnmount?(): void;
-		getChildContext?(): object;
-		componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
-		shouldComponentUpdate?(
-			nextProps: Readonly<P>,
-			nextState: Readonly<S>,
-			nextContext: any
-		): boolean;
-		componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
-		getSnapshotBeforeUpdate?(oldProps: Readonly<P>, oldState: Readonly<S>): any;
-		componentDidUpdate?(
-			previousProps: Readonly<P>,
-			previousState: Readonly<S>,
-			snapshot: any
-		): void;
-		componentDidCatch?(error: any, errorInfo: any): void;
-	}
-
-	abstract class Component<P, S> {
-		constructor(props?: P, context?: any);
-
-		static displayName?: string;
-		static defaultProps?: any;
-		static contextType?: Context<any>;
-
-		// Static members cannot reference class type parameters. This is not
-		// supported in TypeScript. Reusing the same type arguments from `Component`
-		// will lead to an impossible state where one cannot satisfy the type
-		// constraint under no circumstances, see #1356.In general type arguments
-		// seem to be a bit buggy and not supported well at the time of this
-		// writing with TS 3.3.3333.
-		static getDerivedStateFromProps?(
-			props: Readonly<object>,
-			state: Readonly<object>
-		): object | null;
-		static getDerivedStateFromError?(error: any): object | null;
-
-		state: Readonly<S>;
-		props: RenderableProps<P>;
-		context: any;
-		base?: Element | Text;
-
-		// From https://github.com/DefinitelyTyped/DefinitelyTyped/blob/e836acc75a78cf0655b5dfdbe81d69fdd4d8a252/types/react/index.d.ts#L402
-		// // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.
-		// // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257
-		setState<K extends keyof S>(
-			state:
-				| ((prevState: Readonly<S>, props: Readonly<P>) => Pick<S, K> | Partial<S> | null)
-				| (Pick<S, K> | Partial<S> | null),
-			callback?: () => void
-		): void;
-
-		forceUpdate(callback?: () => void): void;
-
-		abstract render(props?: RenderableProps<P>, state?: Readonly<S>, context?: any): ComponentChild;
-	}
-
-	//
-	// Preact createElement
-	// -----------------------------------
-
-	function createElement(
-		type: string,
-		props: (JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any>) | null,
-		...children: ComponentChildren[]
-	): VNode<any>;
-	function createElement<P>(
-		type: ComponentType<P>,
-		props: (Attributes & P) | null,
-		...children: ComponentChildren[]
-	): VNode<any>;
-	namespace createElement {
-		export import JSX = JSXInternal;
-	}
-
-	function h(
-		type: string,
-		props: (JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes & Record<string, any>) | null,
-		...children: ComponentChildren[]
-	): VNode<any>;
-	function h<P>(
-		type: ComponentType<P>,
-		props: (Attributes & P) | null,
-		...children: ComponentChildren[]
-	): VNode<any>;
-	namespace h {
-		export import JSX = JSXInternal;
-	}
-
-
-
-	//
-	// Preact render
-	// -----------------------------------
-
-	function render(
-		vnode: ComponentChild,
-		parent: Element | Document | ShadowRoot | DocumentFragment,
-		replaceNode?: Element | Text
-	): void;
-	function hydrate(
-		vnode: ComponentChild,
-		parent: Element | Document | ShadowRoot | DocumentFragment
-	): void;
-	function cloneElement(
-		vnode: VNode<any>,
-		props?: any,
-		...children: ComponentChildren[]
-	): VNode<any>;
-	function cloneElement<P>(
-		vnode: VNode<P>,
-		props?: any,
-		...children: ComponentChildren[]
-	): VNode<P>;
-
-	//
-	// Preact Built-in Components
-	// -----------------------------------
-
-	// TODO: Revisit what the public type of this is...
-	const Fragment: ComponentClass<{}, {}>;
-
-	//
-	// Preact options
-	// -----------------------------------
-
-	/**
-	 * Global options for preact
-	 */
-	interface Options {
-		/** Attach a hook that is invoked whenever a VNode is created. */
-		vnode?(vnode: VNode): void;
-		/** Attach a hook that is invoked immediately before a vnode is unmounted. */
-		unmount?(vnode: VNode): void;
-		/** Attach a hook that is invoked after a vnode has rendered. */
-		diffed?(vnode: VNode): void;
-		event?(e: Event): any;
-		requestAnimationFrame?: typeof requestAnimationFrame;
-		debounceRendering?(cb: () => void): void;
-		useDebugValue?(value: string | number): void;
-		__suspenseDidResolve?(vnode: VNode, cb: () => void): void;
-		// __canSuspenseResolve?(vnode: VNode, cb: () => void): void;
-	}
-
-	const options: Options;
-
-	//
-	// Preact helpers
-	// -----------------------------------
-	function createRef<T = any>(): RefObject<T>;
-	function toChildArray(children: ComponentChildren): Array<VNode | string | number>;
-	function isValidElement(vnode: any): vnode is VNode;
-
-	//
-	// Context
-	// -----------------------------------
-	interface Consumer<T>
-		extends FunctionComponent<{
-			children: (value: T) => ComponentChildren;
-		}> {}
-	interface PreactConsumer<T> extends Consumer<T> {}
-
-	interface Provider<T>
-		extends FunctionComponent<{
-			value: T;
-			children: ComponentChildren;
-		}> {}
-	interface PreactProvider<T> extends Provider<T> {}
-
-	interface Context<T> {
-		Consumer: Consumer<T>;
-		Provider: Provider<T>;
-	}
-	interface PreactContext<T> extends Context<T> {}
-
-	function createContext<T>(defaultValue: T): Context<T>;
-}

package/lib/preact/src/index.js

@@ -1,14 +0,0 @@
-export { render, hydrate } from './render';
-export {
-	createElement,
-	createElement as h,
-	Fragment,
-	createRef,
-	isValidElement
-} from './create-element';
-export { Component } from './component';
-export { cloneElement } from './clone-element';
-export { createContext } from './create-context';
-export { toChildArray } from './diff/children';
-export { unmount as _unmount } from './diff';
-export { default as options } from './options';

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

@@ -1,94 +0,0 @@
-import * as preact from './index';
-
-export interface Options extends preact.Options {
-	/** Attach a hook that is invoked before render, mainly to check the arguments. */
-	_root?(
-		vnode: preact.ComponentChild,
-		parent: Element | Document | ShadowRoot | DocumentFragment
-	): void;
-	/** Attach a hook that is invoked before a vnode is diffed. */
-	_diff?(vnode: VNode): void;
-	/** Attach a hook that is invoked after a tree was mounted or was updated. */
-	_commit?(vnode: VNode, commitQueue: Component[]): void;
-	/** Attach a hook that is invoked before a vnode has rendered. */
-	_render?(vnode: VNode): void;
-	/** Attach a hook that is invoked before a hook's state is queried. */
-	_hook?(component: Component): void;
-	/** Attach a hook that is invoked after an error is caught in a component but before calling lifecycle hooks */
-	_catchError(error: any, vnode: VNode, oldVNode: VNode | undefined): void;
-}
-
-export interface FunctionalComponent<P = {}>
-	extends preact.FunctionComponent<P> {
-	// Define getDerivedStateFromProps as undefined on FunctionalComponent
-	// to get rid of some errors in `diff()`
-	getDerivedStateFromProps?: undefined;
-}
-
-// Redefine ComponentFactory using our new internal FunctionalComponent interface above
-export type ComponentFactory<P> =
-	| preact.ComponentClass<P>
-	| FunctionalComponent<P>;
-
-export interface PreactElement extends HTMLElement {
-	_children?: VNode<any> | null;
-	/** Event listeners to support event delegation */
-	_listeners: Record<string, (e: Event) => void>;
-
-	// Preact uses this attribute to detect SVG nodes
-	ownerSVGElement?: SVGElement | null;
-
-	// style: HTMLElement["style"]; // From HTMLElement
-
-	data?: string | number; // From Text node
-}
-
-export interface VNode<P = {}> extends preact.VNode<P> {
-	// Redefine type here using our internal ComponentFactory type
-	type: string | ComponentFactory<P>;
-	props: P & { children: preact.ComponentChildren };
-	_children: Array<VNode<any>> | null;
-	_parent: VNode | null;
-	_depth: number | null;
-	/**
-	 * The [first (for Fragments)] DOM child of a VNode
-	 */
-	_dom: PreactElement | Text | null;
-	/**
-	 * The last dom child of a Fragment, or components that return a Fragment
-	 */
-	_nextDom: PreactElement | Text | null;
-	_component: Component | null;
-	constructor: undefined;
-	_original?: VNode | null;
-}
-
-export interface Component<P = {}, S = {}> extends preact.Component<P, S> {
-	// When component is functional component, this is reset to functional component
-	constructor: preact.ComponentType<P>;
-	state: S; // Override Component["state"] to not be readonly for internal use, specifically Hooks
-	base?: PreactElement;
-
-	_dirty: boolean;
-	_force?: boolean;
-	_renderCallbacks: Array<() => void>; // Only class components
-	_globalContext?: any;
-	_vnode?: VNode<P> | null;
-	_nextState?: S | null; // Only class components
-	/** Only used in the devtools to later dirty check if state has changed */
-	_prevState?: S | null;
-	/**
-	 * Pointer to the parent dom node. This is only needed for top-level Fragment
-	 * components or array returns.
-	 */
-	_parentDom?: PreactElement | null;
-	// Always read, set only when handling error
-	_processingException?: Component<any, any> | null;
-	// Always read, set only when handling error. This is used to indicate at diffTime to set _processingException
-	_pendingError?: Component<any, any> | null;
-}
-
-export interface PreactContext extends preact.Context<any> {
-	_id: string;
-	_defaultValue: any;
-}