react-stately 3.45.0 → 3.47.0

package/dist/types/src/table/useTableState.d.ts

@@ -0,0 +1,87 @@
+import { Expandable, Key, MultipleSelection, Node, SelectionMode, Sortable, SortDescriptor } from '@react-types/shared';
+import { GridState } from '../grid/useGridState';
+import { ITableCollection } from './TableCollection';
+import { MultipleSelectionState } from '../selection/types';
+import { MultipleSelectionStateProps } from '../selection/useMultipleSelectionState';
+import { ReactElement } from 'react';
+import { TableBodyProps } from './TableBody';
+import { TableHeaderProps } from './TableHeader';
+export interface TableProps<T> extends MultipleSelection, Sortable, Expandable {
+    /** The elements that make up the table. Includes the TableHeader, TableBody, Columns, and Rows. */
+    children: [ReactElement<TableHeaderProps<T>>, ReactElement<TableBodyProps<T>>];
+    /** A list of row keys to disable. */
+    disabledKeys?: Iterable<Key>;
+    /**
+     * Whether pressing the escape key should clear selection in the table or not.
+     *
+     * Most experiences should not modify this option as it eliminates a keyboard user's ability to
+     * easily clear selection. Only use if the escape key is being handled externally or should not
+     * trigger selection clearing contextually.
+     *
+     * @default 'clearSelection'
+     */
+    escapeKeyBehavior?: 'clearSelection' | 'none';
+    /** Whether selection should occur on press up instead of press down. */
+    shouldSelectOnPressUp?: boolean;
+    /** The id of the column that displays hierarchical data. */
+    treeColumn?: Key;
+}
+export interface TableState<T> extends GridState<T, ITableCollection<T>> {
+    /** A collection of rows and columns in the table. */
+    collection: ITableCollection<T>;
+    /** Whether the row selection checkboxes should be displayed. */
+    showSelectionCheckboxes: boolean;
+    /** The current sorted column and direction. */
+    sortDescriptor: SortDescriptor | null;
+    /** Calls the provided onSortChange handler with the provided column key and sort direction. */
+    sort(columnKey: Key, direction?: 'ascending' | 'descending'): void;
+    /**
+     * Whether keyboard navigation is disabled, such as when the arrow keys should be handled by a
+     * component within a cell.
+     */
+    isKeyboardNavigationDisabled: boolean;
+    /**
+     * Set whether keyboard navigation is disabled, such as when the arrow keys should be handled by a
+     * component within a cell.
+     */
+    setKeyboardNavigationDisabled: (val: boolean) => void;
+    /** A set of keys for items that are expanded. */
+    expandedKeys: Set<Key>;
+    /** Toggles the expanded state for a row by its key. */
+    toggleKey(key: Key): void;
+    /** The id of the column that displays hierarchical data. */
+    treeColumn: Key | null;
+}
+export interface CollectionBuilderContext<T> {
+    showSelectionCheckboxes: boolean;
+    showDragButtons: boolean;
+    selectionMode: SelectionMode;
+    columns: Node<T>[];
+}
+export interface TableStateProps<T> extends MultipleSelectionStateProps, Expandable, Sortable {
+    /** The elements that make up the table. Includes the TableHeader, TableBody, Columns, and Rows. */
+    children?: [ReactElement<TableHeaderProps<T>>, ReactElement<TableBodyProps<T>>];
+    /** A pre-constructed collection to use instead of building one from items and children. */
+    collection?: ITableCollection<T>;
+    /** Whether the row selection checkboxes should be displayed. */
+    showSelectionCheckboxes?: boolean;
+    /**
+     * Whether the row drag button should be displayed.
+     *
+     * @private
+     */
+    showDragButtons?: boolean;
+    /** @private - Do not use unless you know what you're doing. */
+    UNSAFE_selectionState?: MultipleSelectionState;
+    /** The id of the column that displays hierarchical data. */
+    treeColumn?: Key;
+}
+/**
+ * Provides state management for a table component. Handles building a collection of columns and
+ * rows from props. In addition, it tracks row selection and manages sort order changes.
+ */
+export declare function useTableState<T extends object>(props: TableStateProps<T>): TableState<T>;
+/**
+ * Filters a collection using the provided filter function and returns a new TableState.
+ */
+export declare function UNSTABLE_useFilteredTableState<T extends object>(state: TableState<T>, filterFn: ((nodeValue: string, node: Node<T>) => boolean) | null | undefined): TableState<T>;

