@flashist/appframework 0.0.3

package/src/display/views/viewstack/ViewLazyCreationStack.ts

@@ -0,0 +1,47 @@
+import {AssociativeArray, IConstructor} from "@flashist/fcore";
+
+import {DisplayObjectContainer} from "@flashist/flibs";
+
+import {ViewStack} from "./ViewStack";
+
+export class ViewLazyCreationStack<StackViewType extends DisplayObjectContainer = DisplayObjectContainer> extends ViewStack<StackViewType> {
+
+    protected viewClassToIdMap: AssociativeArray<IConstructor<StackViewType>>;
+
+    construction(...args): void {
+        super.construction(...args);
+
+        this.viewClassToIdMap = new AssociativeArray<IConstructor<StackViewType>>();
+    }
+
+    public addViewClass(ViewClass: IConstructor<StackViewType>, id: string): void {
+        this.viewClassToIdMap.push(ViewClass, id);
+    }
+
+    public removeViewClass(ViewClass: IConstructor<StackViewType>): void {
+        this.viewClassToIdMap.remove(ViewClass);
+    }
+
+    public getViewById(id: string): StackViewType {
+        // Check if the needed view exists, if not, then create it
+        if (!super.getViewById(id)) {
+            this.addView(
+                this.getNewInstance(id),
+                id
+            );
+        }
+
+        return super.getViewById(id);
+    }
+
+    protected getNewInstance(id: string): StackViewType {
+        let result: StackViewType;
+
+        let TempClass: IConstructor<any> = (this.viewClassToIdMap.getItem(id) as IConstructor<any>);
+        if (TempClass) {
+            result = new TempClass();
+        }
+
+        return result;
+    }
+}

package/src/display/views/viewstack/ViewStack.ts

@@ -0,0 +1,93 @@
+import {AssociativeArray, IDatable} from "@flashist/fcore";
+
+import {DisplayObjectContainer} from "@flashist/flibs";
+
+import {IResizable} from "../resize/IResizable";
+import {ResizableContainer} from "../resize/ResizableContainer";
+
+export class ViewStack
+    <
+        StackViewType extends DisplayObjectContainer = DisplayObjectContainer,
+        DataType extends object = object
+    >
+    extends ResizableContainer<DataType> implements IResizable {
+
+    protected viewToIdMap: AssociativeArray<StackViewType>;
+
+    protected _selectedId: string;
+    protected _selectedItem: StackViewType;
+
+    construction(...args): void {
+        super.construction(...args);
+
+        this.viewToIdMap = new AssociativeArray<StackViewType>();
+    }
+
+    public addView(view: StackViewType, id: string): void {
+        this.viewToIdMap.push(view, id);
+    }
+
+    public removeView(view: StackViewType): void {
+        this.viewToIdMap.remove(view);
+    }
+
+
+    public get selectedId(): string {
+        return this._selectedId;
+    }
+
+    public set selectedId(value: string) {
+        if (value == this.selectedId) {
+            return;
+        }
+
+        // Remove the previous view
+        if (this.selectedItem) {
+            this.selectedItem.parent.removeChild(this._selectedItem);
+            this._selectedItem = null;
+        }
+
+        this._selectedId = value;
+        this._selectedItem = this.getViewById(this.selectedId);
+        if (this.selectedItem) {
+            this.addChild(this.selectedItem);
+        }
+
+        this.commitData();
+        this.arrange();
+    }
+
+    protected getViewById(id: string): StackViewType {
+        return this.viewToIdMap.getItem(id)
+    }
+
+    public get selectedItem(): StackViewType {
+        return this._selectedItem;
+    }
+
+    protected commitData(): void {
+        super.commitData();
+
+        if (this.selectedItem) {
+            const selectedDatableItem: IDatable = this._selectedItem as any;
+            selectedDatableItem.data = this.data;
+        }
+    }
+
+    protected arrange(): void {
+        super.arrange();
+
+        if (this._selectedItem) {
+            if (this.resizeSize && this.resizeSize.x !== 0 && this.resizeSize.y !== 0) {
+                const selectedResizableItem: IResizable = this._selectedItem as any;
+                if (selectedResizableItem.resize) {
+                    selectedResizableItem.resize(this.resizeSize.x, this.resizeSize.y);
+
+                } else {
+                    this._selectedItem.width = this.resizeSize.x;
+                    this._selectedItem.height = this.resizeSize.y;
+                }
+            }
+        }
+    }
+}

package/src/display/views/viewstack/ViewStackLazyCreation.ts

