create-jen-app 1.2.2 → 1.2.3

package/templates/static/node_modules/preact/src/index.d.ts

@@ -1,402 +0,0 @@
-export as namespace preact;
-
-import { JSXInternal } from './jsx';
-import { DOMAttributes, HTMLAttributes, SVGAttributes } from './dom';
-
-export import JSX = JSXInternal;
-export * from './dom';
-
-//
-// 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 | (() => void);
-export type Ref<T> = RefObject<T> | RefCallback<T> | null;
-
-export type ComponentChild =
-	| VNode<any>
-	| object
-	| string
-	| number
-	| bigint
-	| boolean
-	| null
-	| undefined;
-export type ComponentChildren = ComponentChild[] | ComponentChild;
-
-export interface Attributes {
-	key?: Key | undefined;
-	jsx?: boolean | undefined;
-}
-
-export interface ClassAttributes<T> extends Attributes {
-	ref?: Ref<T>;
-}
-
-export interface PreactDOMAttributes {
-	children?: ComponentChildren;
-	dangerouslySetInnerHTML?: {
-		__html: Parameters<DOMParser['parseFromString']>[0];
-	};
-}
-
-export interface ErrorInfo {
-	componentStack?: 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]
-		: {};
-
-export interface FunctionComponent<P = {}> {
-	(props: RenderableProps<P>, context?: any): ComponentChildren;
-	displayName?: string;
-	defaultProps?: Partial<P> | undefined;
-}
-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>
-	| ComponentConstructor<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: ErrorInfo): 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
-	): ComponentChildren;
-}
-
-//
-// Preact createElement
-// -----------------------------------
-
-export function createElement(
-	type: 'input',
-	props:
-		| (DOMAttributes<HTMLInputElement> &
-				ClassAttributes<HTMLInputElement>)
-		| null,
-	...children: ComponentChildren[]
-): VNode<
-	DOMAttributes<HTMLInputElement> &
-		ClassAttributes<HTMLInputElement>
->;
-export function createElement<
-	P extends HTMLAttributes<T>,
-	T extends HTMLElement
->(
-	type: keyof JSXInternal.IntrinsicElements,
-	props: (ClassAttributes<T> & P) | null,
-	...children: ComponentChildren[]
-): VNode<ClassAttributes<T> & P>;
-export function createElement<
-	P extends SVGAttributes<T>,
-	T extends HTMLElement
->(
-	type: keyof JSXInternal.IntrinsicSVGElements,
-	props: (ClassAttributes<T> & P) | null,
-	...children: ComponentChildren[]
-): VNode<ClassAttributes<T> & P>;
-export function createElement<T extends HTMLElement>(
-	type: string,
-	props:
-		| (ClassAttributes<T> &
-				HTMLAttributes &
-				SVGAttributes)
-		| null,
-	...children: ComponentChildren[]
-): VNode<
-	ClassAttributes<T> & HTMLAttributes & SVGAttributes
->;
-export function createElement<P>(
-	type: ComponentType<P> | string,
-	props: (Attributes & P) | null,
-	...children: ComponentChildren[]
-): VNode<P>;
-export namespace createElement {
-	export import JSX = JSXInternal;
-}
-
-export function h(
-	type: 'input',
-	props:
-		| (DOMAttributes<HTMLInputElement> &
-				ClassAttributes<HTMLInputElement>)
-		| null,
-	...children: ComponentChildren[]
-): VNode<
-	DOMAttributes<HTMLInputElement> &
-		ClassAttributes<HTMLInputElement>
->;
-export function h<
-	P extends HTMLAttributes<T>,
-	T extends HTMLElement
->(
-	type: keyof JSXInternal.IntrinsicElements,
-	props: (ClassAttributes<T> & P) | null,
-	...children: ComponentChildren[]
-): VNode<ClassAttributes<T> & P>;
-export function h<
-	P extends SVGAttributes<T>,
-	T extends HTMLElement
->(
-	type: keyof JSXInternal.IntrinsicSVGElements,
-	props: (ClassAttributes<T> & P) | null,
-	...children: ComponentChildren[]
-): VNode<ClassAttributes<T> & P>;
-export function h<T extends HTMLElement>(
-	type: string,
-	props:
-		| (ClassAttributes<T> &
-				HTMLAttributes &
-				SVGAttributes)
-		| null,
-	...children: ComponentChildren[]
-): VNode<
-	| (ClassAttributes<T> &
-			HTMLAttributes &
-			SVGAttributes)
-	| null
->;
-export function h<P>(
-	type: ComponentType<P> | string,
-	props: (Attributes & P) | null,
-	...children: ComponentChildren[]
-): VNode<Attributes & P>;
-export namespace h {
-	export import JSX = JSXInternal;
-}
-
-//
-// Preact render
-// -----------------------------------
-export interface ContainerNode {
-	readonly nodeType: number;
-	readonly parentNode: ContainerNode | null;
-	readonly firstChild: ContainerNode | null;
-	readonly childNodes: ArrayLike<ContainerNode>;
-
-	contains(other: ContainerNode | null): boolean;
-	insertBefore(node: ContainerNode, child: ContainerNode | null): ContainerNode;
-	appendChild(node: ContainerNode): ContainerNode;
-	removeChild(child: ContainerNode): ContainerNode;
-}
-
-export function render(vnode: ComponentChild, parent: ContainerNode): void;
-/**
- * @deprecated The `replaceNode` parameter will be removed in v11.
- *
- * Replacement Preact 10+ implementation can be found in the `preact-root-fragment` package.
- * Docs: https://github.com/preactjs/preact-root-fragment
- */
-export function render(
-	vnode: ComponentChild,
-	parent: ContainerNode,
-	replaceNode?: Element | Text
-): void;
-export function hydrate(vnode: ComponentChild, parent: ContainerNode): 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: FunctionComponent<{}>;
-
-//
-// 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?(callback: () => void): void;
-	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;
-
-	/**
-	 * Customize attribute serialization when a precompiled JSX transform
-	 * is used.
-	 */
-	attr?(name: string, value: any): string | 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 type ContextType<C extends Context<any>> = C extends Context<infer T>
-	? T
-	: never;
-
-export interface Context<T> extends preact.Provider<T> {
-	Consumer: preact.Consumer<T>;
-	Provider: preact.Provider<T>;
-	displayName?: string;
-}
-
-export interface PreactContext<T> extends Context<T> {}
-
-export function createContext<T>(defaultValue: T): Context<T>;