package/dist/types/src/table/useTreeGridState.d.ts

@@ -0,0 +1,27 @@
+import { GridNode } from '../grid/GridCollection';
+import { Key } from '@react-types/shared';
+import { TableState, TableStateProps } from './useTableState';
+export interface TreeGridState<T> extends Omit<TableState<T>, 'expandedKeys'> {
+    /** A set of keys for items that are expanded. */
+    expandedKeys: 'all' | Set<Key>;
+    /** Toggles the expanded state for a row by its key. */
+    toggleKey(key: Key): void;
+    /** The key map containing nodes representing the collection's tree grid structure. */
+    keyMap: Map<Key, GridNode<T>>;
+    /** The number of leaf columns provided by the user. */
+    userColumnCount: number;
+}
+export interface TreeGridStateProps<T> extends Omit<TableStateProps<T>, 'collection'> {
+    /** The currently expanded keys in the collection (controlled). */
+    UNSTABLE_expandedKeys?: 'all' | Iterable<Key>;
+    /** The initial expanded keys in the collection (uncontrolled). */
+    UNSTABLE_defaultExpandedKeys?: 'all' | Iterable<Key>;
+    /** Handler that is called when items are expanded or collapsed. */
+    UNSTABLE_onExpandedChange?: (keys: Set<Key>) => any;
+}
+/**
+ * Provides state management for a tree grid component. Handles building a collection of columns and
+ * rows from props. In addition, it tracks and manages expanded rows, row selection, and sort order
+ * changes.
+ */
+export declare function UNSTABLE_useTreeGridState<T extends object>(props: TreeGridStateProps<T>): TreeGridState<T>;

package/dist/types/src/tabs/useTabListState.d.ts

@@ -0,0 +1,26 @@
+import { CollectionBase, CollectionStateBase, Key, SingleSelection } from '@react-types/shared';
+import { SingleSelectListState } from '../list/useSingleSelectListState';
+export interface TabListProps<T> extends CollectionBase<T>, Omit<SingleSelection, 'disallowEmptySelection' | 'selectedKey' | 'defaultSelectedKey' | 'onSelectionChange'> {
+    /**
+     * Whether the TabList is disabled.
+     * Shows that a selection exists, but is not available in that circumstance.
+     */
+    isDisabled?: boolean;
+    /** The currently selected key in the collection (controlled). */
+    selectedKey?: Key;
+    /** The initial selected keys in the collection (uncontrolled). */
+    defaultSelectedKey?: Key;
+    /** Handler that is called when the selection changes. */
+    onSelectionChange?: (key: Key) => void;
+}
+export interface TabListStateOptions<T> extends Omit<TabListProps<T>, 'children'>, CollectionStateBase<T> {
+}
+export interface TabListState<T> extends SingleSelectListState<T> {
+    /** Whether the tab list is disabled. */
+    isDisabled: boolean;
+}
+/**
+ * Provides state management for a Tabs component. Tabs include a TabList which tracks
+ * which tab is currently selected and displays the content associated with that Tab in a TabPanel.
+ */
+export declare function useTabListState<T extends object>(props: TabListStateOptions<T>): TabListState<T>;

package/dist/types/src/toast/useToastState.d.ts

