@gitkraken/gitkraken-components 6.0.3 → 7.0.0

package/dist/components/graph/GraphHeaderRow.d.ts

@@ -0,0 +1,36 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { GraphZone } from '../../domain/graph/GraphConstants';
+import type { ExcludeRefsById, GetExternalIcon, GraphItemContext, IncludeOnlyRefsById, OnGraphColumnReOrdered, OnGraphZoneResize, OnGraphZoneResizeEnd, OnGraphZoneResizeFromPropChange, OnPopupGraphHeaderContextMenu, OnToggleRefNodesShown } from '../../domain/graph/GraphTypes';
+import type { TranslationFn } from '../../domain/language/LanguageTypes';
+import type { OnMouseEnter, OnMouseLeave } from '../../domain/ui/UiTypes';
+import type { DndIsDraggable, DndIsDroppable, DndOnDrop } from './dnd/DndContainer';
+type Props = {
+    context?: GraphItemContext;
+    enableResizer?: boolean;
+    getExternalIcon: GetExternalIcon;
+    excludeRefsById: ExcludeRefsById;
+    includeOnlyRefsById: IncludeOnlyRefsById;
+    onColumnReOrdered?: OnGraphColumnReOrdered;
+    onPopupGraphHeaderContextMenu?: OnPopupGraphHeaderContextMenu;
+    onGraphZoneResize?: OnGraphZoneResize;
+    onGraphZoneResizeEnd?: OnGraphZoneResizeEnd;
+    onGraphZoneResizeFromPropChange?: OnGraphZoneResizeFromPropChange;
+    onToggleRefNodesShown: OnToggleRefNodesShown;
+    graphZones: GraphZone[];
+    repoPath: string;
+    showRemoteNamesOnRefs: boolean;
+    translate: TranslationFn;
+    width: number;
+    height: number;
+};
+declare class GraphHeaderRow extends React.PureComponent<Props> {
+    canDrag: boolean;
+    isDraggable: DndIsDraggable;
+    isDroppable: DndIsDroppable;
+    onDrop: DndOnDrop;
+    onZoneHover: OnMouseEnter;
+    onZoneUnHover: OnMouseLeave;
+    render(): ReactElement<'div'>;
+}
+export default GraphHeaderRow;

package/dist/components/graph/GraphScrollMarker.d.ts

@@ -0,0 +1,21 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { GraphMarkerType } from '../../domain/graph/GraphConstants';
+import type { GraphMarkerColors, GraphMarkerRowIndices } from '../../domain/graph/GraphTypes';
+interface Props {
+    enabledScrollMarkerTypes: GraphMarkerType[];
+    viewportWidth: number;
+    viewportHeight: number;
+    markerRowIndices: GraphMarkerRowIndices;
+    markerColors: GraphMarkerColors;
+    scrollWidth?: number;
+    totalRows: number;
+}
+export default class ScrollMarker extends React.PureComponent<Props> {
+    canvas: HTMLCanvasElement | null;
+    componentDidMount(): void;
+    componentWillReceiveProps(nextProps: Props): void;
+    updateCanvas(nextProps?: Props): void;
+    render(): ReactElement<'div'>;
+}
+export {};

package/dist/components/graph/changeszone/ChangesBar.d.ts

@@ -0,0 +1,11 @@
+import type { ReactElement } from 'react';
+import type { RowStats, RowStatsConstraints } from '../../../domain/graph/GraphTypes';
+interface Props {
+    constraints: RowStatsConstraints;
+    isLastColumn: boolean;
+    scrollWidth: number;
+    zoneWidth: number;
+    stats: RowStats;
+}
+export default function ChangesBar(props: Props): ReactElement<'div'>;
+export {};

package/dist/components/graph/commitzone/BackgroundStreak.d.ts

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react';
+type BackgroundStreakProps = {
+    className?: string;
+    marginLeft: number;
+};
+declare function BackgroundStreak({ className, marginLeft }: BackgroundStreakProps): ReactElement<'div'>;
+export default BackgroundStreak;
+export type CommitZoneBackgroundStreakProps = {
+    column: number;
+};
+export declare function CommitZoneBackgroundStreak({ column, }: CommitZoneBackgroundStreakProps): ReactElement<typeof BackgroundStreak>;
+export declare function GutterBackgroundStreak(): ReactElement<typeof BackgroundStreak>;

