onejs-core 0.3.5

package/3rdparty/preact/hooks/internal.d.ts

@@ -0,0 +1,85 @@
+import {
+	Component as PreactComponent,
+	PreactContext,
+	ErrorInfo,
+	VNode as PreactVNode
+} from '../internal';
+import { Reducer } from 'preact/hooks';
+
+export { PreactContext };
+
+/**
+ * The type of arguments passed to a Hook function. While this type is not
+ * strictly necessary, they are given a type name to make it easier to read
+ * the following types and trace the flow of data.
+ */
+export type HookArgs = any;
+
+/**
+ * The return type of a Hook function. While this type is not
+ * strictly necessary, they are given a type name to make it easier to read
+ * the following types and trace the flow of data.
+ */
+export type HookReturnValue = any;
+
+/** The public function a user invokes to use a Hook */
+export type Hook = (...args: HookArgs[]) => HookReturnValue;
+
+// Hook tracking
+
+export interface ComponentHooks {
+	/** The list of hooks a component uses */
+	_list: HookState[];
+	/** List of Effects to be invoked after the next frame is rendered */
+	_pendingEffects: EffectHookState[];
+}
+
+export interface Component extends PreactComponent<any, any> {
+	__hooks?: ComponentHooks;
+}
+
+export interface VNode extends PreactVNode {
+	_mask?: string;
+}
+
+export type HookState =
+	| EffectHookState
+	| MemoHookState
+	| ReducerHookState
+	| ContextHookState
+	| ErrorBoundaryHookState;
+
+export type Effect = () => void | Cleanup;
+export type Cleanup = () => void;
+
+export interface EffectHookState {
+	_value?: Effect;
+	_args?: any[];
+	_pendingArgs?: any[];
+	_cleanup?: Cleanup | void;
+}
+
+export interface MemoHookState {
+	_value?: any;
+	_pendingValue?: any;
+	_args?: any[];
+	_pendingArgs?: any[];
+	_factory?: () => any;
+}
+
+export interface ReducerHookState {
+	_nextValue?: any;
+	_value?: any;
+	_component?: Component;
+	_reducer?: Reducer<any, any>;
+}
+
+export interface ContextHookState {
+	/** Whether this hooks as subscribed to updates yet */
+	_value?: boolean;
+	_context?: PreactContext;
+}
+
+export interface ErrorBoundaryHookState {
+	_value?: (error: any, errorInfo: ErrorInfo) => void;
+}

package/3rdparty/preact/hooks.d.ts

@@ -0,0 +1,145 @@
+
+declare module "preact/hooks" {
+
+	import { PreactContext, Ref as PreactRef } from 'preact'
+
+	type Inputs = ReadonlyArray<unknown>;
+
+	export type StateUpdater<S> = (value: S | ((prevState: S) => S)) => void;
+	/**
+	 * Returns a stateful value, and a function to update it.
+	 * @param initialState The initial value (or a function that returns the initial value)
+	 */
+	export function useState<S>(initialState: S | (() => S)): [S, StateUpdater<S>];
+
+	export function useState<S = undefined>(): [
+		S | undefined,
+		StateUpdater<S | undefined>
+	];
+
+	export type Reducer<S, A> = (prevState: S, action: A) => S;
+	/**
+	 * An alternative to `useState`.
+	 *
+	 * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
+	 * multiple sub-values. It also lets you optimize performance for components that trigger deep
+	 * updates because you can pass `dispatch` down instead of callbacks.
+	 * @param reducer Given the current state and an action, returns the new state
+	 * @param initialState The initial value to store as state
+	 */
+	export function useReducer<S, A>(
+		reducer: Reducer<S, A>,
+		initialState: S
+	): [S, (action: A) => void];
+
+	/**
+	 * An alternative to `useState`.
+	 *
+	 * `useReducer` is usually preferable to `useState` when you have complex state logic that involves
+	 * multiple sub-values. It also lets you optimize performance for components that trigger deep
+	 * updates because you can pass `dispatch` down instead of callbacks.
+	 * @param reducer Given the current state and an action, returns the new state
+	 * @param initialArg The initial argument to pass to the `init` function
+	 * @param init A function that, given the `initialArg`, returns the initial value to store as state
+	 */
+	export function useReducer<S, A, I>(
+		reducer: Reducer<S, A>,
+		initialArg: I,
+		init: (arg: I) => S
+	): [S, (action: A) => void];
+
+	/** @deprecated Use the `Ref` type instead. */
+	type PropRef<T> = MutableRef<T>;
+	interface Ref<T> {
+		readonly current: T | null;
+	}
+
+	interface MutableRef<T> {
+		current: T;
+	}
+
+	/**
+	 * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument
+	 * (`initialValue`). The returned object will persist for the full lifetime of the component.
+	 *
+	 * Note that `useRef()` is useful for more than the `ref` attribute. It’s handy for keeping any mutable
+	 * value around similar to how you’d use instance fields in classes.
+	 *
+	 * @param initialValue the initial value to store in the ref object
+	 */
+	export function useRef<T>(initialValue: T): MutableRef<T>;
+	export function useRef<T>(initialValue: T | null): Ref<T>;
+	export function useRef<T>(): MutableRef<T>;
+
+	type EffectCallback = () => void | (() => void);
+	/**
+	 * Accepts a function that contains imperative, possibly effectful code.
+	 * The effects run after browser paint, without blocking it.
+	 *
+	 * @param effect Imperative function that can return a cleanup function
+	 * @param inputs If present, effect will only activate if the values in the list change (using ===).
+	 */
+	export function useEffect(effect: EffectCallback, inputs?: Inputs): void;
+
+	type CreateHandle = () => object;
+
+	/**
+	 * @param ref The ref that will be mutated
+	 * @param create The function that will be executed to get the value that will be attached to
+	 * ref.current
+	 * @param inputs If present, effect will only activate if the values in the list change (using ===).
+	 */
+	export function useImperativeHandle<T, R extends T>(
+		ref: PreactRef<T>,
+		create: () => R,
+		inputs?: Inputs
+	): void;
+
+	/**
+	 * Accepts a function that contains imperative, possibly effectful code.
+	 * Use this to read layout from the DOM and synchronously re-render.
+	 * Updates scheduled inside `useLayoutEffect` will be flushed synchronously, after all DOM mutations but before the browser has a chance to paint.
+	 * Prefer the standard `useEffect` hook when possible to avoid blocking visual updates.
+	 *
+	 * @param effect Imperative function that can return a cleanup function
+	 * @param inputs If present, effect will only activate if the values in the list change (using ===).
+	 */
+	export function useLayoutEffect(effect: EffectCallback, inputs?: Inputs): void;
+
+	/**
+	 * Returns a memoized version of the callback that only changes if one of the `inputs`
+	 * has changed (using ===).
+	 */
+	export function useCallback<T extends Function>(callback: T, inputs: Inputs): T;
+
+	/**
+	 * Pass a factory function and an array of inputs.
+	 * useMemo will only recompute the memoized value when one of the inputs has changed.
+	 * This optimization helps to avoid expensive calculations on every render.
+	 * If no array is provided, a new value will be computed whenever a new function instance is passed as the first argument.
+	 */
+	// for `inputs`, allow undefined, but don't make it optional as that is very likely a mistake
+	export function useMemo<T>(factory: () => T, inputs: Inputs | undefined): T;
+
+	/**
+	 * Returns the current context value, as given by the nearest context provider for the given context.
+	 * When the provider updates, this Hook will trigger a rerender with the latest context value.
+	 *
+	 * @param context The context you want to use
+	 */
+	export function useContext<T>(context: PreactContext<T>): T;
+
+	/**
+	 * Customize the displayed value in the devtools panel.
+	 *
+	 * @param value Custom hook name or object that is passed to formatter
+	 * @param formatter Formatter to modify value before sending it to the devtools
+	 */
+	export function useDebugValue<T>(value: T, formatter?: (value: T) => any): void;
+
+	export function useErrorBoundary(
+		callback?: (error: any, errorInfo: any) => Promise<void> | void
+	): [any, () => void];
+
+	export function useId(): string;
+}