@@ -0,0 +1,82 @@
+type ToastAction = 'add' | 'remove' | 'clear';
+export interface ToastStateProps {
+    /** The maximum number of toasts to display at a time. */
+    maxVisibleToasts?: number;
+    /** Function to wrap updates in (i.e. document.startViewTransition()). */
+    wrapUpdate?: (fn: () => void, action: ToastAction) => void;
+}
+export interface ToastOptions {
+    /** Handler that is called when the toast is closed, either by the user or after a timeout. */
+    onClose?: () => void;
+    /** A timeout to automatically close the toast after, in milliseconds. */
+    timeout?: number;
+}
+export interface QueuedToast<T> extends ToastOptions {
+    /** The content of the toast. */
+    content: T;
+    /** A unique key for the toast. */
+    key: string;
+    /** A timer for the toast, if a timeout was set. */
+    timer?: Timer;
+}
+export interface ToastState<T> {
+    /** Adds a new toast to the queue. */
+    add(content: T, options?: ToastOptions): string;
+    /**
+     * Closes a toast.
+     */
+    close(key: string): void;
+    /** Pauses the timers for all visible toasts. */
+    pauseAll(): void;
+    /** Resumes the timers for all visible toasts. */
+    resumeAll(): void;
+    /** The visible toasts. */
+    visibleToasts: QueuedToast<T>[];
+}
+/**
+ * Provides state management for a toast queue. Toasts display brief, temporary notifications
+ * of actions, errors, or other events in an application.
+ */
+export declare function useToastState<T>(props?: ToastStateProps): ToastState<T>;
+/**
+ * Subscribes to a provided toast queue and provides methods to update it.
+ */
+export declare function useToastQueue<T>(queue: ToastQueue<T>): ToastState<T>;
+/**
+ * A ToastQueue manages the order of toasts.
+ */
+export declare class ToastQueue<T> {
+    private queue;
+    private subscriptions;
+    private maxVisibleToasts;
+    private wrapUpdate?;
+    /** The currently visible toasts. */
+    visibleToasts: QueuedToast<T>[];
+    constructor(options?: ToastStateProps);
+    private runWithWrapUpdate;
+    /** Subscribes to updates to the visible toasts. */
+    subscribe(fn: () => void): () => void;
+    /** Adds a new toast to the queue. */
+    add(content: T, options?: ToastOptions): string;
+    /**
+     * Closes a toast.
+     */
+    close(key: string): void;
+    private updateVisibleToasts;
+    /** Pauses the timers for all visible toasts. */
+    pauseAll(): void;
+    /** Resumes the timers for all visible toasts. */
+    resumeAll(): void;
+    clear(): void;
+}
+declare class Timer {
+    private timerId;
+    private startTime;
+    private remaining;
+    private callback;
+    constructor(callback: () => void, delay: number);
+    reset(delay: number): void;
+    pause(): void;
+    resume(): void;
+}
+export {};

package/dist/types/src/toggle/useToggleGroupState.d.ts

@@ -0,0 +1,38 @@
+import { Key } from '@react-types/shared';
+export interface ToggleGroupProps {
+    /**
+     * Whether single or multiple selection is enabled.
+     *
+     * @default 'single'
+     */
+    selectionMode?: 'single' | 'multiple';
+    /** Whether the collection allows empty selection. */
+    disallowEmptySelection?: boolean;
+    /** The currently selected keys in the collection (controlled). */
+    selectedKeys?: Iterable<Key>;
+    /** The initial selected keys in the collection (uncontrolled). */
+    defaultSelectedKeys?: Iterable<Key>;
+    /** Handler that is called when the selection changes. */
+    onSelectionChange?: (keys: Set<Key>) => void;
+    /** Whether all items are disabled. */
+    isDisabled?: boolean;
+}
+export interface ToggleGroupState {
+    /** Whether single or multiple selection is enabled. */
+    readonly selectionMode: 'single' | 'multiple';
+    /** Whether all items are disabled. */
+    readonly isDisabled: boolean;
+    /** A set of keys for items that are selected. */
+    readonly selectedKeys: Set<Key>;
+    /** Toggles the selected state for an item by its key. */
+    toggleKey(key: Key): void;
+    /** Sets whether the given key is selected. */
+    setSelected(key: Key, isSelected: boolean): void;
+    /** Replaces the set of selected keys. */
+    setSelectedKeys(keys: Set<Key>): void;
+}
+/**
+ * Manages state for a group of toggles.
+ * It supports both single and multiple selected items.
+ */
+export declare function useToggleGroupState(props: ToggleGroupProps): ToggleGroupState;

package/dist/types/src/toggle/useToggleState.d.ts

