lean4monaco 1.1.3 → 1.1.4

package/dist/lean4-infoview/infoview/collapsing.d.ts

@@ -1,12 +0,0 @@
-import * as React from 'react';
-/** Returns `[node, isVisible]`. Attach `node` to the dom element you care about as `<div ref={node}>...</div>` and
- * `isVisible` will change depending on whether the node is visible in the viewport or not. */
-export declare function useIsVisible(): [(element: HTMLElement) => void, boolean];
-interface DetailsProps {
-    initiallyOpen?: boolean;
-    children: [React.ReactNode, ...React.ReactNode[]];
-    setOpenRef?: (_: React.Dispatch<React.SetStateAction<boolean>>) => void;
-}
-/** Like `<details>` but can be programatically revealed using `setOpenRef`. */
-export declare function Details({ initiallyOpen, children: [summary, ...children], setOpenRef }: DetailsProps): JSX.Element;
-export {};

package/dist/lean4-infoview/infoview/contexts.d.ts

@@ -1,10 +0,0 @@
-import * as React from 'react';
-import type { Diagnostic } from 'vscode-languageserver-protocol';
-import { InfoviewConfig, LeanFileProgressProcessingInfo } from '@leanprover/infoview-api';
-import { EditorConnection } from './editorConnection';
-import { ServerVersion } from './serverVersion';
-export declare const EditorContext: React.Context<EditorConnection>;
-export declare const VersionContext: React.Context<ServerVersion | undefined>;
-export declare const ConfigContext: React.Context<InfoviewConfig>;
-export declare const LspDiagnosticsContext: React.Context<Map<string, Diagnostic[]>>;
-export declare const ProgressContext: React.Context<Map<string, LeanFileProgressProcessingInfo[]>>;

package/dist/lean4-infoview/infoview/editorConnection.d.ts

@@ -1,22 +0,0 @@
-import type { Location } from 'vscode-languageserver-protocol';
-import { EditorApi, InfoviewAction, InfoviewActionKind, InfoviewApi, PlainGoal, PlainTermGoal } from '@leanprover/infoview-api';
-import { EventEmitter, Eventify } from './event';
-import { DocumentPosition } from './util';
-export type EditorEvents = Omit<Eventify<InfoviewApi>, 'requestedAction' | 'goToDefinition'> & {
-    requestedAction: EventEmitter<InfoviewAction, InfoviewActionKind>;
-    goToDefinition: EventEmitter<string, string>;
-};
-/** Provides higher-level wrappers around functionality provided by the editor,
- * e.g. to insert a comment. See also {@link EditorApi}. */
-export declare class EditorConnection {
-    readonly api: EditorApi;
-    readonly events: EditorEvents;
-    constructor(api: EditorApi, events: EditorEvents);
-    /** Highlights the given range in a document in the editor. */
-    revealLocation(loc: Location): Promise<void>;
-    revealPosition(pos: DocumentPosition): Promise<void>;
-    /** Copies the text to a comment at the cursor position. */
-    copyToComment(text: string): Promise<void>;
-    requestPlainGoal(pos: DocumentPosition): Promise<PlainGoal | undefined>;
-    requestPlainTermGoal(pos: DocumentPosition): Promise<PlainTermGoal | undefined>;
-}

package/dist/lean4-infoview/infoview/errors.d.ts

@@ -1,14 +0,0 @@
-import * as React from 'react';
-/** Error boundary as described in https://reactjs.org/docs/error-boundaries.html */
-export declare class ErrorBoundary extends React.Component<{
-    children?: React.ReactNode;
-}, {
-    error: string | undefined;
-}> {
-    constructor(props: {});
-    static getDerivedStateFromError(error: any): {
-        error: any;
-    };
-    componentDidCatch(error: any, errorInfo: any): void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
-}

package/dist/lean4-infoview/infoview/event.d.ts