@@ -0,0 +1,45 @@
+import {AssociativeArray, IConstructor} from "@flashist/fcore";
+
+import {DisplayObject, DisplayObjectContainer} from "@flashist/flibs";
+
+import {ViewStack} from "./ViewStack";
+
+export class ViewStackLazyCreation
+    <
+        StackViewType extends DisplayObjectContainer = DisplayObjectContainer,
+        DataType extends object = object
+    >
+    extends ViewStack<StackViewType, DataType> {
+
+    protected viewClassToIdMap: AssociativeArray<IConstructor<DisplayObject>>;
+
+    construction(...args: any[]): void {
+        super.construction(...args);
+
+        this.viewClassToIdMap = new AssociativeArray<IConstructor<DisplayObject>>();
+    }
+
+    public addViewClass(ViewClass: IConstructor<StackViewType>, id: string): void {
+        this.viewClassToIdMap.push(ViewClass, id);
+    }
+
+    public removeViewClass(ViewClass: IConstructor<StackViewType>): void {
+        this.viewClassToIdMap.remove(ViewClass);
+    }
+
+    public getViewById(id: string): StackViewType {
+        // Check if the needed view exists, if not, then create it
+        if (!super.getViewById(id)) {
+            let TempClass: IConstructor<any> = (this.viewClassToIdMap.getItem(id) as IConstructor<any>);
+            if (TempClass) {
+                this.addView(
+                    new TempClass(),
+                    id
+                );
+            }
+        }
+
+        return super.getViewById(id);
+    }
+
+}

package/src/events/commands/DispatchGlobalEventCommand.ts

@@ -0,0 +1,22 @@
+import {Command} from "@flashist/fcore";
+import {getInstance} from "@flashist/flibs";
+
+import {GlobalEventDispatcher} from "../../globaleventdispatcher/dispatcher/GlobalEventDispatcher";
+
+export class DispatchGlobalEventCommand extends Command {
+
+    protected globalDispatcher: GlobalEventDispatcher;
+    protected event: string;
+
+    constructor(event: string) {
+        super();
+
+        this.event = event;
+        this.globalDispatcher = getInstance(GlobalEventDispatcher);
+    }
+
+    protected executeInternal(): void {
+        this.globalDispatcher.dispatchEvent(this.event);
+        this.notifyComplete();
+    }
+}

package/src/facade/Facade.ts

