isomorfeus-preact 10.5.1 → 10.5.2

data/node_modules/preact/src/diff/props.js

@@ -0,0 +1,158 @@
+import { IS_NON_DIMENSIONAL } from '../constants';
+import options from '../options';
+
+/**
+ * Diff the old and new properties of a VNode and apply changes to the DOM node
+ * @param {import('../internal').PreactElement} dom The DOM node to apply
+ * changes to
+ * @param {object} newProps The new props
+ * @param {object} oldProps The old props
+ * @param {boolean} isSvg Whether or not this node is an SVG node
+ * @param {boolean} hydrate Whether or not we are in hydration mode
+ */
+export function diffProps(dom, newProps, oldProps, isSvg, hydrate) {
+	let i;
+
+	for (i in oldProps) {
+		if (i !== 'children' && i !== 'key' && !(i in newProps)) {
+			setProperty(dom, i, null, oldProps[i], isSvg);
+		}
+	}
+
+	for (i in newProps) {
+		if (
+			(!hydrate || typeof newProps[i] == 'function') &&
+			i !== 'children' &&
+			i !== 'key' &&
+			i !== 'value' &&
+			i !== 'checked' &&
+			oldProps[i] !== newProps[i]
+		) {
+			setProperty(dom, i, newProps[i], oldProps[i], isSvg);
+		}
+	}
+}
+
+function setStyle(style, key, value) {
+	if (key[0] === '-') {
+		style.setProperty(key, value);
+	} else if (value == null) {
+		style[key] = '';
+	} else if (typeof value != 'number' || IS_NON_DIMENSIONAL.test(key)) {
+		style[key] = value;
+	} else {
+		style[key] = value + 'px';
+	}
+}
+
+/**
+ * Set a property value on a DOM node
+ * @param {import('../internal').PreactElement} dom The DOM node to modify
+ * @param {string} name The name of the property to set
+ * @param {*} value The value to set the property to
+ * @param {*} oldValue The old value the property had
+ * @param {boolean} isSvg Whether or not this DOM node is an SVG node or not
+ */
+export function setProperty(dom, name, value, oldValue, isSvg) {
+	let useCapture;
+
+	o: if (name === 'style') {
+		if (typeof value == 'string') {
+			dom.style.cssText = value;
+		} else {
+			if (typeof oldValue == 'string') {
+				dom.style.cssText = oldValue = '';
+			}
+
+			if (oldValue) {
+				for (name in oldValue) {
+					if (!(value && name in value)) {
+						setStyle(dom.style, name, '');
+					}
+				}
+			}
+
+			if (value) {
+				for (name in value) {
+					if (!oldValue || value[name] !== oldValue[name]) {
+						setStyle(dom.style, name, value[name]);
+					}
+				}
+			}
+		}
+	}
+	// Benchmark for comparison: https://esbench.com/bench/574c954bdb965b9a00965ac6
+	else if (name[0] === 'o' && name[1] === 'n') {
+		useCapture = name !== (name = name.replace(/Capture$/, ''));
+
+		// Infer correct casing for DOM built-in events:
+		if (name.toLowerCase() in dom) name = name.toLowerCase().slice(2);
+		else name = name.slice(2);
+
+		if (!dom._listeners) dom._listeners = {};
+		dom._listeners[name + useCapture] = value;
+
+		if (value) {
+			if (!oldValue) {
+				const handler = useCapture ? eventProxyCapture : eventProxy;
+				dom.addEventListener(name, handler, useCapture);
+			}
+		} else {
+			const handler = useCapture ? eventProxyCapture : eventProxy;
+			dom.removeEventListener(name, handler, useCapture);
+		}
+	} else if (name !== 'dangerouslySetInnerHTML') {
+		if (isSvg) {
+			// Normalize incorrect prop usage for SVG:
+			// - xlink:href / xlinkHref --> href (xlink:href was removed from SVG and isn't needed)
+			// - className --> class
+			name = name.replace(/xlink[H:h]/, 'h').replace(/sName$/, 's');
+		} else if (
+			name !== 'href' &&
+			name !== 'list' &&
+			name !== 'form' &&
+			// Default value in browsers is `-1` and an empty string is
+			// cast to `0` instead
+			name !== 'tabIndex' &&
+			name !== 'download' &&
+			name in dom
+		) {
+			try {
+				dom[name] = value == null ? '' : value;
+				// labelled break is 1b smaller here than a return statement (sorry)
+				break o;
+			} catch (e) {}
+		}
+
+		// ARIA-attributes have a different notion of boolean values.
+		// The value `false` is different from the attribute not
+		// existing on the DOM, so we can't remove it. For non-boolean
+		// ARIA-attributes we could treat false as a removal, but the
+		// amount of exceptions would cost us too many bytes. On top of
+		// that other VDOM frameworks also always stringify `false`.
+
+		if (typeof value === 'function') {
+			// never serialize functions as attribute values
+		} else if (
+			value != null &&
+			(value !== false || (name[0] === 'a' && name[1] === 'r'))
+		) {
+			dom.setAttribute(name, value);
+		} else {
+			dom.removeAttribute(name);
+		}
+	}
+}
+
+/**
+ * Proxy an event to hooked event handlers
+ * @param {Event} e The event object from the browser
+ * @private
+ */
+function eventProxy(e) {
+	this._listeners[e.type + false](options.event ? options.event(e) : e);
+}
+
+function eventProxyCapture(e) {
+	this._listeners[e.type + true](options.event ? options.event(e) : e);
+}

data/node_modules/preact/src/index.d.ts