package/dist/components/graph/commitzone/CommitNode.d.ts

@@ -0,0 +1,24 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { CommitType } from '../../../domain/commit/CommitTypes';
+import type { CssVariables } from '../../../domain/generic/GenericTypes';
+import type { GetExternalIcon, GraphItemContext } from '../../../domain/graph/GraphTypes';
+type Props = {
+    authorEmail: string;
+    authorInitials: string;
+    authorName: string;
+    avatarUrl?: string | null;
+    column: number;
+    context?: GraphItemContext | null;
+    cssVariables: CssVariables;
+    getExternalIcon: GetExternalIcon;
+    left: number;
+    message: string;
+    opacity: number;
+    type: CommitType;
+    useAuthorInitialsForAvatars: boolean;
+};
+export default class CommitNode extends React.PureComponent<Props> {
+    render(): ReactElement<any>;
+}
+export {};

package/dist/components/graph/commitzone/CommitZone.d.ts

@@ -0,0 +1,48 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { CommitType, Sha } from '../../../domain/commit/CommitTypes';
+import type { CssVariables, Style } from '../../../domain/generic/GenericTypes';
+import type { ColumnColorByColumn, GetExternalIcon, GraphItemContext, OnClearCurrentlyHoveredGraphCommit, OnClickCommit, OnCommitContextMenu, OnCurrentlyHoveredGraphCommit, OnDoubleClickCommit, RowEdges } from '../../../domain/graph/GraphTypes';
+type Props = {
+    authorEmail: string;
+    authorName: string;
+    avatarContext?: GraphItemContext;
+    avatarUrl?: string;
+    clearCurrentlyHoveredGraphCommit: OnClearCurrentlyHoveredGraphCommit;
+    column: number;
+    columnColorByColumn: ColumnColorByColumn;
+    commitZoneWidth: number;
+    cssVariables: CssVariables;
+    currentlyHoveredCommitSha?: Sha;
+    edgeColumnMax: number;
+    edges: RowEdges;
+    getExternalIcon: GetExternalIcon;
+    hasRefs: boolean;
+    hasTimeline: boolean;
+    isActiveSha: boolean;
+    isInUnsupportedRebase: boolean;
+    isSelected: boolean;
+    leftGutterBoxShadowAlpha: number;
+    leftGutterWidth: number;
+    message: string;
+    nodeOffset: number;
+    nodeOpacity: number;
+    numGraphColumns: number;
+    onContextMenu: OnCommitContextMenu;
+    onClickCommit: OnClickCommit;
+    onDoubleClickCommit: OnDoubleClickCommit;
+    rightGutterBoxShadowAlpha: number;
+    rightGutterWidth: number;
+    rowContext?: GraphItemContext;
+    scrollLeft: number;
+    setAsCurrentlyHoveredGraphCommit: OnCurrentlyHoveredGraphCommit;
+    sha: Sha;
+    style: Style;
+    type: CommitType;
+    useAuthorInitialsForAvatars: boolean;
+    zoneContext?: GraphItemContext;
+};
+export default class CommitZone extends React.PureComponent<Props> {
+    render(): ReactElement<'div'>;
+}
+export {};

package/dist/components/graph/commitzone/GraphAvatar.d.ts

@@ -0,0 +1,39 @@
+import type { ReactElement, RefCallback } from 'react';
+import React from 'react';
+import { OverlayTrigger } from 'react-bootstrap';
+import type { CssVariables, Style } from '../../../domain/generic/GenericTypes';
+import type { GraphItemContext } from '../../../domain/graph/GraphTypes';
+import type { ComponentTooltip } from '../../../domain/ui/UiTypes';
+type Props = {
+    authorInitials?: string;
+    avatarUrl?: string | null;
+    classes?: string[];
+    column?: number;
+    context?: GraphItemContext | null;
+    cssVariables: CssVariables;
+    divStyle?: Style;
+    fontSize: number;
+    height?: number;
+    minWidth?: number;
+    size: number;
+    title?: string;
+    tooltip?: ComponentTooltip;
+    useAuthorInitialsForAvatars: boolean;
+    width?: number;
+};
+type AvatarState = {
+    tooltipText?: string;
+};
+interface OverlayTriggerExt extends OverlayTrigger {
+    show(): void;
+}
+export default class GraphAvatar extends React.Component<Props, AvatarState> {
+    overlayTriggerRef?: OverlayTriggerExt | null;
+    constructor(props: Props);
+    componentDidUpdate(prevProps: Props, prevState: AvatarState): void;
+    getMaybeDefaultAvatar: (height: number, width: number) => ReactElement<'div'>;
+    ensureTooltipText: () => void;
+    setOverlayTriggerRef: RefCallback<OverlayTriggerExt>;
+    render(): ReactElement<any>;
+}
+export {};

