@pixui-dev/pxw 0.1.16

package/lib/types/dom.ts

@@ -0,0 +1,17 @@
+import { createElement, render, Component } from 'preact';
+
+let dumpDOM = (type, props, ...children) => {
+	console.log('==>dom', 'type', type, 'props', props, 'chlidren', children);
+	return {
+		type,
+		props,
+		children,
+	};
+};
+
+console.log('preact check', createElement, render, Component);
+
+export { render, createElement } from 'preact';
+
+//注：这个是给tsx文件import h from 'preact'用的，其实有了上面的插件这句话在js层面可以省略，但少了它之后在ts层面就无法判断jsx元素的类型信息，导致editor里对attr和style的语法提示失效
+export default createElement;

package/lib/types/ext.d.ts

@@ -0,0 +1,81 @@
+interface NodeModule {
+	hot: any;
+}
+
+declare module '*.less' {
+	const resource: { [key: string]: string };
+	export = resource;
+}
+
+declare module '*.png' {
+	const value: any;
+	export default value;
+}
+declare module '*.gif' {
+	const value: any;
+	export default value;
+}
+declare module '*.jpg' {
+	const value: any;
+	export default value;
+}
+
+declare module '*.mp4' {
+	const value: any;
+	export default value;
+}
+
+declare module '*.lottie' {
+	const value: any;
+	export default value;
+}
+
+interface Console {
+	enable_trace: (boolean) => {};
+}
+
+declare class Http2Connection {
+	constructor(url: string, metadata?: string[string], debug?: bool);
+
+	send(msg: Uint8Array): number;
+
+	close(msg: Record<string, any>): number;
+
+	setHeadersCallBack(func: Function): number;
+
+	setDataCallBack(func: Function): number;
+
+	setEndCallBack(func: Function): number;
+}
+
+interface Window {
+	Http2Connection: any;
+	noProto: any;
+}
+
+interface External {
+	sendMessage: (msg: any) => void;
+
+	onmessage: any;
+
+	profileJS: (b: bool) => void;
+	preloadImage: (url: string[], cb: () => void) => void;
+}
+
+declare function LuaProxy(): lua;
+declare class WxCard {
+	Ping(msg: string) {}
+}
+declare class PandoraCommon {
+	static callLua(msg: string): any;
+}
+declare class PandoraSDKAdapter {
+	static external: any;
+	static getInstance();
+	static callLua(name: string, f1: Function, f2: Function, msg: string): any;
+}
+declare class Lua {
+	constructor();
+	callLua(name: string, f1: Function, f2: Function, msg: string): any;
+	PixWxCardRequest: WxCard;
+}

package/lib/types/internal.d.ts

@@ -0,0 +1,94 @@
+import * as preact from '../preact';
+
+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;
+}

package/lib/types/jsx.d.ts

