@player-ui/react 0.8.0--canary.307.9621 → 0.8.0-next.0

package/dist/index.d.ts

@@ -1,397 +0,0 @@
-import * as _player_ui_player from '@player-ui/player';
-import { Asset, AssetWrapper, View, PlayerPlugin, Player, Flow, CompletedState, PlayerFlowState, FlowResult, NavigationFlowViewState, Logger } from '@player-ui/player';
-export * from '@player-ui/player';
-import React from 'react';
-import { SyncWaterfallHook, AsyncParallelHook } from 'tapable-ts';
-import { Registry } from '@player-ui/partial-match-registry';
-import * as _player_ui_types from '@player-ui/types';
-
-declare type AssetRegistryType = Registry<React.ComponentType<any>>;
-interface ContextType {
-    /**
-     * A registry of Asset -> React Components
-     */
-    registry?: AssetRegistryType;
-}
-declare const AssetContext: React.Context<ContextType>;
-/**
- * A React Component that looks up an implementation from a registry
- */
-declare const ReactAsset: (props: Asset<string> | AssetWrapper<Asset<string>>) => JSX.Element;
-
-interface ReactPlayerProps {
-    /**
-     * The Content view object to render
-     */
-    view: View;
-}
-
-interface DevtoolsGlobals {
-    /** A global for a plugin to load to Player for devtools */
-    __PLAYER_DEVTOOLS_PLUGIN?: {
-        new (): ReactPlayerPlugin;
-    };
-}
-declare type DevtoolsWindow = typeof window & DevtoolsGlobals;
-interface ReactPlayerInfo {
-    /** Version of the running player */
-    playerVersion: string;
-    /** Version of the running reactPlayer */
-    reactPlayerVersion: string;
-    /** Hash of the HEAD commit used to build the current player version */
-    playerCommit: string;
-    /** Hash of the HEAD commit used to build the current reactPlayer version */
-    reactPlayerCommit: string;
-}
-interface ReactPlayerPlugin extends Partial<PlayerPlugin> {
-    /** The name of this plugin */
-    name: string;
-    /**
-     * Attach listeners to the web-player instance
-     */
-    applyReact?: (reactPlayer: ReactPlayer) => void;
-}
-interface ReactPlayerOptions {
-    /** A headless player instance to use */
-    player?: Player;
-    /** A set of plugins to apply to this player */
-    plugins?: Array<ReactPlayerPlugin>;
-    /**
-     * If the underlying reactPlayer.Component should use `React.Suspense` to trigger a loading state while waiting for content or content updates.
-     * It requires that a `React.Suspense` component handler be somewhere in the `reactPlayer.Component` hierarchy.
-     */
-    suspend?: boolean;
-}
-declare type ReactPlayerComponentProps = Record<string, unknown>;
-/** A Player that renders UI through React */
-declare class ReactPlayer {
-    readonly options: ReactPlayerOptions;
-    readonly player: Player;
-    readonly assetRegistry: AssetRegistryType;
-    readonly Component: React.ComponentType<ReactPlayerComponentProps>;
-    readonly hooks: {
-        /**
-         * A hook to create a React Component to be used for Player, regardless of the current flow state
-         */
-        webComponent: SyncWaterfallHook<[React.ComponentType<{}>], Record<string, any>>;
-        /**
-         * A hook to create a React Component that's used to render a specific view.
-         * It will be called for each view update from the core player.
-         * Typically this will just be `Asset`
-         */
-        playerComponent: SyncWaterfallHook<[React.ComponentType<ReactPlayerProps>], Record<string, any>>;
-        /**
-         * A hook to execute async tasks before the view resets to undefined
-         */
-        onBeforeViewReset: AsyncParallelHook<[], Record<string, any>>;
-    };
-    private viewUpdateSubscription;
-    private reactPlayerInfo;
-    constructor(options?: ReactPlayerOptions);
-    /** Returns the current version of the underlying core Player */
-    getPlayerVersion(): string;
-    /** Returns the git commit used to build this core Player version */
-    getPlayerCommit(): string;
-    /** Find instance of [Plugin] that has been registered to the web player */
-    findPlugin<Plugin extends ReactPlayerPlugin>(symbol: symbol): Plugin | undefined;
-    /** Register and apply [Plugin] if one with the same symbol is not already registered. */
-    registerPlugin(plugin: ReactPlayerPlugin): void;
-    /** Returns the current version of the running React Player */
-    getReactPlayerVersion(): string;
-    /** Returns the git commit used to build the React Player version */
-    getReactPlayerCommit(): string;
-    private createReactPlayerComponent;
-    private createReactComp;
-    /**
-     * Call this method to force the ReactPlayer to wait for the next view-update before performing the next render.
-     * If the `suspense` option is set, this will suspend while an update is pending, otherwise nothing will be rendered.
-     */
-    setWaitForNextViewUpdate(): Promise<void>;
-    start(flow: Flow): Promise<CompletedState>;
-}
-declare const WebPlayer: typeof ReactPlayer;
-
-interface UseReactPlayerReturn {
-    /** The web-player instance */
-    reactPlayer: ReactPlayer;
-    /** Player instance */
-    player: Player;
-    /** The state of Player */
-    playerState: PlayerFlowState;
-}
-/**
- * The `useReactPlayer` hook is an easy way to integrate the web-player into your React app.
- * Simply supply your config, plugins, and an optional flow, which will be automatically started for you when changed.
- */
-declare const useReactPlayer: (options?: ReactPlayerOptions | undefined) => UseReactPlayerReturn;
-
-interface FinalState {
-    /** Mark the iteration as complete */
-    done: true;
-}
-interface NextState<T> {
-    /** Optional mark the iteration as _not_ completed */
-    done?: false;
-    /** The next value in the iteration */
-    value: T;
-}
-interface FlowManager {
-    /**
-     * An iterator implementation that takes the result of the previous flow and returns a new one or completion marker.
-     *
-     * If `done: true` is passed, the multi-flow experience is completed.
-     *
-     * @param previousValue - The result of the previous flow.
-     */
-    next: (previousValue?: CompletedState) => Promise<FinalState | NextState<Flow>>;
-    /**
-     * Called when the flow is ended early (the react tree is torn down)
-     * Allows clients the opportunity to save-data before destroying the tree
-     */
-    terminate?: (data?: FlowResult['data']) => void;
-}
-interface FallbackProps {
-    /** A callback to reset the flow iteration from the start */
-    reset?: () => void;
-    /** A callback to retry the last failed segment of the iteration */
-    retry?: () => void;
-    /** The error that caused the failure */
-    error?: Error;
-}
-interface ManagedPlayerProps extends ReactPlayerOptions {
-    /** The manager for populating the next flows */
-    manager: FlowManager;
-    /** A callback when a flow is started */
-    onStartedFlow?: () => void;
-    /** A callback when the entire async iteration is completed */
-    onComplete?: (finalState?: CompletedState) => void;
-    /** A callback for any errors */
-    onError?: (e: Error) => void;
-    /** A component to render when there are errors */
-    fallbackComponent?: React.ComponentType<FallbackProps>;
-}
-declare type ManagedPlayerContext = {
-    /** The flow manager */
-    manager: FlowManager;
-    /** The web-player */
-    reactPlayer: ReactPlayer;
-    /** The config for Player */
-    playerConfig: ReactPlayerOptions;
-};
-declare type ManagedPlayerState = {
-    /** The managed player hasn't started yet */
-    value: 'not_started';
-    /** The context for the managed state */
-    context: ManagedPlayerContext;
-} | {
-    /** The managed-player is awaiting a response from the flow manager */
-    value: 'pending';
-    /** The context for the managed state */
-    context: ManagedPlayerContext & {
-        /** The previous completed state */
-        prevResult?: CompletedState;
-        /** A promise from the flow manager for the next state */
-        next: Promise<FinalState | NextState<Flow>>;
-    };
-} | {
-    /** A flow was retrieved from the flow manager, but hasn't been processed yet */
-    value: 'loaded';
-    /** The context for the managed state */
-    context: ManagedPlayerContext & {
-        /** The next flow to load */
-        flow: Flow;
-        /** The previous completed state */
-        prevResult?: CompletedState;
-    };
-} | {
-    /** Player is currently executing a flow */
-    value: 'running';
-    /** The context for the managed state */
-    context: ManagedPlayerContext & {
-        /** The currently running flow */
-        flow: Flow;
-        /** A promise for the completed result */
-        result: Promise<CompletedState>;
-        /** The previous completed result */
-        prevResult?: CompletedState;
-    };
-} | {
-    /** Player has completed a flow */
-    value: 'completed';
-    /** The context for the managed state */
-    context: ManagedPlayerContext & {
-        /** The result of the completed flow */
-        result?: CompletedState;
-    };
-} | {
-    /** The entire flow iteration has completed */
-    value: 'ended';
-    /** The context for the managed state */
-    context: ManagedPlayerContext & {
-        /** The result of the last completed flow */
-        result?: CompletedState;
-    };
-} | {
-    /** One of the steps in the flow has resulted in an error */
-    value: 'error';
-    /** The context for the managed state */
-    context: ManagedPlayerContext & {
-        /** The error that caused the flow to halt */
-        error: Error;
-        /** the result of the last completed flow */
-        prevResult?: CompletedState;
-    };
-};
-interface ManagerMiddleware {
-    /** Middleware for a response from the managed-player */
-    next?: <Type>(nextPromise: Promise<Type>) => Promise<Type>;
-}
-
-interface StateChangeCallback {
-    /** Trigger for state changes */
-    onState: (s: ManagedPlayerState) => void;
-}
-/**
- * An object to store the state of the managed player
- */
-declare class ManagedState {
-    state?: ManagedPlayerState;
-    private callbacks;
-    private middleware?;
-    constructor({ middleware, }: {
-        /** middleware to use in the managed player */
-        middleware?: ManagerMiddleware;
-    });
-    /** Add a listener to state changes */
-    addListener(callback: StateChangeCallback): () => void;
-    /** start the managed flow */
-    start(options: {
-        /** the flow manager to use */
-        manager: FlowManager;
-        /** the config to use when creating a player */
-        playerConfig: ReactPlayerOptions;
-    }): this;
-    /** reset starts from nothing */
-    reset(): void;
-    /** restart starts from the last result */
-    restart(): void;
-    private setState;
-    private processState;
-}
-/** Creates an x-state state machine that persists when this component is no longer renders (due to Suspense) */
-declare const usePersistentStateMachine: (options: {
-    /** the flow manager to use */
-    manager: FlowManager;
-    /** Player config  */
-    playerConfig: ReactPlayerOptions;
-    /** Any middleware for the manager */
-    middleware?: ManagerMiddleware;
-}) => {
-    managedState: ManagedState;
-    state: {
-        value: "not_started";
-        context: ManagedPlayerContext;
-    } | {
-        value: "pending";
-        context: ManagedPlayerContext & {
-            prevResult?: _player_ui_player.CompletedState | undefined;
-            next: Promise<FinalState | NextState<_player_ui_types.Flow<_player_ui_types.Asset<string>>>>;
-        };
-    } | {
-        value: "loaded";
-        context: ManagedPlayerContext & {
-            flow: _player_ui_types.Flow<_player_ui_types.Asset<string>>;
-            prevResult?: _player_ui_player.CompletedState | undefined;
-        };
-    } | {
-        value: "running";
-        context: ManagedPlayerContext & {
-            flow: _player_ui_types.Flow<_player_ui_types.Asset<string>>;
-            result: Promise<_player_ui_player.CompletedState>;
-            prevResult?: _player_ui_player.CompletedState | undefined;
-        };
-    } | {
-        value: "completed";
-        context: ManagedPlayerContext & {
-            result?: _player_ui_player.CompletedState | undefined;
-        };
-    } | {
-        value: "ended";
-        context: ManagedPlayerContext & {
-            result?: _player_ui_player.CompletedState | undefined;
-        };
-    } | {
-        value: "error";
-        context: ManagedPlayerContext & {
-            error: Error;
-            prevResult?: _player_ui_player.CompletedState | undefined;
-        };
-    } | undefined;
-};
-/**
- * A ManagedPlayer is a component responsible for orchestrating multi-flow experiences using Player.
- * Provide a valid `FlowManager` to handle fetching the next flow.
- *
- * `suspense` must be enabled to wait for results in flight.
- */
-declare const ManagedPlayer: (props: ManagedPlayerProps) => JSX.Element | null;
-
-/** hook to time a promise and add it to the metrics plugin */
-declare const useRequestTime: () => {
-    withRequestTime: <Type>(nextPromise: Promise<Type>) => Promise<Type>;
-    RequestTimeMetricsPlugin: ReactPlayerPlugin;
-};
-
-interface PlayerContextType {
-    /**
-     * An instance of a headless player
-     */
-    player?: Player;
-    /** The currently rendered view state */
-    viewState?: NavigationFlowViewState;
-}
-declare const PlayerContext: React.Context<PlayerContextType>;
-/**
- * A hook to get the current player
- */
-declare const usePlayer: () => Player | undefined;
-
-/**
- * A hook to get the logger instance from the current player
- */
-declare function useLogger(): Logger;
-
-/** Common props for any dom node */
-declare function useAssetProps(asset: Asset): {
-    id: string;
-    'data-asset-type': string;
-};
-
-/**
- * Trim leading and trailing slashes from string
- */
-declare function trimSlashes(str: string): string;
-/**
- * Removes any key: value pairs from an object when the value is null or undefined
- */
-declare function removeEmptyValuesFromObject(obj: Record<string, any>): Record<string, NonNullable<any>>;
-/** Check if the object has no keys */
-declare function isEmptyObject(obj: Record<string, unknown>): boolean;
-/** Check if the argument is a function */
-declare function isFunction<ReturnType>(maybeFn: ReturnType | ((...args: unknown[]) => ReturnType)): maybeFn is (...args: unknown[]) => ReturnType;
-/**
- * Calls function with provided data or returns original value
- */
-declare function callOrReturn<ReturnType, FnArgs extends Array<unknown> = unknown[], FnType = (...args: FnArgs) => ReturnType>(maybeFn: FnType | ReturnType, fnArgs: FnArgs): ReturnType;
-
-/**
- * Combines a URL with any additional parameters
- */
-declare function buildUrl(url: string, params?: Record<string, unknown>): string;
-
-/** Hook to get a constant under a specific namespace */
-declare function useGetConstantByType(type: string, key: string): unknown;
-/** Get a constant under the default namespace */
-declare function useGetConstant(key: string): unknown;
-
-export { AssetContext, AssetRegistryType, ContextType, DevtoolsGlobals, DevtoolsWindow, FallbackProps, FinalState, FlowManager, ManagedPlayer, ManagedPlayerContext, ManagedPlayerProps, ManagedPlayerState, ManagerMiddleware, NextState, PlayerContext, PlayerContextType, ReactAsset, ReactPlayer, ReactPlayerComponentProps, ReactPlayerInfo, ReactPlayerOptions, ReactPlayerPlugin, StateChangeCallback, UseReactPlayerReturn, WebPlayer, buildUrl, callOrReturn, isEmptyObject, isFunction, removeEmptyValuesFromObject, trimSlashes, useAssetProps, useGetConstant, useGetConstantByType, useLogger, usePersistentStateMachine, usePlayer, useReactPlayer, useRequestTime };