package/dist/components/graph/commitzone/Gutter.d.ts

@@ -0,0 +1,22 @@
+import type { ReactElement } from 'react';
+interface CommonGutterProps {
+    boxShadowAlpha: number;
+    width: number;
+}
+interface LeftGutterProps extends CommonGutterProps {
+    hasTimeline: boolean;
+    scrollLeft: number;
+}
+interface RightGutterProps extends LeftGutterProps {
+    commitZoneWidth: number;
+}
+interface GutterProps extends CommonGutterProps {
+    boxShadowLeft: number;
+    children?: any;
+    className?: string;
+    left: number;
+}
+declare function Gutter({ boxShadowAlpha, boxShadowLeft, children, className, left, width, }: GutterProps): ReactElement<'div'>;
+export default Gutter;
+export declare function LeftGutter({ boxShadowAlpha, hasTimeline, scrollLeft, width }: LeftGutterProps): ReactElement<any>;
+export declare function RightGutter({ boxShadowAlpha, commitZoneWidth, hasTimeline, scrollLeft, width, }: RightGutterProps): ReactElement<any>;

package/dist/components/graph/commitzone/edges/Arc.d.ts

@@ -0,0 +1,4 @@
+import type { CommitType } from '../../../../domain/commit/CommitTypes';
+import type { ArcEndpointAngle, ColumnColor, SvgElement } from '../../../../domain/graph/GraphTypes';
+declare function getArc(color: ColumnColor, endAngle: ArcEndpointAngle, startAngle: ArcEndpointAngle, type: CommitType, x: number, y: number): SvgElement;
+export default getArc;

package/dist/components/graph/commitzone/edges/EdgeNodes.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnColorByColumn, RowEdges, SvgElement } from '../../../../domain/graph/GraphTypes';
+export declare function clearEdgeNodesCache(): void;
+export declare function getEdgeNodes(edges: RowEdges, edgeColumnMax: number, nodeColumn: number, columnColorByColumn: ColumnColorByColumn): SvgElement;

package/dist/components/graph/commitzone/edges/Edges.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { ColumnColorByColumn, RowEdges } from '../../../../domain/graph/GraphTypes';
+type EdgeProps = {
+    columnColorByColumn: ColumnColorByColumn;
+    edgeColumnMax: number;
+    edges: RowEdges;
+    nodeColumn: number;
+};
+declare class Edges extends React.Component<EdgeProps> {
+    render(): ReactElement<'div'>;
+}
+export default Edges;

package/dist/components/graph/commitzone/edges/EndingEdge.d.ts

@@ -0,0 +1,4 @@
+import type { CommitType } from '../../../../domain/commit/CommitTypes';
+import type { ColumnColorByColumn, SvgElement } from '../../../../domain/graph/GraphTypes';
+export declare function clearEndingEdgeCacheCache(): void;
+export declare function getEndingEdge(edgeColumn: number, nodeColumn: number, type: CommitType, columnColorByColumn: ColumnColorByColumn): SvgElement;

package/dist/components/graph/commitzone/edges/PassThroughEdge.d.ts

@@ -0,0 +1,4 @@
+import type { CommitType } from '../../../../domain/commit/CommitTypes';
+import type { ColumnColorByColumn, SvgElement } from '../../../../domain/graph/GraphTypes';
+export declare function clearPassThroughEdgeCache(): void;
+export declare function getPassThroughEdge(column: number, type: CommitType, columnColorByColumn: ColumnColorByColumn): SvgElement;

package/dist/components/graph/commitzone/edges/StartingEdge.d.ts

@@ -0,0 +1,4 @@
+import type { CommitType } from '../../../../domain/commit/CommitTypes';
+import type { ColumnColorByColumn, SvgElement } from '../../../../domain/graph/GraphTypes';
+export declare function clearStartingEdgeCache(): void;
+export declare function getStartingEdge(edgeColumn: number, nodeColumn: number, type: CommitType, columnColorByColumn: ColumnColorByColumn): SvgElement;