@@ -1,33 +0,0 @@
-import type { Disposable } from 'vscode-languageserver-protocol';
-export declare class EventEmitter<E, in out K> {
-    private freshId;
-    private handlers;
-    private handlersWithKey;
-    current?: E;
-    /**
-     * Register a handler that will receive events from this emitter
-     * and return a closure that removes the handler registration.
-     *
-     * If `key` is specified, only events fired with that key
-     * will be propagated to this handler.
-     */
-    on(handler: (_: E) => void, key?: K): Disposable;
-    /**
-     * Propagate the event to registered handlers.
-     *
-     * The event is propagated to all keyless handlers.
-     * Furthermore if `key` is provided,
-     * the event is also propagated to handlers registered with that key.
-     */
-    fire(event: E, key?: K): void;
-}
-type ExcludeNonEvent<T, U> = T extends (...args: any) => Promise<void> ? U : never;
-/**
- * Turn all fields in `T` which extend `(...args: As) => Promise<void>`
- * into event emitter fields `f: EventEmitter<As>`.
- * Other fields are removed.
- */
-export type Eventify<T> = {
-    [P in keyof T as ExcludeNonEvent<T[P], P>]: T[P] extends (arg: infer A) => Promise<void> ? EventEmitter<A, never> : T[P] extends (...args: infer As) => Promise<void> ? EventEmitter<As, never> : never;
-};
-export {};

package/dist/lean4-infoview/infoview/goalLocation.d.ts

@@ -1,61 +0,0 @@
-import { FVarId, MVarId, SubexprPos } from '@leanprover/infoview-api';
-import * as React from 'react';
-import { HoverState } from './tooltips';
-/**
- * A location within a goal. It is either:
- * - one of the hypotheses; or
- * - (a subexpression of) the type of one of the hypotheses; or
- * - (a subexpression of) the value of one of the let-bound hypotheses; or
- * - (a subexpression of) the goal type. */
-export type GoalLocation = {
-    hyp: FVarId;
-} | {
-    hypType: [FVarId, SubexprPos];
-} | {
-    hypValue: [FVarId, SubexprPos];
-} | {
-    target: SubexprPos;
-};
-export declare namespace GoalLocation {
-    function isEqual(l1: GoalLocation, l2: GoalLocation): boolean;
-    function withSubexprPos(l: GoalLocation, p: SubexprPos): GoalLocation;
-}
-/**
- * A location within a goal state. It identifies a specific goal together with a {@link GoalLocation}
- * within it.  */
-export interface GoalsLocation {
-    /** Which goal the location is in. */
-    mvarId: MVarId;
-    loc: GoalLocation;
-}
-export declare namespace GoalsLocation {
-    function isEqual(l1: GoalsLocation, l2: GoalsLocation): boolean;
-    function withSubexprPos(l: GoalsLocation, p: SubexprPos): GoalsLocation;
-}
-/**
- * An interface available through a React context in components where selecting subexpressions
- * makes sense. Currently this is only the goal state display. There, {@link GoalLocation}s can be
- * selected. */
-export interface Locations {
-    isSelected: (l: GoalsLocation) => boolean;
-    setSelected: (l: GoalsLocation, fn: React.SetStateAction<boolean>) => void;
-    /**
-     * A template for the location of the current component. It is defined if and only if the current
-     * component is a subexpression of a selectable expression. We use
-     * {@link GoalsLocation.withSubexprPos} to map this template to a complete location. */
-    subexprTemplate?: GoalsLocation;
-}
-export declare const LocationsContext: React.Context<Locations | undefined>;
-type SelectableLocationProps = React.PropsWithoutRef<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>> & {
-    locs?: Locations;
-    loc?: GoalsLocation;
-    alwaysHighlight: boolean;
-    setHoverState?: React.Dispatch<React.SetStateAction<HoverState>>;
-};
-/**
- * A `<span>` with a corresponding {@link GoalsLocation} which can be (un)selected using shift-click.
- * If `locs` or `loc` is `undefined`, selection functionality is turned off. The element is also
- * highlighted when hovered over if `alwaysHighlight` is `true` or `locs` and `loc` are both defined.
- * `setHoverState` is passed through to {@link DetectHoverSpan}. */
-export declare function SelectableLocation(props_: SelectableLocationProps): JSX.Element;
-export {};

package/dist/lean4-infoview/infoview/goals.d.ts

