@atlaskit/smart-card 26.34.4 → 26.35.0

package/dist/types-ts4.5/state/helpers.d.ts

@@ -0,0 +1,19 @@
+import { JsonLd } from 'json-ld-types';
+import { CardType, CardStore } from '@atlaskit/linking-common';
+import { DestinationProduct, DestinationSubproduct } from '../utils/analytics/types';
+import { DatasourceResolveResponse, JsonLdDatasourceResponse } from '@atlaskit/link-client-extension';
+export declare const getByDefinitionId: (definitionId: string | undefined, store: CardStore) => string[];
+export declare const getClickUrl: (url: string, jsonLd?: JsonLd.Response) => string;
+export declare const getDefinitionId: (details?: JsonLd.Response) => string | undefined;
+export declare const getExtensionKey: (details?: JsonLd.Response) => string | undefined;
+export declare const getResourceType: (details?: JsonLd.Response) => string | undefined;
+export declare const getProduct: (details?: JsonLd.Response) => DestinationProduct | string | undefined;
+export declare const getSubproduct: (details?: JsonLd.Response) => DestinationSubproduct | string | undefined;
+export declare const getServices: (details?: JsonLd.Response) => JsonLd.Primitives.AuthService[];
+export declare const hasResolved: (details?: JsonLd.Response) => boolean | undefined;
+export declare const isAccessible: ({ meta: { access } }: JsonLd.Response) => boolean;
+export declare const isVisible: ({ meta: { visibility } }: JsonLd.Response) => boolean;
+export declare const getStatusDetails: (details?: JsonLd.Response) => string | undefined;
+export declare const isFinalState: (status: CardType) => boolean;
+export declare const getDatasources: (details?: JsonLdDatasourceResponse) => DatasourceResolveResponse[] | undefined;
+export declare const getCanBeDatasource: (details?: JsonLdDatasourceResponse) => boolean;

package/dist/types-ts4.5/state/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { usePrefetch } from './usePrefetch';
+export { useSmartLink } from './useSmartLink';

package/dist/types-ts4.5/state/hooks/use-invoke/index.d.ts

@@ -0,0 +1,3 @@
+import type { InvokeRequest } from '@atlaskit/linking-types/smart-link-actions';
+declare const useInvoke: () => (req: InvokeRequest, cb?: Function) => Promise<any>;
+export default useInvoke;

package/dist/types-ts4.5/state/hooks/use-invoke/types.d.ts

@@ -0,0 +1,48 @@
+import type { InvokeRequest } from '@atlaskit/linking-types/smart-link-actions';
+import { PreviewActionData } from '../../flexible-ui-context/types';
+/**
+ * Additional details for invoke function that may be required for component
+ */
+export type CardDetails = {
+    /**
+     * An identifier for Smart Link analytics
+     */
+    id?: string;
+    /**
+     * The URL of the Smart Link
+     */
+    url?: string;
+    /**
+     * Preview Modal information. If present, will be used to render an embed modal on an error link click
+     */
+    previewData?: PreviewActionData | null;
+};
+/**
+ * Additional details to reload smart links
+ */
+export type InvokeReloadDetails = {
+    /**
+     * An identifier for Smart Link analytics
+     */
+    id?: string;
+    /**
+     * The URL of the Smart Link
+     */
+    url?: string;
+};
+/**
+ * Invoke request with additional details for the component
+ */
+export type InvokeRequestWithCardDetails = InvokeRequest & {
+    details?: CardDetails;
+    reload?: InvokeReloadDetails;
+};
+/**
+ * CRUD invoke requests for the component that support server actions
+ */
+export type InvokeActions = {
+    create?: InvokeRequest;
+    read?: InvokeRequest;
+    update?: InvokeRequestWithCardDetails;
+    delete?: InvokeRequest;
+};

package/dist/types-ts4.5/state/hooks/use-invoke/utils.d.ts

@@ -0,0 +1,4 @@
+import { InvokeError } from '@atlaskit/linking-types';
+import { TrackQuickActionFailureReason } from '../../../utils/analytics/analytics';
+export declare const getInvokeFailureReason: (err: InvokeError | Error) => TrackQuickActionFailureReason.PermissionError | TrackQuickActionFailureReason.UnknownError;
+export declare const isInvokeCustomError: (err: InvokeError | Error) => err is InvokeError;