package/3rdparty/preact/index.ts

@@ -0,0 +1,13 @@
+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 { default as options } from './options';

package/3rdparty/preact/internal.d.ts

@@ -0,0 +1,155 @@
+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: 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, 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;
+}
+
+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 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
+}
+
+// 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; current: undefined };
+type Ref<T> = RefObject<T> | RefCallback<T>;
+
+export interface VNode<P = {}> extends preact.VNode<P> {
+	// Redefine type here using our internal ComponentType type
+	type: string | 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;
+	/**
+	 * The last dom child of a Fragment, or components that return a Fragment
+	 */
+	_nextDom: PreactElement | null;
+	_component: Component | null;
+	_hydrating: boolean | null;
+	constructor: undefined;
+	_original: number;
+}
+
+export interface Component<P = {}, S = {}> extends preact.Component<P, S> {
+	// 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
+	_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/3rdparty/preact/jsx-runtime/index.ts

@@ -0,0 +1,80 @@
+import { options, Fragment } from 'preact';
+
+/** @typedef {import('preact').VNode} VNode */
+
+let vnodeId = 0;
+
+/**
+ * @fileoverview
+ * This file exports various methods that implement Babel's "automatic" JSX runtime API:
+ * - jsx(type, props, key)
+ * - jsxs(type, props, key)
+ * - jsxDEV(type, props, key, __source, __self)
+ *
+ * The implementation of createVNode here is optimized for performance.
+ * Benchmarks: https://esbench.com/bench/5f6b54a0b4632100a7dcd2b3
+ */
+
+/**
+ * JSX.Element factory used by Babel's {runtime:"automatic"} JSX transform
+ * @param {VNode['type']} type
+ * @param {VNode['props']} props
+ * @param {VNode['key']} [key]
+ * @param {unknown} [isStaticChildren]
+ * @param {unknown} [__source]
+ * @param {unknown} [__self]
+ */
+function createVNode(type, props, key, isStaticChildren, __source, __self) {
+	// We'll want to preserve `ref` in props to get rid of the need for
+	// forwardRef components in the future, but that should happen via
+	// a separate PR.
+	let normalizedProps = {},
+		ref,
+		i;
+	for (i in props) {
+		if (i == 'ref') {
+			ref = props[i];
+		} else {
+			normalizedProps[i] = props[i];
+		}
+	}
+
+	const vnode = {
+		type,
+		props: normalizedProps,
+		key,
+		ref,
+		_children: null,
+		_parent: null,
+		_depth: 0,
+		_dom: null,
+		_nextDom: undefined,
+		_component: null,
+		_hydrating: null,
+		constructor: undefined,
+		_original: --vnodeId,
+		__source,
+		__self
+	};
+
+	// If a Component VNode, check for and apply defaultProps.
+	// Note: `type` is often a String, and can be `undefined` in development.
+	if (typeof type === 'function' && (ref = type.defaultProps)) {
+		for (i in ref)
+			if (typeof normalizedProps[i] === 'undefined') {
+				normalizedProps[i] = ref[i];
+			}
+	}
+
+	if (options.vnode) options.vnode(vnode as any);
+	return vnode;
+}
+
+export {
+	createVNode as jsx,
+	createVNode as jsxs,
+	createVNode as jsxDEV,
+	Fragment
+};
+
+export { type JSXInternal as JSX } from 'preact/jsx'