package/dist/components/graph/common/DraggableGraphHeader.d.ts

@@ -0,0 +1,42 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { GraphZone, GraphZoneType } from '../../../domain/graph/GraphConstants';
+import type { ExcludeRefsById, GetExternalIcon, GraphRefOptData, IncludeOnlyRefsById, OnGraphZoneResize, OnGraphZoneResizeEnd, OnGraphZoneResizeFromPropChange, OnGraphZoneResizeStart, OnToggleRefNodesShown } from '../../../domain/graph/GraphTypes';
+import type { TranslationFn } from '../../../domain/language/LanguageTypes';
+import type { OnClick, OnMouseEnter, OnMouseLeave } from '../../../domain/ui/UiTypes';
+type GraphHeaderProps = {
+    enableResizer?: boolean;
+    getExternalIcon: GetExternalIcon;
+    graphWidth: number;
+    graphHeight: number;
+    graphZones: GraphZone[];
+    graphZoneType: GraphZoneType;
+    excludeRefsById: ExcludeRefsById;
+    id: string;
+    includeOnlyRefsById: IncludeOnlyRefsById;
+    isDraggable: boolean;
+    isDroppable: boolean;
+    repoPath: string;
+    onHover?: OnMouseEnter;
+    onResize?: OnGraphZoneResize;
+    onResizeEnd?: OnGraphZoneResizeEnd;
+    onResizeFromPropChange?: OnGraphZoneResizeFromPropChange;
+    onResizeStart?: OnGraphZoneResizeStart;
+    onToggleRefNodesShown: OnToggleRefNodesShown;
+    onUnhover?: OnMouseLeave;
+    showRemoteNamesOnRefs: boolean;
+    translate: TranslationFn;
+};
+type GraphHeaderState = {
+    showPopoverMenu: boolean;
+    refPopoverMenuTarget: React.ReactInstance | undefined;
+};
+declare class GraphHeader extends React.Component<GraphHeaderProps, GraphHeaderState> {
+    constructor(props: GraphHeaderProps);
+    onHiddenRefsClick: OnClick;
+    onShowRefNodes: OnToggleRefNodesShown;
+    compareGraphRefOpts(a: GraphRefOptData, b: GraphRefOptData): number;
+    render(): ReactElement<any> | null;
+}
+export declare const DraggableGraphHeader: typeof GraphHeader;
+export {};

package/dist/components/graph/common/EntireRowSpan.d.ts

@@ -0,0 +1,15 @@
+import type { ReactElement } from 'react';
+import type { Style } from '../../../domain/generic/GenericTypes';
+import type { GraphZoneType } from '../../../domain/graph/GraphConstants';
+import type { ChildrenElements } from '../../../domain/ui/UiTypes';
+type Props = {
+    children: ChildrenElements;
+    className?: string;
+    height: number;
+    heightAdjustment: number;
+    graphZoneType: GraphZoneType;
+    scrollTop?: number;
+    style: Style;
+};
+declare function EntireRowSpan({ children, className, height, heightAdjustment, graphZoneType, scrollTop, style, }: Props): ReactElement<'div'>;
+export default EntireRowSpan;

package/dist/components/graph/common/GenericGraphZone.d.ts

