@revolist/ui 4.0.1-rc → 4.0.1

package/_shared/data-query/load-options.d.ts

@@ -5,9 +5,9 @@ import type { QueryObserverOptions } from '@tanstack/query-core';
 /** Read policy only: identity, transport, acceptance framing and projection stay engine-owned. */
 export declare const nativeReadOptionKeys: readonly ["enabled", "staleTime", "gcTime", "refetchInterval", "refetchIntervalInBackground", "refetchOnMount", "refetchOnWindowFocus", "refetchOnReconnect", "retry", "retryDelay", "retryOnMount", "networkMode", "meta"];
 /** Native callbacks receive the native Query; its cached data is engine-owned/opaque. */
-export type NativeReadOptions = Pick<QueryObserverOptions<unknown, unknown>, typeof nativeReadOptionKeys[number]>;
+export type NativeReadOptions = Pick<QueryObserverOptions<unknown, unknown>, (typeof nativeReadOptionKeys)[number]>;
 /** Also protects JavaScript callers from overriding keys, queryFn or acceptance framing. */
-export declare function nativeReadOptions<FnData, Data = FnData>(options?: NativeReadOptions): Pick<QueryObserverOptions<FnData, unknown, Data, Data>, typeof nativeReadOptionKeys[number]>;
+export declare function nativeReadOptions<FnData, Data = FnData>(options?: NativeReadOptions): Pick<QueryObserverOptions<FnData, unknown, Data, Data>, (typeof nativeReadOptionKeys)[number]>;
 /**
  * Optional native read policies plus shared scope, consistency and product reconciliation.
  * Native options: enabled, staleTime, gcTime, refetchInterval, refetchIntervalInBackground,

package/_variables.scss

@@ -1,3 +1,4 @@
+@use 'styles/built-in-palettes' as palettes;
 @use './styles/palette';
 /**
 * Variables
@@ -5,47 +6,48 @@
 
 $rv-font-weight-medium: 500 !default;
 
-$primary-color-light: palette.$legacy-007bff;
-$primary-color-dark: palette.$legacy-0d63e8;
+$primary-color-light: palettes.color('common', 'hex007bff');
+$primary-color-dark: palettes.color('common', 'hex0d63e8');
 
-$text-color-light: palette.$legacy-000;
-$text-color-light-secondary: palette.$legacy-757575;
+$text-color-light: palettes.color('common', 'hex000');
+$text-color-light-secondary: palettes.color('common', 'hex757575');
 $text-color-dark: palette.$white;
-$text-color-dark-secondary: palette.$legacy-999;
-$background-color-light: palette.$legacy-f6f6f7;
+$text-color-dark-secondary: palettes.color('common', 'hex999');
+$background-color-light: palettes.color('common', 'hexf6f6f7');
 
-$button-alt-bg-light: palette.$legacy-ebebef;
-$button-alt-bg-light-hover: palette.$legacy-e4e4e9;
+$button-alt-bg-light: palettes.color('common', 'hexebebef');
+$button-alt-bg-light-hover: palettes.color('common', 'hexe4e4e9');
 
-$background-color-dark: palette.$legacy-333333;
+$background-color-dark: palettes.color('common', 'hex333333');
 
-$border-color-light: palette.$legacy-ebebef;
-$border-color-dark: palette.$legacy-ebebef;
+$border-color-light: palettes.color('common', 'hexebebef');
+$border-color-dark: palettes.color('common', 'hexebebef');
 
-$rv-badge-bg-color: palette.$legacy-f0f0f0;
-$rv-badge-bg-color-dark: palette.$legacy-2d2d2d;
+$rv-badge-bg-color: palettes.color('common', 'hexf0f0f0');
+$rv-badge-bg-color-dark: palettes.color('common', 'hex2d2d2d');
 
 $rv-popup-bg-color: palette.$white;
-$rv-popup-border-color: palette.$legacy-d4d4d4;
+$rv-popup-border-color: palettes.color('common', 'hexd4d4d4');
 $rv-popup-border-opacity: 0.5;
-$rv-popup-shadow-color: palette.$legacy-shadow-54;
-$rv-popup-hover-bg-color: palette.$legacy-f6f6f7;
+$rv-popup-shadow-color: palettes.color('common', 'rgba_0_0_0_0_15');
+$rv-popup-hover-bg-color: palettes.color('common', 'hexf6f6f7');
 $rv-popup-border-radius: 8px;
 $rv-popup-padding: 10px;
-$rv-popup-box-shadow: 0 4px 12px #{palette.$legacy-shadow-54};
-$rv-popup-bg-color-dark: palette.$legacy-1c1c1c;
-$rv-popup-border-color-dark: palette.$legacy-686868;
+$rv-popup-box-shadow: 0 4px 12px #{palettes.color('common', 'rgba_0_0_0_0_15')};
+$rv-popup-bg-color-dark: palettes.color('common', 'hex1c1c1c');
+$rv-popup-border-color-dark: palettes.color('common', 'hex686868');
 $rv-popup-border-opacity-dark: 0;
-$rv-popup-shadow-color-dark: palette.$legacy-shadow-57;
-$rv-popup-hover-bg-color-dark: palette.$legacy-2c2c2c;
-$rv-popup-box-shadow-dark: 0 4px 12px #{palette.$legacy-shadow-57};
-
-$rv-low-color: palette.$legacy-fa2057;
-$rv-medium-color: palette.$legacy-f7c605;
-$rv-high-color: palette.$legacy-01c26e;
-$rv-critical-color: palette.$legacy-a8183c;
-$rv-info-color: palette.$legacy-5555fc;
-$rv-neutral-color: palette.$legacy-161a42;
-
-$rv-progress-bg-color: palette.$legacy-f0f0f0;
-$rv-progress-bg-color-dark: palette.$legacy-252525;
+$rv-popup-shadow-color-dark: palettes.color('common', 'rgba_0_0_0_0_5');
+$rv-popup-hover-bg-color-dark: palettes.color('common', 'hex2c2c2c');
+$rv-popup-box-shadow-dark: 0 4px 12px
+  #{palettes.color('common', 'rgba_0_0_0_0_5')};
+
+$rv-low-color: palettes.color('common', 'hexfa2057');
+$rv-medium-color: palettes.color('common', 'hexf7c605');
+$rv-high-color: palettes.color('common', 'hex01c26e');
+$rv-critical-color: palettes.color('common', 'hexa8183c');
+$rv-info-color: palettes.color('common', 'hex5555fc');
+$rv-neutral-color: palettes.color('common', 'hex161a42');
+
+$rv-progress-bg-color: palettes.color('common', 'hexf0f0f0');
+$rv-progress-bg-color-dark: palettes.color('common', 'hex252525');

package/_vendor/preact/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present Jason Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/_vendor/preact/compat/src/index.d.ts

@@ -0,0 +1,353 @@
+import * as _hooks from '../../hooks/src/index';
+// Intentionally not using a relative path to take advantage of
+// the TS version resolution mechanism
+import * as preact from '../../src/index';
+import { JSXInternal } from '../../src/jsx';
+import * as _Suspense from './suspense';
+import * as _SuspenseList from './suspense-list';
+
+// export default React;
+export = React;
+export as namespace React;
+declare namespace React {
+	// Export JSX
+	export import JSX = JSXInternal;
+
+	// Hooks
+	export import CreateHandle = _hooks.CreateHandle;
+	export import EffectCallback = _hooks.EffectCallback;
+	export import Inputs = _hooks.Inputs;
+	export import PropRef = _hooks.PropRef;
+	export import Reducer = _hooks.Reducer;
+	export import Dispatch = _hooks.Dispatch;
+	export import SetStateAction = _hooks.StateUpdater;
+	export import useCallback = _hooks.useCallback;
+	export import useContext = _hooks.useContext;
+	export import useDebugValue = _hooks.useDebugValue;
+	export import useEffect = _hooks.useEffect;
+	export import useImperativeHandle = _hooks.useImperativeHandle;
+	export import useId = _hooks.useId;
+	export import useLayoutEffect = _hooks.useLayoutEffect;
+	export import useMemo = _hooks.useMemo;
+	export import useReducer = _hooks.useReducer;
+	export import useRef = _hooks.useRef;
+	export import useState = _hooks.useState;
+	// React 18 hooks
+	export import useInsertionEffect = _hooks.useLayoutEffect;
+	export function useTransition(): [false, typeof startTransition];
+	export function useDeferredValue<T = any>(val: T): T;
+	export function useSyncExternalStore<T>(
+		subscribe: (flush: () => void) => () => void,
+		getSnapshot: () => T
+	): T;
+
+	// Preact Defaults
+	export import Context = preact.Context;
+	export import ContextType = preact.ContextType;
+	export import RefObject = preact.RefObject;
+	export import Component = preact.Component;
+	export import FunctionComponent = preact.FunctionComponent;
+	export import ComponentType = preact.ComponentType;
+	export import ComponentClass = preact.ComponentClass;
+	export import FC = preact.FunctionComponent;
+	export import createContext = preact.createContext;
+	export import Ref = preact.Ref;
+	export import createRef = preact.createRef;
+	export import Fragment = preact.Fragment;
+	export import createElement = preact.createElement;
+	export import cloneElement = preact.cloneElement;
+	export import ComponentProps = preact.ComponentProps;
+	export import ReactNode = preact.ComponentChild;
+	export import ReactElement = preact.VNode;
+	export import Consumer = preact.Consumer;
+	export import ErrorInfo = preact.ErrorInfo;
+	export import Key = preact.Key;
+
+	// Suspense
+	export import Suspense = _Suspense.Suspense;
+	export import lazy = _Suspense.lazy;
+	export import SuspenseList = _SuspenseList.SuspenseList;
+
+	// Compat
+	export import StrictMode = preact.Fragment;
+	export const version: string;
+	export function startTransition(cb: () => void): void;
+
+	// HTML
+	export interface HTMLAttributes<
+		T extends EventTarget
+	> extends JSXInternal.HTMLAttributes<T> {}
+	export interface HTMLProps<T extends EventTarget>
+		extends JSXInternal.AllHTMLAttributes<T>, preact.ClassAttributes<T> {}
+	export interface AllHTMLAttributes<
+		T extends EventTarget
+	> extends JSXInternal.AllHTMLAttributes<T> {}
+	export import DetailedHTMLProps = JSXInternal.DetailedHTMLProps;
+	export import CSSProperties = JSXInternal.CSSProperties;
+
+	export interface SVGProps<T extends EventTarget>
+		extends JSXInternal.SVGAttributes<T>, preact.ClassAttributes<T> {}
+
+	interface SVGAttributes<
+		T extends EventTarget = SVGElement
+	> extends JSXInternal.SVGAttributes<T> {}
+
+	interface ReactSVG extends JSXInternal.IntrinsicSVGElements {}
+
+	export import AriaAttributes = JSXInternal.AriaAttributes;
+
+	export import HTMLAttributeReferrerPolicy = JSXInternal.HTMLAttributeReferrerPolicy;
+	export import HTMLAttributeAnchorTarget = JSXInternal.HTMLAttributeAnchorTarget;
+	export import HTMLInputTypeAttribute = JSXInternal.HTMLInputTypeAttribute;
+	export import HTMLAttributeCrossOrigin = JSXInternal.HTMLAttributeCrossOrigin;
+
+	export import AnchorHTMLAttributes = JSXInternal.AnchorHTMLAttributes;
+	export import AudioHTMLAttributes = JSXInternal.AudioHTMLAttributes;
+	export import AreaHTMLAttributes = JSXInternal.AreaHTMLAttributes;
+	export import BaseHTMLAttributes = JSXInternal.BaseHTMLAttributes;
+	export import BlockquoteHTMLAttributes = JSXInternal.BlockquoteHTMLAttributes;
+	export import ButtonHTMLAttributes = JSXInternal.ButtonHTMLAttributes;
+	export import CanvasHTMLAttributes = JSXInternal.CanvasHTMLAttributes;
+	export import ColHTMLAttributes = JSXInternal.ColHTMLAttributes;
+	export import ColgroupHTMLAttributes = JSXInternal.ColgroupHTMLAttributes;
+	export import DataHTMLAttributes = JSXInternal.DataHTMLAttributes;
+	export import DetailsHTMLAttributes = JSXInternal.DetailsHTMLAttributes;
+	export import DelHTMLAttributes = JSXInternal.DelHTMLAttributes;
+	export import DialogHTMLAttributes = JSXInternal.DialogHTMLAttributes;
+	export import EmbedHTMLAttributes = JSXInternal.EmbedHTMLAttributes;
+	export import FieldsetHTMLAttributes = JSXInternal.FieldsetHTMLAttributes;
+	export import FormHTMLAttributes = JSXInternal.FormHTMLAttributes;
+	export import IframeHTMLAttributes = JSXInternal.IframeHTMLAttributes;
+	export import ImgHTMLAttributes = JSXInternal.ImgHTMLAttributes;
+	export import InsHTMLAttributes = JSXInternal.InsHTMLAttributes;
+	export import InputHTMLAttributes = JSXInternal.InputHTMLAttributes;
+	export import KeygenHTMLAttributes = JSXInternal.KeygenHTMLAttributes;
+	export import LabelHTMLAttributes = JSXInternal.LabelHTMLAttributes;
+	export import LiHTMLAttributes = JSXInternal.LiHTMLAttributes;
+	export import LinkHTMLAttributes = JSXInternal.LinkHTMLAttributes;
+	export import MapHTMLAttributes = JSXInternal.MapHTMLAttributes;
+	export import MenuHTMLAttributes = JSXInternal.MenuHTMLAttributes;
+	export import MediaHTMLAttributes = JSXInternal.MediaHTMLAttributes;
+	export import MetaHTMLAttributes = JSXInternal.MetaHTMLAttributes;
+	export import MeterHTMLAttributes = JSXInternal.MeterHTMLAttributes;
+	export import QuoteHTMLAttributes = JSXInternal.QuoteHTMLAttributes;
+	export import ObjectHTMLAttributes = JSXInternal.ObjectHTMLAttributes;
+	export import OlHTMLAttributes = JSXInternal.OlHTMLAttributes;
+	export import OptgroupHTMLAttributes = JSXInternal.OptgroupHTMLAttributes;
+	export import OptionHTMLAttributes = JSXInternal.OptionHTMLAttributes;
+	export import OutputHTMLAttributes = JSXInternal.OutputHTMLAttributes;
+	export import ParamHTMLAttributes = JSXInternal.ParamHTMLAttributes;
+	export import ProgressHTMLAttributes = JSXInternal.ProgressHTMLAttributes;
+	export import SlotHTMLAttributes = JSXInternal.SlotHTMLAttributes;
+	export import ScriptHTMLAttributes = JSXInternal.ScriptHTMLAttributes;
+	export import SelectHTMLAttributes = JSXInternal.SelectHTMLAttributes;
+	export import SourceHTMLAttributes = JSXInternal.SourceHTMLAttributes;
+	export import StyleHTMLAttributes = JSXInternal.StyleHTMLAttributes;
+	export import TableHTMLAttributes = JSXInternal.TableHTMLAttributes;
+	export import TextareaHTMLAttributes = JSXInternal.TextareaHTMLAttributes;
+	export import TdHTMLAttributes = JSXInternal.TdHTMLAttributes;
+	export import ThHTMLAttributes = JSXInternal.ThHTMLAttributes;
+	export import TimeHTMLAttributes = JSXInternal.TimeHTMLAttributes;
+	export import TrackHTMLAttributes = JSXInternal.TrackHTMLAttributes;
+	export import VideoHTMLAttributes = JSXInternal.VideoHTMLAttributes;
+
+	// Events
+	export import TargetedEvent = JSXInternal.TargetedEvent;
+	export import ChangeEvent = JSXInternal.TargetedEvent;
+	export import ClipboardEvent = JSXInternal.TargetedClipboardEvent;
+	export import CompositionEvent = JSXInternal.TargetedCompositionEvent;
+	export import DragEvent = JSXInternal.TargetedDragEvent;
+	export import PointerEvent = JSXInternal.TargetedPointerEvent;
+	export import FocusEvent = JSXInternal.TargetedFocusEvent;
+	export import FormEvent = JSXInternal.TargetedEvent;
+	export import InvalidEvent = JSXInternal.TargetedEvent;
+	export import KeyboardEvent = JSXInternal.TargetedKeyboardEvent;
+	export import MouseEvent = JSXInternal.TargetedMouseEvent;
+	export import TouchEvent = JSXInternal.TargetedTouchEvent;
+	export import UIEvent = JSXInternal.TargetedUIEvent;
+	export import AnimationEvent = JSXInternal.TargetedAnimationEvent;
+	export import TransitionEvent = JSXInternal.TargetedTransitionEvent;
+
+	// Event Handler Types
+	export import EventHandler = JSXInternal.EventHandler;
+	export import ChangeEventHandler = JSXInternal.GenericEventHandler;
+	export import ClipboardEventHandler = JSXInternal.ClipboardEventHandler;
+	export import CompositionEventHandler = JSXInternal.CompositionEventHandler;
+	export import DragEventHandler = JSXInternal.DragEventHandler;
+	export import PointerEventHandler = JSXInternal.PointerEventHandler;
+	export import FocusEventHandler = JSXInternal.FocusEventHandler;
+	export import FormEventHandler = JSXInternal.GenericEventHandler;
+	export import InvalidEventHandler = JSXInternal.GenericEventHandler;
+	export import KeyboardEventHandler = JSXInternal.KeyboardEventHandler;
+	export import MouseEventHandler = JSXInternal.MouseEventHandler;
+	export import TouchEventHandler = JSXInternal.TouchEventHandler;
+	export import UIEventHandler = JSXInternal.UIEventHandler;
+	export import AnimationEventHandler = JSXInternal.AnimationEventHandler;
+	export import TransitionEventHandler = JSXInternal.TransitionEventHandler;
+
+	export function createPortal(
+		vnode: preact.ComponentChildren,
+		container: preact.ContainerNode
+	): preact.VNode<any>;
+
+	export function render(
+		vnode: preact.ComponentChild,
+		parent: preact.ContainerNode,
+		callback?: () => void
+	): Component | null;
+
+	export function hydrate(
+		vnode: preact.ComponentChild,
+		parent: preact.ContainerNode,
+		callback?: () => void
+	): Component | null;
+
+	export function unmountComponentAtNode(
+		container: preact.ContainerNode
+	): boolean;
+
+	export function createFactory(
+		type: preact.VNode<any>['type']
+	): (
+		props?: any,
+		...children: preact.ComponentChildren[]
+	) => preact.VNode<any>;
+	export function isValidElement(element: any): boolean;
+	export function isFragment(element: any): boolean;
+	export function isMemo(element: any): boolean;
+	export function findDOMNode(
+		component: preact.Component | Element
+	): Element | null;
+
+	export abstract class PureComponent<
+		P = {},
+		S = {},
+		SS = any
+	> extends preact.Component<P, S> {
+		isPureReactComponent: boolean;
+	}
+
+	export type MemoExoticComponent<C extends preact.FunctionalComponent<any>> =
+		preact.FunctionComponent<ComponentProps<C>> & {
+			readonly type: C;
+		};
+
+	export function memo<P = {}>(
+		component: preact.FunctionalComponent<P>,
+		comparer?: (prev: P, next: P) => boolean
+	): preact.FunctionComponent<P>;
+	export function memo<C extends preact.FunctionalComponent<any>>(
+		component: C,
+		comparer?: (
+			prev: preact.ComponentProps<C>,
+			next: preact.ComponentProps<C>
+		) => boolean
+	): C;
+
+	export interface RefAttributes<R> extends preact.Attributes {
+		ref?: preact.Ref<R> | undefined;
+	}
+
+	/**
+	 * @deprecated Please use `ForwardRefRenderFunction` instead.
+	 */
+	export interface ForwardFn<P = {}, T = any> {
+		(props: P, ref: ForwardedRef<T>): preact.ComponentChild;
+		displayName?: string;
+	}
+
+	export interface ForwardRefRenderFunction<T = any, P = {}> {
+		(props: P, ref: ForwardedRef<T>): preact.ComponentChild;
+		displayName?: string;
+	}
+
+	export interface ForwardRefExoticComponent<
+		P
+	> extends preact.FunctionComponent<P> {
+		defaultProps?: Partial<P> | undefined;
+	}
+
+	export function forwardRef<R, P = {}>(
+		fn: ForwardRefRenderFunction<R, P>
+	): preact.FunctionalComponent<PropsWithoutRef<P> & { ref?: preact.Ref<R> }>;
+
+	export type PropsWithoutRef<P> = Omit<P, 'ref'>;
+
+	interface MutableRefObject<T> {
+		current: T;
+	}
+
+	export type ForwardedRef<T> =
+		| ((instance: T | null) => void)
+		| MutableRefObject<T | null>
+		| null;
+
+	export type ElementType<
+		P = any,
+		Tag extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements
+	> =
+		| { [K in Tag]: P extends JSX.IntrinsicElements[K] ? K : never }[Tag]
+		| ComponentType<P>;
+
+	export type ComponentPropsWithoutRef<T extends ElementType> = PropsWithoutRef<
+		ComponentProps<T>
+	>;
+
+	export type ComponentPropsWithRef<C extends ElementType> = C extends new (
+		props: infer P
+	) => Component<any, any>
+		? PropsWithoutRef<P> & RefAttributes<InstanceType<C>>
+		: ComponentProps<C>;
+
+	export type ElementRef<
+		C extends
+			| ForwardRefExoticComponent<any>
+			| { new (props: any): Component<any, any> }
+			| ((props: any) => ReactNode)
+			| keyof JSXInternal.IntrinsicElements
+	> = 'ref' extends keyof ComponentPropsWithRef<C>
+		? NonNullable<ComponentPropsWithRef<C>['ref']> extends RefAttributes<
+				infer Instance
+			>['ref']
+			? Instance
+			: never
+		: never;
+
+	export function flushSync<R>(fn: () => R): R;
+	export function flushSync<A, R>(fn: (a: A) => R, a: A): R;
+
+	export function unstable_batchedUpdates(
+		callback: (arg?: any) => void,
+		arg?: any
+	): void;
+
+	export type PropsWithChildren<P = unknown> = P & {
+		children?: preact.ComponentChildren | undefined;
+	};
+
+	export const Children: {
+		map<T extends preact.ComponentChild, R>(
+			children: T | T[],
+			fn: (child: T, i: number) => R
+		): R[];
+		forEach<T extends preact.ComponentChild>(
+			children: T | T[],
+			fn: (child: T, i: number) => void
+		): void;
+		count: (children: preact.ComponentChildren) => number;
+		only: (children: preact.ComponentChildren) => preact.ComponentChild;
+		toArray: (children: preact.ComponentChildren) => preact.VNode<{}>[];
+	};
+
+	// scheduler
+	export const unstable_ImmediatePriority: number;
+	export const unstable_UserBlockingPriority: number;
+	export const unstable_NormalPriority: number;
+	export const unstable_LowPriority: number;
+	export const unstable_IdlePriority: number;
+	export function unstable_runWithPriority(
+		priority: number,
+		callback: () => void
+	): void;
+	export const unstable_now: () => number;
+}

