lean4monaco 1.0.45 → 1.1.0

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,10 @@
+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/errors.d.ts

@@ -0,0 +1,14 @@
+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/goalLocation.d.ts

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,2 @@
+/** 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

@@ -0,0 +1,19 @@
+/// <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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,11 @@
+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/tooltips.d.ts

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,39 @@
+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/{vscode-lean4/lean4-infoview/src → lean4-infoview}/infoview/util.d.ts

@@ -65,6 +65,12 @@ export type Keyed<T> = T & {
  * 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;
 }
@@ -92,11 +98,8 @@ export declare function useLogicalDomObserver(elt: React.RefObject<HTMLElement>)
 /**
  * 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.
- * `isActive` controls whether the `onClickOutside` handler is active. This can be useful for performance,
- * since having lots of `onClickOutside` handlers when they are not needed can be expensive.
- */
-export declare function useOnClickOutside(ld: LogicalDomElement, onClickOutside: (_: PointerEvent) => void, isActive?: boolean): void;
+ * 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.
  */

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

@@ -0,0 +1,20 @@
+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;