@@ -0,0 +1,309 @@
+import * as CSS from './css';
+type Defaultize<Props, Defaults> =
+	// Distribute over unions
+	Props extends any // Make any properties included in Default optional
+		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
+		// Include the remaining properties from Props
+		Pick<Props, Exclude<keyof Props, keyof Defaults>>
+		: never;
+
+export interface CSSProperties extends CSS.Properties<string | number> {
+	//增加这条是为了方便注释一个属性:前面加x就好
+	// [P: string]: any;
+}
+
+export namespace JSXInternal {
+	type LibraryManagedAttributes<Component, Props> = Component extends { defaultProps: infer Defaults }
+		? Defaultize<Props, Defaults> //
+		: Props;
+
+	interface IntrinsicAttributes {
+		key?: any;
+	}
+
+	interface Element extends preact.VNode<any> {}
+
+	interface ElementClass extends preact.Component<any, any> {}
+
+	interface ElementAttributesProperty {
+		props: any;
+	}
+
+	interface ElementChildrenAttribute {
+		children: any;
+	}
+
+	type TargetedEvent<Target extends EventTarget = EventTarget, TypedEvent extends Event = Event> = Omit<TypedEvent, 'currentTarget'> & {
+		readonly currentTarget: Target;
+	};
+
+	type TargetedAnimationEvent<Target extends EventTarget> = TargetedEvent<Target, AnimationEvent>;
+	type TargetedClipboardEvent<Target extends EventTarget> = TargetedEvent<Target, ClipboardEvent>;
+	type TargetedCompositionEvent<Target extends EventTarget> = TargetedEvent<Target, CompositionEvent>;
+	type TargetedDragEvent<Target extends EventTarget> = TargetedEvent<Target, DragEvent>;
+	type TargetedFocusEvent<Target extends EventTarget> = TargetedEvent<Target, FocusEvent>;
+	type TargetedKeyboardEvent<Target extends EventTarget> = TargetedEvent<Target, KeyboardEvent>;
+	type TargetedMouseEvent<Target extends EventTarget> = TargetedEvent<Target, Event>;
+	type TargetedPointerEvent<Target extends EventTarget> = TargetedEvent<Target, PointerEvent>;
+	type TargetedTouchEvent<Target extends EventTarget> = TargetedEvent<Target, TouchEvent>;
+	type TargetedTransitionEvent<Target extends EventTarget> = TargetedEvent<Target, TransitionEvent>;
+	type TargetedUIEvent<Target extends EventTarget> = TargetedEvent<Target, UIEvent>;
+	type TargetedWheelEvent<Target extends EventTarget> = TargetedEvent<Target, WheelEvent>;
+
+	interface EventHandler<E extends TargetedEvent> {
+		/**
+		 * The `this` keyword always points to the DOM element the event handler
+		 * was invoked on. See: https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Event_handlers#Event_handlers_parameters_this_binding_and_the_return_value
+		 */
+		(this: E['currentTarget'], event: E): void;
+	}
+
+	type AnimationEventHandler<Target extends EventTarget> = EventHandler<TargetedAnimationEvent<Target>>;
+	type ClipboardEventHandler<Target extends EventTarget> = EventHandler<TargetedClipboardEvent<Target>>;
+	type CompositionEventHandler<Target extends EventTarget> = EventHandler<TargetedCompositionEvent<Target>>;
+	type DragEventHandler<Target extends EventTarget> = EventHandler<TargetedDragEvent<Target>>;
+	type FocusEventHandler<Target extends EventTarget> = EventHandler<TargetedFocusEvent<Target>>;
+	type GenericEventHandler<Target extends EventTarget> = EventHandler<TargetedEvent<Target>>;
+	type KeyboardEventHandler<Target extends EventTarget> = EventHandler<TargetedKeyboardEvent<Target>>;
+	type MouseEventHandler<Target extends EventTarget> = EventHandler<TargetedMouseEvent<Target>>;
+	type PointerEventHandler<Target extends EventTarget> = EventHandler<TargetedPointerEvent<Target>>;
+	type TouchEventHandler<Target extends EventTarget> = EventHandler<TargetedTouchEvent<Target>>;
+	type TransitionEventHandler<Target extends EventTarget> = EventHandler<TargetedTransitionEvent<Target>>;
+	type UIEventHandler<Target extends EventTarget> = EventHandler<TargetedUIEvent<Target>>;
+	type WheelEventHandler<Target extends EventTarget> = EventHandler<TargetedWheelEvent<Target>>;
+	type CompleteEventHandler<Target extends EventTarget> = EventHandler<TargetedEvent<Target>>;
+
+	interface DOMAttributes<Target extends EventTarget> extends preact.PreactDOMAttributes {
+		// Image Events
+		onLoad?: GenericEventHandler<Target>;
+		onError?: GenericEventHandler<Target>;
+
+		// Focus Events
+		onFocus?: FocusEventHandler<Target>;
+		onFocusOut?: FocusEventHandler<Target>;
+		onFocusCapture?: FocusEventHandler<Target>;
+		onBlur?: FocusEventHandler<Target>;
+		onBlurCapture?: FocusEventHandler<Target>;
+
+		onChange?: GenericEventHandler<Target>;
+		onInput?: GenericEventHandler<Target>;
+
+		// Keyboard Events
+		onKeyDown?: KeyboardEventHandler<Target>;
+		onKeyDownCapture?: KeyboardEventHandler<Target>;
+		onKeyPress?: KeyboardEventHandler<Target>;
+		onKeyPressCapture?: KeyboardEventHandler<Target>;
+		onKeyUp?: KeyboardEventHandler<Target>;
+		onKeyUpCapture?: KeyboardEventHandler<Target>;
+
+		// Media Events
+		onAbort?: GenericEventHandler<Target>;
+		onAbortCapture?: GenericEventHandler<Target>;
+		onCanPlay?: GenericEventHandler<Target>;
+		onCanPlayCapture?: GenericEventHandler<Target>;
+		onCanPlayThrough?: GenericEventHandler<Target>;
+		onCanPlayThroughCapture?: GenericEventHandler<Target>;
+		onDurationChange?: GenericEventHandler<Target>;
+		onDurationChangeCapture?: GenericEventHandler<Target>;
+		onEmptied?: GenericEventHandler<Target>;
+		onEmptiedCapture?: GenericEventHandler<Target>;
+		onEncrypted?: GenericEventHandler<Target>;
+		onEncryptedCapture?: GenericEventHandler<Target>;
+		onEnded?: GenericEventHandler<Target>;
+		onEndedCapture?: GenericEventHandler<Target>;
+		onLoadedData?: GenericEventHandler<Target>;
+		onLoadedDataCapture?: GenericEventHandler<Target>;
+		onLoadedMetadata?: GenericEventHandler<Target>;
+		onLoadedMetadataCapture?: GenericEventHandler<Target>;
+		onLoadStart?: GenericEventHandler<Target>;
+		onLoadStartCapture?: GenericEventHandler<Target>;
+		onPause?: GenericEventHandler<Target>;
+		onPauseCapture?: GenericEventHandler<Target>;
+		onPlay?: GenericEventHandler<Target>;
+		onPlayCapture?: GenericEventHandler<Target>;
+		onPlaying?: GenericEventHandler<Target>;
+		onPlayingCapture?: GenericEventHandler<Target>;
+		onProgress?: GenericEventHandler<Target>;
+		onProgressCapture?: GenericEventHandler<Target>;
+		onRateChange?: GenericEventHandler<Target>;
+		onRateChangeCapture?: GenericEventHandler<Target>;
+		onSeeked?: GenericEventHandler<Target>;
+		onSeekedCapture?: GenericEventHandler<Target>;
+		onSeeking?: GenericEventHandler<Target>;
+		onSeekingCapture?: GenericEventHandler<Target>;
+		onStalled?: GenericEventHandler<Target>;
+		onStalledCapture?: GenericEventHandler<Target>;
+		onSuspend?: GenericEventHandler<Target>;
+		onSuspendCapture?: GenericEventHandler<Target>;
+		onTimeUpdate?: GenericEventHandler<Target>;
+		onTimeUpdateCapture?: GenericEventHandler<Target>;
+		onVolumeChange?: GenericEventHandler<Target>;
+		onVolumeChangeCapture?: GenericEventHandler<Target>;
+		onWaiting?: GenericEventHandler<Target>;
+		onWaitingCapture?: GenericEventHandler<Target>;
+
+		// MouseEvents
+		onClick?: MouseEventHandler<Target>;
+		onClickCapture?: MouseEventHandler<Target>;
+		onContextMenu?: MouseEventHandler<Target>;
+		onContextMenuCapture?: MouseEventHandler<Target>;
+		onDblClick?: MouseEventHandler<Target>;
+		onDblClickCapture?: MouseEventHandler<Target>;
+		onDrag?: DragEventHandler<Target>;
+		onDragCapture?: DragEventHandler<Target>;
+		onDragEnd?: DragEventHandler<Target>;
+		onDragEndCapture?: DragEventHandler<Target>;
+		onDragEnter?: DragEventHandler<Target>;
+		onDragEnterCapture?: DragEventHandler<Target>;
+		onDragExit?: DragEventHandler<Target>;
+		onDragExitCapture?: DragEventHandler<Target>;
+		onDragLeave?: DragEventHandler<Target>;
+		onDragLeaveCapture?: DragEventHandler<Target>;
+		onDragOver?: DragEventHandler<Target>;
+		onDragOverCapture?: DragEventHandler<Target>;
+		onDragStart?: DragEventHandler<Target>;
+		onDragStartCapture?: DragEventHandler<Target>;
+		onDrop?: DragEventHandler<Target>;
+		onDropCapture?: DragEventHandler<Target>;
+		onMouseDown?: MouseEventHandler<Target>;
+		onMouseDownCapture?: MouseEventHandler<Target>;
+		onMouseEnter?: MouseEventHandler<Target>;
+		onMouseEnterCapture?: MouseEventHandler<Target>;
+		onMouseLeave?: MouseEventHandler<Target>;
+		onMouseLeaveCapture?: MouseEventHandler<Target>;
+		onMouseMove?: MouseEventHandler<Target>;
+		onMouseMoveCapture?: MouseEventHandler<Target>;
+		onMouseOut?: MouseEventHandler<Target>;
+		onMouseOutCapture?: MouseEventHandler<Target>;
+		onMouseOver?: MouseEventHandler<Target>;
+		onMouseOverCapture?: MouseEventHandler<Target>;
+		onMouseUp?: MouseEventHandler<Target>;
+		onMouseUpCapture?: MouseEventHandler<Target>;
+
+		// Selection Events
+		onSelect?: GenericEventHandler<Target>;
+		onSelectCapture?: GenericEventHandler<Target>;
+
+		// Touch Events
+		onTouchCancel?: TouchEventHandler<Target>;
+		onTouchCancelCapture?: TouchEventHandler<Target>;
+		onTouchEnd?: TouchEventHandler<Target>;
+		onTouchEndCapture?: TouchEventHandler<Target>;
+		onTouchMove?: TouchEventHandler<Target>;
+		onTouchMoveCapture?: TouchEventHandler<Target>;
+		onTouchStart?: TouchEventHandler<Target>;
+		onTouchStartCapture?: TouchEventHandler<Target>;
+
+		// Pointer Events
+		onPointerOver?: PointerEventHandler<Target>;
+		onPointerOverCapture?: PointerEventHandler<Target>;
+		onPointerEnter?: PointerEventHandler<Target>;
+		onPointerEnterCapture?: PointerEventHandler<Target>;
+		onPointerDown?: PointerEventHandler<Target>;
+		onPointerDownCapture?: PointerEventHandler<Target>;
+		onPointerMove?: PointerEventHandler<Target>;
+		onPointerMoveCapture?: PointerEventHandler<Target>;
+		onPointerUp?: PointerEventHandler<Target>;
+		onPointerUpCapture?: PointerEventHandler<Target>;
+		onPointerCancel?: PointerEventHandler<Target>;
+		onPointerCancelCapture?: PointerEventHandler<Target>;
+		onPointerOut?: PointerEventHandler<Target>;
+		onPointerOutCapture?: PointerEventHandler<Target>;
+		onPointerLeave?: PointerEventHandler<Target>;
+		onPointerLeaveCapture?: PointerEventHandler<Target>;
+		onGotPointerCapture?: PointerEventHandler<Target>;
+		onGotPointerCaptureCapture?: PointerEventHandler<Target>;
+		onLostPointerCapture?: PointerEventHandler<Target>;
+		onLostPointerCaptureCapture?: PointerEventHandler<Target>;
+
+		// UI Events
+		onScroll?: UIEventHandler<Target>;
+		onScrollCapture?: UIEventHandler<Target>;
+
+		// Wheel Events
+		onWheel?: WheelEventHandler<Target>;
+		onWheelCapture?: WheelEventHandler<Target>;
+
+		// Animation Events
+		onAnimationStart?: AnimationEventHandler<Target>;
+		onAnimationStartCapture?: AnimationEventHandler<Target>;
+		onAnimationEnd?: AnimationEventHandler<Target>;
+		onAnimationEndCapture?: AnimationEventHandler<Target>;
+		onAnimationIteration?: AnimationEventHandler<Target>;
+		onAnimationIterationCapture?: AnimationEventHandler<Target>;
+
+		// Transition Events
+		onTransitionEnd?: TransitionEventHandler<Target>;
+		onTransitionEndCapture?: TransitionEventHandler<Target>;
+
+		onComplete?: CompleteEventHandler<Target>;
+	}
+
+	interface HTMLAttributes<RefType extends EventTarget = EventTarget> extends preact.ClassAttributes<RefType>, DOMAttributes<RefType> {
+		// Standard HTML Attributes
+		async?: boolean;
+		autoFocus?: boolean;
+		autoPlay?: boolean;
+		checked?: boolean;
+		class?: string;
+		className?: string;
+		content?: string;
+		contentEditable?: boolean;
+		data?: string;
+		default?: boolean;
+		defer?: boolean;
+		dir?: 'auto' | 'rtl' | 'ltr';
+		disabled?: boolean;
+		draggable?: boolean;
+		height?: number | string;
+		hidden?: boolean;
+		href?: string;
+		id?: string;
+		label?: string;
+		lang?: string;
+		loop?: boolean;
+		muted?: boolean;
+		name?: string;
+		open?: boolean;
+		placeholder?: string;
+		poster?: string;
+		preload?: string;
+		readOnly?: boolean;
+		required?: boolean;
+		selected?: boolean;
+		src?: string;
+		style?: CSSProperties;
+		target?: string;
+		title?: string;
+		type?: string;
+		value?: string | string[] | number;
+		volume?: string | number;
+		width?: number | string;
+	}
+
+	interface IntrinsicElements {
+		// HTML
+		a: HTMLAttributes<HTMLAnchorElement>;
+		audio: HTMLAttributes<HTMLAudioElement>;
+		body: HTMLAttributes<HTMLBodyElement>;
+		br: HTMLAttributes<HTMLBRElement>;
+		canvas: HTMLAttributes<HTMLCanvasElement>;
+		dialog: HTMLAttributes<HTMLDialogElement>;
+		div: HTMLAttributes<HTMLDivElement>;
+		text: HTMLAttributes<HTMLTextFieldElement>;
+		header: HTMLAttributes<HTMLElement>;
+		html: HTMLAttributes<HTMLHtmlElement>;
+		img: HTMLAttributes<HTMLImageElement>;
+		lottie: HTMLAttributes<HTMLLottieElement>;
+		input: HTMLAttributes<HTMLInputElement>;
+		link: HTMLAttributes<HTMLLinkElement>;
+		meta: HTMLAttributes<HTMLMetaElement>;
+		pre: HTMLAttributes<HTMLPreElement>;
+		script: HTMLAttributes<HTMLScriptElement>;
+		slot: HTMLAttributes<HTMLSlotElement>;
+		style: HTMLAttributes<HTMLStyleElement>;
+		textarea: HTMLAttributes<HTMLTextAreaElement>;
+		title: HTMLAttributes<HTMLTitleElement>;
+		video: HTMLAttributes<HTMLVideoElement>;
+	}
+}