package/_vendor/preact/compat/src/suspense-list.d.ts

@@ -0,0 +1,16 @@
+// Intentionally not using a relative path to take advantage of
+// the TS version resolution mechanism
+import { Component, ComponentChild, ComponentChildren } from '../../src/index';
+
+//
+// SuspenseList
+// -----------------------------------
+
+export interface SuspenseListProps {
+	children?: ComponentChildren;
+	revealOrder?: 'forwards' | 'backwards' | 'together';
+}
+
+export class SuspenseList extends Component<SuspenseListProps> {
+	render(): ComponentChild;
+}

package/_vendor/preact/compat/src/suspense.d.ts

@@ -0,0 +1,19 @@
+// Intentionally not using a relative path to take advantage of
+// the TS version resolution mechanism
+import { Component, ComponentChild, ComponentChildren } from '../../src/index';
+
+//
+// Suspense/lazy
+// -----------------------------------
+export function lazy<T>(
+	loader: () => Promise<{ default: T } | T>
+): T extends { default: infer U } ? U : T;
+
+export interface SuspenseProps {
+	children?: ComponentChildren;
+	fallback: ComponentChildren;
+}
+
+export class Suspense extends Component<SuspenseProps> {
+	render(): ComponentChild;
+}

package/_vendor/preact/hooks/src/index.d.ts

@@ -0,0 +1,145 @@
+// Intentionally not using a relative path to take advantage of
+// the TS version resolution mechanism
+import { ErrorInfo, PreactContext, Ref, RefObject } from '../../src/index';
+
+type Inputs = ReadonlyArray<unknown>;
+
+export type Dispatch<A> = (value: A) => void;
+export type StateUpdater<S> = S | ((prevState: S) => S);
+
+/**
+ * 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, Dispatch<StateUpdater<S>>];
+
+export function useState<S = undefined>(): [
+	S | undefined,
+	Dispatch<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, Dispatch<A>];
+
+/**
+ * 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, Dispatch<A>];
+
+/** @deprecated Use the `Ref` type instead. */
+type PropRef<T> = MutableRef<T>;
+
+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): RefObject<T>;
+export function useRef<T = undefined>(): MutableRef<T | undefined>;
+
+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: Ref<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: ErrorInfo) => Promise<void> | void
+): [any, () => void];
+
+export function useId(): string;