@@ -0,0 +1,46 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { CommitType, Sha } from '../../../domain/commit/CommitTypes';
+import type { Style } from '../../../domain/generic/GenericTypes';
+import type { GraphZoneType } from '../../../domain/graph/GraphConstants';
+import type { GetExternalIcon, GraphItemContext, OnClearCurrentlyHoveredGraphCommit, OnClickCommit, OnCommitContextMenu, OnCurrentlyHoveredGraphCommit, OnDoubleClickCommit } from '../../../domain/graph/GraphTypes';
+import type { TranslationFn } from '../../../domain/language/LanguageTypes';
+import type { ChildrenElements } from '../../../domain/ui/UiTypes';
+import type { WorkDirStats } from '../../../domain/workdir/WorkDirTypes';
+type Props = {
+    clearCurrentlyHoveredGraphCommit: OnClearCurrentlyHoveredGraphCommit;
+    children: ChildrenElements;
+    column: number;
+    context?: GraphItemContext | null;
+    currentlyHoveredCommitSha: Sha | null;
+    dimRowsOfSelectedCommit?: boolean;
+    getExternalIcon: GetExternalIcon;
+    graphZoneType: GraphZoneType;
+    highlightRowsOnRefHover: boolean;
+    isDimmedMergeCommitRow: boolean;
+    isHighlighted: boolean;
+    isInUnsupportedRebase: boolean;
+    isHovering: boolean;
+    isMissingHoveredRefGroup?: boolean;
+    isSelected: boolean;
+    numGraphColumns: number;
+    onContextMenu: OnCommitContextMenu;
+    onClickCommit: OnClickCommit;
+    onDoubleClickCommit: OnDoubleClickCommit;
+    rowContext?: GraphItemContext | null;
+    setAsCurrentlyHoveredGraphCommit: OnCurrentlyHoveredGraphCommit;
+    sha: Sha;
+    showColorStrip?: boolean;
+    showConflictIcon?: boolean;
+    showTimeline?: boolean;
+    showTimelineMessage?: boolean;
+    style: Style;
+    title?: string | null;
+    translate: TranslationFn;
+    type: CommitType;
+    workDirStats?: WorkDirStats;
+};
+export default class GenericGraphZone extends React.PureComponent<Props> {
+    render(): ReactElement<'div'>;
+}
+export {};

package/dist/components/graph/common/LoadingSpinner.d.ts

@@ -0,0 +1,11 @@
+import type { ReactElement } from 'react';
+import type { GetExternalIcon } from '../../../domain/graph/GraphTypes';
+export type LoadingSpinnerProps = {
+    className?: string;
+    getExternalIcon: GetExternalIcon;
+    inline?: boolean;
+    message?: string | null;
+    size?: number;
+    useSimpleSpinner?: boolean;
+};
+export default function LoadingSpinner({ inline, getExternalIcon, message, size, useSimpleSpinner, }: LoadingSpinnerProps): ReactElement<any>;

package/dist/components/graph/common/RefLine.d.ts

@@ -0,0 +1,17 @@
+import type { ReactElement } from 'react';
+import type { CommitType } from '../../../domain/commit/CommitTypes';
+interface RefLineCommonProps {
+    hasRefs: boolean;
+    isActiveSha: boolean;
+    type: CommitType;
+}
+interface RefLineProps extends RefLineCommonProps {
+    left: number;
+    width: string | number;
+}
+interface RefLineForColumnProps extends RefLineCommonProps {
+    nodeOffset: number;
+}
+declare function RefLine({ hasRefs, isActiveSha, left, type, width }: RefLineProps): ReactElement<any> | null;
+export default RefLine;
+export declare function RefLineForCommit({ hasRefs, isActiveSha, nodeOffset, type, }: RefLineForColumnProps): ReactElement<typeof RefLine>;

package/dist/components/graph/common/Timeline.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from 'react';
+type TimelineProps = {
+    z2?: true;
+};
+declare function Timeline({ z2 }: TimelineProps): ReactElement<'div'>;
+export default Timeline;

package/dist/components/graph/dnd/DndContainer.d.ts

@@ -0,0 +1,44 @@
+import type { Drake } from 'dragula';
+import type { ReactElement, ReactNode } from 'react';
+import React from 'react';
+export type DndDirection = 'vertical' | 'horizontal';
+export type DndIsDraggable = (source: ReactElement<any>) => boolean;
+export type DndIsDroppable = (source: ReactElement<any>, target: ReactElement<any>) => boolean;
+export type DndOnDrop = (source: ReactElement<any>, target: ReactElement<any> | null) => void;
+export type DndContainerProps = {
+    children?: ReactNode;
+    className?: string;
+    isDroppable?: DndIsDroppable;
+    direction?: DndDirection;
+    onDrop?: DndOnDrop;
+    isDraggable?: DndIsDraggable;
+};
+type DraggulaOnDrop = (el: Element, target: Element, source: Element, sibling: Element) => void;
+type DraggulaIsContainer = (el?: Element) => boolean;
+type DraggulaMoves = (el?: Element, container?: Element, handle?: Element, sibling?: Element) => boolean;
+type DraggulaInvalid = (el?: Element, target?: Element) => boolean;
+type DraggulaAccepts = (el?: Element, target?: Element, source?: Element, sibling?: Element) => boolean;
+type ChildReactElementsById = {
+    [id: string]: ReactElement<any>;
+};
+declare class DndContainer extends React.PureComponent<DndContainerProps> {
+    dndDrake?: Drake;
+    childReactElementsById: ChildReactElementsById;
+    constructor(props: DndContainerProps);
+    componentDidMount(): void;
+    componentWillReceiveProps(nextProps: DndContainerProps): void;
+    componentWillUnmount(): void;
+    onDrop: DraggulaOnDrop;
+    isContainerCallback: DraggulaIsContainer;
+    movesCallback: DraggulaMoves;
+    acceptsCallback: DraggulaAccepts;
+    invalidCallBack: DraggulaInvalid;
+    dndDecorator: (instance: HTMLDivElement | null) => void;
+    loadChildrenReactElements(children?: ReactNode): void;
+    addChildReactElement(element: ReactElement<any>): void;
+    sanitizeId(id: string): string;
+    isDraggable(id: string): boolean;
+    isDroppable(id: string, targetId?: string): boolean;
+    render(): ReactElement<any>;
+}
+export default DndContainer;

