@player-ui/react 0.3.0-next.3 → 0.3.0-next.5

package/dist/index.cjs.js

@@ -2,20 +2,119 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var React = require('react');
 var player = require('@player-ui/player');
-var reactAsset = require('@player-ui/react-asset');
-var reactErrorBoundary = require('react-error-boundary');
-var reactUtils = require('@player-ui/react-utils');
+var React = require('react');
 var tapableTs = require('tapable-ts');
 var reactSubscribe = require('@player-ui/react-subscribe');
 var partialMatchRegistry = require('@player-ui/partial-match-registry');
+var reactErrorBoundary = require('react-error-boundary');
 var metricsPlugin = require('@player-ui/metrics-plugin');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+const AssetContext = React__default["default"].createContext({});
+const ReactAsset = (props) => {
+  const { registry } = React__default["default"].useContext(AssetContext);
+  let unwrapped;
+  if ("type" in props && "id" in props) {
+    unwrapped = props;
+  } else if ("asset" in props) {
+    unwrapped = props.asset;
+  }
+  if (!unwrapped || typeof unwrapped !== "object" || (unwrapped == null ? void 0 : unwrapped.type) === void 0) {
+    throw Error(`Cannot determine asset type.`);
+  }
+  const Impl = registry == null ? void 0 : registry.get(unwrapped);
+  if (!Impl) {
+    throw Error(`No implementation found for id: ${unwrapped.id} type: ${unwrapped.type}`);
+  }
+  return /* @__PURE__ */ React__default["default"].createElement(Impl, __spreadValues$3({}, unwrapped));
+};
+
+const PlayerContext = React__default["default"].createContext({});
+const usePlayer = () => {
+  const { player } = React__default["default"].useContext(PlayerContext);
+  return player;
+};
+
+const noopLogger = new player.NoopLogger();
+function useLogger() {
+  var _a;
+  const player = usePlayer();
+  return (_a = player == null ? void 0 : player.logger) != null ? _a : noopLogger;
+}
+
+function useAssetProps(asset) {
+  return {
+    id: asset.id,
+    "data-asset-type": asset.type
+  };
+}
+
+function trimSlashes(str) {
+  return str.replace(/^\/+|\/+$/g, "");
+}
+function removeEmptyValuesFromObject(obj) {
+  return Object.keys(obj).reduce((acc, key) => {
+    const value = obj[key];
+    if (value !== null && value !== void 0) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+}
+function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0 && obj.constructor === Object;
+}
+function isFunction(maybeFn) {
+  return Boolean(maybeFn instanceof Function || typeof maybeFn === "function");
+}
+function callOrReturn(maybeFn, fnArgs) {
+  if (isFunction(maybeFn)) {
+    return maybeFn(fnArgs);
+  }
+  return maybeFn;
+}
+
+function buildUrl(url, params = {}) {
+  const baseUrl = new URL(url);
+  if (params && isEmptyObject(params)) {
+    return baseUrl.toString();
+  }
+  Object.keys(params).forEach((key) => {
+    const value = params[key];
+    baseUrl.searchParams.append(key, String(value));
+  });
+  return baseUrl.toString();
+}
+
+function useGetConstantByType(type, key) {
+  const player = usePlayer();
+  return player == null ? void 0 : player.constantsController.getConstants(key, type);
+}
+function useGetConstant(key) {
+  const player = usePlayer();
+  return player == null ? void 0 : player.constantsController.getConstants(key, "constants");
+}
+
 var __defProp$2 = Object.defineProperty;
 var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
 var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
@@ -32,8 +131,8 @@ var __spreadValues$2 = (a, b) => {
     }
   return a;
 };