@@ -0,0 +1,41 @@
+import { FocusableProps, InputBase, Validation } from '@react-types/shared';
+import { ReactNode } from 'react';
+export interface ToggleStateOptions extends InputBase {
+    /**
+     * Whether the element should be selected (uncontrolled).
+     */
+    defaultSelected?: boolean;
+    /**
+     * Whether the element should be selected (controlled).
+     */
+    isSelected?: boolean;
+    /**
+     * Handler that is called when the element's selection state changes.
+     */
+    onChange?: (isSelected: boolean) => void;
+}
+export interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps {
+    /**
+     * The label for the element.
+     */
+    children?: ReactNode;
+    /**
+     * The value of the input element, used when submitting an HTML form. See
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
+     */
+    value?: string;
+}
+export interface ToggleState {
+    /** Whether the toggle is selected. */
+    readonly isSelected: boolean;
+    /** Whether the toggle is selected by default. */
+    readonly defaultSelected: boolean;
+    /** Updates selection state. */
+    setSelected(isSelected: boolean): void;
+    /** Toggle the selection state. */
+    toggle(): void;
+}
+/**
+ * Provides state management for toggle components like checkboxes and switches.
+ */
+export declare function useToggleState(props?: ToggleStateOptions): ToggleState;

package/dist/types/src/tooltip/useTooltipTriggerState.d.ts

@@ -0,0 +1,51 @@
+import { OverlayTriggerProps } from '../overlays/useOverlayTriggerState';
+export interface TooltipTriggerProps extends OverlayTriggerProps {
+    /**
+     * Whether the tooltip should be disabled, independent from the trigger.
+     */
+    isDisabled?: boolean;
+    /**
+     * The delay time for the tooltip to show up. [See
+     * guidelines](https://spectrum.adobe.com/page/tooltip/#Immediate-or-delayed-appearance).
+     *
+     * @default 1500
+     */
+    delay?: number;
+    /**
+     * The delay time for the tooltip to close. [See
+     * guidelines](https://spectrum.adobe.com/page/tooltip/#Warmup-and-cooldown).
+     *
+     * @default 500
+     */
+    closeDelay?: number;
+    /**
+     * By default, opens for both focus and hover. Can be made to open only for focus.
+     *
+     * @default 'hover'
+     */
+    trigger?: 'hover' | 'focus';
+    /**
+     * Whether the tooltip should close when the trigger is pressed.
+     *
+     * @default true
+     */
+    shouldCloseOnPress?: boolean;
+}
+export interface TooltipTriggerState {
+    /** Whether the tooltip is currently showing. */
+    isOpen: boolean;
+    /**
+     * Shows the tooltip. By default, the tooltip becomes visible after a delay
+     * depending on a global warmup timer. The `immediate` option shows the
+     * tooltip immediately instead.
+     */
+    open(immediate?: boolean): void;
+    /** Hides the tooltip. */
+    close(immediate?: boolean): void;
+}
+/**
+ * Manages state for a tooltip trigger. Tracks whether the tooltip is open, and provides
+ * methods to toggle this state. Ensures only one tooltip is open at a time and controls
+ * the delay for showing a tooltip.
+ */
+export declare function useTooltipTriggerState(props?: TooltipTriggerProps): TooltipTriggerState;

package/dist/types/src/tree/TreeCollection.d.ts

@@ -0,0 +1,19 @@
+import { Collection, Key, Node } from '@react-types/shared';
+export declare class TreeCollection<T> implements Collection<Node<T>> {
+    private keyMap;
+    private iterable;
+    private firstKey;
+    private lastKey;
+    constructor(nodes: Iterable<Node<T>>, { expandedKeys }?: {
+        expandedKeys?: Set<Key>;
+    });
+    [Symbol.iterator](): IterableIterator<Node<T>>;
+    get size(): number;
+    getKeys(): IterableIterator<Key>;
+    getKeyBefore(key: Key): Key | null;
+    getKeyAfter(key: Key): Key | null;
+    getFirstKey(): Key | null;
+    getLastKey(): Key | null;
+    getItem(key: Key): Node<T> | null;
+    at(idx: number): Node<T> | null;
+}

package/dist/types/src/tree/useTreeState.d.ts

