@flopflip/react-redux/dist/index.d.ts

A feature toggle wrapper to use LaunchDarkly with React Redux

import React from "react";
import { ReconfigureAdapter, TToggleFeatureProps, useAdapterReconfiguration } from "@flopflip/react";
import { TAdapter, TAdapterArgs, TAdapterIdentifiers, TAdaptersStatus, TConfigureAdapterChildren, TConfigureAdapterProps, TFlagName, TFlagVariation, TFlags, TFlagsContext } from "@flopflip/types";
import { Reducer, Store, StoreEnhancerStoreCreator } from "redux";

//#region src/branch-on-feature-toggle.d.ts
type TBranchOnFeatureToggleOptions = {
  flag: TFlagName;
  variation?: TFlagVariation;
};
declare function branchOnFeatureToggle<OwnProps extends Record<string, unknown>>({
  flag: flagName,
  variation: flagVariation
}: TBranchOnFeatureToggleOptions, UntoggledComponent?: React.ComponentType): (ToggledComponent: React.ComponentType<OwnProps>) => (ownProps: OwnProps) => React.JSX.Element | null;
//#endregion
//#region src/configure.d.ts
type TBaseProps = {
  readonly children?: TConfigureAdapterChildren;
  readonly shouldDeferAdapterConfiguration?: boolean;
  readonly defaultFlags?: TFlags;
};
type TProps$1<AdapterInstance extends TAdapter> = TBaseProps & TConfigureAdapterProps<AdapterInstance>;
declare function Configure<AdapterInstance extends TAdapter>({
  adapter,
  adapterArgs,
  children,
  defaultFlags,
  shouldDeferAdapterConfiguration
}: TProps$1<AdapterInstance>): React.JSX.Element;
declare namespace Configure {
  var displayName: string;
}
//#endregion
//#region src/constants.d.ts
declare const STATE_SLICE = "@flopflip";
//#endregion
//#region src/types.d.ts
type TState = {
  [STATE_SLICE]: {
    flags?: TFlagsContext;
    status?: TAdaptersStatus;
  };
};
//#endregion
//#region src/ducks/flags.d.ts
declare const selectFlags: () => (state: TState) => TFlagsContext;
declare const selectFlag: (flagName: TFlagName, adapterIdentifiers: TAdapterIdentifiers[]) => (state: TState) => TFlagVariation;
//#endregion
//#region src/ducks/index.d.ts
declare const flopflipReducer: import("redux").Reducer<{
  flags: TFlagsContext;
  status: import("@flopflip/types").TAdaptersStatus;
}, import("redux").UnknownAction, Partial<{
  flags: TFlagsContext | undefined;
  status: import("@flopflip/types").TAdaptersStatus | undefined;
}>>;
declare const createFlopflipReducer: (preloadedState?: TFlagsContext) => import("redux").Reducer<{
  flags: TFlagsContext;
  status: import("@flopflip/types").TAdaptersStatus;
}, import("redux").UnknownAction | {
  payload: {
    id?: import("@flopflip/types").TAdapterIdentifiers;
    flags: import("@flopflip/types").TFlags;
    adapterIdentifiers: string[];
  };
  type: "flags/updateFlags";
}, Partial<{
  flags: never;
  status: import("@flopflip/types").TAdaptersStatus | undefined;
}>>;
//#endregion
//#region src/enhancer.d.ts
declare function createFlopFlipEnhancer(adapter: TAdapter, adapterArgs: TAdapterArgs): <StoreState extends TState>(next: StoreEnhancerStoreCreator<StoreState>) => (reducer: Reducer<StoreState>, preloadedState?: StoreState) => Store;
//#endregion
//#region src/inject-feature-toggle.d.ts
type InjectedProps$1 = Record<string, TFlagVariation>;
declare const injectFeatureToggle: <OwnProps extends Record<string, unknown>>(flagName: TFlagName, propKey?: string) => (Component: React.ComponentType<any>) => React.ComponentType<OwnProps & InjectedProps$1>;
//#endregion
//#region src/inject-feature-toggles.d.ts
type InjectedProps = Record<string, TFlags>;
declare const injectFeatureToggles: <OwnProps extends Record<string, unknown>>(flagNames: TFlagName[], propKey?: string) => (Component: React.ComponentType) => React.ComponentType<OwnProps & InjectedProps>;
//#endregion
//#region src/toggle-feature.d.ts
type TProps = {
  flag: TFlagName;
  variation?: TFlagVariation;
} & Omit<TToggleFeatureProps, 'isFeatureEnabled'>;
declare function ToggleFeature<OwnProps extends TProps>({
  flag,
  variation,
  ...remainingProps
}: OwnProps): React.JSX.Element;
declare namespace ToggleFeature {
  var displayName: string;
}
//#endregion
//#region src/use-adapter-status.d.ts
type TUseAdapterStatusArgs = {
  adapterIdentifiers?: TAdapterIdentifiers[];
};
declare function useAdapterStatus({
  adapterIdentifiers
}?: TUseAdapterStatusArgs): {
  isReady: boolean;
  isUnconfigured: boolean;
  isConfiguring: boolean;
  isConfigured: boolean;
};
//#endregion
//#region src/use-all-feature-toggles.d.ts
declare function useAllFeatureToggles(): TFlags;
//#endregion
//#region src/use-feature-toggle.d.ts
declare function useFeatureToggle(flagName: TFlagName, flagVariation?: TFlagVariation): boolean;
//#endregion
//#region src/use-feature-toggles.d.ts
declare function useFeatureToggles(flags: TFlags): boolean[];
//#endregion
//#region src/use-flag-variation.d.ts
declare function useFlagVariation(flagName?: TFlagName): TFlagVariation;
//#endregion
//#region src/use-flag-variations.d.ts
declare function useFlagVariations(flagNames: (TFlagName | undefined)[]): TFlagVariation[];
//#endregion
//#region src/index.d.ts
declare const version = "__@FLOPFLIP/VERSION_OF_RELEASE__";
//#endregion
export { Configure as ConfigureFlopFlip, STATE_SLICE as FLOPFLIP_STATE_SLICE, ReconfigureAdapter as ReconfigureFlopFlip, ToggleFeature, branchOnFeatureToggle, createFlopFlipEnhancer, createFlopflipReducer, flopflipReducer, injectFeatureToggle, injectFeatureToggles, selectFlag as selectFeatureFlag, selectFlags as selectFeatureFlags, useAdapterReconfiguration, useAdapterStatus, useAllFeatureToggles, useFeatureToggle, useFeatureToggles, useFlagVariation, useFlagVariations, version };
//# sourceMappingURL=index.d.ts.map