-const WebPlayer$1 = ({ view }) => {
-  return /* @__PURE__ */ React__default["default"].createElement("div", null, /* @__PURE__ */ React__default["default"].createElement(reactAsset.Asset, __spreadValues$2({}, view)));
+const ReactPlayer$1 = ({ view }) => {
+  return /* @__PURE__ */ React__default["default"].createElement(ReactAsset, __spreadValues$2({}, view));
 };
 
 class OnUpdatePlugin {
@@ -83,10 +182,10 @@ var __async$1 = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-const WEB_PLAYER_VERSION = "0.3.0-next.3";
-const COMMIT = "92ff0044b739d9cce3b1e37bd729f8241d04a2da";
+const WEB_PLAYER_VERSION = "0.3.0-next.5";
+const COMMIT = "2dcac81d456ce1e2953669f18e6c7c05cd763fd7";
 const _window = typeof window === "undefined" ? void 0 : window;
-class WebPlayer {
+class ReactPlayer {
   constructor(options) {
     this.assetRegistry = new partialMatchRegistry.Registry();
     this.hooks = {
@@ -109,24 +208,24 @@ class WebPlayer {
     const playerPlugins = plugins.filter((p) => Boolean(p.apply));
     this.player = (_b = options == null ? void 0 : options.player) != null ? _b : new player.Player({ plugins: playerPlugins });
     plugins.forEach((plugin) => {
-      if (plugin.applyWeb) {
-        plugin.applyWeb(this);
+      if (plugin.applyReact) {
+        plugin.applyReact(this);
       }
     });
     onUpdatePlugin.apply(this.player);
     this.Component = this.hooks.webComponent.call(this.createReactComp());
-    this.webplayerInfo = {
+    this.reactPlayerInfo = {
       playerVersion: this.player.getVersion(),
       playerCommit: this.player.getCommit(),
-      webplayerVersion: WEB_PLAYER_VERSION,
-      webplayerCommit: COMMIT
+      reactPlayerVersion: WEB_PLAYER_VERSION,
+      reactPlayerCommit: COMMIT
     };
   }
   getPlayerVersion() {
-    return this.webplayerInfo.playerVersion;
+    return this.reactPlayerInfo.playerVersion;
   }
   getPlayerCommit() {
-    return this.webplayerInfo.playerCommit;
+    return this.reactPlayerInfo.playerCommit;
   }
   findPlugin(symbol) {
     var _a;
@@ -134,20 +233,20 @@ class WebPlayer {
   }
   registerPlugin(plugin) {
     var _a;
-    if (!plugin.applyWeb)
+    if (!plugin.applyReact)
       return;
-    plugin.applyWeb(this);
+    plugin.applyReact(this);
     (_a = this.options.plugins) == null ? void 0 : _a.push(plugin);
   }
-  getWebPlayerVersion() {
-    return this.webplayerInfo.webplayerVersion;
+  getReactPlayerVersion() {
+    return this.reactPlayerInfo.reactPlayerVersion;
   }
-  getWebPlayerCommit() {
-    return this.webplayerInfo.webplayerCommit;
+  getReactPlayerCommit() {
+    return this.reactPlayerInfo.reactPlayerCommit;
   }
   createReactComp() {
-    const ActualPlayerComp = this.hooks.playerComponent.call(WebPlayer$1);
-    const WebPlayerComponent = () => {
+    const ActualPlayerComp = this.hooks.playerComponent.call(ReactPlayer$1);
+    const ReactPlayerComponent = () => {
       const view = reactSubscribe.useSubscribedState(this.viewUpdateSubscription);
       if (this.options.suspend) {
         this.viewUpdateSubscription.suspend();
@@ -160,9 +259,9 @@ class WebPlayer {
             playerState.fail(err);
           }
         }
-      }, /* @__PURE__ */ React__default["default"].createElement(reactUtils.PlayerContext.Provider, {
+      }, /* @__PURE__ */ React__default["default"].createElement(PlayerContext.Provider, {
         value: { player: this.player }
-      }, /* @__PURE__ */ React__default["default"].createElement(reactAsset.AssetContext.Provider, {
+      }, /* @__PURE__ */ React__default["default"].createElement(AssetContext.Provider, {
         value: {
           registry: this.assetRegistry
         }
@@ -170,7 +269,7 @@ class WebPlayer {
         view
       }))));
     };
-    return WebPlayerComponent;
+    return ReactPlayerComponent;
   }
   setWaitForNextViewUpdate() {
     const shouldCallResetHook = this.options.suspend && this.hooks.onBeforeViewReset.isUsed();
@@ -186,6 +285,7 @@ class WebPlayer {
     }));
   }
 }
+const WebPlayer = ReactPlayer;
 
 class StateTapPlugin {
   constructor(callback) {
@@ -199,11 +299,11 @@ class StateTapPlugin {
   }
 }
 
-const useWebPlayer = (options) => {
+const useReactPlayer = (options) => {
   const [playerState, setPlayerState] = React__default["default"].useState(player.NOT_STARTED_STATE);
-  const webPlayer = React__default["default"].useMemo(() => {
+  const reactPlayer = React__default["default"].useMemo(() => {
     var _a;
-    const wp = new WebPlayer({
+    const rp = new ReactPlayer({
       player: options == null ? void 0 : options.player,
       plugins: [
         ...(_a = options == null ? void 0 : options.plugins) != null ? _a : [],
@@ -211,11 +311,11 @@ const useWebPlayer = (options) => {
       ],
       suspend: options == null ? void 0 : options.suspend
     });
-    return wp;
+    return rp;
   }, []);
-  const { player: player$1 } = webPlayer;
+  const { player: player$1 } = reactPlayer;
   return {
-    webPlayer,
+    reactPlayer,
     player: player$1,
     playerState
   };
@@ -338,7 +438,7 @@ class ManagedState {
       value: "not_started",
       context: {
         playerConfig,
-        webPlayer: new WebPlayer(playerConfig),
+        reactPlayer: new ReactPlayer(playerConfig),
         manager: options.manager
       }
     };
@@ -357,14 +457,14 @@ class ManagedState {
   restart() {
     var _a;
     if (((_a = this.state) == null ? void 0 : _a.value) === "error") {
-      const { playerConfig, manager, prevResult, webPlayer } = this.state.context;
+      const { playerConfig, manager, prevResult, reactPlayer } = this.state.context;
       this.setState({
         value: "completed",
         context: {
           playerConfig,
           manager,
           result: prevResult,
-          webPlayer
+          reactPlayer
         }
       });
     } else {
@@ -377,11 +477,11 @@ class ManagedState {
       this.callbacks.forEach((c) => {
         c.onState(state);
       });
-      const { manager, webPlayer, playerConfig } = state.context;
+      const { manager, reactPlayer, playerConfig } = state.context;
       try {
         const nextState = yield this.processState(state, {
           manager,
-          webPlayer,
+          reactPlayer,
           playerConfig
         });
         if (nextState) {
@@ -392,7 +492,7 @@ class ManagedState {
           value: "error",
           context: {
             manager,
-            webPlayer,
+            reactPlayer,
             playerConfig,
             error: e
           }
@@ -438,7 +538,7 @@ class ManagedState {
           context: __spreadProps(__spreadValues({}, context), {
             flow: state.context.flow,
             prevResult: state.context.prevResult,
-            result: state.context.webPlayer.start(state.context.flow)
+            result: state.context.reactPlayer.start(state.context.flow)
           })
         };
       }
@@ -500,12 +600,12 @@ const ManagedPlayer = (props) => {
   React__default["default"].useEffect(() => {
     return () => {
       var _a2, _b;
-      const playerState = state == null ? void 0 : state.context.webPlayer.player.getState();
+      const playerState = state == null ? void 0 : state.context.reactPlayer.player.getState();
       if ((state == null ? void 0 : state.value) === "running" && (playerState == null ? void 0 : playerState.status) === "in-progress") {
         (_b = (_a2 = props.manager).terminate) == null ? void 0 : _b.call(_a2, playerState.controllers.data.serialize());
       }
     };
-  }, [props.manager, state == null ? void 0 : state.context.webPlayer.player, state == null ? void 0 : state.value]);
+  }, [props.manager, state == null ? void 0 : state.context.reactPlayer.player, state == null ? void 0 : state.value]);
   if ((state == null ? void 0 : state.value) === "error") {
     if (props.fallbackComponent) {
       return /* @__PURE__ */ React__default["default"].createElement(props.fallbackComponent, {
@@ -522,18 +622,33 @@ const ManagedPlayer = (props) => {
       throw state.context.error;
     }
   }
-  if (state == null ? void 0 : state.context.webPlayer) {
-    const { Component } = state.context.webPlayer;
+  if (state == null ? void 0 : state.context.reactPlayer) {
+    const { Component } = state.context.reactPlayer;
     return /* @__PURE__ */ React__default["default"].createElement(Component, null);
   }
   return null;
 };
 
+exports.AssetContext = AssetContext;
 exports.ManagedPlayer = ManagedPlayer;
+exports.PlayerContext = PlayerContext;
+exports.ReactAsset = ReactAsset;
+exports.ReactPlayer = ReactPlayer;
 exports.WebPlayer = WebPlayer;
+exports.buildUrl = buildUrl;
+exports.callOrReturn = callOrReturn;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.removeEmptyValuesFromObject = removeEmptyValuesFromObject;
+exports.trimSlashes = trimSlashes;
+exports.useAssetProps = useAssetProps;
+exports.useGetConstant = useGetConstant;
+exports.useGetConstantByType = useGetConstantByType;
+exports.useLogger = useLogger;
 exports.usePersistentStateMachine = usePersistentStateMachine;
+exports.usePlayer = usePlayer;
+exports.useReactPlayer = useReactPlayer;
 exports.useRequestTime = useRequestTime;
-exports.useWebPlayer = useWebPlayer;
 Object.keys(player).forEach(function (k) {
   if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/dist/index.d.ts

@@ -1,61 +1,74 @@
-import React from 'react';
 import * as _player_ui_player from '@player-ui/player';
-import { Asset, PlayerPlugin, Player, Flow, CompletedState, PlayerFlowState, FlowResult } 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 { AssetRegistryType } from '@player-ui/react-asset';
+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';
 
-interface WebPlayerProps {
+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: Asset;
+    view: View;
 }
 
 interface DevtoolsGlobals {
     /** A global for a plugin to load to Player for devtools */
     __PLAYER_DEVTOOLS_PLUGIN?: {
-        new (): WebPlayerPlugin;
+        new (): ReactPlayerPlugin;
     };
 }
 declare type DevtoolsWindow = typeof window & DevtoolsGlobals;
-interface WebPlayerInfo {
+interface ReactPlayerInfo {
     /** Version of the running player */
     playerVersion: string;
-    /** Version of the running webplayer */
-    webplayerVersion: 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 webplayer version */
-    webplayerCommit: string;
+    /** Hash of the HEAD commit used to build the current reactPlayer version */
+    reactPlayerCommit: string;
 }
-interface WebPlayerPlugin extends Partial<PlayerPlugin> {
+interface ReactPlayerPlugin extends Partial<PlayerPlugin> {
     /** The name of this plugin */
     name: string;
     /**
      * Attach listeners to the web-player instance
      */
-    applyWeb?: (webPlayer: WebPlayer) => void;
+    applyReact?: (reactPlayer: ReactPlayer) => void;
 }
-interface WebPlayerOptions {
+interface ReactPlayerOptions {
     /** A headless player instance to use */
     player?: Player;
     /** A set of plugins to apply to this player */
-    plugins?: Array<WebPlayerPlugin>;
+    plugins?: Array<ReactPlayerPlugin>;
     /**
-     * If the underlying webPlayer.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 `webPlayer.Component` hierarchy.
+     * 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 WebPlayerComponentProps = Record<string, unknown>;
-/** The React webplayer */
-declare class WebPlayer {
-    readonly options: WebPlayerOptions;
+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<WebPlayerComponentProps>;
+    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
@@ -66,49 +79,50 @@ declare class WebPlayer {
          * It will be called for each view update from the core player.
          * Typically this will just be `Asset`
          */
-        playerComponent: SyncWaterfallHook<[React.ComponentType<WebPlayerProps>], Record<string, any>>;
+        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 webplayerInfo;
-    constructor(options?: WebPlayerOptions);
+    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 WebPlayerPlugin>(symbol: symbol): Plugin | undefined;
+    findPlugin<Plugin extends ReactPlayerPlugin>(symbol: symbol): Plugin | undefined;
     /** Register and apply [Plugin] if one with the same symbol is not already registered. */
-    registerPlugin(plugin: WebPlayerPlugin): void;
+    registerPlugin(plugin: ReactPlayerPlugin): void;
     /** Returns the current version of the running React Player */
-    getWebPlayerVersion(): string;
+    getReactPlayerVersion(): string;
     /** Returns the git commit used to build the React Player version */
-    getWebPlayerCommit(): string;
+    getReactPlayerCommit(): string;
     private createReactComp;
     /**
-     * Call this method to force the WebPlayer to wait for the next view-update before performing the next render.
+     * 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 UseWebPlayerReturn {
+interface UseReactPlayerReturn {
     /** The web-player instance */
-    webPlayer: WebPlayer;
+    reactPlayer: ReactPlayer;
     /** Player instance */
     player: Player;
     /** The state of Player */
     playerState: PlayerFlowState;
 }
 /**
- * The `useWebPlayer` hook is an easy way to integrate the web-player into your React app.
+ * 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 useWebPlayer: (options?: WebPlayerOptions | undefined) => UseWebPlayerReturn;
+declare const useReactPlayer: (options?: ReactPlayerOptions | undefined) => UseReactPlayerReturn;
 
 interface FinalState {
     /** Mark the iteration as complete */
@@ -143,7 +157,7 @@ interface FallbackProps {
     /** The error that caused the failure */
     error?: Error;
 }
-interface ManagedPlayerProps extends WebPlayerOptions {
+interface ManagedPlayerProps extends ReactPlayerOptions {
     /** The manager for populating the next flows */
     manager: FlowManager;
     /** A callback when a flow is started */
@@ -159,9 +173,9 @@ declare type ManagedPlayerContext = {
     /** The flow manager */
     manager: FlowManager;
     /** The web-player */
-    webPlayer: WebPlayer;
+    reactPlayer: ReactPlayer;
     /** The config for Player */
-    playerConfig: WebPlayerOptions;
+    playerConfig: ReactPlayerOptions;
 };
 declare type ManagedPlayerState = {
     /** The managed player hasn't started yet */
@@ -254,7 +268,7 @@ declare class ManagedState {
         /** the flow manager to use */
         manager: FlowManager;
         /** the config to use when creating a player */
-        playerConfig: WebPlayerOptions;
+        playerConfig: ReactPlayerOptions;
     }): this;
     /** reset starts from nothing */
     reset(): void;
@@ -268,7 +282,7 @@ declare const usePersistentStateMachine: (options: {
     /** the flow manager to use */
     manager: FlowManager;
     /** Player config  */
-    playerConfig: WebPlayerOptions;
+    playerConfig: ReactPlayerOptions;
     /** Any middleware for the manager */
     middleware?: ManagerMiddleware;
 }) => {
@@ -324,7 +338,59 @@ 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: WebPlayerPlugin;
+    RequestTimeMetricsPlugin: ReactPlayerPlugin;
 };
 
-export { DevtoolsGlobals, DevtoolsWindow, FallbackProps, FinalState, FlowManager, ManagedPlayer, ManagedPlayerContext, ManagedPlayerProps, ManagedPlayerState, ManagerMiddleware, NextState, StateChangeCallback, UseWebPlayerReturn, WebPlayer, WebPlayerComponentProps, WebPlayerInfo, WebPlayerOptions, WebPlayerPlugin, usePersistentStateMachine, useRequestTime, useWebPlayer };
+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 };