@@ -0,0 +1,194 @@
+import { BaseObject, Command } from "@flashist/fcore";
+
+import { FApp, getInstance, HtmlTools, Point, ServiceLocator } from "@flashist/flibs";
+
+import { GlobalEventDispatcherModule } from "../globaleventdispatcher/GlobalEventDispatcherModule";
+import { AppAppModulesManager } from "../base/modules/AppModulesManager";
+import { PagesModule } from "../pages/PagesModule";
+import { RendererModule } from "../renderer/RendererModule";
+import { IFacadeOptions } from "./IFacadeOptions";
+import { AppModule } from "../app/AppModule";
+import { TimeModule } from "../time/TimeModule";
+import { DebugModule } from "../debug/DebugModule";
+import { LoadModule } from "../load/LoadModule";
+import { DependenciesModule } from "../dependencies/DependenciesModule";
+import { AssetsModule } from "../assets/AssetsModule";
+import { ContainersModule } from "../containers/ContainersModule";
+import { ObjectsPoolModule } from "../pool/ObjectsPoolModule";
+import { LocalesModule } from "../locales/LocalesModule";
+import { StorageModule } from "../storage/StorageModule";
+import { SoundsModule } from "../sounds/SoundsModule";
+import { HTMLModule } from "../html/HTMLModule";
+import { InitApplicationCommand } from "../init/commands/InitApplicationCommand";
+import { RendererManager } from "../renderer/managers/RendererManager";
+import { GlobalEventDispatcher } from "../globaleventdispatcher/dispatcher/GlobalEventDispatcher";
+import { RendererManagerEvent } from "../renderer/events/RendererManagerEvent";
+import { ServerModule } from "../server/ServerModule";
+import { AppMainContainer } from "../app/views/AppMainContainer";
+import { BaseAppModule } from "../base/modules/BaseAppModule";
+
+export class Facade extends BaseObject {
+
+    protected options: IFacadeOptions;
+    protected modulesManager: AppAppModulesManager;
+
+    public app: FApp;
+    public mainContainer: AppMainContainer;
+
+    protected resizeListener: any;
+
+    constructor(options: IFacadeOptions) {
+        super(options);
+    }
+
+    protected construction(options: IFacadeOptions): void {
+        super.construction(options);
+
+        this.options = options;
+
+        Facade._instance = this;
+        if (this.options.debug) {
+            window["Facade"] = this;
+        }
+
+        ServiceLocator.startInit({ debug: this.options.debug });
+
+        this.addModules();
+        this.activateModules();
+
+        this.initView();
+
+        const initCmd: Command = getInstance(InitApplicationCommand);
+        initCmd.execute();
+    }
+
+    protected addModules(): void {
+        this.modulesManager = new AppAppModulesManager();
+
+        this.addSingleModule(new DependenciesModule());
+        this.addSingleModule(new ObjectsPoolModule());
+        this.addSingleModule(new GlobalEventDispatcherModule());
+        this.addSingleModule(new RendererModule());
+        this.addSingleModule(new StorageModule());
+        this.addSingleModule(new LoadModule());
+        this.addSingleModule(new SoundsModule());
+        this.addSingleModule(new HTMLModule());
+        this.addSingleModule(new LocalesModule());
+        this.addSingleModule(new AssetsModule());
+        this.addSingleModule(new PagesModule());
+
+        this.addSingleModule(new RendererModule());
+
+        this.addSingleModule(new AppModule());
+        this.addSingleModule(new TimeModule());
+        this.addSingleModule(new ContainersModule());
+        this.addSingleModule(new ServerModule());
+
+        if (this.options.debug) {
+            this.addSingleModule(new DebugModule());
+        }
+    }
+
+    public activateModules(): void {
+        // First: configure all injections
+        this.modulesManager.initModules();
+        // Second: activate the service locator object
+        ServiceLocator.activate();
+        // Activate modules (after Service Locator activation)
+        this.modulesManager.activateModules();
+    }
+
+    public addSingleModule(module: BaseAppModule): void {
+        this.modulesManager.addModule(module);
+    }
+
+    protected initView(): void {
+        this.mainContainer = getInstance(AppMainContainer);
+        FApp.instance.stage.addChild(this.mainContainer);
+
+        this.onWindowResize();
+        this.onRendererResize();
+    }
+
+    protected addListeners(): void {
+        super.addListeners();
+        /**
+         * Note: temporary solution, until pixi.js improvements are released in npm: https://github.com/pixijs/pixi.js/pull/6415
+         * (when they are released, the Renderer will emit resize event itself, it means
+         * that in combination with resizeTo there won't be a need to "control" resize outside)
+         */
+        this.resizeListener = () => {
+            this.onWindowResize();
+
+            // In some cases there is a need to add timeout for HTML DOM to be updated
+            setTimeout(
+                () => {
+                    this.onWindowResize();
+                },
+                100
+            );
+        };
+        window.addEventListener(
+            "resize",
+            this.resizeListener
+        );
+
+        const globalEventDispatcher: GlobalEventDispatcher = getInstance(GlobalEventDispatcher);
+        this.eventListenerHelper.addEventListener(
+            globalEventDispatcher,
+            RendererManagerEvent.RESIZE,
+            this.onRendererResize
+        )
+    }
+
+    protected removeListeners(): void {
+        super.removeListeners();
+
+        window.removeEventListener(
+            "resize",
+            this.resizeListener
+        );
+    }
+
+    protected onWindowResize(): void {
+        const rendererManager: RendererManager = getInstance(RendererManager);
+        const documentSize: Point = HtmlTools.getDocumentSize();
+        rendererManager.resize(documentSize.x, documentSize.y);
+    }
+
+    protected onRendererResize(): void {
+        this.arrange();
+    }
+
+    protected arrange(): void {
+        const rendererManager: RendererManager = getInstance(RendererManager);
+        this.mainContainer.resize(
+            rendererManager.rendererWidth,
+            rendererManager.rendererHeight
+        );
+    }
+
+    // - - - - -
+
+    private static _instance: Facade;
+
+    static init(options?: IFacadeOptions): void {
+        if (!options) {
+            options = {};
+        }
+        let FacadeClass = options.FacadeClass;
+        if (!FacadeClass) {
+            FacadeClass = Facade;
+        }
+
+        new FacadeClass(options);
+    }
+
+    static get instance(): Facade {
+        if (!Facade._instance) {
+            console.error("ERROR! Facade should be prepared via the Facade.init method before used via Facade.instance!");
+            return;
+        }
+        return Facade._instance;
+    }
+}

package/src/facade/IFacadeOptions.ts

@@ -0,0 +1,7 @@
+import {IConstructor} from "@flashist/fcore";
+import {Facade} from "./Facade";
+
+export interface IFacadeOptions {
+    FacadeClass?: IConstructor<Facade>;
+    debug?: boolean;
+}

