From 11adef144cd1d0b702959c600799ba3f4c10cec8 Mon Sep 17 00:00:00 2001 From: Tu Bui <> Date: Wed, 11 Jun 2025 10:30:27 +0700 Subject: [PATCH] add plugin table-core --- assets/core.meta | 13 + assets/core/plugins.meta | 13 + assets/core/plugins/core.d.ts | 1030 ++++++++++++++++++++++++++++ assets/core/plugins/core.d.ts.meta | 6 + assets/core/plugins/core.i.ts | 410 +++++++++++ assets/core/plugins/core.i.ts.meta | 10 + assets/core/plugins/core.js | 31 + assets/core/plugins/core.js.meta | 10 + 8 files changed, 1523 insertions(+) create mode 100644 assets/core.meta create mode 100644 assets/core/plugins.meta create mode 100644 assets/core/plugins/core.d.ts create mode 100644 assets/core/plugins/core.d.ts.meta create mode 100644 assets/core/plugins/core.i.ts create mode 100644 assets/core/plugins/core.i.ts.meta create mode 100644 assets/core/plugins/core.js create mode 100644 assets/core/plugins/core.js.meta diff --git a/assets/core.meta b/assets/core.meta new file mode 100644 index 0000000..265a545 --- /dev/null +++ b/assets/core.meta @@ -0,0 +1,13 @@ +{ + "ver": "1.1.3", + "uuid": "4fb16fa3-e631-4543-b196-dd6273091509", + "importer": "folder", + "isBundle": false, + "bundleName": "", + "priority": 1, + "compressionType": {}, + "optimizeHotUpdate": {}, + "inlineSpriteFrames": {}, + "isRemoteBundle": {}, + "subMetas": {} +} \ No newline at end of file diff --git a/assets/core/plugins.meta b/assets/core/plugins.meta new file mode 100644 index 0000000..25be221 --- /dev/null +++ b/assets/core/plugins.meta @@ -0,0 +1,13 @@ +{ + "ver": "1.1.3", + "uuid": "453b0527-6cad-43e6-83af-0eb85a63f845", + "importer": "folder", + "isBundle": false, + "bundleName": "", + "priority": 1, + "compressionType": {}, + "optimizeHotUpdate": {}, + "inlineSpriteFrames": {}, + "isRemoteBundle": {}, + "subMetas": {} +} \ No newline at end of file diff --git a/assets/core/plugins/core.d.ts b/assets/core/plugins/core.d.ts new file mode 100644 index 0000000..520cc24 --- /dev/null +++ b/assets/core/plugins/core.d.ts @@ -0,0 +1,1030 @@ +import 'reflect-metadata'; +export declare class GameEventContract implements Core.EventSystem.EventContract { + type: any; + callback: Function; + expired: boolean; + broken: boolean; + register(type: any, callback: Function): void; + off(): void; + on(): void; + break(): void; +} +import { GameEventContract } from "./game-event-contract"; +export declare class GameEventListener implements Core.EventSystem.EventListener { + private listEventContract; + getContract(): GameEventContract[]; + register(type: any, callback: Function): Core.EventSystem.EventContract; +} +import { GameEventListener } from "./game-event-listener"; +export declare class GameEventPublisher implements Core.EventSystem.EventPublisher { + private listEventListener; + add(listener: GameEventListener): void; + emit(type: any): void; + private executeListenerCallback; + private removeBrokenContract; +} +export declare class BetConstantParameter implements Core.Parameter.BetConstantParameter { + get DEFAULT_LIST_BET_OPTION(): number[]; +} +export declare const COMMAND: { + Default: symbol; + Target: symbol; + Decorator: symbol; + PlaceBet: symbol; + ClearBet: symbol; + ClearAllBet: symbol; + DoubleBet: symbol; + Rebet: symbol; + ResetBet: symbol; +}; +export declare const UNDO_MANAGER: { + Bet: symbol; +}; +export declare const CONTROLLER: { + Default: symbol; + Game: symbol; + Room: symbol; + Bet: symbol; + BetOption: symbol; + Balance: symbol; + Countdown: symbol; + Statistic: symbol; + Odds: symbol; + History: symbol; + BetLimit: symbol; + RoundResult: symbol; + Win: symbol; + Error: symbol; + LoungeBetLimit: symbol; + LoungeBetOption: symbol; +}; +export declare const CONTROLLER_EVENT_PUBLISHER: { + Default: symbol; +}; +export declare const CONTROLLER_EVENT_LISTENER: { + Default: symbol; +}; +export declare const GAME_VIEW: { + Bet: symbol; + BetOption: symbol; + Countdown: symbol; + Statistic: symbol; + Odds: symbol; + Balance: symbol; + History: symbol; + BetLimit: symbol; + RoundResult: symbol; + Win: symbol; + Error: symbol; + Lounge: symbol; +}; +export declare const MODEL: { + ApplicationConfig: symbol; + BetLimit: symbol; + RemainBalance: symbol; + BetBalance: symbol; + Bet: symbol; + Rebet: symbol; + BetPosition: symbol; + ListBetOption: symbol; + SelectedBetOption: symbol; + RoomIndex: symbol; + BetConflict: symbol; + ListBetConflict: symbol; + History: symbol; + RoundRecord: symbol; + Statistic: symbol; + ListOdds: symbol; + RoundResult: symbol; + Win: symbol; + Countdown: symbol; + Error: symbol; + HttpServer: symbol; + ListRoomBetOption: symbol; + ListRoomBetLimit: symbol; +}; +export declare const NETWORK_CONNECTOR: { + Default: symbol; + EventProcessor: symbol; +}; +export declare const NETWORK_REQUEST: { + Default: symbol; +}; +export declare const NETWORK_RESPONSE: { + Default: symbol; + OnConnect: symbol; + OnConnectRetry: symbol; + OnDisconnect: symbol; + OnLogout: symbol; + OnRoomJoin: symbol; + OnMessageData: symbol; + OnError: symbol; + OnLoginError: symbol; + OnBetLimit: symbol; + OnBalance: symbol; + OnGameStart: symbol; + OnBetSettings: symbol; + OnStatistic: symbol; + OnRoundStart: symbol; + OnResult: symbol; + OnWin: symbol; + OnRoundEnd: symbol; + OnConfirmBetSuccessfully: symbol; + OnConfirmBetFailed: symbol; + OnOdds: symbol; +}; +export declare const NETWORK_COMMAND: { + Connect: symbol; + JoinRoom: symbol; + StartNewRound: symbol; + ConfirmBet: symbol; + CollectPoint: symbol; +}; +export declare const NETWORK_EVENT_PUBLISHER: { + Default: symbol; +}; +export declare const NETWORK_EVENT_LISTENER: { + Default: symbol; +}; +export declare const DATA_PROCESSOR: { + Default: symbol; + Chain: symbol; +}; +export declare const HTTP_RESPONSE: { + Success: symbol; + Failed: symbol; + Invalid: symbol; + Error: symbol; +}; +export declare const PARAMETER: { + BetConstant: symbol; + GameConstant: symbol; +}; +export declare const AVAILABLE_BET_CALCULATOR: unique symbol; +export declare const VALIDATOR: { + EnoughBalanceToBet: symbol; + BetConflict: symbol; + BetPointBelowMaxBetLimit: symbol; + TotalBetBelowMaxTotalBetLimit: symbol; + BetForbidden: symbol; + EmptyBetTable: symbol; +}; +export type StateMachineKeys = { + EventManager: symbol; + StateMachine: symbol; +}; +export declare const CONTROLLER_STATE_MACHINE: Record; +export declare const STATE_CONTEXT: unique symbol; +export declare const DEFAULT_STATE: unique symbol; +export declare const LIST_STATE_TRANSITION_CREATOR: unique symbol; +export declare const LIST_STATE_TRANSITION_ASSERTOR: { + Default: symbol; + Chain: symbol; +}; +import { Container } from "inversify"; +declare const container: Container; +export { container }; +export declare class AvailableBetCalculator implements Core.Service.AvailableBetCalculator { + private betModel; + private currentBetLimitModel; + private remainBalanceModel; + private listBetOptionModel; + private betConstantParameter; + constructor(betModel: Core.Model.BetModel, currentBetLimitModel: Core.Model.BetLimitModel, remainBalanceModel: Core.Model.BalanceModel, listBetOptionModel: Core.Model.ListBetOptionModel, betConstantParameter: Core.Parameter.BetConstantParameter); + getAvailableBet(betPositionIndex: number): number; + private getAvailableBetPoint; + private getAvailableTotalBet; +} +export declare abstract class ChainDataProcessor implements Core.Network.DataProcessor { + private nextDataProcessor; + constructor(nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; +} +import { CommandWrapper } from "./command-wrapper"; +export declare abstract class CommandProxy extends CommandWrapper { + execute(): void; + protected handleValidateFailed(): void; + protected abstract validate(): boolean; +} +export declare abstract class CommandWrapper implements Core.Pattern.Command { + protected targetCommand: Core.Pattern.Command; + constructor(targetCommand: Core.Pattern.Command); + execute(): void; +} +export declare class UndoManager implements Core.Pattern.UndoManager { + private undoableQueue; + push(undoable: Core.Pattern.Undoable): void; + undo(): void; + isUndoable(): boolean; + reset(): void; + private removeUndoable; +} +export declare class BetConflictValidator implements Core.Service.Validator { + private betModel; + private betPositionModel; + private listBetConflictModel; + constructor(betModel: Core.Model.BetModel, betPositionModel: Core.Model.BetPositionModel, listBetConflictModel: Core.Model.ListBetConflictModel); + validate(): boolean; + private isConflict; +} +export declare class BetPointBelowMaxBetLimitValidator implements Core.Service.Validator { + private betPositionModel; + private betModel; + private betLimitModel; + constructor(betPositionModel: Core.Model.BetPositionModel, betModel: Core.Model.BetModel, betLimitModel: Core.Model.BetLimitModel); + validate(): boolean; +} +export declare class EnoughBalanceToBetValidator implements Core.Service.Validator { + private listBetOptionModel; + private remainBalanceModel; + private betConstantParameter; + constructor(listBetOptionModel: Core.Model.ListBetOptionModel, remainBalanceModel: Core.Model.BalanceModel, betConstantParameter: Core.Parameter.BetConstantParameter); + validate(): boolean; +} +export declare class TotalBetBelowMaxTotalBetLimitValidator implements Core.Service.Validator { + private betModel; + private betLimitModel; + constructor(betModel: Core.Model.BetModel, betLimitModel: Core.Model.BetLimitModel); + validate(): boolean; +} +export declare class EmptyBetTableValidator implements Core.Service.Validator { + private betModel; + constructor(betModel: Core.Model.BetModel); + validate(): boolean; +} +export declare abstract class ListStateTransitionCreator implements Core.State.ListStateTransitionCreator { + private assertor; + constructor(assertor: Core.State.ListStateTransitionAssertor); + create(): Core.State.ListStateTransition; + protected abstract getListStateTransition(): Core.State.ListStateTransition; +} +export declare abstract class ChainListStateTransitionAssertor implements Core.State.ListStateTransitionAssertor { + private nextAssertor?; + constructor(nextAssertor?: Core.State.ListStateTransitionAssertor); + assert(listStateTransition: Core.State.ListStateTransition): void; + protected abstract _assert(listStateTransition: Core.State.ListStateTransition): void; +} +import { ChainListStateTransitionAssertor } from "./chain-list-state-transition-assertor"; +export declare class ListStateTransitionDuplicateAssertor extends ChainListStateTransitionAssertor { + protected _assert(listStateTransition: Core.State.ListStateTransition): void; + private convertTransitionToString; + private isDuplicateTransition; + private isSameFromState; + private isSameEvent; +} +import { ChainListStateTransitionAssertor } from "./chain-list-state-transition-assertor"; +export declare class ListStateTransitionInheritanceAssertor extends ChainListStateTransitionAssertor { + protected _assert(listStateTransition: Core.State.ListStateTransition): void; + private getListState; + private assertNoStateInheritance; + private throwErrorIfInherited; + private isInheritedState; +} +export declare function registerStateMachineNetworkEvent(listNetworkEvent: symbol[], stateMachine: Core.State.StateMachine): void; +import { StateMachineKeys } from "../ioc-config/ioc-config-state"; +export declare function setupStateMachineEventManager(stateMachineKeys: StateMachineKeys): void; +export declare class StateContext implements Core.State.StateContext { + protected currentState: T; + constructor(defaultState: T); + setState(state: T): void; + getState(): T; +} +export declare class StateMachineEventManager implements Core.State.StateMachineEventManager { + private listStateMachine; + registerStateMachine(stateMachine: Core.State.StateMachine): void; + unregisterStateMachine(stateMachine: Core.State.StateMachine): void; + emit(event: symbol): void; +} +export declare class StateMachine implements Core.State.StateMachine { + protected stateContext: Core.State.StateContext; + private listStateTransition; + constructor(stateContext: Core.State.StateContext, listStateTransitionCreator: Core.State.ListStateTransitionCreator); + getState(): T; + changeState(event: Symbol): void; + private getTransition; + private executeTransition; +} +import { interfaces } from "inversify"; +declare class BindingHelper { + targetNamed(request: interfaces.Request, name: string | number | symbol): boolean; + targetTagged(request: interfaces.Request, key: string | number | symbol, value: unknown): boolean; + targetIsDefault(request: interfaces.Request): boolean; + injectInto(request: interfaces.Request, parent: (NewableFunction | string)): boolean; + parentNamed(request: interfaces.Request, name: string | number | symbol): boolean; + parentTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean; + anyAncestorIs(request: interfaces.Request, ancestor: (NewableFunction | string)): boolean; + noAncestorIs(request: interfaces.Request, ancestor: (NewableFunction | string)): boolean; + anyAncestorTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean; + noAncestorTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean; + anyAncestorNamed(request: interfaces.Request, name: string | number | symbol): boolean; + noAncestorNamed(request: interfaces.Request, name: string | number | symbol): boolean; +} +declare var when: BindingHelper; +export { when }; +import { interfaces } from 'inversify'; +declare function customServiceLocator(container: interfaces.Container, doCache?: boolean): { + customInject: (serviceIdentifier: string | symbol | interfaces.Newable | interfaces.Abstract) => (proto: any, key: string) => void; + customInjectNamed: (serviceIdentifier: string | symbol | interfaces.Newable | interfaces.Abstract, named: string) => (proto: any, key: string) => void; + customInjectTagged: (serviceIdentifier: string | symbol | interfaces.Newable | interfaces.Abstract, key: string, value: any) => (proto: any, propertyName: string) => void; + customMultiInject: (serviceIdentifier: string | symbol | interfaces.Newable | interfaces.Abstract) => (proto: any, key: string) => void; +}; +export { customServiceLocator }; +import { interfaces } from "inversify"; +interface DependencyBranch { + from(type: any): DependencyGraphHelper; +} +declare class DependencyGraphHelper implements DependencyBranch { + private container; + private graphs; + private isBranching; + private branchNode; + private isSingletonGraph; + inSingletonScope(): DependencyGraphHelper; + bind(identifier: any, type: any, isConstant?: boolean): DependencyGraphHelper; + branch(identifier: any, type: any, isConstant?: boolean): DependencyBranch; + from(type: any): DependencyGraphHelper; + registerTo(container: interfaces.Container): void; + private registerGraphToContainer; + private resetGraph; + private bindInSingletonScopeTo; + private bindTo; + private bindToConstant; + private recursiveCheckBindingCondition; +} +declare var dependencyGraph: DependencyGraphHelper; +export { dependencyGraph }; +export declare class BalanceController implements Core.Controller.BalanceController { + private betBalanceModel; + private remainBalanceModel; + private balanceGameView; + constructor(betBalanceModel: Core.Model.BalanceModel, remainBalanceModel: Core.Model.BalanceModel, balanceGameView: Core.View.GameView); + updateBalance(credit: number, freeCredit: number): void; + releaseBetCredit(): void; + withdraw(amount: number): void; + deposit(amount: number): void; + private getBalanceModelName; + private transferCredit; + private calculateTransferAmounts; + private resetBetBalance; +} +export declare class ClearAllBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable { + private betModel; + private remainBalanceModel; + private balanceController; + private errorController; + private betUndoManager; + private betGameView; + private listReturnBetPoint; + private get totalReturnBetPoint(); + constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, errorController: Core.Controller.ErrorController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView); + execute(): void; + undo(onSuccess?: Function): void; +} +export declare class ClearBetCommand implements Core.Pattern.Command { + private betPositionModel; + private betModel; + private controllerEventPublisher; + private balanceController; + constructor(betPositionModel: Core.Model.BetPositionModel, betModel: Core.Model.BetModel, controllerEventPublisher: Core.EventSystem.EventPublisher, balanceController: Core.Controller.BalanceController); + execute(): void; +} +import { CommandProxy } from "../../../../../common/service/command/command-proxy"; +export declare class CheckBetConflictCommandProxy extends CommandProxy { + private betConflictValidator; + private errorController; + constructor(targetCommand: Core.Pattern.Command, betConflictValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController); + protected validate(): boolean; + protected handleValidateFailed(): void; +} +import { CommandProxy } from "../../../../../common/service/command/command-proxy"; +export declare class CheckEmptyBetTableCommandProxy extends CommandProxy { + private emptyBetTableValidator; + constructor(targetCommand: Core.Pattern.Command, emptyBetTableValidator: Core.Service.Validator); + protected validate(): boolean; +} +import { CommandProxy } from "../../../../../common/service/command/command-proxy"; +export declare class CheckEnoughBalanceCommandProxy extends CommandProxy { + private enoughBalanceToBetValidator; + private errorController; + constructor(targetCommand: Core.Pattern.Command, enoughBalanceToBetValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController); + protected validate(): boolean; + protected handleValidateFailed(): void; +} +import { CommandProxy } from "../../../../../common/service/command/command-proxy"; +export declare class CheckMaxBetLimitCommandProxy extends CommandProxy { + private betPointBelowMaxBetLimitValidator; + private errorController; + constructor(targetCommand: Core.Pattern.Command, betPointBelowMaxBetLimitValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController); + protected validate(): boolean; + protected handleValidateFailed(): void; +} +import { CommandProxy } from "../../../../../common/service/command/command-proxy"; +export declare class CheckMaxTotalBetLimitCommandProxy extends CommandProxy { + private totalBetBelowMaxTotalBetLimitValidator; + private errorController; + constructor(targetCommand: Core.Pattern.Command, totalBetBelowMaxTotalBetLimitValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController); + protected validate(): boolean; + protected handleValidateFailed(): void; +} +import { CommandWrapper } from "../../../../../common/service/command/command-wrapper"; +export declare class DoubleBetCommandWrapper extends CommandWrapper { +} +import { PlaceMultiBetCommand } from "../place-multi-bet/place-multi-bet-command"; +import { PlaceMultiBetData } from "../place-multi-bet/place-multi-bet-data"; +export declare class DoubleBetCommand extends PlaceMultiBetCommand { + constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator); + protected getTargetPlaceMultiBetData(): PlaceMultiBetData; +} +import { CommandWrapper } from "../../../../../common/service/command/command-wrapper"; +export declare class PlaceBetCommandWrapper extends CommandWrapper { +} +export declare class PlaceBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable { + protected betPositionModel: Core.Model.BetPositionModel; + protected selectedBetOptionModel: Core.Model.SelectedBetOptionModel; + protected betModel: Core.Model.BetModel; + protected availableBetCalculator: Core.Service.AvailableBetCalculator; + protected betUndoManager: Core.Pattern.UndoManager; + private balanceController; + private betGameView; + constructor(betPositionModel: Core.Model.BetPositionModel, selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betModel: Core.Model.BetModel, availableBetCalculator: Core.Service.AvailableBetCalculator, betUndoManager: Core.Pattern.UndoManager, balanceController: Core.Controller.BalanceController, betGameView: Core.View.GameView); + protected placeBetPositionIndex: number; + protected placedBetValue: number; + execute(): void; + undo(onSuccess?: Function): void; + private placeBet; +} +import { PlaceMultiBetData } from "./place-multi-bet-data"; +export declare abstract class PlaceMultiBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable { + protected betModel: Core.Model.BetModel; + protected remainBalanceModel: Core.Model.BalanceModel; + protected balanceController: Core.Controller.BalanceController; + protected betUndoManager: Core.Pattern.UndoManager; + protected betGameView: Core.View.GameView; + private availableBetCalculator; + private listPlacedBet; + constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator); + execute(): void; + undo(onSuccess?: Function): void; + private registerUndo; + private adjustBets; + private adjustBetsToAvailableBet; + private adjustBetsToBalance; + protected abstract getTargetPlaceMultiBetData(): PlaceMultiBetData; +} +export type PlaceMultiBetData = { + betPositionIndex: number; + betPoint: number; +}[]; +import { CommandWrapper } from "../../../../../common/service/command/command-wrapper"; +export declare class RebetCommandWrapper extends CommandWrapper { +} +import { PlaceMultiBetCommand } from "../place-multi-bet/place-multi-bet-command"; +import { PlaceMultiBetData } from "../place-multi-bet/place-multi-bet-data"; +export declare class RebetCommand extends PlaceMultiBetCommand { + private rebetModel; + constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator, rebetModel: Core.Model.BetModel); + protected getTargetPlaceMultiBetData(): PlaceMultiBetData; +} +export declare class ResetBetCommand implements Core.Pattern.Command { + private balanceController; + private betBalanceModel; + private betModel; + private betUndoManager; + private betGameView; + constructor(balanceController: Core.Controller.BalanceController, betBalanceModel: Core.Model.BalanceModel, betModel: Core.Model.BetModel, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView); + execute(): void; + private returnBetPointToBalance; + private resetBet; +} +export declare class BetController implements Core.Controller.BetController { + private betControllerStateMachine; + constructor(betControllerStateMachine: Core.State.BetControllerStateMachine); + placeBet(betPositionIndex: number): void; + clearBet(betPositionIndex: number): void; + clearAllBet(): void; + doubleBet(): void; + rebet(): void; + undo(): void; + reset(): void; +} +export declare class BetControllerDisableState implements Core.State.BetControllerState { + placeBet(): void; + clearBet(): void; + clearAllBet(): void; + doubleBet(): void; + undo(): void; + rebet(): void; + reset(): void; + enter(): void; + leave(): void; +} +export declare class BetControllerEnableState implements Core.State.BetControllerState { + private betPositionModel; + private betUndoManager; + constructor(betPositionModel: Core.Model.BetPositionModel, betUndoManager: Core.Pattern.UndoManager); + placeBet(betPositionIndex: number): void; + clearBet(betPositionIndex: number): void; + clearAllBet(): void; + doubleBet(): void; + rebet(): void; + undo(): void; + reset(): void; + enter(): void; + leave(): void; +} +export declare const BET_CONTROLLER_EVENT: { + Enable: symbol; + Disable: symbol; +}; +import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator"; +export declare class BetControllerListStateTransitionCreator extends ListStateTransitionCreator { + protected getListStateTransition(): Core.State.ListStateTransition; +} +import { StateContext } from "../../../../common/state/state-context"; +export declare class BetControllerStateContext extends StateContext implements BetControllerStateContext { +} +import { StateMachine } from "../../../../common/state/state-machine"; +export declare class BetControllerStateMachine extends StateMachine { +} +export declare class BetLimitController implements Core.Controller.BetLimitController { + private listRoomBetLimitModel; + private betLimitModel; + private betLimitGameView; + constructor(listRoomBetLimitModel: Core.Model.ListRoomBetLimitModel, betLimitModel: Core.Model.BetLimitModel, betLimitGameView: Core.View.GameView); + updateCurrentBetLimit(roomIndex: number): void; +} +export declare class LoungeBetLimitController implements Core.Controller.LoungeBetLimitController { + private listRoomBetLimitModel; + private loungeGameView; + constructor(listRoomBetLimitModel: Core.Model.ListRoomBetLimitModel, loungeGameView: Core.View.GameView); + updateBetLimitSetting(listBetLimitSetting: Core.Model.BetLimitModel[]): void; +} +export declare class BetOptionController implements Core.Controller.BetOptionController { + private listBetOptionModel; + private selectedBetOptionModel; + private betOptionGameView; + private betOptionControllerStateMachine; + constructor(listBetOptionModel: Core.Model.ListBetOptionModel, selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betOptionGameView: Core.View.GameView, betOptionControllerStateMachine: Core.State.StateMachine); + updateListBetOption(listBetOption: number[], defaultBetOption: number): void; + changeBetOption(betOption: number): void; +} +export declare class LoungeBetOptionController implements Core.Controller.LoungeBetOptionController { + private listRoomBetOptionModel; + private loungeGameView; + constructor(listRoomBetOptionModel: Core.Model.ListRoomBetOptionModel, loungeGameView: Core.View.GameView); + updateBetOptionSetting(listBetOptionSetting: Core.Model.ListBetOptionModel[]): void; +} +export declare class BetOptionControllerDisableState implements Core.State.BetOptionControllerState { + updateListBetOption(listBetOption: number[], defaultBetOption: number): void; + changeBetOption(betOption: number): void; + enter(): void; + leave(): void; +} +export declare class BetOptionControllerEnableState implements Core.State.BetOptionControllerState { + private selectedBetOptionModel; + private betOptionGameView; + constructor(selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betOptionGameView: Core.View.GameView); + changeBetOption(betOption: number): void; + updateListBetOption(listBetOption: number[], defaultBetOption: number): void; + enter(): void; + leave(): void; +} +export declare const BET_OPTION_CONTROLLER_EVENT: { + Disable: symbol; + Enable: symbol; +}; +import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator"; +export declare class BetOptionControllerListStateTransitionCreator extends ListStateTransitionCreator { + protected getListStateTransition(): Core.State.ListStateTransition; +} +import { StateContext } from "../../../../common/state/state-context"; +export declare class BetOptionControllerStateContext extends StateContext implements Core.State.BetOptionControllerStateContext { +} +import { StateMachine } from "../../../../common/state/state-machine"; +export declare class BetOptionControllerStateMachine extends StateMachine { +} +export declare class SecondTickCountdownController implements Core.Controller.CountdownController { + private countdownModel; + private countdownGameView; + private intervalId; + constructor(countdownModel: Core.Model.CountdownModel, countdownGameView: Core.View.GameView); + startCountdown(duration: number, callbacks?: { + onComplete?: Function; + onTick?: Function; + }): void; + stop(): void; + reset(): void; + private setRemainTime; +} +export declare class ErrorController implements Core.Controller.ErrorController { + private errorModel; + private errorGameView; + constructor(errorModel: Core.Model.ErrorModel, errorGameView: Core.View.GameView); + handleServerError(errorCode: number): void; + handleError(error: Symbol): void; +} +export declare const ERROR_TYPE: { + MaxBetReached: symbol; + BetConflict: symbol; + NotEnoughBalanceToBet: symbol; + ServerError: symbol; + Disconnect: symbol; +}; +export declare class GameController implements Core.Controller.GameController { + private gameControllerStateMachine; + constructor(gameControllerStateMachine: Core.State.GameControllerStateMachine); + startNewRound(): void; + confirmBet(): void; + collectPoint(): void; +} +import { GameControllerState } from "./game-controller-state"; +export declare class GameControllerBetState extends GameControllerState { + private connector; + private betModel; + private gameControllerEventManager; + private betControllerEventManager; + private betOptionControllerEventManager; + constructor(connector: Core.Network.Connector, betModel: Core.Model.BetModel, gameControllerEventManager: Core.State.StateMachineEventManager, betControllerEventManager: Core.State.StateMachineEventManager, betOptionControllerEventManager: Core.State.StateMachineEventManager); + confirmBet(): void; + enter(): void; + leave(): void; + private enableControllers; + private disableControllers; +} +import { GameControllerState } from "./game-controller-state"; +export declare class GameControllerCollectingPointState extends GameControllerState { + private connector; + constructor(connector: Core.Network.Connector); + collectPoint(): void; +} +import { GameControllerState } from "./game-controller-state"; +export declare class GameControllerDisableState extends GameControllerState { + private betControllerEventManager; + private betOptionControllerEventManager; + constructor(betControllerEventManager: Core.State.StateMachineEventManager, betOptionControllerEventManager: Core.State.StateMachineEventManager); + enter(): void; +} +import { GameControllerState } from "./game-controller-state"; +export declare class GameControllerEndRoundState extends GameControllerState { + private betController; + private connector; + constructor(betController: Core.Controller.BetController, connector: Core.Network.Connector); + startNewRound(): void; + leave(): void; +} +export declare class GameControllerState implements Core.State.GameControllerState { + startNewRound(): void; + confirmBet(): void; + collectPoint(): void; + enter(): void; + leave(): void; +} +export declare const GAME_CONTROLLER_EVENT: { + SendNetworkRequest: symbol; +}; +import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator"; +export declare class GameControllerListStateTransitionCreator extends ListStateTransitionCreator { + protected getListStateTransition(): Core.State.ListStateTransition; +} +import { StateContext } from "../../../../common/state/state-context"; +export declare class GameControllerStateContext extends StateContext { +} +import { StateMachine } from "../../../../common/state/state-machine"; +export declare class GameControllerStateMachine extends StateMachine { +} +export declare class HistoryController implements Core.Controller.HistoryController { + private historyModel; + private historyGameView; + constructor(historyModel: Core.Model.HistoryModel, historyGameView: Core.View.GameView); + updateHistory(listRoundRecord: Core.Model.RoundRecordModel[]): void; +} +export declare class OddsController implements Core.Controller.OddsController { + private listOddsModel; + private oddsView; + constructor(listOddsModel: Core.Model.ListOddsModel, oddsView: Core.View.GameView); + updateListOdds(listOdds: number[]): void; +} +export declare class RoundResultController implements Core.Controller.RoundResultController { + private statisticController; + private roundResultModel; + private roundResultGameView; + constructor(statisticController: Core.Controller.StatisticController, roundResultModel: Core.Model.RoundResultModel, roundResultGameView: Core.View.GameView); + updateRoundResult(roundResult: RoundResult): void; +} +export declare class RoomController implements Core.Controller.RoomController { + private roomControllerStateMachine; + constructor(roomControllerStateMachine: Core.State.StateMachine); + joinRoom(roomIndex: number): void; + leaveRoom(): void; +} +import { RoomControllerState } from "./room-controller-state"; +export declare class RoomControllerDisableState extends RoomControllerState { +} +export declare const ROOM_CONTROLLER_EVENT: { + RequestJoinRoom: symbol; + LeaveRoom: symbol; +}; +import { RoomControllerState } from "./room-controller-state"; +export declare class RoomControllerInRoomState extends RoomControllerState { + private roomControllerEventManager; + private rebetModel; + private statisticModel; + private betController; + constructor(roomControllerEventManager: Core.State.StateMachineEventManager, rebetModel: Core.Model.BetModel, statisticModel: Core.Model.StatisticModel, betController: Core.Controller.BetController); + leaveRoom(): void; + leave(): void; + private clearStatistics; + private clearBet; +} +import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator"; +export declare class RoomControllerListStateTransitionCreator extends ListStateTransitionCreator { + protected getListStateTransition(): Core.State.ListStateTransition; +} +import { RoomControllerState } from "./room-controller-state"; +export declare class RoomControllerLoungeState extends RoomControllerState { + private roomControllerEventManager; + private connector; + constructor(roomControllerEventManager: Core.State.StateMachineEventManager, connector: Core.Network.Connector); + joinRoom(roomIndex: number): void; +} +import { StateContext } from "../../../../common/state/state-context"; +export declare class RoomControllerStateContext extends StateContext implements Core.State.RoomControllerStateContext { +} +import { StateMachine } from "../../../../common/state/state-machine"; +export declare class RoomControllerStateMachine extends StateMachine { +} +export declare class RoomControllerState implements Core.State.RoomControllerState { + joinRoom(roomIndex: number): void; + leaveRoom(): void; + enter(): void; + leave(): void; +} +export declare class StatisticController implements Core.Controller.StatisticController { + private statisticModel; + private statisticView; + constructor(statisticModel: Core.Model.StatisticModel, statisticView: Core.View.GameView); + addRoundResult(roundResult: RoundResult): void; + addListRoundResult(listRoundResult: RoundResult[]): void; +} +export declare class WinController implements Core.Controller.WinController { + private winModel; + private winGameView; + constructor(winModel: Core.Model.WinModel, winGameView: Core.View.GameView); + updateTotalWinPoint(totalWinPoint: number): void; +} +export declare abstract class HttpNetworkCommand implements Core.Pattern.Command { + protected networkRequest: Core.Network.NetworkRequest; + constructor(networkRequest: Core.Network.NetworkRequest); + execute(param: ParamType): void; + protected getRequestData(param: ParamType): any; +} +export declare class Connector implements Core.Network.Connector { + private connectCommand; + private joinRoomCommand; + private startNewRoundCommand; + private confirmBetCommand; + private collectPointCommand; + constructor(connectCommand: Core.Pattern.Command, joinRoomCommand: Core.Pattern.Command, startNewRoundCommand: Core.Pattern.Command, confirmBetCommand: Core.Pattern.Command, collectPointCommand: Core.Pattern.Command); + connectToServer(): void; + joinRoom(roomIndex: number): void; + startNewRound(): void; + sendConfirmBet(betArray: number[]): void; + collectPoint(): void; +} +import { RESTfulAPIRequest } from "./restful-api-request"; +export declare abstract class APIGet extends RESTfulAPIRequest { + protected getAPIMethod(): string; +} +import { RESTfulAPIRequest } from "./restful-api-request"; +export declare abstract class APIPost extends RESTfulAPIRequest { + protected getAPIMethod(): string; +} +export declare abstract class RESTfulAPIRequest implements Core.Network.NetworkRequest { + private successResponseHandler; + private invalidResponseHandler?; + private failedResponseHandler?; + private errorResponseHandler?; + private httpServerModel; + constructor(successResponseHandler: Core.Network.NetworkResponse, invalidResponseHandler?: Core.Network.NetworkResponse, failedResponseHandler?: Core.Network.NetworkResponse, errorResponseHandler?: Core.Network.NetworkResponse); + send(data?: any): void; + private sendHTTPRequest; + protected getHeader(): HeadersInit; + protected abstract getAPIMethod(): string; + protected abstract getAPIName(): string; + private onSuccessResponse; + private onInvalidResponse; + private onRequestFailed; + private onError; +} +export declare class ConsoleTraceResponse implements Core.Network.NetworkResponse { + onResponse(data?: any): void; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultBalanceProcessor extends ChainDataProcessor { + private balanceController; + private betController; + private betBalanceModel; + constructor(balanceController: Core.Controller.BalanceController, betController: Core.Controller.BetController, betBalanceModel: Core.Model.BalanceModel, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getBalance; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultBetOptionProcessor extends ChainDataProcessor { + private betOptionController; + constructor(betOptionController: Core.Controller.BetOptionController, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getDefaultBetOption; + private getListBetOption; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultBetSettingProcessor extends ChainDataProcessor { + private betLimitController; + private roomIndexModel; + constructor(betLimitController: Core.Controller.BetLimitController, roomIndexModel: Core.Model.RoomIndexModel, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getRoomIndex; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultLoungeBetLimitProcessor extends ChainDataProcessor { + private loungeBetLimitController; + constructor(loungeBetLimitController: Core.Controller.LoungeBetLimitController, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getListBetLimitSetting; + private getBetLimit; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultLoungeBetOptionProcessor extends ChainDataProcessor { + private loungeBetOptionController; + constructor(loungeBetOptionController: Core.Controller.LoungeBetOptionController, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getListBetOptionSetting; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultOddsProcessor extends ChainDataProcessor { + private oddsController; + constructor(oddsController: Core.Controller.OddsController, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getListOdds; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultServerErrorProcessor extends ChainDataProcessor { + private errorController; + constructor(errorController: Core.Controller.ErrorController, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getErrorCode; +} +import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor"; +export declare class DefaultWinProcessor extends ChainDataProcessor { + private winController; + constructor(winController: Core.Controller.WinController, nextDataProcessor?: Core.Network.DataProcessor); + process(data: any): void; + private getTotalWinPoint; +} +export declare abstract class NetworkResponse implements Core.Network.NetworkResponse { + protected networkEventPublisher: Core.EventSystem.EventPublisher; + protected dataProcessor?: Core.Network.DataProcessor; + constructor(networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor); + onResponse(data?: any): void; + protected abstract getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnBalance extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnBetLimitResponse extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnBetSettings extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnConfirmBetFailed extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnConfirmBetSuccessfully extends NetworkResponse { + private betModel; + private rebetModel; + private balanceController; + constructor(betModel: Core.Model.BetModel, rebetModel: Core.Model.BetModel, balanceController: Core.Controller.BalanceController, networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor); + protected getNetworkResponseSymbol(): Symbol; + onResponse(data?: any): void; + private setConfirmedBetToRebet; +} +import { NetworkResponse } from "./network-response"; +export declare class OnConnect extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnDisconnect extends NetworkResponse { + private errorController; + constructor(errorController: Core.Controller.ErrorController, networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor); + onResponse(data?: any): void; + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnError extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnGameStart extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnOdds extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnRoomJoin extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnRoundEnd extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnRoundResult extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnRoundStart extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnStatistic extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +import { NetworkResponse } from "./network-response"; +export declare class OnWin extends NetworkResponse { + protected getNetworkResponseSymbol(): Symbol; +} +export declare class ApplicationConfigModel implements Core.Model.ApplicationConfigModel { + sessionOCode: string; + sessionHash: string; + platform: string; + port: number; + address: string; + currency: string; + publisher: string; + enabledSSL: boolean; +} +export declare class BalanceModel implements Core.Model.BalanceModel { + credit: number; + freeCredit: number; + get totalCredit(): number; +} +export declare class BetLimitModel implements Core.Model.BetLimitModel { + listMinBetPoint: number[]; + listMaxBetPoint: number[]; + minTotalBetPoint: number; + maxTotalBetPoint: number; +} +export declare class BetModel implements Core.Model.BetModel { + listBetPoint: number[]; + constructor(gameConstantParameter: Core.Parameter.GameConstantParameter); +} +export declare class BetPositionModel implements Core.Model.BetPositionModel { + index: number; +} +export declare class CountdownModel implements Core.Model.CountdownModel { + remainTime: number; +} +export declare class ErrorModel implements Core.Model.ErrorModel { + errorType: Symbol; + serverErrorCode: number; +} +export declare class ListBetConflictModel implements Core.Model.ListBetConflictModel { + listBetConflict: Core.Model.BetConflictModel[]; +} +export declare class ListBetOptionModel implements Core.Model.ListBetOptionModel { + listBetOption: number[]; +} +export declare class ListOddsModel implements Core.Model.ListOddsModel { + listOdds: number[]; + constructor(gameConstantParameter: Core.Parameter.GameConstantParameter); +} +export declare class ListRoomBetLimitModel implements Core.Model.ListRoomBetLimitModel { + listRoomBetLimit: Core.Model.BetLimitModel[]; +} +export declare class ListRoomBetOptionModel implements Core.Model.ListRoomBetOptionModel { + listRoomBetOption: Core.Model.ListBetOptionModel[]; +} +export declare class RoomIndexModel implements Core.Model.RoomIndexModel { + roomIndex: number; +} +export declare class RoundResultModel implements Core.Model.RoundResultModel { + roundResult: RoundResult; +} +export declare class SelectedBetOptionModel implements Core.Model.SelectedBetOptionModel { + selectedBetOption: number; +} +export declare class WinModel implements Core.Model.WinModel { + totalWinPoint: number; +} +export declare class GameView implements Core.View.GameView { + private listComponent; + addComponent(component: Core.View.ComponentView): void; + update(): void; +} diff --git a/assets/core/plugins/core.d.ts.meta b/assets/core/plugins/core.d.ts.meta new file mode 100644 index 0000000..b56620d --- /dev/null +++ b/assets/core/plugins/core.d.ts.meta @@ -0,0 +1,6 @@ +{ + "ver": "2.0.2", + "uuid": "8735d714-0f46-4c44-b32b-e28eca191190", + "importer": "text", + "subMetas": {} +} \ No newline at end of file diff --git a/assets/core/plugins/core.i.ts b/assets/core/plugins/core.i.ts new file mode 100644 index 0000000..7040b99 --- /dev/null +++ b/assets/core/plugins/core.i.ts @@ -0,0 +1,410 @@ +declare namespace Core.Pattern { + interface Command { + execute(param: ParamType): void; + } +} +declare namespace Core.Pattern { + interface UndoManager { + push(undoable: Undoable): any; + undo(): any; + isUndoable(): boolean; + reset(): any; + } +} +declare namespace Core.Pattern { + interface Undoable { + undo(onSuccess?: Function): void; + } +} +declare namespace Core.Controller { + interface BalanceController { + updateBalance(credit: number, freeCredit: number): void; + withdraw(credit: number): void; + deposit(credit: number): void; + releaseBetCredit(): void; + } +} +declare namespace Core.Controller { + interface BetController { + placeBet(betPositionIndex: number): void; + clearBet(betPositionIndex: number): void; + clearAllBet(): void; + doubleBet(): void; + undo(): void; + rebet(): void; + reset(): void; + } +} +declare namespace Core.Controller { + interface BetLimitController { + updateCurrentBetLimit(roomIndex: number): any; + } +} +declare namespace Core.Controller { + interface BetOptionController { + updateListBetOption(listBetOption: number[], defaultBetOption: number): void; + changeBetOption(betOption: number): void; + } +} +declare namespace Core.Controller { + interface CountdownController { + startCountdown(duration: number, callbacks?: { + onComplete?: Function; + onTick?: Function; + }): any; + stop(): any; + reset(): any; + } +} +declare namespace Core.Controller { + interface ErrorController { + handleError(error: Symbol): void; + handleServerError(errorCode: number): void; + } +} +declare namespace Core.Controller { + interface GameController { + startNewRound(): void; + confirmBet(): void; + collectPoint(): void; + } +} +declare namespace Core.Controller { + interface HistoryController { + updateHistory(listRoundRecord: Core.Model.RoundRecordModel[]): void; + } +} +declare namespace Core.Controller { + interface LoungeBetLimitController { + updateBetLimitSetting(listBetLimitSetting: Core.Model.BetLimitModel[]): void; + } +} +declare namespace Core.Controller { + interface LoungeBetOptionController { + updateBetOptionSetting(listBetOptionSetting: Model.ListBetOptionModel[]): void; + } +} +declare namespace Core.Controller { + interface OddsController { + updateListOdds(listOdds: number[]): any; + } +} +declare namespace Core.Controller { + interface RoomController { + joinRoom(roomIndex: number): void; + leaveRoom(): void; + } +} +declare namespace Core.Controller { + interface RoundResultController { + updateRoundResult(roundResult: RoundResult): void; + } +} +declare namespace Core.Controller { + interface StatisticController { + addRoundResult(roundResult: RoundResult): void; + addListRoundResult(listRoundResult: RoundResult[]): void; + } +} +declare namespace Core.Controller { + interface WinController { + updateTotalWinPoint(totalWinPoint: number): void; + } +} +declare namespace Core.EventSystem { + interface EventListener { + register(type: any, callback: Function): EventContract; + } + interface EventPublisher { + emit(type: any): void; + } + interface EventContract { + on(): void; + off(): void; + break(): void; + } +} +declare namespace Core.Model { + interface ApplicationConfigModel { + sessionOCode: string; + sessionHash: string; + platform: string; + port: number; + address: string; + currency: string; + publisher: string; + enabledSSL: boolean; + } +} +declare namespace Core.Model { + interface BalanceModel { + credit: number; + freeCredit: number; + get totalCredit(): number; + } +} +declare namespace Core.Model { + interface BetConflictModel { + listConflictBetPosition: number[]; + } +} +declare namespace Core.Model { + interface BetLimitModel { + listMinBetPoint: number[]; + listMaxBetPoint: number[]; + minTotalBetPoint: number; + maxTotalBetPoint: number; + } +} +declare namespace Core.Model { + interface BetModel { + listBetPoint: number[]; + } +} +declare namespace Core.Model { + interface BetPositionModel { + index: number; + } +} +declare namespace Core.Model { + interface BetSettingModel { + listBetPoint: number[]; + } +} +declare namespace Core.Model { + interface CountdownModel { + remainTime: number; + } +} +declare namespace Core.Model { + interface ErrorModel { + errorType: Symbol; + serverErrorCode: number; + } +} +declare namespace Core.Model { + interface HistoryModel { + listRoundRecord: RoundRecordModel[]; + } +} +declare namespace Core.Model { + interface HTTPServerModel { + url: string; + } +} +declare namespace Core.Model { + interface ListBetConflictModel { + listBetConflict: BetConflictModel[]; + } +} +declare namespace Core.Model { + interface ListBetOptionModel { + listBetOption: number[]; + } +} +declare namespace Core.Model { + interface ListOddsModel { + listOdds: number[]; + } +} +declare namespace Core.Model { + interface ListPlayerModel { + listPlayer: PlayerModel[]; + } +} +declare namespace Core.Model { + interface ListRoomBetLimitModel { + listRoomBetLimit: BetLimitModel[]; + } +} +declare namespace Core.Model { + interface ListRoomBetOptionModel { + listRoomBetOption: ListBetOptionModel[]; + } +} +declare namespace Core.Model { + interface PlayerModel { + id: string; + name: string; + balance: number; + } +} +declare namespace Core.Model { + interface RoomIndexModel { + roomIndex: number; + } +} +declare namespace Core.Model { + interface RoundRecordModel { + roundId: string; + betTime: Date; + stake: number; + win: number; + profitLoss: number; + roundResult: RoundResult; + } +} +declare namespace Core.Model { + interface RoundResultModel { + roundResult: RoundResult; + } +} +declare namespace Core.Model { + interface SelectedBetOptionModel { + selectedBetOption: number; + } +} +declare namespace Core.Model { + interface StatisticModel { + listRoundResult: RoundResult[]; + } +} +declare namespace Core.Model { + interface WinModel { + totalWinPoint: number; + } +} +declare namespace Core.Network { + interface Connector { + connectToServer(): void; + joinRoom(roomIndex: number): void; + startNewRound(): void; + sendConfirmBet(betArray: number[]): void; + collectPoint(): void; + } +} +declare namespace Core.Network { + interface DataProcessor { + process(data: any): void; + } +} +declare namespace Core.Network { + interface NetworkController { + connectToServer(): any; + disconnectFromServer(): any; + } +} +declare namespace Core.Network { + interface NetworkRequest { + send(data?: any): void; + } +} +declare namespace Core.Network { + interface NetworkResponse { + onResponse(data?: any): any; + } +} +declare namespace Core.Parameter { + interface BetConstantParameter { + get DEFAULT_LIST_BET_OPTION(): number[]; + } +} +declare namespace Core.Parameter { + interface GameConstantParameter { + get BET_POSITION_COUNT(): number; + } +} +declare namespace Core.Service { + interface AvailableBetCalculator { + getAvailableBet(betPositionIndex: number): number; + } +} +declare namespace Core.Service { + interface Validator { + validate(): boolean; + } +} +declare namespace Core.State { + interface BetControllerStateContext extends StateContext { + } +} +declare namespace Core.State { + interface BetControllerStateMachine extends StateMachine { + } +} +declare namespace Core.State { + interface BetControllerState extends Controller.BetController, State { + } +} +declare namespace Core.State { + interface BetOptionControllerStateContext extends StateContext { + } +} +declare namespace Core.State { + interface BetOptionControllerStateMachine extends StateMachine { + } +} +declare namespace Core.State { + interface BetOptionControllerState extends Controller.BetOptionController, State { + } +} +declare namespace Core.State { + interface GameControllerStateContext extends StateContext { + } +} +declare namespace Core.State { + interface GameControllerStateMachine extends StateMachine { + } +} +declare namespace Core.State { + interface GameControllerState extends Controller.GameController, State { + } +} +declare namespace Core.State { + interface RoomControllerStateContext extends StateContext { + } +} +declare namespace Core.State { + interface RoomControllerStateMachine extends StateMachine { + } +} +declare namespace Core.State { + interface RoomControllerState extends Controller.RoomController, State { + } +} +declare namespace Core.State { + interface StateContext { + setState(state: T): void; + getState(): T; + } +} +declare namespace Core.State { + interface StateMachine { + changeState(event: symbol): void; + getState(): T; + } + interface StateMachineEventManager { + registerStateMachine(stateMachine: StateMachine): void; + unregisterStateMachine(stateMachine: StateMachine): void; + emit(event: symbol): void; + } +} +declare namespace Core.State { + interface StateTransition { + from?: new (...arg: any[]) => T; + event: symbol; + to: new (...arg: any[]) => T; + } + type ListStateTransition = StateTransition[]; + interface ListStateTransitionAssertor { + assert(listStateTransition: ListStateTransition): any; + } + interface ListStateTransitionCreator { + create(): ListStateTransition; + } +} +declare namespace Core.State { + interface State { + enter(): void; + leave(): void; + } +} +declare namespace Core.View { + interface ComponentView { + render(): void; + } + interface GameView { + addComponent(component: ComponentView): void; + update(): void; + } +} diff --git a/assets/core/plugins/core.i.ts.meta b/assets/core/plugins/core.i.ts.meta new file mode 100644 index 0000000..f6b11b4 --- /dev/null +++ b/assets/core/plugins/core.i.ts.meta @@ -0,0 +1,10 @@ +{ + "ver": "1.1.0", + "uuid": "6e64a7a1-b33d-4971-b81c-12a4531f88bb", + "importer": "typescript", + "isPlugin": false, + "loadPluginInWeb": true, + "loadPluginInNative": true, + "loadPluginInEditor": false, + "subMetas": {} +} \ No newline at end of file diff --git a/assets/core/plugins/core.js b/assets/core/plugins/core.js new file mode 100644 index 0000000..7c18378 --- /dev/null +++ b/assets/core/plugins/core.js @@ -0,0 +1,31 @@ +var _i=Object.create;var Cn=Object.defineProperty;var mo=Object.getOwnPropertyDescriptor;var Bi=Object.getOwnPropertyNames;var Ti=Object.getPrototypeOf,xi=Object.prototype.hasOwnProperty;var Oi=(n,e)=>()=>(e||n((e={exports:{}}).exports,e),e.exports);var Ai=(n,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of Bi(e))!xi.call(n,o)&&o!==t&&Cn(n,o,{get:()=>e[o],enumerable:!(r=mo(e,o))||r.enumerable});return n};var Ni=(n,e,t)=>(t=n!=null?_i(Ti(n)):{},Ai(e||!n||!n.__esModule?Cn(t,"default",{value:n,enumerable:!0}):t,n));var a=(n,e,t,r)=>{for(var o=r>1?void 0:r?mo(e,t):e,c=n.length-1,m;c>=0;c--)(m=n[c])&&(o=(r?m(e,t,o):m(o))||o);return r&&o&&Cn(e,t,o),o},i=(n,e)=>(t,r)=>e(t,r,n);var po=Oi(()=>{var uo;(function(n){(function(e){var t=typeof globalThis=="object"?globalThis:typeof global=="object"?global:typeof self=="object"?self:typeof this=="object"?this:b(),r=o(n);typeof t.Reflect<"u"&&(r=o(t.Reflect,r)),e(r,t),typeof t.Reflect>"u"&&(t.Reflect=n);function o(f,R){return function(B,L){Object.defineProperty(f,B,{configurable:!0,writable:!0,value:L}),R&&R(B,L)}}function c(){try{return Function("return this;")()}catch{}}function m(){try{return(0,eval)("(function() { return this; })()")}catch{}}function b(){return c()||m()}})(function(e,t){var r=Object.prototype.hasOwnProperty,o=typeof Symbol=="function",c=o&&typeof Symbol.toPrimitive<"u"?Symbol.toPrimitive:"@@toPrimitive",m=o&&typeof Symbol.iterator<"u"?Symbol.iterator:"@@iterator",b=typeof Object.create=="function",f={__proto__:[]}instanceof Array,R=!b&&!f,B={create:b?function(){return yn(Object.create(null))}:f?function(){return yn({__proto__:null})}:function(){return yn({})},has:R?function(d,u){return r.call(d,u)}:function(d,u){return u in d},get:R?function(d,u){return r.call(d,u)?d[u]:void 0}:function(d,u){return d[u]}},L=Object.getPrototypeOf(Function),W=typeof Map=="function"&&typeof Map.prototype.entries=="function"?Map:Si(),ee=typeof Set=="function"&&typeof Set.prototype.entries=="function"?Set:Mi(),Ae=typeof WeakMap=="function"?WeakMap:wi(),se=o?Symbol.for("@reflect-metadata:registry"):void 0,Ce=gi(),Xe=yi(Ce);function st(d,u,p,v){if(E(p)){if(!ro(d))throw new TypeError;if(!no(u))throw new TypeError;return di(d,u)}else{if(!ro(d))throw new TypeError;if(!D(u))throw new TypeError;if(!D(v)&&!E(v)&&!We(v))throw new TypeError;return We(v)&&(v=void 0),p=de(p),mi(d,u,p,v)}}e("decorate",st);function hn(d,u){function p(v,M){if(!D(v))throw new TypeError;if(!E(M)&&!vi(M))throw new TypeError;Qn(d,u,v,M)}return p}e("metadata",hn);function ri(d,u,p,v){if(!D(p))throw new TypeError;return E(v)||(v=de(v)),Qn(d,u,p,v)}e("defineMetadata",ri);function ni(d,u,p){if(!D(u))throw new TypeError;return E(p)||(p=de(p)),Yn(d,u,p)}e("hasMetadata",ni);function oi(d,u,p){if(!D(u))throw new TypeError;return E(p)||(p=de(p)),vn(d,u,p)}e("hasOwnMetadata",oi);function ii(d,u,p){if(!D(u))throw new TypeError;return E(p)||(p=de(p)),Jn(d,u,p)}e("getMetadata",ii);function ai(d,u,p){if(!D(u))throw new TypeError;return E(p)||(p=de(p)),zn(d,u,p)}e("getOwnMetadata",ai);function si(d,u){if(!D(d))throw new TypeError;return E(u)||(u=de(u)),Xn(d,u)}e("getMetadataKeys",si);function li(d,u){if(!D(d))throw new TypeError;return E(u)||(u=de(u)),Zn(d,u)}e("getOwnMetadataKeys",li);function ci(d,u,p){if(!D(u))throw new TypeError;if(E(p)||(p=de(p)),!D(u))throw new TypeError;E(p)||(p=de(p));var v=Ze(u,p,!1);return E(v)?!1:v.OrdinaryDeleteMetadata(d,u,p)}e("deleteMetadata",ci);function di(d,u){for(var p=d.length-1;p>=0;--p){var v=d[p],M=v(u);if(!E(M)&&!We(M)){if(!no(M))throw new TypeError;u=M}}return u}function mi(d,u,p,v){for(var M=d.length-1;M>=0;--M){var k=d[M],U=k(u,p,v);if(!E(U)&&!We(U)){if(!D(U))throw new TypeError;v=U}}return v}function Yn(d,u,p){var v=vn(d,u,p);if(v)return!0;var M=gn(u);return We(M)?!1:Yn(d,M,p)}function vn(d,u,p){var v=Ze(u,p,!1);return E(v)?!1:to(v.OrdinaryHasOwnMetadata(d,u,p))}function Jn(d,u,p){var v=vn(d,u,p);if(v)return zn(d,u,p);var M=gn(u);if(!We(M))return Jn(d,M,p)}function zn(d,u,p){var v=Ze(u,p,!1);if(!E(v))return v.OrdinaryGetOwnMetadata(d,u,p)}function Qn(d,u,p,v){var M=Ze(p,v,!0);M.OrdinaryDefineOwnMetadata(d,u,p,v)}function Xn(d,u){var p=Zn(d,u),v=gn(d);if(v===null)return p;var M=Xn(v,u);if(M.length<=0)return p;if(p.length<=0)return M;for(var k=new ee,U=[],x=0,g=p;x=0&&g=this._keys.length?(this._index=-1,this._keys=u,this._values=u):this._index++,{value:y,done:!1}}return{value:void 0,done:!0}},x.prototype.throw=function(g){throw this._index>=0&&(this._index=-1,this._keys=u,this._values=u),g},x.prototype.return=function(g){return this._index>=0&&(this._index=-1,this._keys=u,this._values=u),{value:g,done:!0}},x}(),v=function(){function x(){this._keys=[],this._values=[],this._cacheKey=d,this._cacheIndex=-2}return Object.defineProperty(x.prototype,"size",{get:function(){return this._keys.length},enumerable:!0,configurable:!0}),x.prototype.has=function(g){return this._find(g,!1)>=0},x.prototype.get=function(g){var y=this._find(g,!1);return y>=0?this._values[y]:void 0},x.prototype.set=function(g,y){var C=this._find(g,!0);return this._values[C]=y,this},x.prototype.delete=function(g){var y=this._find(g,!1);if(y>=0){for(var C=this._keys.length,S=y+1;S0)throw new fe(he.missingInjectionDecorator,`Found unexpected missing metadata on type "${n.name}" at constructor indexes "${t.join('", "')}". + +Are you using @inject, @multiInject or @unmanaged decorators at those indexes? + +If you're using typescript and want to rely on auto injection, set "emitDecoratorMetadata" compiler option to true`)}function go(n){return{kind:Y.singleInjection,name:void 0,optional:!1,tags:new Map,targetName:void 0,value:n}}function et(n){let e=n.find(m=>m.key===xn),t=n.find(m=>m.key===On);if(n.find(m=>m.key===Bn)!==void 0)return function(m,b){if(b!==void 0||m!==void 0)throw new fe(he.missingInjectionDecorator,"Expected a single @inject, @multiInject or @unmanaged metadata");return{kind:Y.unmanaged}}(e,t);if(t===void 0&&e===void 0)throw new fe(he.missingInjectionDecorator,"Expected @inject, @multiInject or @unmanaged metadata");let r=n.find(m=>m.key===ct),o=n.find(m=>m.key===Tn),c=n.find(m=>m.key===_n);return{kind:e===void 0?Y.multipleInjection:Y.singleInjection,name:r?.value,optional:o!==void 0,tags:new Map(n.filter(m=>Pi.every(b=>m.key!==b)).map(m=>[m.key,m.value])),targetName:c?.value,value:e===void 0?t?.value:e.value}}function yo(n,e,t){try{return et(t)}catch(r){throw fe.isErrorOfKind(r,he.missingInjectionDecorator)?new fe(he.missingInjectionDecorator,`Expected a single @inject, @multiInject or @unmanaged decorator at type "${n.name}" at constructor arguments at index "${e.toString()}"`,{cause:r}):r}}function Ii(n){let e=me(n,"design:paramtypes"),t=me(n,"inversify:tagged"),r=[];if(t!==void 0)for(let[o,c]of Object.entries(t)){let m=parseInt(o);r[m]=yo(n,m,c)}if(e!==void 0){for(let o=0;oNumber.MIN_SAFE_INTEGER):Mn(Object,En,o,c=>c+1),o}(),this.#n=e,this.#t=void 0,this.#e=t,this.#o=new Rn(typeof e=="string"?e:e.toString().slice(7,-1)),this.#i=r}get id(){return this.#r}get identifier(){return this.#n}get metadata(){return this.#t===void 0&&(this.#t=ki(this.#e)),this.#t}get name(){return this.#o}get type(){return this.#i}get serviceIdentifier(){return qe.is(this.#e.value)?this.#e.value.unwrap():this.#e.value}getCustomTags(){return[...this.#e.tags.entries()].map(([e,t])=>({key:e,value:t}))}getNamedTag(){return this.#e.name===void 0?null:{key:ct,value:this.#e.name}}hasTag(e){return this.metadata.some(t=>t.key===e)}isArray(){return this.#e.kind===Y.multipleInjection}isNamed(){return this.#e.name!==void 0}isOptional(){return this.#e.optional}isTagged(){return this.#e.tags.size>0}matchesArray(e){return this.isArray()&&this.#e.value===e}matchesNamedTag(e){return this.#e.name===e}matchesTag(e){return t=>this.metadata.some(r=>r.key===e&&r.value===t)}},An=n=>function(e,t){return function(r){let o=e(r),c=fo(r);for(;c!==void 0&&c!==Object;){let b=t(c);for(let[f,R]of b)o.properties.has(f)||o.properties.set(f,R);c=fo(c)}let m=[];for(let b of o.constructorArguments)if(b.kind!==Y.unmanaged){let f=b.targetName??"";m.push(new Ne(f,b,"ConstructorArgument"))}for(let[b,f]of o.properties)if(f.kind!==Y.unmanaged){let R=f.targetName??b;m.push(new Ne(R,f,"ClassProperty"))}return m}}(n===void 0?ji:e=>Di(e,n),n===void 0?So:e=>Mo(e,n));var te="named",No="name",Wn="unmanaged",ht="optional",vt="inject",bt="multi_inject",Fn="inversify:tagged",qn="inversify:tagged_props",Nn="inversify:paramtypes",Un="design:paramtypes",dt="post_construct",nt="pre_destroy",Gi=[vt,bt,No,Wn,te,ht],Ma=Object.freeze({__proto__:null,DESIGN_PARAM_TYPES:Un,INJECT_TAG:vt,MULTI_INJECT_TAG:bt,NAMED_TAG:te,NAME_TAG:No,NON_CUSTOM_TAG_KEYS:Gi,OPTIONAL_TAG:ht,PARAM_TYPES:Nn,POST_CONSTRUCT:dt,PRE_DESTROY:nt,TAGGED:Fn,TAGGED_PROP:qn,UNMANAGED_TAG:Wn}),G={Request:"Request",Singleton:"Singleton",Transient:"Transient"},P={ConstantValue:"ConstantValue",Constructor:"Constructor",DynamicValue:"DynamicValue",Factory:"Factory",Function:"Function",Instance:"Instance",Invalid:"Invalid",Provider:"Provider"},Po={ClassProperty:"ClassProperty",ConstructorArgument:"ConstructorArgument",Variable:"Variable"},Wi=0;function gt(){return Wi++}var Pn=class n{id;moduleId;activated;serviceIdentifier;implementationType;cache;dynamicValue;scope;type;factory;provider;constraint;onActivation;onDeactivation;constructor(e,t){this.id=gt(),this.activated=!1,this.serviceIdentifier=e,this.scope=t,this.type=P.Invalid,this.constraint=r=>!0,this.implementationType=null,this.cache=null,this.factory=null,this.provider=null,this.onActivation=null,this.onDeactivation=null,this.dynamicValue=null}clone(){let e=new n(this.serviceIdentifier,this.scope);return e.activated=e.scope===G.Singleton&&this.activated,e.implementationType=this.implementationType,e.dynamicValue=this.dynamicValue,e.scope=this.scope,e.type=this.type,e.factory=this.factory,e.provider=this.provider,e.constraint=this.constraint,e.onActivation=this.onActivation,e.onDeactivation=this.onDeactivation,e.cache=this.cache,e}},Io="Metadata key was used more than once in a parameter:",wo="NULL argument",Eo="Key Not Found",Fi="Ambiguous match found for serviceIdentifier:",qi="No matching bindings found for serviceIdentifier:",jo="The @inject @multiInject @tagged and @named decorators must be applied to the parameters of a class constructor or a class property.",In=(n,e)=>`onDeactivation() error in class ${n}: ${e}`,jn=class{getConstructorMetadata(e){return{compilerGeneratedMetadata:Reflect.getMetadata(Un,e)??[],userGeneratedMetadata:Reflect.getMetadata(Fn,e)??{}}}getPropertiesMetadata(e){return Reflect.getMetadata(qn,e)??{}}},Ue;function Lo(n){return n instanceof RangeError||n.message==="Maximum call stack size exceeded"}(function(n){n[n.MultipleBindingsAvailable=2]="MultipleBindingsAvailable",n[n.NoBindingsAvailable=0]="NoBindingsAvailable",n[n.OnlyOneBindingAvailable=1]="OnlyOneBindingAvailable"})(Ue||(Ue={}));function Me(n){return typeof n=="function"?n.name:typeof n=="symbol"?n.toString():n}function Ro(n,e,t){let r="",o=t(n,e);return o.length!==0&&(r=` +Registered bindings:`,o.forEach(c=>{let m="Object";c.implementationType!==null&&(m=Vo(c.implementationType)),r=`${r} + ${m}`,c.constraint.metaData&&(r=`${r} - ${c.constraint.metaData}`)})),r}function Do(n,e){return n.parentRequest!==null&&(n.parentRequest.serviceIdentifier===e||Do(n.parentRequest,e))}function ko(n){n.childRequests.forEach(e=>{if(Do(n,e.serviceIdentifier)){let t=function(r){return function c(m,b=[]){let f=Me(m.serviceIdentifier);return b.push(f),m.parentRequest!==null?c(m.parentRequest,b):b}(r).reverse().join(" --> ")}(e);throw new Error(`Circular dependency found: ${t}`)}ko(e)})}function Vo(n){if(n.name!=null&&n.name!=="")return n.name;{let e=n.toString(),t=e.match(/^function\s*([^\s(]+)/);return t===null?`Anonymous function: ${e}`:t[1]}}function _o(n){return`{"key":"${n.key.toString()}","value":"${n.value.toString()}"}`}var mt=class{id;container;plan;currentRequest;constructor(e){this.id=gt(),this.container=e}addPlan(e){this.plan=e}setCurrentRequest(e){this.currentRequest=e}},ge=class{key;value;constructor(e,t){this.key=e,this.value=t}toString(){return this.key===te?`named: ${String(this.value).toString()} `:`tagged: { key:${this.key.toString()}, value: ${String(this.value)} }`}},Ln=class{parentContext;rootRequest;constructor(e,t){this.parentContext=e,this.rootRequest=t}};function Go(n,e){let t=function(b){return Object.getPrototypeOf(b.prototype)?.constructor}(e);if(t===void 0||t===Object)return 0;let r=An(n)(t),o=r.map(b=>b.metadata.filter(f=>f.key===Wn)),c=[].concat.apply([],o).length,m=r.length-c;return m>0?m:Go(n,t)}var ot=class n{id;serviceIdentifier;parentContext;parentRequest;bindings;childRequests;target;requestScope;constructor(e,t,r,o,c){this.id=gt(),this.serviceIdentifier=e,this.parentContext=t,this.parentRequest=r,this.target=c,this.childRequests=[],this.bindings=Array.isArray(o)?o:[o],this.requestScope=r===null?new Map:null}addChildRequest(e,t,r){let o=new n(e,this.parentContext,this,t,r);return this.childRequests.push(o),o}};function ut(n){return n._bindingDictionary}function Bo(n,e,t,r,o){let c=tt(t.container,o.serviceIdentifier),m=[];return c.length===Ue.NoBindingsAvailable&&t.container.options.autoBindInjectable===!0&&typeof o.serviceIdentifier=="function"&&n.getConstructorMetadata(o.serviceIdentifier).compilerGeneratedMetadata&&(t.container.bind(o.serviceIdentifier).toSelf(),c=tt(t.container,o.serviceIdentifier)),m=e?c:c.filter(b=>{let f=new ot(b.serviceIdentifier,t,r,b,o);return b.constraint(f)}),function(b,f,R,B,L){switch(f.length){case Ue.NoBindingsAvailable:if(B.isOptional())return f;{let W=Me(b),ee=qi;throw ee+=function(Ae,se){if(se.isTagged()||se.isNamed()){let Ce="",Xe=se.getNamedTag(),st=se.getCustomTags();return Xe!==null&&(Ce+=_o(Xe)+` +`),st!==null&&st.forEach(hn=>{Ce+=_o(hn)+` +`}),` ${Ae} + ${Ae} - ${Ce}`}return` ${Ae}`}(W,B),ee+=Ro(L,W,tt),R!==null&&(ee+=` +Trying to resolve bindings for "${Me(R.serviceIdentifier)}"`),new Error(ee)}case Ue.OnlyOneBindingAvailable:return f;case Ue.MultipleBindingsAvailable:default:if(B.isArray())return f;{let W=Me(b),ee=`${Fi} ${W}`;throw ee+=Ro(L,W,tt),new Error(ee)}}}(o.serviceIdentifier,m,r,o,t.container),m}function Wo(n,e){let t=e.isMultiInject?bt:vt,r=[new ge(t,n)];return e.customTag!==void 0&&r.push(new ge(e.customTag.key,e.customTag.value)),e.isOptional===!0&&r.push(new ge(ht,!0)),r}function Fo(n,e,t,r,o,c){let m,b;if(o===null){m=Bo(n,e,r,null,c),b=new ot(t,r,null,m,c);let f=new Ln(r,b);r.addPlan(f)}else m=Bo(n,e,r,o,c),b=o.addChildRequest(c.serviceIdentifier,m,c);m.forEach(f=>{let R=null;if(c.isArray())R=b.addChildRequest(f.serviceIdentifier,f,c);else{if(f.cache!==null)return;R=b}if(f.type===P.Instance&&f.implementationType!==null){let B=function(L,W){return An(L)(W)}(n,f.implementationType);if(r.container.options.skipBaseClassChecks!==!0){let L=Go(n,f.implementationType);if(B.length= than the number of constructor arguments of its base class.`;throw new Error(W)}}B.forEach(L=>{Fo(n,!1,L.serviceIdentifier,r,R,L)})}})}function tt(n,e){let t=[],r=ut(n);return r.hasKey(e)?t=r.get(e):n.parent!==null&&(t=tt(n.parent,e)),t}function Ui(n,e,t,r,o,c=!1){let m=new mt(e),b=function(f,R,B){let L=Wo(R,B),W=et(L);if(W.kind===Y.unmanaged)throw new Error("Unexpected metadata when creating target");return new Ne("",W,f)}(t,r,o);try{return Fo(n,c,r,m,null,b),m}catch(f){throw Lo(f)&&ko(m.plan.rootRequest),f}}function z(n){return(typeof n=="object"&&n!==null||typeof n=="function")&&typeof n.then=="function"}function qo(n){return!!z(n)||Array.isArray(n)&&n.some(z)}var Hi=(n,e,t)=>{n.has(e.id)||n.set(e.id,t)},$i=(n,e)=>{n.cache=e,n.activated=!0,z(e)&&Ki(n,e)},Ki=async(n,e)=>{try{let t=await e;n.cache=t}catch(t){throw n.cache=null,n.activated=!1,t}},rt;(function(n){n.DynamicValue="toDynamicValue",n.Factory="toFactory",n.Provider="toProvider"})(rt||(rt={}));function Yi(n,e,t){let r;if(e.length>0){let o=function(m,b){return m.reduce((f,R)=>{let B=b(R);return R.target.type===Po.ConstructorArgument?f.constructorInjections.push(B):(f.propertyRequests.push(R),f.propertyInjections.push(B)),f.isAsync||(f.isAsync=qo(B)),f},{constructorInjections:[],isAsync:!1,propertyInjections:[],propertyRequests:[]})}(e,t),c={...o,constr:n};r=o.isAsync?async function(m){let b=await xo(m.constructorInjections),f=await xo(m.propertyInjections);return To({...m,constructorInjections:b,propertyInjections:f})}(c):To(c)}else r=new n;return r}function To(n){let e=new n.constr(...n.constructorInjections);return n.propertyRequests.forEach((t,r)=>{let o=t.target.identifier,c=n.propertyInjections[r];t.target.isOptional()&&c===void 0||(e[o]=c)}),e}async function xo(n){let e=[];for(let t of n)Array.isArray(t)?e.push(Promise.all(t)):e.push(t);return Promise.all(e)}function Oo(n,e){let t=function(r,o){if(Reflect.hasMetadata(dt,r)){let b=Reflect.getMetadata(dt,r);try{return o[b.value]?.()}catch(f){if(f instanceof Error)throw new Error((c=r.name,m=f.message,`@postConstruct error in class ${c}: ${m}`))}}var c,m}(n,e);return z(t)?t.then(()=>e):e}function Ji(n,e){n.scope!==G.Singleton&&function(t,r){let o=`Class cannot be instantiated in ${t.scope===G.Request?"request":"transient"} scope.`;if(typeof t.onDeactivation=="function")throw new Error(In(r.name,o));if(Reflect.hasMetadata(nt,r))throw new Error(`@preDestroy error in class ${r.name}: ${o}`)}(n,e)}var Hn=n=>e=>{e.parentContext.setCurrentRequest(e);let t=e.bindings,r=e.childRequests,o=e.target&&e.target.isArray(),c=!(e.parentRequest&&e.parentRequest.target&&e.target&&e.parentRequest.target.matchesArray(e.target.serviceIdentifier));if(o&&c)return r.map(m=>Hn(n)(m));{if(e.target.isOptional()&&t.length===0)return;let m=t[0];return Zi(n,e,m)}},zi=(n,e)=>{let t=(r=>{switch(r.type){case P.Factory:return{factory:r.factory,factoryType:rt.Factory};case P.Provider:return{factory:r.provider,factoryType:rt.Provider};case P.DynamicValue:return{factory:r.dynamicValue,factoryType:rt.DynamicValue};default:throw new Error(`Unexpected factory type ${r.type}`)}})(n);return((r,o)=>{try{return r()}catch(c){throw Lo(c)?o():c}})(()=>t.factory.bind(n)(e),()=>{return new Error((r=t.factoryType,o=e.currentRequest.serviceIdentifier.toString(),`It looks like there is a circular dependency in one of the '${r}' bindings. Please investigate bindings with service identifier '${o}'.`));var r,o})},Qi=(n,e,t)=>{let r,o=e.childRequests;switch((c=>{let m=null;switch(c.type){case P.ConstantValue:case P.Function:m=c.cache;break;case P.Constructor:case P.Instance:m=c.implementationType;break;case P.DynamicValue:m=c.dynamicValue;break;case P.Provider:m=c.provider;break;case P.Factory:m=c.factory}if(m===null){let b=Me(c.serviceIdentifier);throw new Error(`Invalid binding type: ${b}`)}})(t),t.type){case P.ConstantValue:case P.Function:r=t.cache;break;case P.Constructor:r=t.implementationType;break;case P.Instance:r=function(c,m,b,f){Ji(c,m);let R=Yi(m,b,f);return z(R)?R.then(B=>Oo(m,B)):Oo(m,R)}(t,t.implementationType,o,Hn(n));break;default:r=zi(t,e.parentContext)}return r},Xi=(n,e,t)=>{let r=((o,c)=>c.scope===G.Singleton&&c.activated?c.cache:c.scope===G.Request&&o.has(c.id)?o.get(c.id):null)(n,e);return r!==null||(r=t(),((o,c,m)=>{c.scope===G.Singleton&&$i(c,m),c.scope===G.Request&&Hi(o,c,m)})(n,e,r)),r},Zi=(n,e,t)=>Xi(n,t,()=>{let r=Qi(n,e,t);return r=z(r)?r.then(o=>Ao(e,t,o)):Ao(e,t,r),r});function Ao(n,e,t){let r=ea(n.parentContext,e,t),o=na(n.parentContext.container),c,m=o.next();do{c=m.value;let b=n.parentContext,f=n.serviceIdentifier,R=ra(c,f);r=z(r)?Uo(R,b,r):ta(R,b,r),m=o.next()}while(m.done!==!0&&!ut(c).hasKey(n.serviceIdentifier));return r}var ea=(n,e,t)=>{let r;return r=typeof e.onActivation=="function"?e.onActivation(n,t):t,r},ta=(n,e,t)=>{let r=n.next();for(;r.done!==!0;){if(z(t=r.value(e,t)))return Uo(n,e,t);r=n.next()}return t},Uo=async(n,e,t)=>{let r=await t,o=n.next();for(;o.done!==!0;)r=await o.value(e,r),o=n.next();return r},ra=(n,e)=>{let t=n._activations;return t.hasKey(e)?t.get(e).values():[].values()},na=n=>{let e=[n],t=n.parent;for(;t!==null;)e.push(t),t=t.parent;return{next:()=>{let r=e.pop();return r!==void 0?{done:!1,value:r}:{done:!0,value:void 0}}}},K=(n,e)=>{let t=n.parentRequest;return t!==null&&(!!e(t)||K(t,e))},be=n=>e=>{let t=r=>r!==null&&r.target!==null&&r.target.matchesTag(n)(e);return t.metaData=new ge(n,e),t},Se=be(te),Pe=n=>e=>{let t=null;if(e!==null){if(t=e.bindings[0],typeof n=="string")return t.serviceIdentifier===n;{let r=e.bindings[0].implementationType;return n===r}}return!1},He=class{_binding;constructor(e){this._binding=e}when(e){return this._binding.constraint=e,new H(this._binding)}whenTargetNamed(e){return this._binding.constraint=Se(e),new H(this._binding)}whenTargetIsDefault(){return this._binding.constraint=e=>e===null?!1:e.target!==null&&!e.target.isNamed()&&!e.target.isTagged(),new H(this._binding)}whenTargetTagged(e,t){return this._binding.constraint=be(e)(t),new H(this._binding)}whenInjectedInto(e){return this._binding.constraint=t=>t!==null&&Pe(e)(t.parentRequest),new H(this._binding)}whenParentNamed(e){return this._binding.constraint=t=>t!==null&&Se(e)(t.parentRequest),new H(this._binding)}whenParentTagged(e,t){return this._binding.constraint=r=>r!==null&&be(e)(t)(r.parentRequest),new H(this._binding)}whenAnyAncestorIs(e){return this._binding.constraint=t=>t!==null&&K(t,Pe(e)),new H(this._binding)}whenNoAncestorIs(e){return this._binding.constraint=t=>t!==null&&!K(t,Pe(e)),new H(this._binding)}whenAnyAncestorNamed(e){return this._binding.constraint=t=>t!==null&&K(t,Se(e)),new H(this._binding)}whenNoAncestorNamed(e){return this._binding.constraint=t=>t!==null&&!K(t,Se(e)),new H(this._binding)}whenAnyAncestorTagged(e,t){return this._binding.constraint=r=>r!==null&&K(r,be(e)(t)),new H(this._binding)}whenNoAncestorTagged(e,t){return this._binding.constraint=r=>r!==null&&!K(r,be(e)(t)),new H(this._binding)}whenAnyAncestorMatches(e){return this._binding.constraint=t=>t!==null&&K(t,e),new H(this._binding)}whenNoAncestorMatches(e){return this._binding.constraint=t=>t!==null&&!K(t,e),new H(this._binding)}},H=class{_binding;constructor(e){this._binding=e}onActivation(e){return this._binding.onActivation=e,new He(this._binding)}onDeactivation(e){return this._binding.onDeactivation=e,new He(this._binding)}},ce=class{_bindingWhenSyntax;_bindingOnSyntax;_binding;constructor(e){this._binding=e,this._bindingWhenSyntax=new He(this._binding),this._bindingOnSyntax=new H(this._binding)}when(e){return this._bindingWhenSyntax.when(e)}whenTargetNamed(e){return this._bindingWhenSyntax.whenTargetNamed(e)}whenTargetIsDefault(){return this._bindingWhenSyntax.whenTargetIsDefault()}whenTargetTagged(e,t){return this._bindingWhenSyntax.whenTargetTagged(e,t)}whenInjectedInto(e){return this._bindingWhenSyntax.whenInjectedInto(e)}whenParentNamed(e){return this._bindingWhenSyntax.whenParentNamed(e)}whenParentTagged(e,t){return this._bindingWhenSyntax.whenParentTagged(e,t)}whenAnyAncestorIs(e){return this._bindingWhenSyntax.whenAnyAncestorIs(e)}whenNoAncestorIs(e){return this._bindingWhenSyntax.whenNoAncestorIs(e)}whenAnyAncestorNamed(e){return this._bindingWhenSyntax.whenAnyAncestorNamed(e)}whenAnyAncestorTagged(e,t){return this._bindingWhenSyntax.whenAnyAncestorTagged(e,t)}whenNoAncestorNamed(e){return this._bindingWhenSyntax.whenNoAncestorNamed(e)}whenNoAncestorTagged(e,t){return this._bindingWhenSyntax.whenNoAncestorTagged(e,t)}whenAnyAncestorMatches(e){return this._bindingWhenSyntax.whenAnyAncestorMatches(e)}whenNoAncestorMatches(e){return this._bindingWhenSyntax.whenNoAncestorMatches(e)}onActivation(e){return this._bindingOnSyntax.onActivation(e)}onDeactivation(e){return this._bindingOnSyntax.onDeactivation(e)}},Dn=class{_binding;constructor(e){this._binding=e}inRequestScope(){return this._binding.scope=G.Request,new ce(this._binding)}inSingletonScope(){return this._binding.scope=G.Singleton,new ce(this._binding)}inTransientScope(){return this._binding.scope=G.Transient,new ce(this._binding)}},pt=class{_bindingInSyntax;_bindingWhenSyntax;_bindingOnSyntax;_binding;constructor(e){this._binding=e,this._bindingWhenSyntax=new He(this._binding),this._bindingOnSyntax=new H(this._binding),this._bindingInSyntax=new Dn(e)}inRequestScope(){return this._bindingInSyntax.inRequestScope()}inSingletonScope(){return this._bindingInSyntax.inSingletonScope()}inTransientScope(){return this._bindingInSyntax.inTransientScope()}when(e){return this._bindingWhenSyntax.when(e)}whenTargetNamed(e){return this._bindingWhenSyntax.whenTargetNamed(e)}whenTargetIsDefault(){return this._bindingWhenSyntax.whenTargetIsDefault()}whenTargetTagged(e,t){return this._bindingWhenSyntax.whenTargetTagged(e,t)}whenInjectedInto(e){return this._bindingWhenSyntax.whenInjectedInto(e)}whenParentNamed(e){return this._bindingWhenSyntax.whenParentNamed(e)}whenParentTagged(e,t){return this._bindingWhenSyntax.whenParentTagged(e,t)}whenAnyAncestorIs(e){return this._bindingWhenSyntax.whenAnyAncestorIs(e)}whenNoAncestorIs(e){return this._bindingWhenSyntax.whenNoAncestorIs(e)}whenAnyAncestorNamed(e){return this._bindingWhenSyntax.whenAnyAncestorNamed(e)}whenAnyAncestorTagged(e,t){return this._bindingWhenSyntax.whenAnyAncestorTagged(e,t)}whenNoAncestorNamed(e){return this._bindingWhenSyntax.whenNoAncestorNamed(e)}whenNoAncestorTagged(e,t){return this._bindingWhenSyntax.whenNoAncestorTagged(e,t)}whenAnyAncestorMatches(e){return this._bindingWhenSyntax.whenAnyAncestorMatches(e)}whenNoAncestorMatches(e){return this._bindingWhenSyntax.whenNoAncestorMatches(e)}onActivation(e){return this._bindingOnSyntax.onActivation(e)}onDeactivation(e){return this._bindingOnSyntax.onDeactivation(e)}},kn=class{_binding;constructor(e){this._binding=e}to(e){return this._binding.type=P.Instance,this._binding.implementationType=e,new pt(this._binding)}toSelf(){if(typeof this._binding.serviceIdentifier!="function")throw new Error("The toSelf function can only be applied when a constructor is used as service identifier");let e=this._binding.serviceIdentifier;return this.to(e)}toConstantValue(e){return this._binding.type=P.ConstantValue,this._binding.cache=e,this._binding.dynamicValue=null,this._binding.implementationType=null,this._binding.scope=G.Singleton,new ce(this._binding)}toDynamicValue(e){return this._binding.type=P.DynamicValue,this._binding.cache=null,this._binding.dynamicValue=e,this._binding.implementationType=null,new pt(this._binding)}toConstructor(e){return this._binding.type=P.Constructor,this._binding.implementationType=e,this._binding.scope=G.Singleton,new ce(this._binding)}toFactory(e){return this._binding.type=P.Factory,this._binding.factory=e,this._binding.scope=G.Singleton,new ce(this._binding)}toFunction(e){if(typeof e!="function")throw new Error("Value provided to function binding must be a function!");let t=this.toConstantValue(e);return this._binding.type=P.Function,this._binding.scope=G.Singleton,t}toAutoFactory(e){return this._binding.type=P.Factory,this._binding.factory=t=>()=>t.container.get(e),this._binding.scope=G.Singleton,new ce(this._binding)}toAutoNamedFactory(e){return this._binding.type=P.Factory,this._binding.factory=t=>r=>t.container.getNamed(e,r),new ce(this._binding)}toProvider(e){return this._binding.type=P.Provider,this._binding.provider=e,this._binding.scope=G.Singleton,new ce(this._binding)}toService(e){this._binding.type=P.DynamicValue,Object.defineProperty(this._binding,"cache",{configurable:!0,enumerable:!0,get:()=>null,set(t){}}),this._binding.dynamicValue=t=>{try{return t.container.get(e)}catch{return t.container.getAsync(e)}},this._binding.implementationType=null}},Vn=class n{bindings;activations;deactivations;middleware;moduleActivationStore;static of(e,t,r,o,c){let m=new n;return m.bindings=e,m.middleware=t,m.deactivations=o,m.activations=r,m.moduleActivationStore=c,m}},ve=class n{_map;constructor(){this._map=new Map}getMap(){return this._map}add(e,t){if(this._checkNonNulish(e),t==null)throw new Error(wo);let r=this._map.get(e);r!==void 0?r.push(t):this._map.set(e,[t])}get(e){this._checkNonNulish(e);let t=this._map.get(e);if(t!==void 0)return t;throw new Error(Eo)}remove(e){if(this._checkNonNulish(e),!this._map.delete(e))throw new Error(Eo)}removeIntersection(e){this.traverse((t,r)=>{let o=e.hasKey(t)?e.get(t):void 0;if(o!==void 0){let c=r.filter(m=>!o.some(b=>m===b));this._setValue(t,c)}})}removeByCondition(e){let t=[];return this._map.forEach((r,o)=>{let c=[];for(let m of r)e(m)?t.push(m):c.push(m);this._setValue(o,c)}),t}hasKey(e){return this._checkNonNulish(e),this._map.has(e)}clone(){let e=new n;return this._map.forEach((t,r)=>{t.forEach(o=>{var c;e.add(r,typeof(c=o)=="object"&&c!==null&&"clone"in c&&typeof c.clone=="function"?o.clone():o)})}),e}traverse(e){this._map.forEach((t,r)=>{e(r,t)})}_checkNonNulish(e){if(e==null)throw new Error(wo)}_setValue(e,t){t.length>0?this._map.set(e,t):this._map.delete(e)}},Gn=class n{_map=new Map;remove(e){let t=this._map.get(e);return t===void 0?this._getEmptyHandlersStore():(this._map.delete(e),t)}addDeactivation(e,t,r){this._getModuleActivationHandlers(e).onDeactivations.add(t,r)}addActivation(e,t,r){this._getModuleActivationHandlers(e).onActivations.add(t,r)}clone(){let e=new n;return this._map.forEach((t,r)=>{e._map.set(r,{onActivations:t.onActivations.clone(),onDeactivations:t.onDeactivations.clone()})}),e}_getModuleActivationHandlers(e){let t=this._map.get(e);return t===void 0&&(t=this._getEmptyHandlersStore(),this._map.set(e,t)),t}_getEmptyHandlersStore(){return{onActivations:new ve,onDeactivations:new ve}}},ft=class n{id;parent;options;_middleware;_bindingDictionary;_activations;_deactivations;_snapshots;_metadataReader;_moduleActivationStore;constructor(e){let t=e||{};if(typeof t!="object")throw new Error("Invalid Container constructor argument. Container options must be an object.");if(t.defaultScope===void 0)t.defaultScope=G.Transient;else if(t.defaultScope!==G.Singleton&&t.defaultScope!==G.Transient&&t.defaultScope!==G.Request)throw new Error('Invalid Container option. Default scope must be a string ("singleton" or "transient").');if(t.autoBindInjectable===void 0)t.autoBindInjectable=!1;else if(typeof t.autoBindInjectable!="boolean")throw new Error("Invalid Container option. Auto bind injectable must be a boolean");if(t.skipBaseClassChecks===void 0)t.skipBaseClassChecks=!1;else if(typeof t.skipBaseClassChecks!="boolean")throw new Error("Invalid Container option. Skip base check must be a boolean");this.options={autoBindInjectable:t.autoBindInjectable,defaultScope:t.defaultScope,skipBaseClassChecks:t.skipBaseClassChecks},this.id=gt(),this._bindingDictionary=new ve,this._snapshots=[],this._middleware=null,this._activations=new ve,this._deactivations=new ve,this.parent=null,this._metadataReader=new jn,this._moduleActivationStore=new Gn}static merge(e,t,...r){let o=new n,c=[e,t,...r].map(b=>ut(b)),m=ut(o);return c.forEach(b=>{var f;f=m,b.traverse((R,B)=>{B.forEach(L=>{f.add(L.serviceIdentifier,L.clone())})})}),o}load(...e){let t=this._getContainerModuleHelpersFactory();for(let r of e){let o=t(r.id);r.registry(o.bindFunction,o.unbindFunction,o.isboundFunction,o.rebindFunction,o.unbindAsyncFunction,o.onActivationFunction,o.onDeactivationFunction)}}async loadAsync(...e){let t=this._getContainerModuleHelpersFactory();for(let r of e){let o=t(r.id);await r.registry(o.bindFunction,o.unbindFunction,o.isboundFunction,o.rebindFunction,o.unbindAsyncFunction,o.onActivationFunction,o.onDeactivationFunction)}}unload(...e){e.forEach(t=>{let r=this._removeModuleBindings(t.id);this._deactivateSingletons(r),this._removeModuleHandlers(t.id)})}async unloadAsync(...e){for(let t of e){let r=this._removeModuleBindings(t.id);await this._deactivateSingletonsAsync(r),this._removeModuleHandlers(t.id)}}bind(e){return this._bind(this._buildBinding(e))}rebind(e){return this.unbind(e),this.bind(e)}async rebindAsync(e){return await this.unbindAsync(e),this.bind(e)}unbind(e){if(this._bindingDictionary.hasKey(e)){let t=this._bindingDictionary.get(e);this._deactivateSingletons(t)}this._removeServiceFromDictionary(e)}async unbindAsync(e){if(this._bindingDictionary.hasKey(e)){let t=this._bindingDictionary.get(e);await this._deactivateSingletonsAsync(t)}this._removeServiceFromDictionary(e)}unbindAll(){this._bindingDictionary.traverse((e,t)=>{this._deactivateSingletons(t)}),this._bindingDictionary=new ve}async unbindAllAsync(){let e=[];this._bindingDictionary.traverse((t,r)=>{e.push(this._deactivateSingletonsAsync(r))}),await Promise.all(e),this._bindingDictionary=new ve}onActivation(e,t){this._activations.add(e,t)}onDeactivation(e,t){this._deactivations.add(e,t)}isBound(e){let t=this._bindingDictionary.hasKey(e);return!t&&this.parent&&(t=this.parent.isBound(e)),t}isCurrentBound(e){return this._bindingDictionary.hasKey(e)}isBoundNamed(e,t){return this.isBoundTagged(e,te,t)}isBoundTagged(e,t,r){let o=!1;if(this._bindingDictionary.hasKey(e)){let c=this._bindingDictionary.get(e),m=function(b,f,R){let B=Wo(f,R),L=et(B);if(L.kind===Y.unmanaged)throw new Error("Unexpected metadata when creating target");let W=new Ne("",L,"Variable"),ee=new mt(b);return new ot(f,ee,null,[],W)}(this,e,{customTag:{key:t,value:r},isMultiInject:!1});o=c.some(b=>b.constraint(m))}return!o&&this.parent&&(o=this.parent.isBoundTagged(e,t,r)),o}snapshot(){this._snapshots.push(Vn.of(this._bindingDictionary.clone(),this._middleware,this._activations.clone(),this._deactivations.clone(),this._moduleActivationStore.clone()))}restore(){let e=this._snapshots.pop();if(e===void 0)throw new Error("No snapshot available to restore.");this._bindingDictionary=e.bindings,this._activations=e.activations,this._deactivations=e.deactivations,this._middleware=e.middleware,this._moduleActivationStore=e.moduleActivationStore}createChild(e){let t=new n(e||this.options);return t.parent=this,t}applyMiddleware(...e){let t=this._middleware?this._middleware:this._planAndResolve();this._middleware=e.reduce((r,o)=>o(r),t)}applyCustomMetadataReader(e){this._metadataReader=e}get(e){let t=this._getNotAllArgs(e,!1,!1);return this._getButThrowIfAsync(t)}async getAsync(e){let t=this._getNotAllArgs(e,!1,!1);return this._get(t)}getTagged(e,t,r){let o=this._getNotAllArgs(e,!1,!1,t,r);return this._getButThrowIfAsync(o)}async getTaggedAsync(e,t,r){let o=this._getNotAllArgs(e,!1,!1,t,r);return this._get(o)}getNamed(e,t){return this.getTagged(e,te,t)}async getNamedAsync(e,t){return this.getTaggedAsync(e,te,t)}getAll(e,t){let r=this._getAllArgs(e,t,!1);return this._getButThrowIfAsync(r)}async getAllAsync(e,t){let r=this._getAllArgs(e,t,!1);return this._getAll(r)}getAllTagged(e,t,r){let o=this._getNotAllArgs(e,!0,!1,t,r);return this._getButThrowIfAsync(o)}async getAllTaggedAsync(e,t,r){let o=this._getNotAllArgs(e,!0,!1,t,r);return this._getAll(o)}getAllNamed(e,t){return this.getAllTagged(e,te,t)}async getAllNamedAsync(e,t){return this.getAllTaggedAsync(e,te,t)}resolve(e){let t=this.isBound(e);t||this.bind(e).toSelf();let r=this.get(e);return t||this.unbind(e),r}tryGet(e){let t=this._getNotAllArgs(e,!1,!0);return this._getButThrowIfAsync(t)}async tryGetAsync(e){let t=this._getNotAllArgs(e,!1,!0);return this._get(t)}tryGetTagged(e,t,r){let o=this._getNotAllArgs(e,!1,!0,t,r);return this._getButThrowIfAsync(o)}async tryGetTaggedAsync(e,t,r){let o=this._getNotAllArgs(e,!1,!0,t,r);return this._get(o)}tryGetNamed(e,t){return this.tryGetTagged(e,te,t)}async tryGetNamedAsync(e,t){return this.tryGetTaggedAsync(e,te,t)}tryGetAll(e,t){let r=this._getAllArgs(e,t,!0);return this._getButThrowIfAsync(r)}async tryGetAllAsync(e,t){let r=this._getAllArgs(e,t,!0);return this._getAll(r)}tryGetAllTagged(e,t,r){let o=this._getNotAllArgs(e,!0,!0,t,r);return this._getButThrowIfAsync(o)}async tryGetAllTaggedAsync(e,t,r){let o=this._getNotAllArgs(e,!0,!0,t,r);return this._getAll(o)}tryGetAllNamed(e,t){return this.tryGetAllTagged(e,te,t)}async tryGetAllNamedAsync(e,t){return this.tryGetAllTaggedAsync(e,te,t)}_preDestroy(e,t){if(e!==void 0&&Reflect.hasMetadata(nt,e)){let r=Reflect.getMetadata(nt,e);return t[r.value]?.()}}_removeModuleHandlers(e){let t=this._moduleActivationStore.remove(e);this._activations.removeIntersection(t.onActivations),this._deactivations.removeIntersection(t.onDeactivations)}_removeModuleBindings(e){return this._bindingDictionary.removeByCondition(t=>t.moduleId===e)}_deactivate(e,t){let r=t==null?void 0:Object.getPrototypeOf(t).constructor;try{if(this._deactivations.hasKey(e.serviceIdentifier)){let c=this._deactivateContainer(t,this._deactivations.get(e.serviceIdentifier).values());if(z(c))return this._handleDeactivationError(c.then(async()=>this._propagateContainerDeactivationThenBindingAndPreDestroyAsync(e,t,r)),e.serviceIdentifier)}let o=this._propagateContainerDeactivationThenBindingAndPreDestroy(e,t,r);if(z(o))return this._handleDeactivationError(o,e.serviceIdentifier)}catch(o){if(o instanceof Error)throw new Error(In(Me(e.serviceIdentifier),o.message))}}async _handleDeactivationError(e,t){try{await e}catch(r){if(r instanceof Error)throw new Error(In(Me(t),r.message))}}_deactivateContainer(e,t){let r=t.next();for(;typeof r.value=="function";){let o=r.value(e);if(z(o))return o.then(async()=>this._deactivateContainerAsync(e,t));r=t.next()}}async _deactivateContainerAsync(e,t){let r=t.next();for(;typeof r.value=="function";)await r.value(e),r=t.next()}_getContainerModuleHelpersFactory(){let e=f=>R=>{let B=this._buildBinding(R);return B.moduleId=f,this._bind(B)},t=()=>f=>{this.unbind(f)},r=()=>async f=>this.unbindAsync(f),o=()=>f=>this.isBound(f),c=f=>{let R=e(f);return B=>(this.unbind(B),R(B))},m=f=>(R,B)=>{this._moduleActivationStore.addActivation(f,R,B),this.onActivation(R,B)},b=f=>(R,B)=>{this._moduleActivationStore.addDeactivation(f,R,B),this.onDeactivation(R,B)};return f=>({bindFunction:e(f),isboundFunction:o(),onActivationFunction:m(f),onDeactivationFunction:b(f),rebindFunction:c(f),unbindAsyncFunction:r(),unbindFunction:t()})}_bind(e){return this._bindingDictionary.add(e.serviceIdentifier,e),new kn(e)}_buildBinding(e){let t=this.options.defaultScope||G.Transient;return new Pn(e,t)}async _getAll(e){return Promise.all(this._get(e))}_get(e){let t={...e,contextInterceptor:r=>r,targetType:Po.Variable};if(this._middleware){let r=this._middleware(t);if(r==null)throw new Error("Invalid return type in middleware. Middleware must return!");return r}return this._planAndResolve()(t)}_getButThrowIfAsync(e){let t=this._get(e);if(qo(t))throw new Error(`You are attempting to construct ${function(r){return typeof r=="function"?`[function/class ${r.name||""}]`:typeof r=="symbol"?r.toString():`'${r}'`}(e.serviceIdentifier)} in a synchronous way but it has asynchronous dependencies.`);return t}_getAllArgs(e,t,r){return{avoidConstraints:!t?.enforceBindingConstraints,isMultiInject:!0,isOptional:r,serviceIdentifier:e}}_getNotAllArgs(e,t,r,o,c){return{avoidConstraints:!1,isMultiInject:t,isOptional:r,key:o,serviceIdentifier:e,value:c}}_getPlanMetadataFromNextArgs(e){let t={isMultiInject:e.isMultiInject};return e.key!==void 0&&(t.customTag={key:e.key,value:e.value}),e.isOptional===!0&&(t.isOptional=!0),t}_planAndResolve(){return e=>{let t=Ui(this._metadataReader,this,e.targetType,e.serviceIdentifier,this._getPlanMetadataFromNextArgs(e),e.avoidConstraints);return t=e.contextInterceptor(t),function(o){return Hn(o.plan.rootRequest.requestScope)(o.plan.rootRequest)}(t)}}_deactivateIfSingleton(e){if(e.activated)return z(e.cache)?e.cache.then(t=>this._deactivate(e,t)):this._deactivate(e,e.cache)}_deactivateSingletons(e){for(let t of e)if(z(this._deactivateIfSingleton(t)))throw new Error("Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)")}async _deactivateSingletonsAsync(e){await Promise.all(e.map(async t=>this._deactivateIfSingleton(t)))}_propagateContainerDeactivationThenBindingAndPreDestroy(e,t,r){return this.parent?this._deactivate.bind(this.parent)(e,t):this._bindingDeactivationAndPreDestroy(e,t,r)}async _propagateContainerDeactivationThenBindingAndPreDestroyAsync(e,t,r){this.parent?await this._deactivate.bind(this.parent)(e,t):await this._bindingDeactivationAndPreDestroyAsync(e,t,r)}_removeServiceFromDictionary(e){try{this._bindingDictionary.remove(e)}catch{throw new Error(`Could not unbind serviceIdentifier: ${Me(e)}`)}}_bindingDeactivationAndPreDestroy(e,t,r){if(typeof e.onDeactivation=="function"){let o=e.onDeactivation(t);if(z(o))return o.then(()=>this._preDestroy(r,t))}return this._preDestroy(r,t)}async _bindingDeactivationAndPreDestroyAsync(e,t,r){typeof e.onDeactivation=="function"&&await e.onDeactivation(t),await this._preDestroy(r,t)}};function oa(n,e,t,r){(function(o){if(o!==void 0)throw new Error(jo)})(e),Ho(Fn,n,t.toString(),r)}function ia(n){let e=[];if(Array.isArray(n)){e=n;let t=function(r){let o=new Set;for(let c of r){if(o.has(c))return c;o.add(c)}}(e.map(r=>r.key));if(t!==void 0)throw new Error(`${Io} ${t.toString()}`)}else e=[n];return e}function Ho(n,e,t,r){let o=ia(r),c={};Reflect.hasOwnMetadata(n,e)&&(c=Reflect.getMetadata(n,e));let m=c[t];if(m===void 0)m=[];else for(let b of m)if(o.some(f=>f.key===b.key))throw new Error(`${Io} ${b.key.toString()}`);m.push(...o),c[t]=m,Reflect.defineMetadata(n,c,e)}function $o(n){return(e,t,r)=>{typeof r=="number"?oa(e,t,r,n):function(o,c,m){if(o.prototype!==void 0)throw new Error(jo);Ho(qn,o.constructor,c,m)}(e,t,n)}}function s(){return function(n){if(Reflect.hasOwnMetadata(Nn,n))throw new Error("Cannot apply @injectable decorator multiple times.");let e=Reflect.getMetadata(Un,n)||[];return Reflect.defineMetadata(Nn,e,n),n}}function Ko(n){return e=>(t,r,o)=>{if(e===void 0){let c=typeof t=="function"?t.name:t.constructor.name;throw new Error(`@inject called with undefined this could mean that the class ${c} has a circular dependency problem. You can use a LazyServiceIdentifer to overcome this limitation.`)}$o(new ge(n,e))(t,r,o)}}var l=Ko(vt);function N(){return $o(new ge(ht,!0))}var wa=Ko(bt);function Yo(n,e){return()=>(t,r)=>{let o=new ge(n,r);if(Reflect.hasOwnMetadata(n,t.constructor))throw new Error(e);Reflect.defineMetadata(n,o,t.constructor)}}var Ea=Yo(dt,"Cannot apply @postConstruct decorator multiple times in the same class"),Ra=Yo(nt,"Cannot apply @preDestroy decorator multiple times in the same class");var yt=class{constructor(){this.listEventContract=[]}getContract(){return this.listEventContract}register(e,t){var r=this.listEventContract.find(c=>c.type==e&&c.callback==t);if(r)return r.expired=!1,r.broken=!1,r;var o=new lt;return o.register(e,t),this.listEventContract.push(o),o}};yt=a([s()],yt);var Ct=class{constructor(){this.listEventListener=[]}add(e){var t=this.listEventListener.indexOf(e)!=-1;t==!1&&this.listEventListener.push(e)}emit(e){this.listEventListener.forEach(t=>{var r=t.getContract();this.removeBrokenContract(r),this.executeListenerCallback(e,r)})}executeListenerCallback(e,t){var r=t.filter(o=>o.type==e);for(let o=0;o=0;t--)e[t].broken&&e.splice(t,1)}};Ct=a([s()],Ct);var St=class{get DEFAULT_LIST_BET_OPTION(){return[1,5,10,20]}};St=a([s()],St);var F={Default:Symbol("DefaultCommand"),Target:Symbol("TargetCommand"),Decorator:Symbol("DecoratorCommand"),PlaceBet:Symbol("PlaceBetCommand"),ClearBet:Symbol("ClearBetCommand"),ClearAllBet:Symbol("ClearAllBetCommand"),DoubleBet:Symbol("DoubleBetCommand"),Rebet:Symbol("RebetCommand"),ResetBet:Symbol("ResetBetCommand")},Q={Bet:Symbol("BetUndoManager")};var w={Default:Symbol("DefaultController"),Game:Symbol("GameController"),Room:Symbol("RoomController"),Bet:Symbol("BetController"),BetOption:Symbol("BetOptionController"),Balance:Symbol("BalanceController"),Countdown:Symbol("CountdownController"),Statistic:Symbol("StatisticController"),Odds:Symbol("OddsController"),History:Symbol("HistoryController"),BetLimit:Symbol("BetLimitController"),RoundResult:Symbol("RoundResultController"),Win:Symbol("WinController"),Error:Symbol("ErrorController"),LoungeBetLimit:Symbol("LoungeBetLimitController"),LoungeBetOption:Symbol("LoungeBetOptionController")},Jo={Default:Symbol("DefaultControllerEventPublisher")},Va={Default:Symbol("DefaultControllerEventListener")};var T={Bet:Symbol("BetGameView"),BetOption:Symbol("BetOptionGameView"),Countdown:Symbol("CountdownGameView"),Statistic:Symbol("StatisticGameView"),Odds:Symbol("OddsGameView"),Balance:Symbol("BalanceGameView"),History:Symbol("HistoryGameView"),BetLimit:Symbol("BetLimitGameView"),RoundResult:Symbol("RoundResultGameView"),Win:Symbol("WinGameView"),Error:Symbol("ErrorGameView"),Lounge:Symbol("LoungeGameView")};var h={ApplicationConfig:Symbol("ApplicationConfig"),BetLimit:Symbol("BetLimitModel"),RemainBalance:Symbol("RemainBalanceModel"),BetBalance:Symbol("BetBalanceModel"),Bet:Symbol("BetModel"),Rebet:Symbol("RebetModel"),BetPosition:Symbol("BetPositionModel"),ListBetOption:Symbol("ListBetOptionModel"),SelectedBetOption:Symbol("SelectedBetOptionModel"),RoomIndex:Symbol("RoomIndexModel"),BetConflict:Symbol("BetConflictModel"),ListBetConflict:Symbol("ListBetConflictModel"),History:Symbol("HistoryModel"),RoundRecord:Symbol("RoundRecordModel"),Statistic:Symbol("StatisticModel"),ListOdds:Symbol("ListOddsModel"),RoundResult:Symbol("RoundResultModel"),Win:Symbol("WinModel"),Countdown:Symbol("CountdownModel"),Error:Symbol("ErrorModel"),HttpServer:Symbol("HttpServerModel"),ListRoomBetOption:Symbol("ListRoomBetOptionModel"),ListRoomBetLimit:Symbol("ListRoomBetLimitModel")};var we={Default:Symbol("DefaultNetworkConnector"),EventProcessor:Symbol("EventProcessor")},zo={Default:Symbol("DefaultNetworkRequest")},_={Default:Symbol("DefaultNetworkResponse"),OnConnect:Symbol("OnConnectResponse"),OnConnectRetry:Symbol("OnConnectRetryResponse"),OnDisconnect:Symbol("OnDisconnectResponse"),OnLogout:Symbol("OnLogoutResponse"),OnRoomJoin:Symbol("OnRoomJoinResponse"),OnMessageData:Symbol("OnMessageDataResponse"),OnError:Symbol("OnErrorResponse"),OnLoginError:Symbol("OnLoginErrorResponse"),OnBetLimit:Symbol("OnBetLimitResponse"),OnBalance:Symbol("OnBalanceResponse"),OnGameStart:Symbol("OnGameStartResponse"),OnBetSettings:Symbol("OnBetSettingsResponse"),OnStatistic:Symbol("OnStatisticResponse"),OnRoundStart:Symbol("OnRoundStartResponse"),OnResult:Symbol("OnResultResponse"),OnWin:Symbol("OnWinResponse"),OnRoundEnd:Symbol("OnRoundEndResponse"),OnConfirmBetSuccessfully:Symbol("OnConfirmBetSuccessfullyResponse"),OnConfirmBetFailed:Symbol("OnConfirmBetFailedResponse"),OnOdds:Symbol("OnOddsResponse")},$e={Connect:Symbol("ConnectCommand"),JoinRoom:Symbol("JoinRoomCommand"),StartNewRound:Symbol("StartNewRoundCommand"),ConfirmBet:Symbol("ConfirmBetCommand"),CollectPoint:Symbol("CollectPointCommand")},Ke={Default:Symbol("DefaultNetworkEventPublisher")},Qo={Default:Symbol("DefaultNetworkEventListener")},j={Default:Symbol("DefaultDataProcessor"),Chain:Symbol("ChainDataProcessor")},it={Success:Symbol("SuccessHttpResponse"),Failed:Symbol("FailedHttpResponse"),Invalid:Symbol("InvalidHttpResponse"),Error:Symbol("ErrorHttpResponse")};var Ee={BetConstant:Symbol("BetConstantParameter"),GameConstant:Symbol("GameConstantParameter")};var Re=Symbol("AvailableBetCalculator"),ue={EnoughBalanceToBet:Symbol("EnoughBalanceToBetValidator"),BetConflict:Symbol("BetConflictValidator"),BetPointBelowMaxBetLimit:Symbol("BetPointBelowMaxBetLimitValidator"),TotalBetBelowMaxTotalBetLimit:Symbol("TotalBetBelowMaxTotalBetLimitValidator"),BetForbidden:Symbol("BetForbiddenValidator"),EmptyBetTable:Symbol("EmptyBetTableValidator")};var $={Game:{StateMachine:Symbol("GameControllerStateMachine"),EventManager:Symbol("GameControllerStateMachineEventManager")},Bet:{StateMachine:Symbol("BetControllerStateMachine"),EventManager:Symbol("BetControllerStateMachineEventManager")},BetOption:{StateMachine:Symbol("BetOptionControllerStateMachine"),EventManager:Symbol("BetOptionControllerStateMachineEventManager")},Room:{StateMachine:Symbol("RoomControllerStateMachine"),EventManager:Symbol("RoomControllerStateMachineEventManager")}},Xo=Symbol("StateContext"),Zo=Symbol("DefaultState"),ei=Symbol("ListStateTransitionCreator"),Mt={Default:Symbol("DefaultListStateTransitionAssertor"),Chain:Symbol("ChainListStateTransitionAssertor")};var J=new ft;var wt=class{constructor(e,t,r,o,c){this.betModel=e;this.currentBetLimitModel=t;this.remainBalanceModel=r;this.listBetOptionModel=o;this.betConstantParameter=c}getAvailableBet(e){let t=Math.min(...this.betConstantParameter.DEFAULT_LIST_BET_OPTION,...this.listBetOptionModel.listBetOption);if(this.remainBalanceModel.totalCreditc+o,0);return e-t}};wt=a([s(),i(0,l(h.Bet)),i(1,l(h.BetLimit)),i(2,l(h.RemainBalance)),i(3,l(h.ListBetOption)),i(4,l(Ee.BetConstant))],wt);var q=class{constructor(e){this.nextDataProcessor=e}process(e){this.nextDataProcessor&&this.nextDataProcessor.process(e)}};q=a([s(),i(0,l(j.Chain)),i(0,N())],q);var re=class{constructor(e){this.targetCommand=e}execute(){this.targetCommand.execute()}};re=a([s(),i(0,l(F.Target))],re);var X=class extends re{execute(){this.validate()?this.targetCommand.execute():this.handleValidateFailed()}handleValidateFailed(){}};X=a([s()],X);var Et=class{constructor(){this.undoableQueue=[]}push(e){this.undoableQueue.push(e)}undo(){let e=this.undoableQueue[this.undoableQueue.length-1];e&&e.undo(()=>this.removeUndoable(e))}isUndoable(){return this.undoableQueue.length>0}reset(){this.undoableQueue=[]}removeUndoable(e){let t=this.undoableQueue.indexOf(e);t>=0&&this.undoableQueue.splice(t,1)}};Et=a([s()],Et);var Rt=class{constructor(e,t,r){this.betModel=e;this.betPositionModel=t;this.listBetConflictModel=r}validate(){let e=this.listBetConflictModel.listBetConflict.length,t=this.betPositionModel.index;for(let r=0;re.listBetPoint[o]>0&&o!=t):!1}};Rt=a([s(),i(0,l(h.Bet)),i(1,l(h.BetPosition)),i(2,l(h.ListBetConflict))],Rt);var _t=class{constructor(e,t,r){this.betPositionModel=e;this.betModel=t;this.betLimitModel=r}validate(){let e=this.betPositionModel.index,t=this.betModel.listBetPoint[e],r=this.betLimitModel.listMaxBetPoint[e];return t=e}};Bt=a([s(),i(0,l(h.ListBetOption)),i(1,l(h.RemainBalance)),i(2,l(Ee.BetConstant))],Bt);var Tt=class{constructor(e,t){this.betModel=e;this.betLimitModel=t}validate(){let e=this.betModel.listBetPoint.reduce((o,c)=>o+c),t=this.betLimitModel.maxTotalBetPoint;return e0)return!1;return!0}};xt=a([s(),i(0,l(h.Bet))],xt);var ne=class{constructor(e){this.assertor=e}create(){let e=this.getListStateTransition();return this.assertor.assert(e),e}};ne=a([s(),i(0,l(Mt.Default))],ne);var _e=class{constructor(e){this.nextAssertor=e}assert(e){this._assert(e),this.nextAssertor?.assert(e)}};_e=a([s(),i(0,l(Mt.Chain)),i(0,N())],_e);var Ot=class extends _e{_assert(e){e.forEach((t,r)=>{e.forEach((o,c)=>{if(r ${e.event.description} -> ${e.to.name}`}isDuplicateTransition(e,t){let r=this.isSameFromState(e,t);return this.isSameEvent(e,t)&&r}isSameFromState(e,t){let r=e.from,o=t.from;return r==null||o==null||r===o}isSameEvent(e,t){return e.event===t.event}};Ot=a([s()],Ot);var At=class extends _e{_assert(e){let t=this.getListState(e);this.assertNoStateInheritance(t)}getListState(e){let t=[],r=o=>{t.indexOf(o)==-1&&t.push(o)};return e.forEach(o=>{let c=o.from,m=o.to;c!=null&&r(c),r(m)}),t}assertNoStateInheritance(e){e.forEach((t,r)=>{e.forEach((o,c)=>{r!=c&&this.throwErrorIfInherited(o,t)})})}throwErrorIfInherited(e,t){if(this.isInheritedState(e,t))throw new Error("States in listTransition must not inherit from each other."+e.name+" inherits from "+t.name)}isInheritedState(e,t){return t.prototype.isPrototypeOf(e.prototype)}};At=a([s()],At);function el(n,e){let t=J.get(Qo.Default);n.forEach(r=>{t.register(r,()=>{e.changeState(r)})})}function nl(n){let e=J.get(n.EventManager),t=J.get(n.StateMachine);e.registerStateMachine(t)}var oe=class{constructor(e){this.setState(e)}setState(e){this.currentState?.leave(),e.enter(),this.currentState=e}getState(){return this.currentState}};oe=a([s(),i(0,l(Zo))],oe);var ie=class{constructor(e,t){this.stateContext=e;this.listStateTransition=t.create()}getState(){return this.stateContext.getState()}changeState(e){let t=this.getTransition(e);t!=null&&this.executeTransition(t)}getTransition(e){let t=this.stateContext.getState();for(let r=0;rt!=e)}emit(e){this.listStateMachine.forEach(t=>t.changeState(e))}};Nt=a([s()],Nt);var $n=class{targetNamed(e,t){return e!=null&&e.target.matchesNamedTag(t.toString())}targetTagged(e,t,r){return e!=null&&e.target.matchesTag(t)(r)}targetIsDefault(e){return e!=null&&e.target!=null&&!e.target.isNamed()&&!e.target.isTagged()}injectInto(e,t){return e!=null&&Pe(t)(e.parentRequest)}parentNamed(e,t){return e!=null&&Se(parent)(e.parentRequest)}parentTagged(e,t,r){return e!=null&&be(t)(r)(e.parentRequest)}anyAncestorIs(e,t){return K(e,Pe(t))}noAncestorIs(e,t){return!K(e,Pe(t))}anyAncestorTagged(e,t,r){return K(e,be(t)(r))}noAncestorTagged(e,t,r){return!K(e,be(t)(r))}anyAncestorNamed(e,t){return K(e,Se(t))}noAncestorNamed(e,t){return!K(e,Se(t))}},ti=new $n;var at=Symbol.for("INJECTION");function Pt(n,e,t){function r(){return t&&!Reflect.hasMetadata(at,this,n)&&Reflect.defineMetadata(at,e(),this,n),Reflect.hasMetadata(at,this,n)?Reflect.getMetadata(at,this,n):e()}function o(c){Reflect.defineMetadata(at,c,this,n)}return{configurable:!0,enumerable:!0,get:r,set:o}}function aa(n,e){return function(t){return function(r,o){var c=function(){return n.get(t)};return Pt(o,c,e)}}}function sa(n,e){return function(t,r){return function(o,c){var m=function(){return n.getNamed(t,r)};return Pt(c,m,e)}}}function la(n,e){return function(t,r,o){return function(c,m){var b=function(){return n.getTagged(t,r,o)};return Pt(m,b,e)}}}function ca(n,e){return function(t){return function(r,o){var c=function(){return n.getAll(t)};return Pt(o,c,e)}}}function Cl(n,e=!0){var t=aa(n,e),r=sa(n,e),o=la(n,e),c=ca(n,e);return{customInject:t,customInjectNamed:r,customInjectTagged:o,customMultiInject:c}}var Kn=class{constructor(){this.graphs=[]}inSingletonScope(){return this.graphs.length>1&&(console.error("Can only set the root node as Singleton."),console.error("Check error at: ",this.graphs[this.graphs.length-1])),this.isSingletonGraph=!0,this}bind(e,t,r=!1){this.isBranching&&console.error("Please specify which class to be branched from. Parameters: ",e," ",t);var o=this.graphs[this.graphs.length-1],c={identifier:e,type:t,parent:o,isConstant:r};return this.graphs.push(c),this}branch(e,t,r=!1){return this.graphs.length==0&&console.error('Dependency graph cannot start with a "branch". It must start with a "bind" function.Parameters: ',e," ",t),this.isBranching&&console.error("Please specify which class to be branched from. Parameters: ",e," ",t),this.isBranching=!0,this.branchNode={identifier:e,type:t,isConstant:r,parent:null},this}from(e){this.isBranching==!1&&console.error('A "from" function must be called after a "branch" function. Parameters: ',e),this.isBranching=!1;var t=this.graphs.filter(r=>r.type==e).pop();return this.branchNode.parent=t,this.graphs.push(this.branchNode),this}registerTo(e){this.isBranching&&console.error('Please specify which class to be branched from before call "register" function.'),this.container=e,this.registerGraphToContainer(),this.resetGraph()}registerGraphToContainer(){for(let e=0;ethis.recursiveCheckBindingCondition(t,e))}bindToConstant(e){this.container.bind(e.identifier).toConstantValue(e.type).when(t=>this.recursiveCheckBindingCondition(t,e))}recursiveCheckBindingCondition(e,t){if(t.parent==null)return!0;var r=ti.injectInto(e,t.parent.type)&&this.recursiveCheckBindingCondition(e.parentRequest,t.parent);return r}},wl=new Kn;var It=class{constructor(e,t,r){this.betBalanceModel=e;this.remainBalanceModel=t;this.balanceGameView=r}updateBalance(e,t){let r=this.betBalanceModel.totalCredit;if(r>e+t)throw new Error("Not enough credit to hold bet");this.remainBalanceModel.credit=e,this.remainBalanceModel.freeCredit=t,this.resetBetBalance(),this.withdraw(r)}releaseBetCredit(){this.resetBetBalance(),this.balanceGameView.update()}withdraw(e){this.transferCredit(this.remainBalanceModel,this.betBalanceModel,e,"freeCredit"),this.balanceGameView.update()}deposit(e){this.transferCredit(this.betBalanceModel,this.remainBalanceModel,e,"credit"),this.balanceGameView.update()}getBalanceModelName(e){return e===this.betBalanceModel?"Bet Balance":e===this.remainBalanceModel?"Remain Balance":"Unknown Balance"}transferCredit(e,t,r,o){if(e.totalCredite+t,0)}execute(){this.listReturnBetPoint=[...this.betModel.listBetPoint];for(let e=0;e0&&(this.balanceController.deposit(this.totalReturnBetPoint),this.betUndoManager.push(this),this.betGameView.update())}undo(e){if(this.remainBalanceModel.totalCredit0&&(this.betModel.listBetPoint[e]=0,this.balanceController.deposit(t))}};qt=a([s(),i(0,l(h.BetPosition)),i(1,l(h.Bet)),i(2,l(Jo.Default)),i(3,l(w.Balance))],qt);var Ut=class extends X{constructor(t,r,o){super(t);this.betConflictValidator=r;this.errorController=o}validate(){return this.betConflictValidator.validate()===!1}handleValidateFailed(){this.errorController.handleError(Z.BetConflict)}};Ut=a([s(),i(0,l(F.Target)),i(1,l(ue.BetConflict)),i(2,l(w.Error))],Ut);var Ht=class extends X{constructor(t,r){super(t);this.emptyBetTableValidator=r}validate(){return this.emptyBetTableValidator.validate()}};Ht=a([s(),i(0,l(F.Target)),i(1,l(ue.EmptyBetTable))],Ht);var $t=class extends X{constructor(t,r,o){super(t);this.enoughBalanceToBetValidator=r;this.errorController=o}validate(){return this.enoughBalanceToBetValidator.validate()}handleValidateFailed(){this.errorController.handleError(Z.NotEnoughBalanceToBet)}};$t=a([s(),i(0,l(F.Target)),i(1,l(ue.EnoughBalanceToBet)),i(2,l(w.Error))],$t);var Kt=class extends X{constructor(t,r,o){super(t);this.betPointBelowMaxBetLimitValidator=r;this.errorController=o}validate(){return this.betPointBelowMaxBetLimitValidator.validate()}handleValidateFailed(){this.errorController.handleError(Z.MaxBetReached)}};Kt=a([s(),i(0,l(F.Target)),i(1,l(ue.BetPointBelowMaxBetLimit)),i(2,l(w.Error))],Kt);var Yt=class extends X{constructor(t,r,o){super(t);this.totalBetBelowMaxTotalBetLimitValidator=r;this.errorController=o}validate(){return this.totalBetBelowMaxTotalBetLimitValidator.validate()}handleValidateFailed(){this.errorController.handleError(Z.MaxBetReached)}};Yt=a([s(),i(0,l(F.Target)),i(1,l(ue.TotalBetBelowMaxTotalBetLimit)),i(2,l(w.Error))],Yt);var Te=class{constructor(e,t,r,o,c,m){this.betModel=e;this.remainBalanceModel=t;this.balanceController=r;this.betUndoManager=o;this.betGameView=c;this.availableBetCalculator=m;this.listPlacedBet=[]}execute(){let e=this.getTargetPlaceMultiBetData(),t=this.adjustBets(e),r=0;t.forEach(o=>{this.betModel.listBetPoint[o.betPositionIndex]+=o.betPoint,r+=o.betPoint}),r>0&&(this.balanceController.withdraw(r),this.registerUndo(t),this.betGameView.update())}undo(e){let t=0;this.listPlacedBet.forEach(r=>{let o=r.betPositionIndex,c=r.betPoint;this.betModel.listBetPoint[o]-=c,t+=c}),this.balanceController.deposit(t),e?.(),this.betGameView.update()}registerUndo(e){this.listPlacedBet=e,this.betUndoManager.push(this)}adjustBets(e){let t=e;return t=this.adjustBetsToAvailableBet(t),t=this.adjustBetsToBalance(t,this.remainBalanceModel.totalCredit),t}adjustBetsToAvailableBet(e){let t=[];return e.forEach(r=>{let o=this.availableBetCalculator.getAvailableBet(r.betPositionIndex),c=Math.min(o,r.betPoint);t.push({betPositionIndex:r.betPositionIndex,betPoint:c})}),t}adjustBetsToBalance(e,t){let r=e.reduce((c,m)=>c+m.betPoint,0);if(r<=t)return e;let o=[...e];for(let c=o.length-1;c>=0&&r>t;c--){let m=o[c],b=r-t,f=Math.min(b,m.betPoint);m.betPoint-=f,r-=f,m.betPoint<=0&&o.splice(c,1)}return o}};Te=a([s(),i(0,l(h.Bet)),i(1,l(h.RemainBalance)),i(2,l(w.Balance)),i(3,l(Q.Bet)),i(4,l(T.Bet)),i(5,l(Re))],Te);var Jt=class extends Te{constructor(e,t,r,o,c,m){super(e,t,r,o,c,m)}getTargetPlaceMultiBetData(){let e=this.betModel.listBetPoint,t=[];return e.forEach((r,o)=>{r>0&&t.push({betPoint:r,betPositionIndex:o})}),t}};Jt=a([s(),i(0,l(h.Bet)),i(1,l(h.RemainBalance)),i(2,l(w.Balance)),i(3,l(Q.Bet)),i(4,l(T.Bet)),i(5,l(Re))],Jt);var zt=class extends re{};zt=a([s()],zt);var Qt=class{constructor(e,t,r,o,c,m,b){this.betPositionModel=e;this.selectedBetOptionModel=t;this.betModel=r;this.availableBetCalculator=o;this.betUndoManager=c;this.balanceController=m;this.betGameView=b}execute(){let e=this.betPositionModel.index,t=this.selectedBetOptionModel.selectedBetOption,r=this.availableBetCalculator.getAvailableBet(this.betPositionModel.index),o=Math.min(t,r);o>0&&(this.placeBet(e,o),this.betUndoManager.push(this),this.balanceController.withdraw(o),this.betGameView.update())}undo(e){this.betModel.listBetPoint[this.placeBetPositionIndex]-=this.placedBetValue,this.balanceController.deposit(this.placedBetValue),e?.(),this.betGameView.update()}placeBet(e,t){this.betModel.listBetPoint[e]+=t,this.placeBetPositionIndex=e,this.placedBetValue=t}};Qt=a([s(),i(0,l(h.BetPosition)),i(1,l(h.SelectedBetOption)),i(2,l(h.Bet)),i(3,l(Re)),i(4,l(Q.Bet)),i(5,l(w.Balance)),i(6,l(T.Bet))],Qt);var Xt=class extends re{};Xt=a([s()],Xt);var Zt=class extends Te{constructor(t,r,o,c,m,b,f){super(t,r,o,c,m,b);this.rebetModel=f}getTargetPlaceMultiBetData(){let t=this.rebetModel.listBetPoint,r=[];return t.forEach((o,c)=>{o>0&&r.push({betPoint:o,betPositionIndex:c})}),r}};Zt=a([s(),i(0,l(h.Bet)),i(1,l(h.RemainBalance)),i(2,l(w.Balance)),i(3,l(Q.Bet)),i(4,l(T.Bet)),i(5,l(Re)),i(6,l(h.Rebet))],Zt);var er=class extends re{};er=a([s()],er);var tr=class{constructor(e,t,r,o,c){this.balanceController=e;this.betBalanceModel=t;this.betModel=r;this.betUndoManager=o;this.betGameView=c}execute(){this.returnBetPointToBalance(),this.resetBet()}returnBetPointToBalance(){let e=this.betBalanceModel.totalCredit;this.balanceController.deposit(e)}resetBet(){this.betModel.listBetPoint.fill(0),this.betUndoManager.reset(),this.betGameView.update()}};tr=a([s(),i(0,l(w.Balance)),i(1,l(h.BetBalance)),i(2,l(h.Bet)),i(3,l(Q.Bet)),i(4,l(T.Bet))],tr);var rr=class{constructor(e){this.betControllerStateMachine=e}placeBet(e){this.betControllerStateMachine.getState().placeBet(e)}clearBet(e){this.betControllerStateMachine.getState().clearBet(e)}clearAllBet(){this.betControllerStateMachine.getState().clearAllBet()}doubleBet(){this.betControllerStateMachine.getState().doubleBet()}rebet(){this.betControllerStateMachine.getState().rebet()}undo(){this.betControllerStateMachine.getState().undo()}reset(){J.get(F.ResetBet).execute(),this.betControllerStateMachine.getState().reset()}};rr=a([s(),i(0,l($.Bet.StateMachine))],rr);var Le=class{placeBet(){}clearBet(){}clearAllBet(){}doubleBet(){}undo(){}rebet(){}reset(){}enter(){}leave(){}};Le=a([s()],Le);var De=class{constructor(e,t){this.betPositionModel=e;this.betUndoManager=t}placeBet(e){this.betPositionModel.index=e,J.get(F.PlaceBet).execute()}clearBet(e){this.betPositionModel.index=e,J.get(F.ClearBet).execute()}clearAllBet(){J.get(F.ClearAllBet).execute()}doubleBet(){J.get(F.DoubleBet).execute()}rebet(){J.get(F.Rebet).execute()}undo(){this.betUndoManager.undo()}reset(){}enter(){}leave(){}};De=a([s(),i(0,l(h.BetPosition)),i(1,l(Q.Bet))],De);var xe={Enable:Symbol("EnableBetController"),Disable:Symbol("DisableBetController")};var nr=class extends ne{getListStateTransition(){return[{from:De,event:xe.Disable,to:Le},{from:Le,event:xe.Enable,to:De}]}};nr=a([s()],nr);var or=class extends oe{};or=a([s()],or);var ir=class extends ie{};ir=a([s()],ir);var ar=class{constructor(e,t){this.countdownModel=e;this.countdownGameView=t}startCountdown(e,t){this.stop();let r=e,o=t?.onComplete,c=t?.onTick;this.setRemainTime(r),this.intervalId=setInterval(()=>{r--,this.setRemainTime(r),c?.(),r<=0&&(this.stop(),o?.())},1e3)}stop(){clearInterval(this.intervalId)}reset(){this.stop(),this.setRemainTime(0)}setRemainTime(e){this.countdownModel.remainTime=e,this.countdownGameView.update()}};ar=a([s(),i(0,l(h.Countdown)),i(1,l(T.Countdown))],ar);var sr=class{constructor(e,t){this.errorModel=e;this.errorGameView=t}handleServerError(e){this.errorModel.errorType=Z.ServerError,this.errorModel.serverErrorCode=e,this.errorGameView.update()}handleError(e){this.errorModel.errorType=e,this.errorGameView.update()}};sr=a([s(),i(0,l(h.Error)),i(1,l(T.Error))],sr);var lr=class{constructor(e){this.gameControllerStateMachine=e}startNewRound(){this.gameControllerStateMachine.getState().startNewRound()}confirmBet(){this.gameControllerStateMachine.getState().confirmBet()}collectPoint(){this.gameControllerStateMachine.getState().collectPoint()}};lr=a([s(),i(0,l($.Game.StateMachine))],lr);var cr={SendNetworkRequest:Symbol("GameControllerSendRequest")};var ae=class{startNewRound(){}confirmBet(){}collectPoint(){}enter(){}leave(){}};ae=a([s()],ae);var Oe=class extends ae{constructor(t,r,o,c,m){super();this.connector=t;this.betModel=r;this.gameControllerEventManager=o;this.betControllerEventManager=c;this.betOptionControllerEventManager=m}confirmBet(){let t=this.betModel.listBetPoint;this.connector.sendConfirmBet(t),this.gameControllerEventManager.emit(cr.SendNetworkRequest)}enter(){this.enableControllers()}leave(){this.disableControllers()}enableControllers(){this.betControllerEventManager.emit(xe.Enable),this.betOptionControllerEventManager.emit(Be.Enable)}disableControllers(){this.betControllerEventManager.emit(xe.Disable),this.betOptionControllerEventManager.emit(Be.Disable)}};Oe=a([s(),i(0,l(we.Default)),i(1,l(h.Bet)),i(2,l($.Game.EventManager)),i(3,l($.Bet.EventManager)),i(4,l($.BetOption.EventManager))],Oe);var Ye=class extends ae{constructor(t){super();this.connector=t}collectPoint(){this.connector.collectPoint()}};Ye=a([s(),i(0,l(we.Default))],Ye);var Je=class extends ae{constructor(t,r){super();this.betControllerEventManager=t;this.betOptionControllerEventManager=r}enter(){this.betControllerEventManager.emit(xe.Disable),this.betOptionControllerEventManager.emit(Be.Disable)}};Je=a([s(),i(0,l($.Bet.EventManager)),i(1,l($.BetOption.EventManager))],Je);var ze=class extends ae{constructor(t,r){super();this.betController=t;this.connector=r}startNewRound(){this.connector.startNewRound()}leave(){this.betController.reset()}};ze=a([s(),i(0,l(w.Bet)),i(1,l(we.Default))],ze);var dr=class extends ne{getListStateTransition(){return[{event:cr.SendNetworkRequest,to:Je},{event:_.OnGameStart,to:Oe},{event:_.OnRoundStart,to:Oe},{event:_.OnConfirmBetFailed,to:Oe},{event:_.OnResult,to:Ye},{event:_.OnBalance,to:ze}]}};dr=a([s()],dr);var mr=class extends oe{};mr=a([s()],mr);var ur=class extends ie{};ur=a([s()],ur);var pr=class{constructor(e,t){this.historyModel=e;this.historyGameView=t}updateHistory(e){this.historyModel.listRoundRecord=e,this.historyGameView.update()}};pr=a([s(),i(0,l(h.History)),i(1,l(T.History))],pr);var fr=class{constructor(e,t){this.listOddsModel=e;this.oddsView=t}updateListOdds(e){this.listOddsModel.listOdds=e,this.oddsView.update()}};fr=a([s(),i(0,l(h.ListOdds)),i(1,l(T.Odds))],fr);var hr=class{constructor(e,t,r){this.statisticController=e;this.roundResultModel=t;this.roundResultGameView=r}updateRoundResult(e){this.roundResultModel.roundResult=e,this.statisticController.addRoundResult(e),this.roundResultGameView.update()}};hr=a([s(),i(0,l(w.Statistic)),i(1,l(h.RoundResult)),i(2,l(T.RoundResult))],hr);var vr=class{constructor(e){this.roomControllerStateMachine=e}joinRoom(e){this.roomControllerStateMachine.getState().joinRoom(e)}leaveRoom(){this.roomControllerStateMachine.getState().leaveRoom()}};vr=a([s(),i(0,l($.Room.StateMachine))],vr);var pe=class{joinRoom(e){}leaveRoom(){}enter(){}leave(){}};pe=a([s()],pe);var Qe=class extends pe{};Qe=a([s()],Qe);var ke={RequestJoinRoom:Symbol("RequestJoinRoom"),LeaveRoom:Symbol("LeaveRoom")};var Ve=class extends pe{constructor(t,r,o,c){super();this.roomControllerEventManager=t;this.rebetModel=r;this.statisticModel=o;this.betController=c}leaveRoom(){this.roomControllerEventManager.emit(ke.LeaveRoom)}leave(){this.clearBet(),this.clearStatistics()}clearStatistics(){this.statisticModel.listRoundResult=[]}clearBet(){this.rebetModel.listBetPoint.fill(0),this.betController.reset()}};Ve=a([s(),i(0,l($.Room.EventManager)),i(1,l(h.Rebet)),i(2,l(h.Statistic)),i(3,l(w.Bet))],Ve);var Ge=class extends pe{constructor(t,r){super();this.roomControllerEventManager=t;this.connector=r}joinRoom(t){this.connector.joinRoom(t),this.roomControllerEventManager.emit(ke.RequestJoinRoom)}};Ge=a([s(),i(0,l($.Room.EventManager)),i(1,l(we.Default))],Ge);var br=class extends ne{getListStateTransition(){return[{event:_.OnConnect,to:Ge},{event:ke.RequestJoinRoom,to:Qe},{event:_.OnRoomJoin,to:Ve},{from:Ve,event:ke.LeaveRoom,to:Ge}]}};br=a([s()],br);var gr=class extends oe{};gr=a([s()],gr);var yr=class extends ie{};yr=a([s()],yr);var Cr=class{constructor(e,t){this.statisticModel=e;this.statisticView=t}addRoundResult(e){this.statisticModel.listRoundResult.push(e),this.statisticView.update()}addListRoundResult(e){this.statisticModel.listRoundResult.push(...e),this.statisticView.update()}};Cr=a([s(),i(0,l(h.Statistic)),i(1,l(T.Statistic))],Cr);var Sr=class{constructor(e,t){this.winModel=e;this.winGameView=t}updateTotalWinPoint(e){this.winModel.totalWinPoint=e,this.winGameView.update()}};Sr=a([s(),i(0,l(h.Win)),i(1,l(T.Win))],Sr);var Mr=class{constructor(e){this.networkRequest=e}execute(e){let t=this.getRequestData(e);this.networkRequest.send(t)}getRequestData(e){return{}}};Mr=a([s(),i(0,l(zo.Default))],Mr);var wr=class{constructor(e,t,r,o,c){this.connectCommand=e;this.joinRoomCommand=t;this.startNewRoundCommand=r;this.confirmBetCommand=o;this.collectPointCommand=c}connectToServer(){this.connectCommand.execute()}joinRoom(e){this.joinRoomCommand.execute(e)}startNewRound(){this.startNewRoundCommand.execute()}sendConfirmBet(e){this.confirmBetCommand.execute(e)}collectPoint(){this.collectPointCommand.execute()}};wr=a([s(),i(0,l($e.Connect)),i(1,l($e.JoinRoom)),i(2,l($e.StartNewRound)),i(3,l($e.ConfirmBet)),i(4,l($e.CollectPoint))],wr);var ye=class{constructor(e,t,r,o){this.successResponseHandler=e;this.invalidResponseHandler=t;this.failedResponseHandler=r;this.errorResponseHandler=o}send(e){this.sendHTTPRequest(e)}sendHTTPRequest(e){let t=this.httpServerModel.url+(this.httpServerModel.url.endsWith("/")?"":"/")+this.getAPIName(),r=JSON.stringify(e);fetch(t,{method:this.getAPIMethod(),headers:this.getHeader(),body:r}).then(o=>{o.json().then(c=>{o.status==200?c.error?this.onInvalidResponse(c):this.onSuccessResponse(c):this.onRequestFailed(c)})}).catch(o=>this.onError(o))}getHeader(){var e=[["Content-Type","application/json"]];return e}onSuccessResponse(e){this.successResponseHandler.onResponse(e)}onInvalidResponse(e){this.invalidResponseHandler&&this.invalidResponseHandler.onResponse(e)}onRequestFailed(e){this.failedResponseHandler&&this.failedResponseHandler.onResponse(e)}onError(e){this.errorResponseHandler&&this.errorResponseHandler.onResponse(e)}};a([l(h.HttpServer)],ye.prototype,"httpServerModel",2),ye=a([s(),i(0,l(it.Success)),i(1,l(it.Invalid)),i(1,N()),i(2,l(it.Failed)),i(2,N()),i(3,l(it.Error)),i(3,N())],ye);var Er=class extends ye{getAPIMethod(){return"GET"}};Er=a([s()],Er);var Rr=class extends ye{getAPIMethod(){return"POST"}};Rr=a([s()],Rr);var _r=class{onResponse(e){console.trace("DefaultResponse: ",e)}};_r=a([s()],_r);var Br=class extends q{constructor(t,r,o,c){super(c);this.balanceController=t;this.betController=r;this.betBalanceModel=o}process(t){let r=this.getBalance(t),o=r.credit+r.freeCredit,c=this.betBalanceModel.totalCredit;oe.render())}};fn=a([s()],fn);export{Er as APIGet,Rr as APIPost,Re as AVAILABLE_BET_CALCULATOR,Qr as ApplicationConfigModel,wt as AvailableBetCalculator,xe as BET_CONTROLLER_EVENT,Be as BET_OPTION_CONTROLLER_EVENT,It as BalanceController,Xr as BalanceModel,Rt as BetConflictValidator,St as BetConstantParameter,rr as BetController,Le as BetControllerDisableState,De as BetControllerEnableState,nr as BetControllerListStateTransitionCreator,or as BetControllerStateContext,ir as BetControllerStateMachine,jt as BetLimitController,Zr as BetLimitModel,en as BetModel,Dt as BetOptionController,Ie as BetOptionControllerDisableState,je as BetOptionControllerEnableState,Vt as BetOptionControllerListStateTransitionCreator,Gt as BetOptionControllerStateContext,Wt as BetOptionControllerStateMachine,_t as BetPointBelowMaxBetLimitValidator,tn as BetPositionModel,F as COMMAND,w as CONTROLLER,Va as CONTROLLER_EVENT_LISTENER,Jo as CONTROLLER_EVENT_PUBLISHER,$ as CONTROLLER_STATE_MACHINE,q as ChainDataProcessor,_e as ChainListStateTransitionAssertor,Ut as CheckBetConflictCommandProxy,Ht as CheckEmptyBetTableCommandProxy,$t as CheckEnoughBalanceCommandProxy,Kt as CheckMaxBetLimitCommandProxy,Yt as CheckMaxTotalBetLimitCommandProxy,Ft as ClearAllBetCommand,qt as ClearBetCommand,X as CommandProxy,re as CommandWrapper,wr as Connector,_r as ConsoleTraceResponse,rn as CountdownModel,j as DATA_PROCESSOR,Zo as DEFAULT_STATE,Br as DefaultBalanceProcessor,Tr as DefaultBetOptionProcessor,xr as DefaultBetSettingProcessor,Or as DefaultLoungeBetLimitProcessor,Ar as DefaultLoungeBetOptionProcessor,Nr as DefaultOddsProcessor,Pr as DefaultServerErrorProcessor,Ir as DefaultWinProcessor,Jt as DoubleBetCommand,zt as DoubleBetCommandWrapper,Z as ERROR_TYPE,xt as EmptyBetTableValidator,Bt as EnoughBalanceToBetValidator,sr as ErrorController,nn as ErrorModel,cr as GAME_CONTROLLER_EVENT,T as GAME_VIEW,lr as GameController,Oe as GameControllerBetState,Ye as GameControllerCollectingPointState,Je as GameControllerDisableState,ze as GameControllerEndRoundState,dr as GameControllerListStateTransitionCreator,ae as GameControllerState,mr as GameControllerStateContext,ur as GameControllerStateMachine,lt as GameEventContract,yt as GameEventListener,Ct as GameEventPublisher,fn as GameView,it as HTTP_RESPONSE,pr as HistoryController,Mr as HttpNetworkCommand,Mt as LIST_STATE_TRANSITION_ASSERTOR,ei as LIST_STATE_TRANSITION_CREATOR,on as ListBetConflictModel,an as ListBetOptionModel,sn as ListOddsModel,ln as ListRoomBetLimitModel,cn as ListRoomBetOptionModel,ne as ListStateTransitionCreator,Ot as ListStateTransitionDuplicateAssertor,At as ListStateTransitionInheritanceAssertor,Lt as LoungeBetLimitController,kt as LoungeBetOptionController,h as MODEL,$e as NETWORK_COMMAND,we as NETWORK_CONNECTOR,Qo as NETWORK_EVENT_LISTENER,Ke as NETWORK_EVENT_PUBLISHER,zo as NETWORK_REQUEST,_ as NETWORK_RESPONSE,A as NetworkResponse,fr as OddsController,jr as OnBalance,Lr as OnBetLimitResponse,Dr as OnBetSettings,kr as OnConfirmBetFailed,Vr as OnConfirmBetSuccessfully,Gr as OnConnect,Wr as OnDisconnect,Fr as OnError,qr as OnGameStart,Ur as OnOdds,Hr as OnRoomJoin,$r as OnRoundEnd,Kr as OnRoundResult,Yr as OnRoundStart,Jr as OnStatistic,zr as OnWin,Ee as PARAMETER,Qt as PlaceBetCommand,Xt as PlaceBetCommandWrapper,Te as PlaceMultiBetCommand,ye as RESTfulAPIRequest,ke as ROOM_CONTROLLER_EVENT,Zt as RebetCommand,er as RebetCommandWrapper,tr as ResetBetCommand,vr as RoomController,Qe as RoomControllerDisableState,Ve as RoomControllerInRoomState,br as RoomControllerListStateTransitionCreator,Ge as RoomControllerLoungeState,pe as RoomControllerState,gr as RoomControllerStateContext,yr as RoomControllerStateMachine,dn as RoomIndexModel,hr as RoundResultController,mn as RoundResultModel,Xo as STATE_CONTEXT,ar as SecondTickCountdownController,un as SelectedBetOptionModel,oe as StateContext,ie as StateMachine,Nt as StateMachineEventManager,Cr as StatisticController,Tt as TotalBetBelowMaxTotalBetLimitValidator,Q as UNDO_MANAGER,Et as UndoManager,ue as VALIDATOR,Sr as WinController,pn as WinModel,J as container,Cl as customServiceLocator,wl as dependencyGraph,el as registerStateMachineNetworkEvent,nl as setupStateMachineEventManager,ti as when}; +/*! Bundled license information: + +reflect-metadata/Reflect.js: + (*! ***************************************************************************** + Copyright (C) Microsoft. All rights reserved. + Licensed under the Apache License, Version 2.0 (the "License"); you may not use + this file except in compliance with the License. You may obtain a copy of the + License at http://www.apache.org/licenses/LICENSE-2.0 + + THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED + WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, + MERCHANTABLITY OR NON-INFRINGEMENT. + + See the Apache Version 2.0 License for specific language governing permissions + and limitations under the License. + ***************************************************************************** *) +*/ diff --git a/assets/core/plugins/core.js.meta b/assets/core/plugins/core.js.meta new file mode 100644 index 0000000..f16ffff --- /dev/null +++ b/assets/core/plugins/core.js.meta @@ -0,0 +1,10 @@ +{ + "ver": "1.1.0", + "uuid": "c7f8a66a-65a3-4281-8ef2-361ebb759f39", + "importer": "javascript", + "isPlugin": false, + "loadPluginInWeb": true, + "loadPluginInNative": true, + "loadPluginInEditor": false, + "subMetas": {} +} \ No newline at end of file