@@ -0,0 +1,25 @@
+import { Collection, CollectionStateBase, DisabledBehavior, Expandable, Key, MultipleSelection, Node } from '@react-types/shared';
+import { SelectionManager } from '../selection/SelectionManager';
+export interface TreeProps<T> extends CollectionStateBase<T>, Expandable, MultipleSelection {
+    /** Whether `disabledKeys` applies to all interactions, or only selection. */
+    disabledBehavior?: DisabledBehavior;
+}
+export interface TreeState<T> {
+    /** A collection of items in the tree. */
+    readonly collection: Collection<Node<T>>;
+    /** A set of keys for items that are disabled. */
+    readonly disabledKeys: Set<Key>;
+    /** A set of keys for items that are expanded. */
+    readonly expandedKeys: Set<Key>;
+    /** Toggles the expanded state for an item by its key. */
+    toggleKey(key: Key): void;
+    /** Replaces the set of expanded keys. */
+    setExpandedKeys(keys: Set<Key>): void;
+    /** A selection manager to read and update multiple selection state. */
+    readonly selectionManager: SelectionManager;
+}
+/**
+ * Provides state management for tree-like components. Handles building a collection
+ * of items from props, item expanded state, and manages multiple selection state.
+ */
+export declare function useTreeState<T>(props: TreeProps<T>): TreeState<T>;

package/dist/types/src/utils/number.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Takes a value and forces it to the closest min/max if it's outside. Also forces it to the closest
+ * valid step.
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+export declare function roundToStepPrecision(value: number, step: number): number;
+export declare function snapValueToStep(value: number, min: number | undefined, max: number | undefined, step: number): number;
+export declare function toFixedNumber(value: number, digits: number, base?: number): number;

package/dist/types/src/utils/useControlledState.d.ts

@@ -0,0 +1,3 @@
+import { SetStateAction } from 'react';
+export declare function useControlledState<T, C = T>(value: Exclude<T, undefined>, defaultValue: Exclude<T, undefined> | undefined, onChange?: (v: C, ...args: any[]) => void): [T, (value: SetStateAction<T>, ...args: any[]) => void];
+export declare function useControlledState<T, C = T>(value: Exclude<T, undefined> | undefined, defaultValue: Exclude<T, undefined>, onChange?: (v: C, ...args: any[]) => void): [T, (value: SetStateAction<T>, ...args: any[]) => void];

package/dist/types/src/virtualizer/Layout.d.ts

@@ -0,0 +1,71 @@
+import { InvalidationContext } from './types';
+import { ItemDropTarget, Key, LayoutDelegate, Node } from '@react-types/shared';
+import { LayoutInfo } from './LayoutInfo';
+import { Rect } from './Rect';
+import { Size } from './Size';
+import { Virtualizer } from './Virtualizer';
+/**
+ * Virtualizer supports arbitrary layout objects, which compute what items are visible, and how
+ * to position and style them. However, layouts do not render items directly. Instead,
+ * layouts produce lightweight LayoutInfo objects which describe various properties of an item,
+ * such as its position and size. The Virtualizer is then responsible for creating the actual
+ * views as needed, based on this layout information.
+ *
+ * Every layout extends from the Layout abstract base class. Layouts must implement the
+ * `getVisibleLayoutInfos`, `getLayoutInfo`, and `getContentSize` methods. All other methods can be
+ * optionally overridden to implement custom behavior.
+ */
+export declare abstract class Layout<T extends object = Node<any>, O = any> implements LayoutDelegate {
+    /** The Virtualizer the layout is currently attached to. */
+    virtualizer: Virtualizer<T, any> | null;
+    /**
+     * Returns an array of `LayoutInfo` objects which are inside the given rectangle.
+     * Should be implemented by subclasses.
+     *
+     * @param rect The rectangle that should contain the returned LayoutInfo objects.
+     */
+    abstract getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    /**
+     * Returns a `LayoutInfo` for the given key.
+     * Should be implemented by subclasses.
+     *
+     * @param key The key of the LayoutInfo to retrieve.
+     */
+    abstract getLayoutInfo(key: Key): LayoutInfo | null;
+    /**
+     * Returns size of the content. By default, it returns virtualizer's size.
+     */
+    abstract getContentSize(): Size;
+    /**
+     * Returns whether the layout should invalidate in response to
+     * visible rectangle changes. By default, it only invalidates
+     * when the virtualizer's size changes. Return true always
+     * to make the layout invalidate while scrolling (e.g. sticky headers).
+     */
+    shouldInvalidate(newRect: Rect, oldRect: Rect): boolean;
+    /**
+     * Returns whether the layout should invalidate when the layout options change.
+     * By default it invalidates when the object identity changes. Override this
+     * method to optimize layout updates based on specific option changes.
+     */
+    shouldInvalidateLayoutOptions(newOptions: O, oldOptions: O): boolean;
+    /**
+     * This method allows the layout to perform any pre-computation
+     * it needs to in order to prepare LayoutInfos for retrieval.
+     * Called by the virtualizer before `getVisibleLayoutInfos`
+     * or `getLayoutInfo` are called.
+     */
+    update(invalidationContext: InvalidationContext<O>): void;
+    /**
+     * Updates the size of the given item.
+     */
+    updateItemSize?(key: Key, size: Size): boolean;
+    /**
+     * Returns a `LayoutInfo` for the given drop target.
+     */
+    getDropTargetLayoutInfo?(target: ItemDropTarget): LayoutInfo;
+    /** @private */
+    getItemRect(key: Key): Rect | null;
+    /** @private */
+    getVisibleRect(): Rect;
+}