package/src/globaleventdispatcher/GlobalEventDispatcherModule.ts

@@ -0,0 +1,16 @@
+import {serviceLocatorAdd} from "@flashist/flibs";
+
+import {GlobalEventDispatcher} from "./dispatcher/GlobalEventDispatcher";
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {GlobalEventsCommandManager} from "./managers/GlobalEventsCommandManager";
+
+export class GlobalEventDispatcherModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+        
+        serviceLocatorAdd(GlobalEventDispatcher, {isSingleton: true});
+        serviceLocatorAdd(GlobalEventsCommandManager, {isSingleton: true});
+    }
+
+}

package/src/globaleventdispatcher/commands/WaitGlobalEventCommand.ts

@@ -0,0 +1,25 @@
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+
+export class WaitGlobalEventCommand extends BaseAppCommand {
+
+    constructor(protected event: string, guard?: () => boolean) {
+        super();
+
+        if (guard) {
+            this.guard = guard;
+        }
+    }
+
+    protected executeInternal(): void {
+        this.eventListenerHelper.addEventListener(
+            this.globalDispatcher,
+            this.event,
+            () => {
+                if (!this.guard || this.guard()) {
+                    this.notifyComplete();
+                }
+            }
+        );
+    }
+
+}3

package/src/globaleventdispatcher/dispatcher/GlobalEventDispatcher.ts

@@ -0,0 +1,53 @@
+import {BaseObject, IEventListenerCallback} from "@flashist/fcore";
+
+import {GlobalEventDispatcherEvent} from "./GlobalEventDispatcherEvent";
+
+export class GlobalEventDispatcher extends BaseObject {
+
+    dispatchEvent(type: string, ...args): void {
+        super.dispatchEvent(
+            this.getModifiedEventType(type, GlobalEventDispatcherEvent.PRE_DISPATCH_EVENT),
+            ...args
+        );
+
+        super.dispatchEvent(type, ...args);
+
+        //
+        super.dispatchEvent(
+            this.getModifiedEventType(type, GlobalEventDispatcherEvent.POST_DISPATCH_EVENT),
+            ...args
+        );
+    }
+
+    public addPreEventListener(type: string, listener: IEventListenerCallback): void {
+        this.addEventListener(
+            this.getModifiedEventType(type, GlobalEventDispatcherEvent.PRE_DISPATCH_EVENT),
+            listener
+        );
+    }
+
+    public addPostEventListener(type: string, listener: IEventListenerCallback): void {
+        this.addEventListener(
+            this.getModifiedEventType(type, GlobalEventDispatcherEvent.POST_DISPATCH_EVENT),
+            listener
+        );
+    }
+
+    public removePreEventListener(type: string, listener: IEventListenerCallback): void {
+        this.removeEventListener(
+            this.getModifiedEventType(type, GlobalEventDispatcherEvent.PRE_DISPATCH_EVENT),
+            listener
+        );
+    }
+
+    public removePostEventListener(type: string, listener: IEventListenerCallback): void {
+        this.removeEventListener(
+            this.getModifiedEventType(type, GlobalEventDispatcherEvent.POST_DISPATCH_EVENT),
+            listener
+        );
+    }
+
+    protected getModifiedEventType(type: string, preText: string): string {
+        return preText + type;
+    }
+}

package/src/globaleventdispatcher/dispatcher/GlobalEventDispatcherEvent.ts

@@ -0,0 +1,4 @@
+export const GlobalEventDispatcherEvent = {
+    PRE_DISPATCH_EVENT: "GlobalEventDispatcherEvent.PRE_DISPATCH_EVENT ",
+    POST_DISPATCH_EVENT: "GlobalEventDispatcherEvent.POST_DISPATCH_EVENT "
+};

package/src/globaleventdispatcher/dispatcher/IGlobalDispatchEventVO.ts

@@ -0,0 +1,4 @@
+export interface IGlobalDispatchEventVO {
+    event: string,
+    args: any[]
+}

package/src/globaleventdispatcher/managers/GlobalEventsCommandManager.ts