package/dist/types-ts4.5/state/hooks/use-invoke-client-action/index.d.ts

@@ -0,0 +1,6 @@
+import type { InvokeClientActionProps, UseInvokeClientActionProps } from './types';
+/**
+ * Invoke client action such as preview, download and open link
+ */
+declare const useInvokeClientAction: ({ analytics }: UseInvokeClientActionProps) => ({ actionType, actionFn, extensionKey, display, }: InvokeClientActionProps) => Promise<void>;
+export default useInvokeClientAction;

package/dist/types-ts4.5/state/hooks/use-invoke-client-action/types.d.ts

@@ -0,0 +1,30 @@
+import type { AnalyticsFacade } from '../../analytics';
+import type { CardInnerAppearance } from '../../../view/Card/types';
+export type UseInvokeClientActionProps = {
+    /**
+     * Analytics object
+     */
+    analytics?: AnalyticsFacade;
+};
+export type InvokeClientActionProps = {
+    /**
+     * Invoke action to execute.
+     */
+    actionFn: () => Promise<void>;
+    /**
+     * Invoke action type for analytics purposes.
+     */
+    actionType: string;
+    /**
+     * Smart card display type
+     * This value should already be set in analytics context.
+     * However, we still need to set this value for ufo experience.
+     */
+    display?: CardInnerAppearance;
+    /**
+     * Link provider extension key
+     * This value should have already been set in analytics object through
+     * useSmartLinkAnalytics() and/or into the analytic context.
+     */
+    extensionKey?: string;
+};

package/dist/types-ts4.5/state/hooks/use-resolve/index.d.ts

@@ -0,0 +1,2 @@
+declare const useResolve: () => (url: string, isReloading?: any, isMetadataRequest?: any, id?: any) => Promise<void>;
+export default useResolve;

package/dist/types-ts4.5/state/hooks/usePrefetch.d.ts

@@ -0,0 +1 @@
+export declare function usePrefetch(url: string): () => Promise<void>;

package/dist/types-ts4.5/state/hooks/useSmartLink.d.ts