@@ -0,0 +1,310 @@
+export as namespace preact;
+
+import { JSXInternal } from './jsx';
+
+export import JSX = JSXInternal;
+
+//
+// Preact Virtual DOM
+// -----------------------------------
+
+export interface VNode<P = {}> {
+	type: ComponentType<P> | string;
+	props: P & { children: ComponentChildren };
+	key: Key;
+	/**
+	 * ref is not guaranteed by React.ReactElement, for compatibility 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
+// -----------------------------------
+
+export type Key = string | number | any;
+
+export type RefObject<T> = { current: T | null };
+export type RefCallback<T> = (instance: T | null) => void;
+export type Ref<T> = RefObject<T> | RefCallback<T>;
+
+export type ComponentChild =
+	| VNode<any>
+	| object
+	| string
+	| number
+	| bigint
+	| boolean
+	| null
+	| undefined;
+export type ComponentChildren = ComponentChild[] | ComponentChild;
+
+export interface Attributes {
+	key?: Key;
+	jsx?: boolean;
+}
+
+export interface ClassAttributes<T> extends Attributes {
+	ref?: Ref<T>;
+}
+
+export interface PreactDOMAttributes {
+	children?: ComponentChildren;
+	dangerouslySetInnerHTML?: {
+		__html: string;
+	};
+}
+
+export type RenderableProps<P, RefType = any> = P &
+	Readonly<Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }>;
+
+export type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
+export type ComponentFactory<P = {}> = ComponentType<P>;
+
+export type ComponentProps<
+	C extends ComponentType<any> | keyof JSXInternal.IntrinsicElements
+> = C extends ComponentType<infer P>
+	? P
+	: C extends keyof JSXInternal.IntrinsicElements
+	? JSXInternal.IntrinsicElements[C]
+	: never;
+
+export interface FunctionComponent<P = {}> {
+	(props: RenderableProps<P>, context?: any): VNode<any> | null;
+	displayName?: string;
+	defaultProps?: Partial<P>;
+}
+export interface FunctionalComponent<P = {}> extends FunctionComponent<P> {}
+
+export interface ComponentClass<P = {}, S = {}> {
+	new (props: P, context?: any): Component<P, S>;
+	displayName?: string;
+	defaultProps?: Partial<P>;
+	contextType?: Context<any>;
+	getDerivedStateFromProps?(
+		props: Readonly<P>,
+		state: Readonly<S>
+	): Partial<S> | null;
+	getDerivedStateFromError?(error: any): Partial<S> | null;
+}
+export interface ComponentConstructor<P = {}, S = {}>
+	extends ComponentClass<P, S> {}
+
+// Type alias for a component instance considered generally, whether stateless or stateful.
+export type AnyComponent<P = {}, S = {}> =
+	| FunctionComponent<P>
+	| Component<P, S>;
+
+export interface Component<P = {}, S = {}> {
+	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;
+}
+
+export 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
+// -----------------------------------
+
+export function createElement(
+	type: string,
+	props:
+		| (JSXInternal.HTMLAttributes &
+				JSXInternal.SVGAttributes &
+				Record<string, any>)
+		| null,
+	...children: ComponentChildren[]
+): VNode<any>;
+export function createElement<P>(
+	type: ComponentType<P>,
+	props: (Attributes & P) | null,
+	...children: ComponentChildren[]
+): VNode<any>;
+export namespace createElement {
+	export import JSX = JSXInternal;
+}
+
+export function h(
+	type: string,
+	props:
+		| (JSXInternal.HTMLAttributes &
+				JSXInternal.SVGAttributes &
+				Record<string, any>)
+		| null,
+	...children: ComponentChildren[]
+): VNode<any>;
+export function h<P>(
+	type: ComponentType<P>,
+	props: (Attributes & P) | null,
+	...children: ComponentChildren[]
+): VNode<any>;
+export namespace h {
+	export import JSX = JSXInternal;
+}
+
+//
+// Preact render
+// -----------------------------------
+
+export function render(
+	vnode: ComponentChild,
+	parent: Element | Document | ShadowRoot | DocumentFragment,
+	replaceNode?: Element | Text
+): void;
+export function hydrate(
+	vnode: ComponentChild,
+	parent: Element | Document | ShadowRoot | DocumentFragment
+): void;
+export function cloneElement(
+	vnode: VNode<any>,
+	props?: any,
+	...children: ComponentChildren[]
+): VNode<any>;
+export 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...
+export const Fragment: ComponentClass<{}, {}>;
+
+//
+// Preact options
+// -----------------------------------
+
+/**
+ * Global options for preact
+ */
+export 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;
+	_addHookName?(name: string | number): void;
+	__suspenseDidResolve?(vnode: VNode, cb: () => void): void;
+	// __canSuspenseResolve?(vnode: VNode, cb: () => void): void;
+}
+
+export const options: Options;
+
+//
+// Preact helpers
+// -----------------------------------
+export function createRef<T = any>(): RefObject<T>;
+export function toChildArray(
+	children: ComponentChildren
+): Array<VNode | string | number>;
+export function isValidElement(vnode: any): vnode is VNode;
+
+//
+// Context
+// -----------------------------------
+export interface Consumer<T>
+	extends FunctionComponent<{
+		children: (value: T) => ComponentChildren;
+	}> {}
+export interface PreactConsumer<T> extends Consumer<T> {}
+
+export interface Provider<T>
+	extends FunctionComponent<{
+		value: T;
+		children: ComponentChildren;
+	}> {}
+export interface PreactProvider<T> extends Provider<T> {}
+
+export interface Context<T> {
+	Consumer: Consumer<T>;
+	Provider: Provider<T>;
+	displayName?: string;
+}
+export interface PreactContext<T> extends Context<T> {}
+
+export function createContext<T>(defaultValue: T): Context<T>;