package/dist/components/graph/refzone/Icon.d.ts

@@ -0,0 +1,39 @@
+import type { ReactElement } from 'react';
+import type { GetExternalIcon, GraphItemContext } from '../../../domain/graph/GraphTypes';
+import type { HostingServiceType } from '../../../domain/hostingservice/HostingServiceTypes';
+type IconProps = {
+    icon: ReactElement<any>;
+    tooltipClassName?: string;
+    tooltipId?: string;
+    tooltipText?: string;
+};
+type IssueProps = {
+    displayId: string;
+    id: string;
+    title: string;
+    getExternalIcon: GetExternalIcon;
+};
+type RefIconProps = {
+    avatarUrl?: string;
+    context: GraphItemContext | null;
+    icon: ReactElement<any>;
+    tooltipText?: string;
+};
+type PullRequestProps = {
+    icon: ReactElement<any>;
+    hostingServiceType: HostingServiceType;
+    id: string | number;
+    title: string;
+};
+type UpStreamIndicatorProps = {
+    icon: ReactElement<any>;
+    type: string;
+    upstream: string;
+    tooltipText?: string;
+};
+export declare function Icon({ icon, tooltipClassName, tooltipId, tooltipText }: IconProps): ReactElement<any>;
+export declare function IssueIcon({ displayId, id, title, getExternalIcon }: IssueProps): ReactElement<typeof Icon>;
+export declare function PullRequestIcon({ hostingServiceType, icon, id, title }: PullRequestProps): ReactElement<typeof Icon>;
+export declare function UpstreamIndicatorIcon({ icon, type, upstream, tooltipText, }: UpStreamIndicatorProps): ReactElement<typeof Icon>;
+export declare function RefIcon({ avatarUrl, context, icon, tooltipText }: RefIconProps): ReactElement<typeof Icon>;
+export {};

package/dist/components/graph/refzone/OverflowCount.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from 'react';
+export type OverflowCountProps = {
+    hasActive: boolean;
+    overflowCount: number;
+};
+declare function OverflowCount({ hasActive, overflowCount }: OverflowCountProps): ReactElement<'span'>;
+export default OverflowCount;

package/dist/components/graph/refzone/RefName.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from 'react';
+export type RefNameProps = {
+    name: string;
+};
+declare function RefName({ name }: RefNameProps): ReactElement<'span'>;
+export default RefName;

package/dist/components/graph/refzone/RefNode.d.ts

