@tastic/shell 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,487 @@
+import * as react from 'react';
+import { ComponentType, ReactNode } from 'react';
+import * as _rific_auto_paper from '@rific/auto-paper';
+import { ThemeAppearance } from '@rific/auto-paper';
+import { ViewRotation } from '@tastic/core';
+import { PopoverHost, MenuOption } from '@tastic/hud';
+import { GuideStep } from '@tastic/hud/guide';
+import { FontSource } from 'expo-font';
+import * as redux from 'redux';
+import { Reducer, Action } from 'redux';
+import * as _rific_core from '@rific/core';
+export { safeBack } from '@rific/core';
+import * as _tastic_profile from '@tastic/profile';
+import { profilesReducer, Profile, CreateProfileInput, SeatColorsState as SeatColorsState$1 } from '@tastic/profile';
+import * as _rific_feedback_press from '@rific/feedback-press';
+import { SoundSettings } from '@rific/feedback-press';
+import * as redux_persist from 'redux-persist';
+import { PersistedState, Persistor } from 'redux-persist';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux_thunk from 'redux-thunk';
+import * as redux_persist_es_persistReducer from 'redux-persist/es/persistReducer';
+import { ImageSourcePropType } from 'react-native';
+import * as _tastic_achievements from '@tastic/achievements';
+import { UnlockedAchievementsState, AchievementDefinition, AchievementsState } from '@tastic/achievements';
+
+interface ActiveRound {
+    game: string;
+    mode: RoundMode;
+    settings: object;
+}
+type LiveplaySliceState = {
+    activelyPlaying: boolean;
+    activeRound: ActiveRound | null;
+};
+declare const reducer$3: _rific_core.SettingsReducer<LiveplaySliceState>;
+declare const liveplayActions: {
+    initialize: {
+        (payload: LiveplaySliceState): _rific_core.SettingsAction<LiveplaySliceState>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<LiveplaySliceState>;
+    };
+} & {
+    setActivelyPlaying: {
+        (payload: boolean): _rific_core.SettingsAction<boolean>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<boolean>;
+    };
+    setActiveRound: {
+        (payload: ActiveRound | null): _rific_core.SettingsAction<ActiveRound | null>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<ActiveRound | null>;
+    };
+};
+
+interface OpponentState {
+    seatTwo: SeatTwo;
+}
+declare const DEFAULT_OPPONENT: OpponentState;
+declare const reducer$2: _rific_core.SettingsReducer<OpponentState>;
+declare const opponentActions: {
+    initialize: {
+        (payload: OpponentState): _rific_core.SettingsAction<OpponentState>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<OpponentState>;
+    };
+} & {
+    setSeatTwo: {
+        (payload: SeatTwo): _rific_core.SettingsAction<SeatTwo>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<SeatTwo>;
+    };
+};
+
+interface AppSettings {
+    lockOrientation: boolean;
+    lockedRotation?: ViewRotation;
+    deferBottomEdgeGestures: boolean;
+}
+declare const DEFAULT_APP_SETTINGS: AppSettings;
+declare const reducer$1: _rific_core.SettingsReducer<AppSettings>;
+declare const appSettingsActions: {
+    initialize: {
+        (payload: Partial<AppSettings>): _rific_core.SettingsAction<Partial<AppSettings>>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<Partial<AppSettings>>;
+    };
+} & {};
+
+type LastActiveGameState = {
+    gameId: string | null;
+};
+
+declare function createShellReducers({ seatColors, appearance }: Pick<PackDefinition, 'seatColors' | 'appearance'>): {
+    theme: _rific_core.SettingsReducer<_rific_auto_paper.ThemeState>;
+    haptic: _rific_core.SettingsReducer<_rific_feedback_press.HapticSettings>;
+    sound: (state: SoundSettings | undefined, action: {
+        type: string;
+    }) => SoundSettings;
+    keepAwake: _rific_core.SettingsReducer<_rific_core.KeepAwakeSettings>;
+    profiles: typeof profilesReducer;
+    profileSelection: (state: _tastic_profile.ProfileSelectionState<Seat> | undefined, action: {
+        type: string;
+        payload?: unknown;
+    }) => _tastic_profile.ProfileSelectionState<Seat>;
+    seatColors: (state: _tastic_profile.SeatColorsState<Seat> | undefined, action: {
+        type: string;
+        payload?: unknown;
+    }) => _tastic_profile.SeatColorsState<Seat>;
+    appSettings: _rific_core.SettingsReducer<AppSettings>;
+    opponent: _rific_core.SettingsReducer<OpponentState>;
+    liveplay: _rific_core.SettingsReducer<LiveplaySliceState>;
+};
+type ShellReducers = ReturnType<typeof createShellReducers>;
+type ShellState = {
+    [K in keyof ShellReducers]: ReturnType<ShellReducers[K]>;
+} & {
+    lastActiveGame?: LastActiveGameState;
+};
+
+type Seat = 1 | 2;
+type SeatTwo = 'cpu' | 'person' | 'nobody';
+type RoundMode = 'vsCpu' | 'twoPlayer' | 'solo';
+declare function roundModeFor(seatTwo: SeatTwo): RoundMode;
+declare function seatTwoFor(saved: SeatTwo, choices: readonly SeatTwo[] | undefined): SeatTwo;
+declare function humanSeatsFor(mode: RoundMode): Seat[];
+interface LoadoutOptionsProps {
+    host: PopoverHost;
+    rotation: ViewRotation;
+    accentColor: string;
+    mutedColor: string;
+    onAccentColor: string;
+    dark: boolean;
+    onRandomize?: () => void;
+    onReset?: () => void;
+}
+interface SeatControlLook {
+    accentColor: string;
+    seatColor: string;
+    mutedColor: string;
+    dark: boolean;
+    rotation: ViewRotation;
+}
+interface GameLoadout {
+    roundSettings: object;
+    options: (props: LoadoutOptionsProps) => ReactNode;
+    optionIds: readonly string[];
+    randomize: () => void;
+    reset: () => void;
+    seatControl: (seat: Seat, host: PopoverHost, look: SeatControlLook) => ReactNode | undefined;
+    cpuDifficulty?: {
+        value: string;
+        options: MenuOption<string>[];
+        onChange: (value: string) => void;
+    };
+}
+interface GameGuide {
+    version: number;
+    selectVersionSeen: (state: ShellState) => number;
+    markSeen: (version: number) => Action;
+    selectInput: (state: ShellState) => object;
+    getSteps: (input: object, context: {
+        touch: boolean;
+        mode: RoundMode;
+    }) => GuideStep[];
+}
+interface GameIconProps {
+    size: number;
+    p1Color: string;
+    p2Color: string;
+    dark: boolean;
+}
+interface GamePreviewProps {
+    width: number;
+    height: number;
+    p1Color: string;
+    p2Color: string;
+    dark: boolean;
+}
+interface GameDefinition {
+    id: string;
+    title: string;
+    blurb: string;
+    icon: ComponentType<GameIconProps>;
+    Preview?: ComponentType<GamePreviewProps>;
+    seatTwo?: readonly SeatTwo[];
+    twoPlayerSeats?: {
+        faceToFaceOnWeb: boolean;
+        followUpsideDown: boolean;
+    };
+    reducers: Record<string, Reducer>;
+    Provider: ComponentType<{
+        children: ReactNode;
+    }>;
+    useLoadout?: (mode: RoundMode) => GameLoadout;
+    PlayScreen: ComponentType;
+    resumable?: boolean;
+    StatsSections: ComponentType<{
+        profileId: string | null;
+    }>;
+    AchievementList: ComponentType<{
+        profileId: string | null;
+    }>;
+    resetStats: () => Action;
+    guide: GameGuide;
+}
+interface HeroTitleProps {
+    words: readonly [string, string];
+    color: string;
+    p1Color: string;
+    p2Color: string;
+    active: boolean;
+    fit?: {
+        width: number;
+        height: number;
+    };
+}
+interface PackStatsSectionsProps {
+    profileId: string | null;
+    gameId: string | null;
+}
+interface PackDefinition {
+    name: string;
+    wordmark: readonly [string, string];
+    colorCaption: string;
+    games: readonly GameDefinition[];
+    seatColors: Record<Seat, string>;
+    appearance?: ThemeAppearance;
+    HeroTitle: ComponentType<HeroTitleProps>;
+    fonts?: Record<string, FontSource>;
+    fontFamily?: string;
+    otaVersion: number;
+    SettingsSections?: ComponentType;
+    reducers?: Record<string, Reducer>;
+    StatsSections?: ComponentType<PackStatsSectionsProps>;
+}
+
+declare function PackProvider({ pack, children }: {
+    pack: PackDefinition;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function usePack(): PackDefinition;
+declare function usePackGame(id: string | undefined): GameDefinition | undefined;
+
+interface PackStoreConfig {
+    keyPrefix: string;
+    migrate?: (state: PersistedState, version: number) => Promise<PersistedState>;
+}
+type PackStoreSource = Pick<PackDefinition, 'seatColors' | 'appearance' | 'reducers'> & {
+    games: readonly Pick<GameDefinition, 'reducers' | 'resumable'>[];
+};
+declare function createPackStore(pack: PackStoreSource, { keyPrefix, migrate }: PackStoreConfig): {
+    store: _reduxjs_toolkit.EnhancedStore<{
+        theme: _rific_auto_paper.ThemeState;
+        haptic: _rific_feedback_press.HapticSettings;
+        sound: _rific_feedback_press.SoundSettings;
+        keepAwake: _rific_core.KeepAwakeSettings;
+        profiles: _tastic_profile.Profile[];
+        profileSelection: _tastic_profile.ProfileSelectionState<Seat>;
+        seatColors: _tastic_profile.SeatColorsState<Seat>;
+        appSettings: AppSettings;
+        opponent: OpponentState;
+        liveplay: LiveplaySliceState;
+    } & redux_persist_es_persistReducer.PersistPartial, {
+        type: string;
+        payload?: unknown;
+    } | {
+        type: string;
+        payload?: unknown;
+    } | {
+        type: string;
+    } | {
+        type: string;
+    } | {
+        type: string;
+    }, _reduxjs_toolkit.Tuple<[redux.StoreEnhancer<{
+        dispatch: redux_thunk.ThunkDispatch<{
+            theme: _rific_auto_paper.ThemeState;
+            haptic: _rific_feedback_press.HapticSettings;
+            sound: _rific_feedback_press.SoundSettings;
+            keepAwake: _rific_core.KeepAwakeSettings;
+            profiles: _tastic_profile.Profile[];
+            profileSelection: _tastic_profile.ProfileSelectionState<Seat>;
+            seatColors: _tastic_profile.SeatColorsState<Seat>;
+            appSettings: AppSettings;
+            opponent: OpponentState;
+            liveplay: LiveplaySliceState;
+        } & redux_persist_es_persistReducer.PersistPartial, undefined, redux.UnknownAction>;
+    }>, redux.StoreEnhancer]>>;
+    persistor: redux_persist.Persistor;
+};
+type PackStore = ReturnType<typeof createPackStore>['store'];
+
+interface RootLayoutProps {
+    pack: PackDefinition;
+    store: PackStore;
+    persistor: Persistor;
+}
+declare function RootLayout({ pack, store, persistor }: RootLayoutProps): react.JSX.Element;
+
+declare function LoadoutRoute(): react.JSX.Element;
+declare function PlayRoute(): react.JSX.Element;
+
+declare function HomeScreen(): react.JSX.Element;
+
+declare const PREVIEW_ASPECT: number;
+
+declare function ProfilesRoute(): react.JSX.Element;
+
+declare function StatsScreen(): react.JSX.Element;
+
+interface GameGuideContextValue {
+    openFirstTime: (gameId: string, next: () => void) => void;
+    openFor: (gameId: string) => void;
+}
+declare function useGameGuide(): GameGuideContextValue;
+
+declare function imageGameIcon(images: {
+    light: ImageSourcePropType;
+    dark: ImageSourcePropType;
+}): ComponentType<GameIconProps>;
+
+interface SettingsDialogProps {
+    visible: boolean;
+    onDismiss: () => void;
+    rotation?: ViewRotation;
+    onShowHowToPlay?: () => void;
+    children?: ReactNode;
+}
+declare function SettingsDialog({ visible, onDismiss, rotation, onShowHowToPlay, children }: SettingsDialogProps): react.JSX.Element;
+
+declare function useActiveRound<S extends object>(game: string, defaults: S): {
+    mode: RoundMode;
+    settings: S;
+};
+
+declare function useAppSettings(): {
+    settings: AppSettings;
+    setSettings: (patch: Partial<AppSettings>) => void;
+};
+
+declare function useOpponent(): {
+    seatTwo: SeatTwo;
+    setSeatTwo: (seatTwo: SeatTwo) => void;
+};
+
+interface ProfilesContextValue {
+    profiles: Profile[];
+    lastSelected: Record<Seat, string | null>;
+    loaded: boolean;
+    createProfile: (input: CreateProfileInput) => Profile;
+    updateProfile: (id: string, patch: Partial<CreateProfileInput>) => void;
+    deleteProfile: (id: string) => void;
+    selectProfile: (seat: Seat, profileId: string | null) => void;
+}
+interface Props {
+    children: ReactNode;
+}
+declare function ProfilesProvider({ children }: Props): react.JSX.Element;
+declare function useProfiles(): ProfilesContextValue;
+
+declare function useSeatColors(p2IsHuman: boolean): {
+    p1Color: string;
+    p2Color: string;
+    handleP1ColorChange: (hex: string) => void;
+    handleP2ColorChange: (hex: string) => void;
+};
+
+interface GameGuideState {
+    versionSeen: number;
+}
+declare function createGameGuideSlice(mountKey: string): {
+    actions: {
+        markSeen: (version: number) => {
+            type: string;
+            payload: number;
+        };
+    };
+    reducer: (state: GameGuideState | undefined, action: Action & {
+        payload?: unknown;
+    }) => GameGuideState;
+    selectVersionSeen: (rootState: object) => number;
+};
+
+declare function onProfileRemoved<S>(reducer: Reducer<S>, forget: (state: S, profileId: string) => S): Reducer<S>;
+declare function forgetProfileAchievements<T, S extends {
+    stats: T;
+    unlocked: UnlockedAchievementsState;
+}>(dropStats: (stats: T, profileId: string) => T): (state: S, profileId: string) => S;
+
+type ProfileSelectionState = Record<Seat, string | null>;
+declare const defaultProfileSelectionState: ProfileSelectionState;
+declare const reducer: (state: _tastic_profile.ProfileSelectionState<Seat> | undefined, action: {
+    type: string;
+    payload?: unknown;
+}) => _tastic_profile.ProfileSelectionState<Seat>;
+declare const profileSelectionActions: _tastic_profile.ProfileSelectionActions<Seat>;
+
+type SeatColorsState = SeatColorsState$1<Seat>;
+declare function defaultSeatColorsState(seatColors: Record<Seat, string>): SeatColorsState;
+declare function createSeatColorsReducer(seatColors: Record<Seat, string>): (state: SeatColorsState$1<Seat> | undefined, action: {
+    type: string;
+    payload?: unknown;
+}) => SeatColorsState$1<Seat>;
+declare const seatColorsActions: _tastic_profile.SeatColorsActions<Seat>;
+
+interface RecordResult<TStats> {
+    device: AchievementDefinition<TStats>[];
+    profiles: Partial<Record<Seat, AchievementDefinition<TStats>[]>>;
+}
+interface GameStatsContextValue<TStats> {
+    stats: TStats;
+    unlockedAchievements: UnlockedAchievementsState;
+    record: (update: (prev: TStats) => TStats, profileIds?: Partial<Record<Seat, string>>) => RecordResult<TStats>;
+    resetAll: () => void;
+}
+interface GameStatsOptions<TStats, TBucket> {
+    key: string;
+    defaultStats: TStats;
+    isValidStats?: (value: unknown) => boolean;
+    catalog: AchievementDefinition<TStats>[];
+    getProfileStatsView: (bucket: TBucket) => TStats;
+}
+declare function createGameStats<TStats extends {
+    profiles: Record<string, TBucket>;
+}, TBucket>({ key, defaultStats, isValidStats, catalog, getProfileStatsView }: GameStatsOptions<TStats, TBucket>): {
+    reducer: redux.Reducer<AchievementsState<TStats>>;
+    actions: _tastic_achievements.AchievementsActions<TStats>;
+    Provider: ({ children }: {
+        children: ReactNode;
+    }) => react.JSX.Element;
+    useStats: () => GameStatsContextValue<TStats>;
+};
+
+declare function seatPlayerKey(selection: Record<Seat, string | null>, seat: Seat): string;
+type WithControls<C> = {
+    controlScheme: Record<Seat, C>;
+};
+type PlayerSettingsState<S> = Record<string, Partial<Omit<S, 'controlScheme'>>>;
+type PlayerControlsState<C> = Record<string, C>;
+interface PlayerSettingsOptions<S extends WithControls<C>, C> {
+    id: string;
+    defaults: S;
+    distinctControls?: readonly C[];
+}
+declare function createPlayerSettings<S extends WithControls<C>, C>({ id, defaults, distinctControls }: PlayerSettingsOptions<S, C>): {
+    reducers: {
+        [x: string]: redux.Reducer<PlayerSettingsState<S>> | redux.Reducer<PlayerControlsState<C>>;
+    };
+    settingsReducer: redux.Reducer<PlayerSettingsState<S>>;
+    controlsReducer: redux.Reducer<PlayerControlsState<C>>;
+    actions: {
+        patch: (player: string, changes: Partial<Omit<S, "controlScheme">>) => {
+            type: string;
+            payload: {
+                player: string;
+                changes: Partial<Omit<S, "controlScheme">>;
+            };
+        };
+        setControl: (player: string, control: C) => {
+            type: string;
+            payload: {
+                player: string;
+                control: C;
+            };
+        };
+    };
+    compose: (saved: PlayerSettingsState<S> | undefined, controls: PlayerControlsState<C> | undefined, selection: Record<Seat, string | null>, seatTwoIsPerson: boolean) => S;
+    select: (state: ShellState) => S;
+    useSettings: () => {
+        settings: S;
+        setSettings: (patch: Partial<S>) => void;
+    };
+};
+
+export { type ActiveRound, type AppSettings, DEFAULT_APP_SETTINGS, DEFAULT_OPPONENT, type GameDefinition, type GameGuide, type GameGuideState, type GameIconProps, type GameLoadout, type GamePreviewProps, type HeroTitleProps, HomeScreen, type LiveplaySliceState, type LoadoutOptionsProps, LoadoutRoute, type OpponentState, PREVIEW_ASPECT, type PackDefinition, PackProvider, type PackStatsSectionsProps, type PackStore, type PackStoreConfig, type PackStoreSource, PlayRoute, type PlayerControlsState, type PlayerSettingsState, type ProfileSelectionState, ProfilesProvider, ProfilesRoute, type RecordResult, RootLayout, type RoundMode, type Seat, type SeatColorsState, type SeatControlLook, type SeatTwo, SettingsDialog, type SettingsDialogProps, type ShellState, StatsScreen, appSettingsActions, reducer$1 as appSettingsReducer, createGameGuideSlice, createGameStats, createPackStore, createPlayerSettings, createSeatColorsReducer, createShellReducers, defaultProfileSelectionState, defaultSeatColorsState, forgetProfileAchievements, humanSeatsFor, imageGameIcon, liveplayActions, reducer$3 as liveplayReducer, onProfileRemoved, opponentActions, reducer$2 as opponentReducer, profileSelectionActions, reducer as profileSelectionReducer, roundModeFor, seatColorsActions, seatPlayerKey, seatTwoFor, useActiveRound, useAppSettings, useGameGuide, useOpponent, usePack, usePackGame, useProfiles, useSeatColors };