package/templates/static/node_modules/preact/src/index.js

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

package/templates/static/node_modules/preact/src/internal.d.ts

@@ -1,190 +0,0 @@
-// Intentionally not using a relative path to take advantage of
-// the TS version resolution mechanism
-import * as preact from 'preact';
-
-export enum HookType {
-	useState = 1,
-	useReducer = 2,
-	useEffect = 3,
-	useLayoutEffect = 4,
-	useRef = 5,
-	useImperativeHandle = 6,
-	useMemo = 7,
-	useCallback = 8,
-	useContext = 9,
-	useErrorBoundary = 10,
-	// Not a real hook, but the devtools treat is as such
-	useDebugvalue = 11
-}
-
-export interface DevSource {
-	fileName: string;
-	lineNumber: number;
-}
-
-export interface ErrorInfo {
-	componentStack?: string;
-}
-
-export interface Options extends preact.Options {
-	/** Attach a hook that is invoked before render, mainly to check the arguments. */
-	_root?(vnode: ComponentChild, parent: preact.ContainerNode): 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, index: number, type: HookType): void;
-	/** Bypass effect execution. Currenty only used in devtools for hooks inspection */
-	_skipEffects?: boolean;
-	/** 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,
-		errorInfo?: ErrorInfo | undefined
-	): void;
-	/** Attach a hook that fires when hydration can't find a proper DOM-node to match with */
-	_hydrationMismatch?(
-		vnode: VNode,
-		excessDomChildren: Array<PreactElement | null>
-	): void;
-}
-
-export type ComponentChild =
-	| VNode<any>
-	| string
-	| number
-	| boolean
-	| null
-	| undefined;
-export type ComponentChildren = ComponentChild[] | ComponentChild;
-
-export interface FunctionComponent<P = {}>
-	extends preact.FunctionComponent<P> {
-	// Internally, createContext uses `contextType` on a Function component to
-	// implement the Consumer component
-	contextType?: PreactContext;
-
-	// Internally, createContext stores a ref to the context object on the Provider
-	// Function component to help devtools
-	_contextRef?: PreactContext;
-
-	// Define these properties as undefined on FunctionComponent to get rid of
-	// some errors in `diff()`
-	getDerivedStateFromProps?: undefined;
-	getDerivedStateFromError?: undefined;
-}
-
-export interface ComponentClass<P = {}> extends preact.ComponentClass<P> {
-	_contextRef?: any;
-
-	// Override public contextType with internal PreactContext type
-	contextType?: PreactContext;
-}
-
-// Redefine ComponentType using our new internal FunctionComponent interface above
-export type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
-
-export interface PreactElement extends preact.ContainerNode {
-	// Namespace detection
-	readonly namespaceURI?: string;
-	// Property used to update Text nodes
-	data?: CharacterData['data'];
-	// Property to set __dangerouslySetInnerHTML
-	innerHTML?: Element['innerHTML'];
-
-	// Attribute reading and setting
-	readonly attributes?: Element['attributes'];
-	setAttribute?: Element['setAttribute'];
-	removeAttribute?: Element['removeAttribute'];
-
-	// Event listeners
-	addEventListener?: Element['addEventListener'];
-	removeEventListener?: Element['removeEventListener'];
-
-	// Setting styles
-	readonly style?: CSSStyleDeclaration;
-
-	// nextSibling required for inserting nodes
-	readonly nextSibling: PreactElement | null;
-
-	// Used to match DOM nodes to VNodes during hydration. Note: doesn't exist
-	// on Text nodes
-	readonly localName?: string;
-
-	// Input handling
-	value?: HTMLInputElement['value'];
-	checked?: HTMLInputElement['checked'];
-
-	// Internal properties
-	_children?: VNode<any> | null;
-	/** Event listeners to support event delegation */
-	_listeners?: Record<string, (e: Event) => void>;
-}
-
-export interface PreactEvent extends Event {
-	_dispatched?: number;
-}
-
-// We use the `current` property to differentiate between the two kinds of Refs so
-// internally we'll define `current` on both to make TypeScript happy
-type RefObject<T> = { current: T | null };
-type RefCallback<T> = {
-	(instance: T | null): void | (() => void);
-	current: undefined;
-};
-export type Ref<T> = RefObject<T> | RefCallback<T>;
-
-export interface VNode<P = {}> extends preact.VNode<P> {
-	// Redefine type here using our internal ComponentType type, and specify
-	// string has an undefined `defaultProps` property to make TS happy
-	type: (string & { defaultProps: undefined }) | ComponentType<P>;
-	props: P & { children: ComponentChildren };
-	ref?: Ref<any> | null;
-	_children: Array<VNode<any>> | null;
-	_parent: VNode | null;
-	_depth: number | null;
-	/**
-	 * The [first (for Fragments)] DOM child of a VNode
-	 */
-	_dom: PreactElement | null;
-	_component: Component | null;
-	constructor: undefined;
-	_original: number;
-	_index: number;
-	_flags: number;
-}
-
-export interface Component<P = {}, S = {}> extends Omit<preact.Component<P, S>, 'base'> {
-	// When component is functional component, this is reset to functional component
-	constructor: 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
-	_stateCallbacks: 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;
-}