@@ -0,0 +1,36 @@
+import type { ReactElement } from 'react';
+import React from 'react';
+import type { Sha } from '../../../domain/commit/CommitTypes';
+import type { GetExternalIcon, GetMissingRefMetadata, GraphItemContext, GraphRef, GraphRefGroup, OnClickRef, OnClickRefMetadata, OnDoubleClickRef, OnDoubleClickRefMetadata, OnHideRefClick, OnRefNodeHovered, OnRefZoneContextMenu, RefMetadataById, RefMetadataType } from '../../../domain/graph/GraphTypes';
+import type { TranslationFn } from '../../../domain/language/LanguageTypes';
+import type { OnClick, OnContextMenu, OnDoubleClick } from '../../../domain/ui/UiTypes';
+type RefNodeProps = {
+    getExternalIcon: GetExternalIcon;
+    groupIsHovered: boolean;
+    hasActive: boolean;
+    hasRefs: boolean;
+    isInUnsupportedRebase: boolean;
+    isRefGroupIncluded: boolean;
+    onClick: OnClickRef;
+    onContextMenu: OnRefZoneContextMenu;
+    onDoubleClick: OnDoubleClickRef;
+    onHovered: OnRefNodeHovered;
+    onMissingRefMetadata: GetMissingRefMetadata;
+    onHideRefClick: OnHideRefClick;
+    refGroup: GraphRefGroup;
+    refGroupContext: GraphItemContext | null;
+    refMetadata: RefMetadataById | null;
+    sha: Sha;
+    enabledRefMetadataTypes: RefMetadataType[];
+    translate: TranslationFn;
+};
+export declare function getRefIconAndTooltipForRef(getExternalIcon: GetExternalIcon, ref: GraphRef, translate: TranslationFn, index?: number): ReactElement<any>;
+export default class RefNode extends React.PureComponent<RefNodeProps> {
+    onContextMenu: OnContextMenu;
+    onClick: OnClick;
+    onClickMetadata: OnClickRefMetadata;
+    onDoubleClick: OnDoubleClick;
+    onDoubleClickMetadata: OnDoubleClickRefMetadata;
+    render(): ReactElement<any | 'span'>;
+}
+export {};

package/dist/components/graph/refzone/RefNodes.d.ts

@@ -0,0 +1,31 @@
+import type { ReactElement } from 'react';
+import type { Sha } from '../../../domain/commit/CommitTypes';
+import type { GetExternalIcon, GetMissingRefMetadata, GraphItemContext, IncludeOnlyRefsById, IncludeOnlyRemotesByName, OnClickRef, OnDoubleClickRef, OnRefNodeHovered, OnRefZoneContextMenu, OnToggleRefNodesShown, GraphRefGroup as RefGroup, RefGroupContexts, RefMetadataById, RefMetadataType, RefTargetFunc } from '../../../domain/graph/GraphTypes';
+import type { TranslationFn } from '../../../domain/language/LanguageTypes';
+type RefNodesProps = {
+    onDoubleClickRef: OnDoubleClickRef;
+    enabledRefMetadataTypes: RefMetadataType[];
+    column: number;
+    context: GraphItemContext | null;
+    getExternalIcon: GetExternalIcon;
+    getTargetRef: RefTargetFunc;
+    hasActive: boolean;
+    hasRefs: boolean;
+    includeOnlyRefsById: IncludeOnlyRefsById;
+    includeOnlyRemotesByName: IncludeOnlyRemotesByName;
+    isHovered: boolean;
+    isInUnsupportedRebase: boolean;
+    numGraphColumns: number;
+    onClickRef: OnClickRef;
+    onMissingRefMetadata: GetMissingRefMetadata;
+    refGroupContexts: RefGroupContexts | null;
+    refGroupsByName: RefGroup[];
+    refMetadata: RefMetadataById | null;
+    refNodeHovered: OnRefNodeHovered;
+    onToggleRefNodesShown: OnToggleRefNodesShown;
+    sha: Sha;
+    showContextMenuForGroupedRef: OnRefZoneContextMenu;
+    translate: TranslationFn;
+};
+declare function RefNodes({ enabledRefMetadataTypes, column, context, getTargetRef, hasActive, hasRefs, getExternalIcon, includeOnlyRefsById, includeOnlyRemotesByName, isHovered, isInUnsupportedRebase, numGraphColumns, onMissingRefMetadata, refGroupContexts, refGroupsByName, refMetadata, refNodeHovered, sha, showContextMenuForGroupedRef, onClickRef, onDoubleClickRef, onToggleRefNodesShown, translate, }: RefNodesProps): ReactElement<'span' | 'div'>;
+export default RefNodes;

package/dist/components/graph/refzone/RefPopover.d.ts

@@ -0,0 +1,15 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { OnMouseEnter, OnMouseLeave } from '../../../domain/ui/UiTypes';
+type RefPopoverStyle = {
+    top: number;
+};
+type Props = {
+    children?: ReactNode;
+    column: number;
+    numGraphColumns: number;
+    onMouseEnter?: OnMouseEnter;
+    onMouseLeave?: OnMouseLeave;
+    style?: RefPopoverStyle;
+};
+declare function RefPopover({ style, children, column, numGraphColumns, onMouseEnter, onMouseLeave, }: Props): ReactElement<'div'>;
+export default RefPopover;