@@ -0,0 +1,77 @@
+import { AnalyticsHandler } from '../../utils/types';
+export declare function useSmartLink(id: string, url: string, 
+/**
+ * @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-2681 Internal documentation for deprecation (no external access)}
+ * Avoid prop drilling analytics handlers. Continue passing a handler for now if there's already one in place.
+ */
+dispatchAnalytics?: AnalyticsHandler): {
+    state: import("@atlaskit/linking-common").CardState;
+    actions: {
+        register: () => Promise<void>;
+        reload: () => void;
+        authorize: (appearance: import("../../view/Card/types").CardInnerAppearance) => void;
+        invoke: (opts: import("../../model/invoke-opts").InvokeClientOpts | import("../../model/invoke-opts").InvokeServerOpts, appearance: import("../../view/Card/types").CardInnerAppearance) => Promise<void | import("json-ld-types").JsonLd.Response<import("json-ld-types").JsonLd.Data.BaseData>>;
+        loadMetadata: () => Promise<void> | undefined;
+    };
+    config: (import("@atlaskit/link-provider").CardProviderCacheOpts & import("@atlaskit/link-provider").CardAuthFlowOpts) | undefined;
+    analytics: {
+        ui: {
+            authEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiAuthEventProps) => void;
+            authAlternateAccountEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiAuthAlternateAccountEventProps) => void;
+            buttonClickedEvent: (data: Partial<import("../../utils/types").AnalyticsPayload> & {
+                actionSubjectId: string;
+            }) => void;
+            cardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: import("../../utils/analytics/types").UiCardClickedEventProps) => void;
+            iframeDwelledEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, dwellTime, dwellPercentVisible, }: import("../../utils/analytics/types").UiIframeDwelledEventProps) => void;
+            iframeFocusedEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, }: import("../../utils/analytics/types").UiIframeFocusedEventProps) => void;
+            actionClickedEvent: ({ id, actionType, display, extensionKey: overrideExtensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiActionClickedEventProps) => void;
+            hoverCardOpenLinkClickedEvent: ({ previewDisplay, definitionId, extensionKey, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: import("../../utils/analytics/types").UiHoverCardOpenLinkClickedEventProps) => void;
+            closedAuthEvent: ({ display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiClosedAuthEventProps) => void;
+            modalClosedEvent: (data: Partial<import("../../utils/types").AnalyticsPayload> & {
+                actionSubjectId: string;
+            }) => void;
+            renderSuccessEvent: ({ display, status, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, canBeDatasource, }: import("../../utils/analytics/types").UiRenderSuccessEventProps) => void;
+            renderFailedEvent: ({ display, id, error, errorInfo, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiRenderFailedEventProps) => void;
+            hoverCardViewedEvent: ({ previewDisplay, previewInvokeMethod, id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, status, }: import("../../utils/analytics/types").UiHoverCardViewedEventProps) => void;
+            hoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, previewInvokeMethod, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, status, }: import("../../utils/analytics/types").UiHoverCardDismissedEventProps) => void;
+            learnMoreClickedEvent: () => void;
+            smartLinkLozengeActionClickedEvent: () => void;
+            smartLinkLozengeActionListItemClickedEvent: () => void;
+            smartLinkLozengeActionErrorOpenPreviewClickedEvent: () => void;
+            smartLinkServerActionClickedEvent: (props: import("../../utils/analytics/types").UiServerActionClickedEventProps) => void;
+        };
+        operational: {
+            invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").InvokeSucceededEventProps) => void;
+            invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").InvokeFailedEventProps) => void;
+            connectSucceededEvent: ({ id, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").ConnectSucceededEventProps) => void;
+            connectFailedEvent: ({ id, reason, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").ConnectFailedEventProps) => void;
+            instrument: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: import("../../utils/analytics/types").InstrumentEventProps) => void;
+            chunkloadFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").UiRenderFailedEventProps) => void;
+        };
+        track: {
+            appAccountConnected: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").CommonEventProps) => void;
+            appAccountAuthStarted: ({ extensionKey, location, }: import("../../utils/analytics/types").CommonEventProps) => void;
+            linkUpdated: () => void;
+            smartLinkQuickActionStarted: (props: {
+                smartLinkActionType: import("@atlaskit/linking-types").SmartLinkActionType | import("../../utils/analytics/analytics").TrackQuickActionType;
+            }) => void;
+            smartLinkQuickActionSuccess: (props: {
+                smartLinkActionType: import("@atlaskit/linking-types").SmartLinkActionType | import("../../utils/analytics/analytics").TrackQuickActionType;
+            }) => void;
+            smartLinkQuickActionFailed: (props: {
+                smartLinkActionType: import("@atlaskit/linking-types").SmartLinkActionType | import("../../utils/analytics/analytics").TrackQuickActionType;
+                reason?: import("../../utils/analytics/analytics").TrackQuickActionFailureReason | undefined;
+                step?: string | undefined;
+            }) => void;
+            hoverCardResolutionStarted: () => void;
+        };
+        screen: {
+            authPopupEvent: ({ extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, }: import("../../utils/analytics/types").CommonEventProps) => void;
+            modalViewedEvent: (data: Partial<import("../../utils/types").AnalyticsPayload> & {
+                name: "embedPreviewModal";
+            }) => void;
+        };
+    };
+    renderers: import("@atlaskit/link-provider").CardProviderRenderers | undefined;
+    error: Error | null;
+};

package/dist/types-ts4.5/state/hooks-external/useSmartLinkActions.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="react" />
+import { JsonLd } from 'json-ld-types';
+import type { AnalyticsHandler, AnalyticsOrigin } from '../../utils/types';
+import type { CardInnerAppearance } from '../../view/Card/types';
+export interface LinkAction {
+    /**
+     * Unique ID for the action.
+     * @example `delete-action`
+     */
+    id: string;
+    /**
+     * Text to render for the action.
+     * @description Use this in tooltips and UI.
+     * @example `Delete`.
+     */
+    text: React.ReactNode;
+    /**
+     * Promise to invoke on triggering this action.
+     * @example Clicking on `Delete` leading to deletion of content.
+     */
+    invoke: () => Promise<any>;
+}
+export interface UseSmartLinkActionsOpts {
+    /**
+     * Smart Link URL for which actions will be invoked.
+     * @example https://start.atlassian.com
+     */
+    url: string;
+    /**
+     * Appearance under which these actions will be invoked.
+     * @example `block` for card views.
+     */
+    appearance: CardInnerAppearance;
+    /**
+     * Callback for sending analytics events.
+     * @description Accepts an analytics payload and fires it to a system.
+     *
+     * @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-2681 Internal documentation for deprecation (no external access)}
+     * Overriding the analytics dispatch method is deprecated. Please omit this property.
+     */
+    analyticsHandler?: AnalyticsHandler;
+    /**
+     * Platform on which actions are being invoked.
+     * @default 'web'
+     */
+    platform?: JsonLd.Primitives.Platforms;
+    /**
+     * Smart link origin that the action being invoked from.
+     */
+    origin?: AnalyticsOrigin;
+}
+export declare function useSmartLinkActions({ url, appearance, analyticsHandler, platform, origin, }: UseSmartLinkActionsOpts): LinkAction[];

package/dist/types-ts4.5/state/hooks-external/useSmartLinkReload.d.ts

@@ -0,0 +1,22 @@
+import type { AnalyticsHandler } from '../../utils/types';
+export interface UseSmartLinkReloadOpts {
+    /**
+     * Smart Link URL for which the reload will be invoked.
+     * @example https://start.atlassian.com
+     */
+    url: string;
+    /**
+     * Callback for sending analytics events.
+     * @description Accepts an analytics payload and fires it to a system.
+     *
+     * @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-2681 Internal documentation for deprecation (no external access)}
+     * Overriding the analytics dispatch method is deprecated. Please omit this property.
+     */
+    analyticsHandler?: AnalyticsHandler;
+}
+/**
+ * Exposes a programmatic way to reload the data being used to render a Smart Link.
+ * @param
+ * @returns
+ */
+export declare function useSmartLinkReload({ url, analyticsHandler, }: UseSmartLinkReloadOpts): () => void;

package/dist/types-ts4.5/state/index.d.ts

@@ -0,0 +1,5 @@
+export { SmartCardContext, SmartCardProvider, useSmartLinkContext, } from '@atlaskit/link-provider';
+export type { CardContext, ProviderProps } from '@atlaskit/link-provider';
+export type { CardType } from '@atlaskit/linking-common';
+export { useSmartLink, usePrefetch } from './hooks';
+export { useSmartLinkAnalytics } from './analytics';

package/dist/types-ts4.5/state/reducers/types.d.ts

@@ -0,0 +1,4 @@
+import { Reducer } from 'react';
+import { CardAction, CardActionType } from '@atlaskit/linking-common';
+export type CardReducerMap<StateType, ActionType> = Record<CardActionType, CardReducer<StateType, ActionType>>;
+export type CardReducer<StateType, ActionType> = Reducer<StateType, CardAction<ActionType>>;

package/dist/types-ts4.5/state/renderers/index.d.ts

@@ -0,0 +1,2 @@
+import { CardContext } from '@atlaskit/link-provider';
+export declare const useSmartLinkRenderers: () => CardContext['renderers'] | undefined;

package/dist/types-ts4.5/state/store/index.d.ts

@@ -0,0 +1,3 @@
+import { CardState } from '@atlaskit/linking-common';
+export type { CardType } from '@atlaskit/linking-common';
+export declare function useSmartCardState(url: string): CardState;

package/dist/types-ts4.5/state/types.d.ts

@@ -0,0 +1 @@
+export type { CardStore, CardState } from '@atlaskit/linking-common';

package/dist/types-ts4.5/types.d.ts

@@ -0,0 +1,20 @@
+import { JsonLd } from 'json-ld-types';
+import { RequestAccessMessageKey } from './messages';
+export type { CardContext } from '@atlaskit/link-provider';
+import { AccessContext } from './view/types';
+import { ActionProps } from './view/BlockCard/components/Action';
+export type ResolveResponse = JsonLd.Response;
+export type { ProviderProps, CardType } from './state';
+export type { CardProps, CardAppearance, CardPlatform, } from './view/Card/types';
+export interface RequestAccessContextProps extends AccessContext {
+    action?: ActionProps;
+    callToActionMessageKey?: RequestAccessMessageKey;
+    descriptiveMessageKey?: RequestAccessMessageKey;
+}
+export type InlinePreloaderStyle = 'on-left-with-skeleton' | 'on-right-without-skeleton';
+export type LozengeColor = 'default' | 'success' | 'removed' | 'inprogress' | 'new' | 'moved';
+export interface LozengeProps {
+    text: string;
+    appearance?: LozengeColor;
+    isBold?: boolean;
+}

package/dist/types-ts4.5/utils/actions/create-invoke-request.d.ts

@@ -0,0 +1,3 @@
+import type { InvokeRequest } from '@atlaskit/linking-types/smart-link-actions';
+declare const createInvokeRequest: <TPayload extends object>(request: InvokeRequest, payload?: TPayload | undefined) => InvokeRequest<TPayload>;
+export default createInvokeRequest;

package/dist/types-ts4.5/utils/actions/create-status-update-request.d.ts

@@ -0,0 +1,4 @@
+import type { InvokeRequest } from '@atlaskit/linking-types/smart-link-actions';
+import { StatusUpdateActionPayload } from '@atlaskit/linking-types/smart-link-actions';
+declare const createStatusUpdateRequest: (request: InvokeRequest, id: string) => InvokeRequest<StatusUpdateActionPayload>;
+export default createStatusUpdateRequest;

package/dist/types-ts4.5/utils/analytics/LinkAnalyticsContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+type LinkAnalyticsContextProps = {
+    url?: string;
+    /**
+     * The display mode of the link
+     * @example 'url'
+     */
+    display?: string | undefined;
+    id?: string | undefined;
+    source?: string;
+    children?: React.ReactNode;
+};
+/**
+ * Provides an analytics context to supply attributes to events based on a URL
+ */
+export declare const LinkAnalyticsContext: ({ display, id, children, source, }: LinkAnalyticsContextProps) => JSX.Element;
+export {};

package/dist/types-ts4.5/utils/analytics/SmartLinkAnalyticsContext.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+type SmartLinkAnalyticsContextProps = {
+    url: string;
+    display?: string;
+    id?: string | undefined;
+    source?: string;
+    children?: React.ReactNode;
+};
+/**
+ * Provides an analytics context to supply attributes to events based on a URL
+ * and the link state in the store
+ */
+export declare const SmartLinkAnalyticsContext: (props: SmartLinkAnalyticsContextProps) => JSX.Element;
+export {};

package/dist/types-ts4.5/utils/analytics/__mocks__/analytics.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/types-ts4.5/utils/analytics/analytics.d.ts

@@ -0,0 +1,62 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { AnalyticsPayload } from '../types';
+import { CardInnerAppearance } from '../../view/Card/types';
+import { CommonEventProps, ConnectFailedEventProps, ConnectSucceededEventProps, InvokeFailedEventProps, InvokeSucceededEventProps, ResolvedEventProps, ScreenAuthPopupEventProps, TrackAppAccountConnectedProps, UiActionClickedEventProps, UiAuthAlternateAccountEventProps, UiAuthEventProps, UiCardClickedEventProps, UiClosedAuthEventProps, UiHoverCardDismissedEventProps, UiHoverCardOpenLinkClickedEventProps, UiHoverCardViewedEventProps, UiIframeDwelledEventProps, UiIframeFocusedEventProps, UiRenderFailedEventProps, UiRenderSuccessEventProps, UiServerActionClickedEventProps, UnresolvedEventProps } from './types';
+import { SmartLinkActionType } from '@atlaskit/linking-types';
+export declare const ANALYTICS_CHANNEL = "media";
+export declare const context: {
+    componentName: string;
+    packageName: string;
+    packageVersion: string;
+};
+export declare enum TrackQuickActionType {
+    StatusUpdate = "StatusUpdate"
+}
+export declare enum TrackQuickActionFailureReason {
+    PermissionError = "PermissionError",
+    ValidationError = "ValidationError",
+    UnknownError = "UnknownError"
+}
+export declare const SmartLinkActionTypeTrackingEventMapper: Record<string, string>;
+export declare const SmartLinkActionTypeUiEventMapper: Record<string, string>;
+export declare class SmartLinkEvents {
+    insertSmartLink(url: string, type: CardInnerAppearance, createAnalyticsEvent?: CreateUIAnalyticsEvent): void;
+}
+export declare const fireSmartLinkEvent: (payload: AnalyticsPayload, createAnalyticsEvent?: CreateUIAnalyticsEvent) => void;
+export declare const resolvedEvent: (props: ResolvedEventProps) => AnalyticsPayload;
+export declare const unresolvedEvent: ({ id, definitionId, extensionKey, resourceType, destinationSubproduct, destinationProduct, error, status, location, }: UnresolvedEventProps) => AnalyticsPayload;
+export declare const invokeSucceededEvent: ({ id, actionType, display, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: InvokeSucceededEventProps) => AnalyticsPayload;
+export declare const invokeFailedEvent: ({ id, actionType, display, reason, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: InvokeFailedEventProps) => AnalyticsPayload;
+export declare const connectSucceededEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, }: ConnectSucceededEventProps) => AnalyticsPayload;
+export declare const connectFailedEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, reason, }: ConnectFailedEventProps) => AnalyticsPayload;
+export declare const trackAppAccountConnected: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, }: TrackAppAccountConnectedProps) => AnalyticsPayload;
+export declare const trackAppAccountAuthStarted: ({ extensionKey, location, }: TrackAppAccountConnectedProps) => AnalyticsPayload;
+export declare const trackSmartLinkQuickActionStarted: ({ smartLinkActionType, ...attributes }: CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType | TrackQuickActionType;
+}) => AnalyticsPayload;
+export declare const trackSmartLinkQuickActionSuccess: ({ smartLinkActionType, ...attributes }: CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType | TrackQuickActionType;
+}) => AnalyticsPayload;
+export declare const trackSmartLinkQuickActionFailed: ({ smartLinkActionType, ...attributes }: CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType | TrackQuickActionType;
+}) => AnalyticsPayload;
+export declare const trackHoverCardResolutionStarted: ({ display, ...attributes }: UiAuthEventProps) => AnalyticsPayload;
+export declare const uiAuthEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, display, }: UiAuthEventProps) => AnalyticsPayload;
+export declare const uiAuthAlternateAccountEvent: ({ definitionId, extensionKey, destinationProduct, destinationSubproduct, location, display, }: UiAuthAlternateAccountEventProps) => AnalyticsPayload;
+export declare const uiCardClickedEvent: ({ id, display, status, definitionId, extensionKey, isModifierKeyPressed, location, destinationProduct, destinationSubproduct, actionSubjectId, }: UiCardClickedEventProps) => AnalyticsPayload;
+export declare const uiIframeDwelledEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, dwellTime, dwellPercentVisible, }: UiIframeDwelledEventProps) => AnalyticsPayload;
+export declare const uiIframeFocusedEvent: ({ id, display, status, definitionId, extensionKey, location, destinationProduct, destinationSubproduct, }: UiIframeFocusedEventProps) => AnalyticsPayload;
+export declare const uiActionClickedEvent: ({ id, actionType, extensionKey, display, definitionId, destinationProduct, destinationSubproduct, location, }: UiActionClickedEventProps) => AnalyticsPayload;
+export declare const uiClosedAuthEvent: ({ display, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiClosedAuthEventProps) => AnalyticsPayload;
+export declare const screenAuthPopupEvent: ({ extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: ScreenAuthPopupEventProps) => AnalyticsPayload;
+export declare const uiRenderSuccessEvent: ({ display, status, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, canBeDatasource, }: UiRenderSuccessEventProps) => AnalyticsPayload;
+export declare const uiRenderFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderFailedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardViewedEvent: ({ id, previewDisplay, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, status, }: UiHoverCardViewedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardDismissedEvent: ({ id, previewDisplay, hoverTime, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, status, }: UiHoverCardDismissedEventProps) => AnalyticsPayload;
+export declare const uiHoverCardOpenLinkClickedEvent: ({ id, previewDisplay, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, previewInvokeMethod, }: UiHoverCardOpenLinkClickedEventProps) => AnalyticsPayload;
+export declare const uiLearnMoreLinkClickedEvent: () => AnalyticsPayload;
+export declare const chunkloadFailedEvent: ({ display, error, errorInfo, extensionKey, definitionId, destinationProduct, destinationSubproduct, location, }: UiRenderFailedEventProps) => AnalyticsPayload;
+export declare const uiSmartLinkStatusLozengeButtonClicked: () => AnalyticsPayload;
+export declare const uiSmartLinkStatusListItemButtonClicked: () => AnalyticsPayload;
+export declare const uiSmartLinkStatusOpenPreviewButtonClicked: () => AnalyticsPayload;
+export declare const uiServerActionClicked: ({ smartLinkActionType, }: UiServerActionClickedEventProps) => AnalyticsPayload;

package/dist/types-ts4.5/utils/analytics/click.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { AnalyticsEventPayload, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { GasPayload } from '@atlaskit/analytics-gas-types';
+import { ClickOutcome, ClickType, UiLinkClickedEventProps } from './types';
+import { AnalyticsPayload } from '../types';
+export declare const buttonMap: Map<number | undefined, "left" | "right" | "none" | "middle">;
+export declare const getKeys: (e: React.MouseEvent) => ("meta" | "alt" | "shift" | "ctrl")[];
+export declare function getLinkClickOutcome(e: React.MouseEvent, clickType: ClickType): ClickOutcome;
+export declare const createLinkClickedPayload: (event: React.MouseEvent) => AnalyticsPayload | undefined;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare const fireLinkClickedEvent: (createAnalyticsEvent: (payload: AnalyticsEventPayload) => UIAnalyticsEvent) => (event: React.MouseEvent, overrides?: DeepPartial<Omit<GasPayload, 'attributes'> & {
+    attributes: UiLinkClickedEventProps;
+}>) => void;
+export declare function withLinkClickedEvent<Component extends React.ElementType<{
+    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLAnchorElement>;
+}>>(WrappedComponent: Component): {
+    (props: React.ComponentProps<Component>): React.ReactElement<{
+        onClick?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+        onMouseDown?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
+    }, string | React.JSXElementConstructor<any>>;
+    displayName: string;
+};
+export {};

package/dist/types-ts4.5/utils/analytics/index.d.ts

@@ -0,0 +1,4 @@
+import { AnalyticsPayload } from '../types';
+import { InstrumentEventProps } from './types';
+export { ANALYTICS_CHANNEL, context, fireSmartLinkEvent, resolvedEvent, unresolvedEvent, invokeSucceededEvent, invokeFailedEvent, chunkloadFailedEvent, connectSucceededEvent, connectFailedEvent, trackAppAccountAuthStarted, trackAppAccountConnected, uiAuthEvent, uiAuthAlternateAccountEvent, uiCardClickedEvent, uiActionClickedEvent, uiClosedAuthEvent, screenAuthPopupEvent, uiRenderSuccessEvent, uiRenderFailedEvent, uiHoverCardViewedEvent, uiHoverCardDismissedEvent, uiHoverCardOpenLinkClickedEvent, uiLearnMoreLinkClickedEvent, uiIframeDwelledEvent, uiSmartLinkStatusLozengeButtonClicked, uiSmartLinkStatusListItemButtonClicked, uiSmartLinkStatusOpenPreviewButtonClicked, } from './analytics';
+export declare const instrumentEvent: ({ id, status, extensionKey, definitionId, resourceType, destinationProduct, destinationSubproduct, location, error, }: InstrumentEventProps) => AnalyticsPayload | undefined;

package/dist/types-ts4.5/utils/analytics/types.d.ts

@@ -0,0 +1,136 @@
+import { APIError, CardType } from '@atlaskit/linking-common';
+import { SmartLinkActionType } from '@atlaskit/linking-types';
+import { PreviewDisplay, PreviewInvokeMethod } from '../../view/HoverCard/types';
+import { ErrorInfo } from 'react';
+import { CardInnerAppearance } from '../../view/Card/types';
+import { InvokeType } from '../../model/invoke-opts';
+export type DestinationProduct = 'jira' | 'confluence' | 'bitbucket' | 'trello';
+export type DestinationSubproduct = 'core' | 'software' | 'servicedesk';
+export interface CommonEventProps {
+    id?: string;
+    definitionId?: string;
+    extensionKey?: string;
+    resourceType?: string;
+    destinatinoObjectType?: string;
+    destinationSubproduct?: DestinationSubproduct | string;
+    destinationProduct?: DestinationProduct | string;
+    location?: string;
+    statusDetails?: string;
+}
+export type ResolvedEventProps = CommonEventProps & {
+    id: string;
+};
+export type UnresolvedEventProps = CommonEventProps & {
+    id: string;
+    status: string;
+    error?: APIError;
+};
+export type InvokeSucceededEventProps = CommonEventProps & {
+    id?: string;
+    actionType: string;
+    display?: CardInnerAppearance;
+};
+export type InvokeFailedEventProps = CommonEventProps & {
+    id?: string;
+    actionType: string;
+    display?: CardInnerAppearance;
+    reason: string;
+};
+export type ConnectSucceededEventProps = CommonEventProps & {
+    id?: string;
+};
+export type ConnectFailedEventProps = CommonEventProps & {
+    id?: string;
+    reason?: string;
+};
+export type TrackAppAccountConnectedProps = CommonEventProps;
+export type UiAuthEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export type UiAuthAlternateAccountEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export type UiCardClickedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+    isModifierKeyPressed?: boolean;
+    actionSubjectId?: string;
+};
+export type UiIframeDwelledEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+    dwellTime: number;
+    dwellPercentVisible: number;
+};
+export type UiIframeFocusedEventProps = CommonEventProps & {
+    id: string;
+    display: CardInnerAppearance;
+    status: CardType;
+};
+export type UiActionClickedEventProps = CommonEventProps & {
+    id?: string;
+    display?: CardInnerAppearance;
+    actionType: string;
+    invokeType?: InvokeType;
+};
+export type UiServerActionClickedEventProps = CommonEventProps & {
+    smartLinkActionType: SmartLinkActionType;
+};
+export type ScreenAuthPopupEventProps = CommonEventProps;
+export type UiClosedAuthEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+};
+export type UiRenderSuccessEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+    status: CardType;
+    canBeDatasource?: boolean;
+};
+export type UiRenderFailedEventProps = CommonEventProps & {
+    display: CardInnerAppearance;
+    error: Error;
+    errorInfo: ErrorInfo;
+};
+export type UiHoverCardViewedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    previewInvokeMethod?: PreviewInvokeMethod;
+    status: CardType;
+};
+export type UiHoverCardDismissedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    hoverTime: number;
+    previewInvokeMethod?: PreviewInvokeMethod;
+    status: CardType;
+};
+export type UiHoverCardOpenLinkClickedEventProps = CommonEventProps & {
+    previewDisplay: PreviewDisplay;
+    previewInvokeMethod?: PreviewInvokeMethod;
+};
+export type InstrumentEventProps = CommonEventProps & {
+    error?: APIError;
+    status: CardType;
+    id: string;
+};
+export type ClickType = 'left' | 'middle' | 'right' | 'keyboard' | 'none';
+export type ClickOutcome = 'prevented' | 'clickThrough' | 'clickThroughNewTabOrWindow' | 'contextMenu' | 'alt' | 'contentEditable' | 'unknown';
+export type UiLinkClickedEventProps = {
+    /**
+     * Whether the click occurred with the left, middle or right mouse button
+     */
+    clickType: ClickType;
+    /**
+     * The user outcome for clicking the link as far as can be reasonably be determined
+     * This ignores any programmatic cancellation of the outcome (ie e.preventDefault()) and
+     * thus this represents the user intent, not necessarily the actual outcome
+     */
+    clickOutcome: ClickOutcome;
+    /**
+     * The keys held by the user at the time of clicking the link (which influence `clickOutcome`)
+     */
+    keysHeld: ('alt' | 'ctrl' | 'meta' | 'shift')[];
+    /**
+     * Whether the browser's default behaviour was prevented programmatically
+     */
+    defaultPrevented: boolean;
+};

package/dist/types-ts4.5/utils/flexible.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare const isFlexibleUiCard: (children?: React.ReactNode) => boolean;
+export declare const isFlexibleUiBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiElement: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiTitleBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiPreviewBlock: (node: React.ReactNode) => boolean;
+export declare const isFlexibleUiFooterBlock: (node: React.ReactNode) => boolean;