package/dist/types/src/virtualizer/LayoutInfo.d.ts

@@ -0,0 +1,77 @@
+import { Key } from '@react-types/shared';
+import { Rect } from './Rect';
+/**
+ * Instances of this lightweight class are created by `Layout` subclasses
+ * to represent each item in the `Virtualizer`. LayoutInfo objects describe
+ * various properties of an item, such as its position and size, and style information.
+ * The virtualizer uses this information when creating actual DOM elements to display.
+ */
+export declare class LayoutInfo {
+    /**
+     * The type of element represented by this LayoutInfo. Should match the `type` of the
+     * corresponding collection node.
+     */
+    type: string;
+    /**
+     * A unique key for this LayoutInfo. Should match the `key` of the corresponding collection node.
+     */
+    key: Key;
+    /**
+     * The key for a parent LayoutInfo, if any.
+     */
+    parentKey: Key | null;
+    /**
+     * Content for this item if it was generated by the layout rather than coming from the Collection.
+     */
+    content: any | null;
+    /**
+     * The rectangle describing the size and position of this element.
+     */
+    rect: Rect;
+    /**
+     * Whether the size is estimated. `false` by default.
+     * Items with estimated sizes will be measured the first time they are added to the DOM.
+     * The estimated size is used to calculate the size and position of the scrollbar.
+     *
+     * @default false
+     */
+    estimatedSize: boolean;
+    /**
+     * Whether the layout info sticks to the viewport when scrolling.
+     *
+     * @default false
+     */
+    isSticky: boolean;
+    /**
+     * The element's opacity.
+     *
+     * @default 1
+     */
+    opacity: number;
+    /**
+     * A CSS transform string to apply to the element. `null` by default.
+     */
+    transform: string | null;
+    /**
+     * The z-index of the element. 0 by default.
+     */
+    zIndex: number;
+    /**
+     * Whether the element allows its contents to overflow its container.
+     *
+     * @default false
+     */
+    allowOverflow: boolean;
+    /**
+     * @param type The type of element represented by this LayoutInfo. Should match the `type` of the
+     *   corresponding collection node.
+     * @param key A unique key for this LayoutInfo. Should match the `key` of the corresponding
+     *   collection node.
+     * @param rect The rectangle describing the size and position of this element.
+     */
+    constructor(type: string, key: Key, rect: Rect);
+    /**
+     * Returns a copy of the LayoutInfo.
+     */
+    copy(): LayoutInfo;
+}

package/dist/types/src/virtualizer/OverscanManager.d.ts

@@ -0,0 +1,8 @@
+import { Rect } from './Rect';
+export declare class OverscanManager {
+    private startTime;
+    private velocity;
+    private visibleRect;
+    setVisibleRect(rect: Rect): void;
+    getOverscannedRect(): Rect;
+}

package/dist/types/src/virtualizer/Point.d.ts

@@ -0,0 +1,19 @@
+export declare class Point {
+    /** The x-coordinate of the point. */
+    x: number;
+    /** The y-coordinate of the point. */
+    y: number;
+    constructor(x?: number, y?: number);
+    /**
+     * Returns a copy of this point.
+     */
+    copy(): Point;
+    /**
+     * Checks if two points are equal.
+     */
+    equals(point: Point): boolean;
+    /**
+     * Returns true if this point is the origin.
+     */
+    isOrigin(): boolean;
+}