@@ -1,46 +0,0 @@
-import { InfoviewActionKind, InteractiveGoal, InteractiveGoals } from '@leanprover/infoview-api';
-import * as React from 'react';
-export declare function goalsToString(goals: InteractiveGoals): string;
-interface GoalFilterState {
-    /** If true reverse the list of hypotheses, if false present the order received from LSP. */
-    reverse: boolean;
-    /** If true show hypotheses that have isType=True, otherwise hide them. */
-    showType: boolean;
-    /** If true show hypotheses that have isInstance=True, otherwise hide them. */
-    showInstance: boolean;
-    /** If true show hypotheses that contain a dagger in the name, otherwise hide them. */
-    showHiddenAssumption: boolean;
-    /** If true show the bodies of let-values, otherwise hide them. */
-    showLetValue: boolean;
-}
-interface GoalProps {
-    goal: InteractiveGoal;
-    filter: GoalFilterState;
-    additionalClassNames: string;
-}
-/**
- * Displays the hypotheses, target type and optional case label of a goal according to the
- * provided `filter`. */
-export declare const Goal: React.MemoExoticComponent<(props: GoalProps) => import("react/jsx-runtime").JSX.Element>;
-interface FilteredGoalsProps {
-    /** Components to render in the header. */
-    headerChildren: React.ReactNode;
-    /**
-     * When this is `undefined`, the component will not appear at all but will remember its state
-     * by virtue of still being mounted in the React tree. When it does appear again, the filter
-     * settings and collapsed state will be as before. */
-    goals?: InteractiveGoals;
-    /** Whether or not to display the number of goals. */
-    displayCount: boolean;
-    /** Whether the list of goals should be expanded on first render. */
-    initiallyOpen: boolean;
-    /** If specified, the display will be toggled (collapsed/expanded) when this action is requested
-     * by the user. */
-    togglingAction?: InfoviewActionKind;
-}
-/**
- * Display goals together with a header containing the provided children as well as buttons
- * to control how the goals are displayed.
- */
-export declare const FilteredGoals: React.MemoExoticComponent<({ headerChildren, goals, displayCount, initiallyOpen, togglingAction }: FilteredGoalsProps) => import("react/jsx-runtime").JSX.Element>;
-export {};

package/dist/lean4-infoview/infoview/info.d.ts