@@ -0,0 +1,26 @@
+import {Dictionary, Command, IConstructor} from "@flashist/fcore";
+import {getInstance} from "@flashist/flibs";
+
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+
+export class GlobalEventsCommandManager extends BaseAppManager {
+
+    public bindCommand(event: string, CommandClass: IConstructor<Command<any | never>>, guard?: (...args: any) => boolean): void {
+        this.eventListenerHelper.addEventListener(
+            this.globalDispatcher,
+            event,
+            (...args) => {
+                // If there is no guard function, or if there is a guard function and the checking is passed,
+                // then create command and execute it
+                if (!guard || guard(...args)) {
+                    getInstance(CommandClass, ...args)
+                        .execute();
+                }
+            }
+        );
+    }
+
+    // TODO: implement logic of REMOVING / UNBINDING commands from global events
+    //  (should be possible to remove one binding without removing other,
+    //  because one command might be binded to different events and to a single event, but with different guard methods)
+}

package/src/hints/commands/AnimateHintCommand.ts

@@ -0,0 +1,99 @@
+import {NumberTools, ObjectTools} from "@flashist/fcore";
+import {DisplayObject, FContainer, getInstance} from "@flashist/flibs";
+
+import {Back, Sine, TweenLite} from "gsap";
+
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {ContainersManager} from "../../containers/managers/ContainersManager";
+import {HintContainerId} from "../data/HintContainerId";
+import {IHintConfig} from "../data/IHintConfig";
+import {DefaultHintConfig} from "../data/DefaultHintConfig";
+
+export class AnimateHintCommand extends BaseAppCommand {
+
+    protected config: IHintConfig;
+
+    constructor(protected hint: DisplayObject, config: Partial<IHintConfig>) {
+        super();
+
+        this.config = {} as any;
+
+        ObjectTools.copyProps(
+            this.config,
+            config
+        );
+
+        ObjectTools.copyProps(
+            this.config,
+            new DefaultHintConfig(),
+            {
+                ignoreExistedProperties: true
+            }
+        );
+    }
+
+    protected executeInternal(): void {
+
+        const containersManager: ContainersManager = getInstance(ContainersManager);
+        const effectsCont: FContainer = containersManager.getContainer(HintContainerId);
+        effectsCont.addChild(this.hint);
+
+        const localPos = effectsCont.toLocal(this.config.startGlobalPos);
+        this.hint.x = localPos.x;
+        this.hint.y = localPos.y;
+
+        const tempFinalY: number = localPos.y + NumberTools.getRandom(
+            this.config.finalGlobalPosMinChange.y,
+            this.config.finalGlobalPosMaxChange.y
+        );
+        TweenLite.to(
+            this.hint,
+            this.config.positionTweenDuration,
+            {
+                y: tempFinalY,
+                ease: Sine.easeOut
+            }
+        );
+
+        const tempFinalX: number = localPos.x + NumberTools.getRandom(
+            this.config.finalGlobalPosMinChange.x,
+            this.config.finalGlobalPosMaxChange.x
+        );
+        TweenLite.to(
+            this.hint,
+            this.config.positionTweenDuration,
+            {
+                x: tempFinalX,
+                ease: Back.easeOut
+            }
+        );
+
+        this.hint.alpha = this.config.startAlpha;
+        TweenLite.to(
+            this.hint,
+            this.config.startAlphaTweenDuration,
+            {
+                delay: this.config.startAlphaTweenDelay,
+
+                alpha: this.config.mainAlpha
+            }
+        );
+        TweenLite.to(
+            this.hint,
+            this.config.startAlphaTweenDuration,
+            {
+                delay: this.config.finalAlphaTweenDelay,
+                alpha: this.config.finalAlpha,
+                onComplete: () => {
+                    this.readyToComplete();
+                }
+            }
+        );
+    }
+
+    protected readyToComplete(): void {
+        this.hint.parent.removeChild(this.hint);
+
+        this.notifyComplete();
+    }
+}

package/src/hints/data/DefaultHintConfig.ts

@@ -0,0 +1,22 @@
+import {IHintConfig} from "./IHintConfig";
+import {Point} from "@flashist/flibs";
+import {HintContainerId} from "./HintContainerId";
+
+export class DefaultHintConfig implements Partial<IHintConfig> {
+
+    containerId: string = HintContainerId;
+
+    positionTweenDuration: number = 1.5;
+    finalGlobalPosMinChange: Point = new Point(0, -100);
+    finalGlobalPosMaxChange: Point = new Point(0, -150);
+
+    startAlphaTweenDuration: number = 0.25;
+    startAlphaTweenDelay: number = 0;
+    finalAlphaTweenDuration: number = 0.25;
+    finalAlphaTweenDelay: number = 1.25;
+
+    startAlpha: number = 0;
+    mainAlpha: number = 1;
+    finalAlpha: number = 0;
+
+}

package/src/hints/data/HintContainerId.ts

@@ -0,0 +1 @@
+export const HintContainerId = "hintContainer";