@@ -1,18 +0,0 @@
-import { DocumentPosition } from './util';
-type InfoKind = 'cursor' | 'pin';
-interface InfoPinnable {
-    kind: InfoKind;
-    /** Takes an argument for caching reasons, but should only ever (un)pin itself. */
-    onPin: (pos: DocumentPosition) => void;
-}
-/**
- * Note: in the cursor view, we have to keep the cursor position as part of the component state
- * to avoid flickering when the cursor moved. Otherwise, the component is re-initialised and the
- * goal states reset to `undefined` on cursor moves.
- */
-export type InfoProps = InfoPinnable & {
-    pos?: DocumentPosition;
-};
-/** Fetches info from the server and renders an {@link InfoDisplay}. */
-export declare function Info(props: InfoProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/lean4-infoview/infoview/infos.d.ts

@@ -1,2 +0,0 @@
-/** Manages and displays pinned infos, as well as info for the current location. */
-export declare function Infos(): import("react/jsx-runtime").JSX.Element;

package/dist/lean4-infoview/infoview/interactiveCode.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="react" />
-import { SubexprInfo, TaggedText } from '@leanprover/infoview-api';
-export interface InteractiveTextComponentProps<T> {
-    fmt: TaggedText<T>;
-}
-export interface InteractiveTagProps<T> extends InteractiveTextComponentProps<T> {
-    tag: T;
-}
-export interface InteractiveTaggedTextProps<T> extends InteractiveTextComponentProps<T> {
-    InnerTagUi: (_: InteractiveTagProps<T>) => JSX.Element;
-}
-/**
- * Core loop to display {@link TaggedText} objects. Invokes `InnerTagUi` on `tag` nodes in order to support
- * various embedded information, for example subexpression information stored in {@link CodeWithInfos}.
- * */
-export declare function InteractiveTaggedText<T>({ fmt, InnerTagUi }: InteractiveTaggedTextProps<T>): import("react/jsx-runtime").JSX.Element;
-export type InteractiveCodeProps = InteractiveTextComponentProps<SubexprInfo>;
-/** Displays a {@link CodeWithInfos} obtained via RPC from the Lean server. */
-export declare function InteractiveCode(props: InteractiveCodeProps): import("react/jsx-runtime").JSX.Element;

package/dist/lean4-infoview/infoview/main.d.ts

@@ -1,13 +0,0 @@
-import '@vscode/codicons/dist/codicon.css';
-import '@vscode/codicons/dist/codicon.ttf';
-import 'tachyons/css/tachyons.css';
-import './index.css';
-import { EditorApi, InfoviewApi } from '@leanprover/infoview-api';
-/**
- * Render the Lean infoview into the DOM element `uiElement`.
- *
- * @param editorApi is a collection of methods which the infoview needs to be able to invoke
- * on the editor in order to function correctly (such as inserting text or moving the cursor).
- * @returns a collection of methods which must be invoked when the relevant editor events occur.
- */
-export declare function renderInfoview(editorApi: EditorApi, uiElement: HTMLElement): InfoviewApi;

package/dist/lean4-infoview/infoview/messages.d.ts

@@ -1,19 +0,0 @@
-import * as React from 'react';
-import { Diagnostic, DocumentUri } from 'vscode-languageserver-protocol';
-import { InteractiveDiagnostic } from '@leanprover/infoview-api';
-/** Shows the given messages assuming they are for the given file. */
-export declare const MessagesList: React.MemoExoticComponent<({ uri, messages }: {
-    uri: DocumentUri;
-    messages: InteractiveDiagnostic[];
-}) => import("react/jsx-runtime").JSX.Element>;
-/** Displays all messages for the specified file. Can be paused. */
-export declare function AllMessages({ uri: uri0 }: {
-    uri: DocumentUri;
-}): import("react/jsx-runtime").JSX.Element;
-/**
- * Provides a `LspDiagnosticsContext` which stores the latest version of the
- * diagnostics as sent by the publishDiagnostics notification.
- */
-export declare function WithLspDiagnosticsContext({ children }: React.PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element;
-/** Embeds a non-interactive diagnostic into the type `InteractiveDiagnostic`. */
-export declare function lspDiagToInteractive(diag: Diagnostic): InteractiveDiagnostic;

package/dist/lean4-infoview/infoview/rpcSessions.d.ts

@@ -1,11 +0,0 @@
-import { RpcSessionAtPos } from '@leanprover/infoview-api';
-import * as React from 'react';
-import type { TextDocumentPositionParams } from 'vscode-languageserver-protocol';
-import { DocumentPosition } from './util';
-/** Manages a Lean RPC connection by providing an {@link RpcSessionsContext} to the children. */
-export declare function WithRpcSessions({ children }: {
-    children: React.ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-export declare function useRpcSessionAtTdpp(pos: TextDocumentPositionParams): RpcSessionAtPos;
-export declare function useRpcSessionAtPos(pos: DocumentPosition): RpcSessionAtPos;
-export declare const RpcContext: React.Context<RpcSessionAtPos>;

package/dist/lean4-infoview/infoview/serverVersion.d.ts

@@ -1,10 +0,0 @@
-/**
- * Keeps track of the Lean server version and available features.
- * @module
- */
-export declare class ServerVersion {
-    major: number;
-    minor: number;
-    patch: number;
-    constructor(version: string);
-}

package/dist/lean4-infoview/infoview/tooltips.d.ts

@@ -1,32 +0,0 @@
-import * as React from 'react';
-export type TooltipProps = React.PropsWithChildren<React.HTMLProps<HTMLDivElement>> & {
-    reference: HTMLElement | null;
-};
-export declare function Tooltip(props_: TooltipProps): React.ReactPortal;
-export declare const WithToggleableTooltip: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLSpanElement> & {
-    isTooltipShown: boolean;
-    hideTooltip: () => void;
-    tooltipChildren: React.ReactNode;
-}, "ref"> & React.RefAttributes<HTMLSpanElement>>;
-/** Hover state of an element. The pointer can be
- * - elsewhere (`off`)
- * - over the element (`over`)
- * - over the element with Ctrl or Meta (⌘ on Mac) held (`ctrlOver`)
- */
-export type HoverState = 'off' | 'over' | 'ctrlOver';
-/** An element which calls `setHoverState` when the hover state of its DOM children changes.
- *
- * It is implemented with JS rather than CSS in order to allow nesting of these elements. When nested,
- * only the smallest (deepest in the DOM tree) {@link DetectHoverSpan} has an enabled hover state. */
-export declare const DetectHoverSpan: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLSpanElement> & React.HTMLAttributes<HTMLSpanElement> & {
-    setHoverState: React.Dispatch<React.SetStateAction<HoverState>>;
-}, "ref"> & React.RefAttributes<HTMLSpanElement>>;
-/** Shows a tooltip when the children are hovered over or clicked.
- *
- * An `onClick` middleware can optionally be given in order to control what happens when the
- * hoverable area is clicked. The middleware can invoke `next` to execute the default action
- * which is to pin the tooltip open. */
-export declare const WithTooltipOnHover: React.ForwardRefExoticComponent<Omit<Omit<React.HTMLProps<HTMLSpanElement>, "onClick"> & {
-    tooltipChildren: React.ReactNode;
-    onClick?: ((event: React.MouseEvent<HTMLSpanElement>, next: React.MouseEventHandler<HTMLSpanElement>) => void) | undefined;
-}, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/lean4-infoview/infoview/traceExplorer.d.ts

@@ -1,11 +0,0 @@
-/**
- * Traces of any substantial compilation or elaboration process are usually extremely verbose,
- * which makes them slow (or even infeasible) to pretty-print and difficult to understand.
- * Instead, we provide a "TraceExplorer" UI which allows users to lazily expand trace subtrees,
- * and (TODO) execute search queries.
- *
- * @module
- */
-import { MsgEmbed } from '@leanprover/infoview-api';
-import { InteractiveTextComponentProps } from './interactiveCode';
-export declare function InteractiveMessage({ fmt }: InteractiveTextComponentProps<MsgEmbed>): import("react/jsx-runtime").JSX.Element;

package/dist/lean4-infoview/infoview/userWidget.d.ts

@@ -1,39 +0,0 @@
-import * as React from 'react';
-import { InteractiveGoal, InteractiveTermGoal, RpcSessionAtPos, UserWidgetInstance } from '@leanprover/infoview-api';
-import { GoalsLocation } from './goalLocation';
-import { DocumentPosition } from './util';
-/**
- * Fetch source code from Lean and dynamically import it as a JS module.
- *
- * The source must hash to `hash` (in Lean) and must have been annotated with `@[widget]`
- * or `@[widget_module]` at some point before `pos`. */
-export declare function importWidgetModule(rs: RpcSessionAtPos, pos: DocumentPosition, hash: string): Promise<any>;
-export interface DynamicComponentProps {
-    pos: DocumentPosition;
-    hash: string;
-    props: any;
-}
-/**
- * Use {@link importWidgetModule} to import a module which must `export default` a React component,
- * and render that with `props`. Errors in the component are caught in an error boundary. */
-export declare function DynamicComponent(props_: React.PropsWithChildren<DynamicComponentProps>): import("react/jsx-runtime").JSX.Element;
-interface PanelWidgetDisplayProps {
-    pos: DocumentPosition;
-    goals: InteractiveGoal[];
-    termGoal?: InteractiveTermGoal;
-    selectedLocations: GoalsLocation[];
-    widget: UserWidgetInstance;
-}
-/** Props that every infoview panel widget receives as input to its `default` export. */
-export interface PanelWidgetProps {
-    /** Cursor position in the file at which the widget is being displayed. */
-    pos: DocumentPosition;
-    /** The current tactic-mode goals. */
-    goals: InteractiveGoal[];
-    /** The current term-mode goal, if any. */
-    termGoal?: InteractiveTermGoal;
-    /** Locations currently selected in the goal state. */
-    selectedLocations: GoalsLocation[];
-}
-export declare function PanelWidgetDisplay({ pos, goals, termGoal, selectedLocations, widget }: PanelWidgetDisplayProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/lean4-infoview/infoview/util.d.ts

@@ -1,144 +0,0 @@
-import * as React from 'react';
-import type { DocumentUri, Position, Range, TextDocumentPositionParams } from 'vscode-languageserver-protocol';
-import { EventEmitter } from './event';
-/** A document URI and a position in that document. */
-export interface DocumentPosition extends Position {
-    uri: DocumentUri;
-}
-export declare namespace DocumentPosition {
-    function isEqual(p1: DocumentPosition, p2: DocumentPosition): boolean;
-    function toTdpp(p: DocumentPosition): TextDocumentPositionParams;
-    function toString(p: DocumentPosition): string;
-}
-export declare namespace PositionHelpers {
-    function isLessThanOrEqual(p1: Position, p2: Position): boolean;
-}
-export declare namespace RangeHelpers {
-    function contains(range: Range, pos: Position, ignoreCharacter?: boolean): boolean;
-}
-export declare function escapeHtml(s: string): string;
-/** @deprecated (unused) */
-export declare function colorizeMessage(goal: string): string;
-export declare function basename(path: string): string;
-/**
- * A specialization of {@link React.useEffect} which executes `f` with the event data
- * whenever `ev` fires.
- * If `key` is provided, `f` is only invoked on events fired with that key.
- */
-export declare function useEvent<E, K>(ev: EventEmitter<E, K>, f: (_: E) => void, dependencies?: React.DependencyList, key?: K): void;
-/**
- * A piece of React {@link React.useState} which returns the data that `ev` most recently fired with.
- * If `f` is provided, the data is mapped through `f` first. */
-export declare function useEventResult<E, K>(ev: EventEmitter<E, K>): E | undefined;
-export declare function useEventResult<E, K, T>(ev: EventEmitter<E, K>, f: (newVal: E) => T): T | undefined;
-export declare function useServerNotificationEffect<T>(method: string, f: (params: T) => void, deps?: React.DependencyList): void;
-/**
- * Returns the same tuple as `setState` such that whenever a server notification with `method`
- * arrives at the editor, the state will be updated according to `f`.
- */
-export declare function useServerNotificationState<S, T>(method: string, initial: S, f: (params: T) => Promise<(state: S) => S>, deps?: React.DependencyList): [S, React.Dispatch<React.SetStateAction<S>>];
-export declare function useClientNotificationEffect<T>(method: string, f: (params: T) => void, deps?: React.DependencyList): void;
-/**
- * Like {@link useServerNotificationState} but for client->server notifications sent by the editor.
- */
-export declare function useClientNotificationState<S, T>(method: string, initial: S, f: (state: S, params: T) => S, deps?: React.DependencyList): [S, React.Dispatch<React.SetStateAction<S>>];
-/** Useful for controlling {@link usePausableState} from child components. */
-export interface PausableProps {
-    isPaused: boolean;
-    setPaused: React.Dispatch<React.SetStateAction<boolean>>;
-}
-/**
- * Returns `[{ isPaused, setPaused }, tPausable, tRef]` s.t.
- * - `[isPaused, setPaused]` are the paused status state
- * - for as long as `isPaused` is set, `tPausable` holds its initial value (the `t` passed before pausing)
- *   rather than updates with changes to `t`.
- * - `tRef` can be used to overwrite the paused state
- *
- * To pause child components, `startPaused` can be passed in their props.
- */
-export declare function usePausableState<T>(startPaused: boolean, t: T): [PausableProps, T, React.MutableRefObject<T>];
-export type Keyed<T> = T & {
-    key: string;
-};
-/**
- * Adds a unique `key` property to each element in `elems` using
- * the values of (possibly non-injective) `getId`.
- */
-export declare function addUniqueKeys<T>(elems: T[], getId: (el: T) => string): Keyed<T>[];
-/** Like `React.forwardRef`, but also allows reading the ref inside the forwarding component.
- * Adapted from https://itnext.io/reusing-the-ref-from-forwardref-with-react-hooks-4ce9df693dd */
-export declare function forwardAndUseRef<T, P>(render: (props: P, ref: React.RefObject<T>, setRef: (_: T | null) => void) => React.ReactElement | null): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
-/** Like `forwardAndUseRef`, but the ref is stored in state so that setting it triggers a render.
- * Should only be used if re-rendering is necessary. */
-export declare function forwardAndUseStateRef<T, P>(render: (props: P, ref: T | null, setRef: (_: T | null) => void) => React.ReactElement | null): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
-export interface LogicalDomElement {
-    contains(el: Node): boolean;
-}
-export interface LogicalDomStorage {
-    /** Registers a descendant in the logical DOM.
-     * Returns a function which disposes of the registration. */
-    registerDescendant(el: LogicalDomElement): () => void;
-}
-export declare const LogicalDomContext: React.Context<LogicalDomStorage>;
-/** Suppose a component B appears as a React descendant of the component A. For layout reasons,
- * we sometimes don't want B to appear as a descendant of A in the DOM, so we use `createPortal`.
- * We may still however want to carry out `contains` checks as if B were there, i.e. according to
- * the React tree structure rather than the DOM structure. While React already correctly propagates
- * DOM events up the React tree, other functionality such as `contains` is not provided. We provide
- * it in this hook.
- *
- * Accepts a ref to the observed {@link HTMLElement} (A in the example). Returns:
- * - a {@link LogicalDomElement} which provides `contains` checks for that {@link HTMLElement}; and
- * - a {@link LogicalDomStorage} which MUST be passed to a {@link LogicalDomContext} enclosing
- *   the observed {@link HTMLElement}.
- *
- * Additionally, any component which introduces a portal MUST call `registerDescendant` in the
- * {@link LogicalDomContext} with a ref to the portalled component (B in the example). */
-export declare function useLogicalDomObserver(elt: React.RefObject<HTMLElement>): [LogicalDomElement, LogicalDomStorage];
-/**
- * An effect which calls `onClickOutside` whenever an element not logically descending from `ld`
- * (see {@link useLogicalDomObserver}) is clicked. Note that `onClickOutside` is not called on clicks
- * on the scrollbar since these should usually not impact the app's state. */
-export declare function useOnClickOutside(ld: LogicalDomElement, onClickOutside: (_: PointerEvent) => void): void;
-/** Sends an exception object to a throwable error.
- * Maps JSON Rpc errors to throwable errors.
- */
-export declare function mapRpcError(err: unknown): Error;
-/** Catch handler for RPC methods that just returns undefined if the method is not found.
- * This is useful for compatibility with versions of Lean that do not yet have the given RPC method.
- */
-export declare function discardMethodNotFound(e: unknown): undefined;
-export type AsyncState<T> = {
-    state: 'loading';
-} | {
-    state: 'resolved';
-    value: T;
-} | {
-    state: 'rejected';
-    error: any;
-};
-export type AsyncWithTriggerState<T> = {
-    state: 'notStarted';
-} | AsyncState<T>;
-export declare function useAsyncWithTrigger<T>(fn: () => Promise<T>, deps?: React.DependencyList): [AsyncWithTriggerState<T>, () => Promise<void>];
-/** This React hook will run the given promise function `fn` whenever the deps change
- * and use it to update the status and result when the promise resolves.
- *
- * This function prevents race conditions if the requests resolve in a
- * different order to that which they were requested in:
- *
- * - Request 1 is sent with, say, line=42.
- * - Request 2 is sent with line=90.
- * - Request 2 returns with diags=[].
- * - Request 1 returns with diags=['error'].
- *
- * Without `useAsync` we would now return the diagnostics for line 42 even though we're at line 90.
- *
- * When the deps change, the function immediately returns `{ state: 'loading' }`.
- */
-export declare function useAsync<T>(fn: () => Promise<T>, deps?: React.DependencyList): AsyncState<T>;
-/** Like {@link useAsync} but never transitions from `resolved` to `loading` by internally storing
- * the latest `resolved` state and continuing to return it while an update is in flight. The lower
- * amount of re-renders tends to be less visually jarring.
- */
-export declare function useAsyncPersistent<T>(fn: () => Promise<T>, deps?: React.DependencyList): AsyncState<T>;

package/dist/lean4-infoview/loader.d.ts

@@ -1,20 +0,0 @@
-import 'es-module-shims';
-import type { renderInfoview } from './index';
-/**
- * Dynamically load the infoview module, execute `renderInfoview` with the provided `args`,
- * and pass its return value to `next`. See `README.md` for why this is needed.
- *
- * @param imports is the `imports` section of an [`importmap`](https://github.com/WICG/import-maps).
- * It must contain URLs for `@leanprover/infoview`, `react`, `react/jsx-runtime`, `react-dom`,
- * It may include additional URLs. The listed libraries become `import`able
- * from user widgets. Note that `dist/` already includes these files, so the following works:
- * ```js
- * {
- * '@leanprover/infoview': 'https://unpkg.com/@leanprover/infoview/dist/index.production.min.js',
- * 'react': 'https://unpkg.com/@leanprover/infoview/dist/react.production.min.js',
- * 'react/jsx-runtime': 'https://unpkg.com/@leanprover/infoview/dist/react-jsx-runtime.production.min.js',
- * 'react-dom': 'https://unpkg.com/@leanprover/infoview/dist/react-dom.production.min.js',
- * }
- * ```
- */
-export declare function loadRenderInfoview(imports: Record<string, string>, args: Parameters<typeof renderInfoview>, next: (_: ReturnType<typeof renderInfoview>) => void): void;