@flashist/appframework 0.0.3

package/gulp/tasks/clean.js

@@ -0,0 +1,9 @@
+var gulp = require("gulp");
+var rimraf = require("rimraf");
+
+gulp.task(
+    "clean",
+    (cb) => {
+        return rimraf("./dist/**/*", cb);
+    }
+);

package/gulp/tasks/compile.js

@@ -0,0 +1,27 @@
+var gulp = require("gulp");
+var shell = require('gulp-shell');
+
+gulp.task(
+    "compile",
+    function (cb) {
+
+        gulp.src(".", {read: false})
+            .pipe(
+                shell(
+                    ["tsc"]
+                )
+
+            ).on(
+            "end",
+            function () {
+                cb();
+            }
+
+        ).on(
+            "error",
+            function () {
+                console.error("ERROR! compile.js");
+            }
+        );
+    }
+);

package/gulp/tasks/copy-to-dist.js

@@ -0,0 +1,15 @@
+var gulp = require("gulp");
+
+gulp.task(
+    "copy-to-dist",
+    function () {
+        // console.log("START! copy-to-dist.js");
+
+        return gulp.src(
+                ["./package.json"]
+            )
+            .pipe(
+                gulp.dest("./dist")
+            );
+    }
+);

package/gulp/tasks/generate-definitions.js

@@ -0,0 +1,86 @@
+var gulp = require("gulp");
+var fs = require("fs");
+var path = require("path");
+var glob = require("glob");
+
+gulp.task(
+    "generate-definitions",
+    async () => {
+
+        await new Promise(
+            (resolve) => {
+
+                // console.log("START! generate-definitions.js");
+
+                var getSafeDirPath = function(dirPath) {
+                    dirPath += dirPath.charAt(dirPath.length - 1) == "/" ? "" : "/";
+                    return dirPath;
+                };
+
+                var argv = {};
+
+                var basePath = "./src/";
+                // console.log("BEFORE argv.src: " + argv.src);
+                argv.src = argv.src ? argv.src : basePath;
+                // Adding a closing slash to make correct folder path (if needed)
+                argv.src = getSafeDirPath(argv.src);
+                // console.log("AFTER argv.src: " + argv.src);
+
+                // console.log("BEFORE argv.outFile: " + argv.outFile);
+                argv.outFile = argv.outFile ? argv.outFile : "index";
+                // console.log("AFTER argv.outFile: " + argv.outFile);
+
+                // console.log("BEFORE argv.outDir: " + argv.outDir);
+                argv.outDir = argv.outDir ? argv.outDir : basePath;
+                argv.outDir = getSafeDirPath(argv.outDir);
+                // console.log("AFTER argv.outDir: " + argv.outDir);
+
+                var outFileName = argv.outFile + ".ts";
+                // console.log("outFileName: " + outFileName);
+                // Remove prev index file
+                if (fs.existsSync(basePath + outFileName)) {
+                    fs.unlinkSync(basePath + outFileName);
+                }
+
+                var resultDeclarationText = "";
+
+                // console.log("Imported files:");
+                var tempSettings = `${argv.src}**/*.ts`;
+
+                glob(
+                    tempSettings,
+                    (error, files) => {
+                        var filesCount = files.length;
+                        for (var fileIndex = 0; fileIndex < filesCount; fileIndex++) {
+                            var singleFile = files[fileIndex];
+                            console.log("singleFile: ", singleFile);
+
+                            let importPath = path.relative(basePath, singleFile);
+                            if (importPath.indexOf(".d.ts") != -1) {
+                                importPath = importPath.substr(0, importPath.lastIndexOf(".d.ts"));
+                            } else if (importPath.indexOf(".ts") != -1) {
+                                importPath = importPath.substr(0, importPath.lastIndexOf(".ts"));
+                            }
+                            // console.log("- " + importPath);
+
+                            resultDeclarationText += "export * from '" + "./" + importPath + "'";
+                            resultDeclarationText += "\n";
+                        }
+
+                        console.log("Declarations: ");
+                        console.log(resultDeclarationText);
+
+                        fs.writeFile(
+                            argv.outDir + outFileName,
+                            resultDeclarationText,
+                            () => {
+                                console.log("WRITE COMPLETE!");
+                                resolve();
+                            }
+                        );
+                    }
+                );
+            }
+        );
+    }
+);

package/gulpfile.js

@@ -0,0 +1,22 @@
+var gulp = require("gulp");
+var requireDir = require("require-dir");
+
+var tasks = requireDir("./gulp/tasks");
+
+gulp.task(
+    'build',
+    gulp.series(
+        "clean",
+        // "generate-definitions",
+        "copy-to-dist",
+        "compile"
+    )
+);
+
+// Default
+gulp.task(
+    "default",
+    gulp.series(
+        "build"
+    )
+);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@flashist/appframework",
+  "version": "0.0.3",
+  "scripts": {
+    "build": "gulp",
+    "publish:patch": "npm version patch && npm run build && cd ./dist && npm publish",
+    "publish:minor": "npm version minor && npm run build && cd ./dist && npm publish",
+    "publish:major": "npm version major && npm run build && cd ./dist && npm publish"
+  },
+  "license": "MIT",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flashist/appframework"
+  },
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "dependencies": {
+    "@flashist/flibs": "0.x",
+    "@flashist/fconsole": "0.x"
+  },
+  "devDependencies": {
+    "@types/webfontloader": "^1.6.29",
+    "gulp": "^4.0.2",
+    "gulp-shell": "^0.8.0",
+    "require-dir": "^1.2.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.0.2"
+  }
+}

package/src/app/AppModule.ts

@@ -0,0 +1,26 @@
+import {GenericObjectsByTypeModel, getInstance, serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {AppModel} from "./models/AppModel";
+import {AppConfigModel} from "./models/AppConfigModel";
+import {AppManager} from "./managers/AppManager";
+
+export class AppModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(AppModel, {isSingleton: true});
+        serviceLocatorAdd(AppConfigModel, {isSingleton: true});
+
+        serviceLocatorAdd(AppManager, {isSingleton: true, forceCreation: true});
+    }
+
+    activateCompleteHook(): void {
+        super.activateCompleteHook();
+
+        const genericObjectsByTypeModel: GenericObjectsByTypeModel = getInstance(GenericObjectsByTypeModel);
+        const model: AppConfigModel = getInstance(AppConfigModel);
+        genericObjectsByTypeModel.mapModelToType(model, model.itemsType);
+    }
+}

package/src/app/AppSettings.ts

@@ -0,0 +1,9 @@
+export const AppSettings = {
+    storageParamId: "appModel",
+
+    appConfigPath: "assets/app-config.json",
+
+    assetsConfigFileId: "assetsConfigFile",
+    localeConfigFileId: "localeConfigFile",
+    staticItemsFileId: "staticItemsFile"
+};

package/src/app/commands/LoadAppConfigCommand.ts

@@ -0,0 +1,61 @@
+import {CommandErrorCode} from "@flashist/fcore";
+import {
+    GenericObjectsByTypeModel,
+    getInstance,
+    LoadItemCommand,
+    LoadItemsListCommand,
+    LoadManager
+} from "@flashist/flibs";
+
+import {AppConfigModel} from "../models/AppConfigModel";
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {AppSettings} from "../AppSettings";
+import {AppConfigVO} from "../data/AppConfigVO";
+
+export class LoadAppConfigCommand extends BaseAppCommand {
+    BasePageView
+    protected executeInternal(): void {
+        const appConfigModel: AppConfigModel = getInstance(AppConfigModel);
+        new LoadItemCommand(
+            {
+                src: AppSettings.appConfigPath,
+                id: AppSettings.appConfigPath
+            }
+        )
+            .execute()
+            .then(
+                (data: AppConfigVO) => {
+                    console.log("LoadAppConfigCommand | executeInternal __ data: ", data);
+
+                    //
+                    const genericObjectsByTypeModel: GenericObjectsByTypeModel = getInstance(GenericObjectsByTypeModel);
+                    genericObjectsByTypeModel.commitItems([data]);
+
+                    //
+                    const loadManager: LoadManager = getInstance(LoadManager);
+                    loadManager.addSubstituteParams(
+                        {
+                            locale: appConfigModel.appConfig.locale
+                        }
+                    );
+
+                    //
+                    if (data.files) {
+                        new LoadItemsListCommand(appConfigModel.appConfig.files)
+                            .execute();
+                    }
+
+                    this.notifyComplete();
+                },
+                () => {
+                    const errorText: string = "LoadAppConfigCommand | executeInternal __ ERROR! Can't load the app-config.json file!";
+                    console.error(errorText);
+                    alert(errorText);
+
+                    this.errorCode = CommandErrorCode.GENERAL_ERROR;
+                    this.terminate();
+                }
+            );
+    }
+
+}

package/src/app/commands/ParseStaticItemsConfigCommand.ts

@@ -0,0 +1,32 @@
+import {CommandErrorCode} from "@flashist/fcore";
+import {AbstractLoadItem, GenericObjectsByTypeModel, getInstance, LoadManager} from "@flashist/flibs";
+
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {AppSettings} from "../AppSettings";
+import {IItemsConfigVO} from "../data/IItemsConfigVO";
+
+export class ParseStaticItemsConfigCommand extends BaseAppCommand {
+
+    protected executeInternal(): void {
+
+        let loadManager: LoadManager = getInstance(LoadManager);
+        let staticItemsConfigFileItem: AbstractLoadItem = loadManager.getLoadItem(AppSettings.staticItemsFileId);
+        if (staticItemsConfigFileItem && staticItemsConfigFileItem.data) {
+            const staticData: IItemsConfigVO = staticItemsConfigFileItem.data;
+
+            let genericObjectsByTypeModel: GenericObjectsByTypeModel = getInstance(GenericObjectsByTypeModel);
+            if (staticData.items) {
+                genericObjectsByTypeModel.commitItems(staticData.items);
+            }
+
+            this.notifyComplete();
+
+        } else {
+            console.error("ParseStaticItemsCommand | executeInternal __ ERROR! Can't find config file!");
+            this.errorCode = CommandErrorCode.GENERAL_ERROR;
+            this.terminate();
+        }
+
+    }
+
+}

package/src/app/data/AppConfigType.ts

@@ -0,0 +1 @@
+export const AppConfigType: string = "appConfig";

package/src/app/data/AppConfigVO.ts

@@ -0,0 +1,27 @@
+import {BaseDataVO, ILoadItemConfig, Rectangle} from "@flashist/flibs";
+
+export class AppConfigVO extends BaseDataVO {
+
+    files?: ILoadItemConfig[];
+
+    locale?: string;
+
+    targetFps?: number;
+    sizeArea?: Partial<Rectangle>;
+
+    // Param for app-specific settings (type can be specified in app-level classes)
+    appSettings?: any;
+
+    constructor() {
+        super();
+
+        this.explicitSourcePropertyNames.push(
+            "files",
+            "locale",
+            "targetFps",
+            "sizeArea",
+            "appSettings"
+        );
+    }
+
+}

package/src/app/data/IAppModelStorageVO.ts

@@ -0,0 +1,4 @@
+export interface IAppModelStorageVO {
+    appLaunchesCount: number;
+    totalUsageTime: number;
+}

package/src/app/data/IItemsConfigVO.ts

@@ -0,0 +1,5 @@
+import {IGenericObjectVO} from "@flashist/flibs";
+
+export interface IItemsConfigVO {
+    items: IGenericObjectVO[];
+}

package/src/app/managers/AppManager.ts

@@ -0,0 +1,68 @@
+import {getInstance} from "@flashist/flibs";
+
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+import {AppModel} from "../models/AppModel";
+import {StorageManager} from "../../storage/managers/StorageManager";
+import {AppSettings} from "../AppSettings";
+import {IAppModelStorageVO} from "../data/IAppModelStorageVO";
+
+export class AppManager extends BaseAppManager {
+
+    protected appModel: AppModel;
+    protected storageManager: StorageManager;
+
+    protected updateTimeInterval: any;
+
+    protected construction(...args): void {
+        super.construction(args);
+
+        this.appModel = getInstance(AppModel);
+        this.storageManager = getInstance(StorageManager);
+
+        const appModelStorageData: IAppModelStorageVO = this.storageManager.getParam<IAppModelStorageVO>(AppSettings.storageParamId);
+        this.applyStorageData(appModelStorageData);
+
+        this.appModel.previousSessionTotalUsageTime = this.appModel.totalUsageDuration;
+        this.appModel.sessionStartTime = Date.now();
+
+        // Increase app launch counter
+        this.appModel.appLaunchesCount++;
+
+        this.updateStorageData();
+        this.updateTimeInterval = setInterval(
+            () => {
+                this.updateUsageTime();
+            },
+            // 1 min
+            1000 * 60
+        );
+    }
+
+    protected updateUsageTime(): void {
+        let sessionTimeDelta: number = Date.now() - this.appModel.sessionStartTime;
+        this.appModel.totalUsageDuration = this.appModel.previousSessionTotalUsageTime + sessionTimeDelta;
+
+        this.updateStorageData();
+    }
+
+    protected applyStorageData(data: IAppModelStorageVO): void {
+        if (!data) {
+            return;
+        }
+
+        this.appModel.appLaunchesCount = data.appLaunchesCount;
+        this.appModel.totalUsageDuration = data.totalUsageTime;
+    }
+
+    protected updateStorageData(): void {
+        const storageData: IAppModelStorageVO = this.generateStorageData();
+        this.storageManager.setParam<IAppModelStorageVO>(AppSettings.storageParamId, storageData);
+    }
+
+    protected generateStorageData(): IAppModelStorageVO {
+        return {
+            appLaunchesCount: this.appModel.appLaunchesCount,
+            totalUsageTime: this.appModel.totalUsageDuration
+        };
+    }
+}

package/src/app/models/AppConfigModel.ts

@@ -0,0 +1,20 @@
+import {GenericObjectsModel} from "@flashist/flibs";
+
+import {AppConfigVO} from "../data/AppConfigVO";
+import {AppConfigType} from "../data/AppConfigType";
+
+export class AppConfigModel<ConfigDataType extends AppConfigVO = AppConfigVO>
+    extends GenericObjectsModel<ConfigDataType> {
+
+    constructor() {
+        super();
+
+        this.itemsType = AppConfigType;
+        this.DefaultItemClass = (AppConfigVO as any);
+    }
+
+    public get appConfig(): ConfigDataType {
+        return this.items.getItemByIndex(0);
+    }
+
+}

package/src/app/models/AppModel.ts

@@ -0,0 +1,18 @@
+import {BaseAppGenericObjectsModel} from "../../base/models/BaseAppGenericObjectsModel";
+
+export class AppModel extends BaseAppGenericObjectsModel {
+
+    public appLaunchesCount: number;
+    public totalUsageDuration: number;
+
+    public sessionStartTime: number;
+    public previousSessionTotalUsageTime: number;
+
+    protected construction(...args): void {
+        super.construction(args);
+
+        this.appLaunchesCount = 0;
+        this.totalUsageDuration = 0;
+    }
+
+}

package/src/app/views/AppMainContainer.ts

@@ -0,0 +1,23 @@
+import {PagesView} from "../../pages/views/PagesView";
+import {ResizableContainer} from "../../display/views/resize/ResizableContainer";
+
+export class AppMainContainer extends ResizableContainer {
+
+    protected pagesView: PagesView;
+
+    protected construction(...args): void {
+        super.construction(...args);
+
+        this.pagesView = new PagesView();
+        this.addChild(this.pagesView);
+    }
+
+    protected arrange(): void {
+        super.arrange();
+
+        this.pagesView.resize(
+            this.resizeSize.x,
+            this.resizeSize.y
+        );
+    }
+}

package/src/assets/AssetsModule.ts

@@ -0,0 +1,13 @@
+import {serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {AssetsModel} from "./models/AssetsModel";
+
+export class AssetsModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(AssetsModel, {isSingleton: true});
+    }
+}

package/src/assets/commands/ParseAssetsConfigCommand.ts

@@ -0,0 +1,25 @@
+import {AbstractLoadItem, getInstance, LoadItemsListCommand, LoadManager} from "@flashist/flibs";
+
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {AppSettings} from "../../app/AppSettings";
+
+export class ParseAssetsConfigCommand extends BaseAppCommand {
+
+    protected executeInternal(): void {
+        let loadManager: LoadManager = getInstance(LoadManager);
+        let assetsConfigFileLoadItem: AbstractLoadItem = loadManager.getLoadItem(AppSettings.assetsConfigFileId);
+
+        if (assetsConfigFileLoadItem && assetsConfigFileLoadItem.data) {
+            if (assetsConfigFileLoadItem.data.files) {
+                new LoadItemsListCommand(assetsConfigFileLoadItem.data.files)
+                    .execute();
+            }
+
+            this.notifyComplete();
+
+        } else {
+            console.error("ParseAssetsConfigCommand | executeInternal __ ERROR! Can't find config file!");
+            this.terminate();
+        }
+    }
+}

package/src/assets/data/IAssetsConfigVO.ts

@@ -0,0 +1,5 @@
+import {ILoadItemConfig} from "@flashist/flibs";
+
+export interface IAssetsConfigVO {
+    files: ILoadItemConfig[];
+}

package/src/assets/models/AssetsModel.ts

@@ -0,0 +1,7 @@
+import {BaseAppGenericObjectsModel} from "../../base/models/BaseAppGenericObjectsModel";
+
+export class AssetsModel extends BaseAppGenericObjectsModel {
+
+    // public assetsConfig: IAssetsConfigVO;
+
+}

package/src/base/BaseObjectWithGlobalDispatcher.ts

@@ -0,0 +1,23 @@
+import {BaseObject} from "@flashist/fcore";
+import {getInstance} from "@flashist/flibs";
+
+import {GlobalEventDispatcher} from "../globaleventdispatcher/dispatcher/GlobalEventDispatcher";
+
+export class BaseObjectWithGlobalDispatcher extends BaseObject {
+
+    protected globalDispatcher: GlobalEventDispatcher;
+
+    protected construction(...args): void {
+        super.construction(...args);
+
+        this.globalDispatcher = getInstance(GlobalEventDispatcher);
+    }
+
+    dispatchEvent(event: string, ...args: any[]): void {
+        super.dispatchEvent(event, ...args);
+
+        // Redispatch event to the global level
+        this.globalDispatcher.dispatchEvent(event, ...args);
+    }
+
+}

package/src/base/commands/BaseAppCommand.ts

@@ -0,0 +1,22 @@
+import {Command} from "@flashist/fcore";
+import {GlobalEventDispatcher} from "../../globaleventdispatcher/dispatcher/GlobalEventDispatcher";
+import {getInstance} from "@flashist/flibs";
+
+export abstract class BaseAppCommand<ResolveType = any> extends Command<ResolveType> {
+
+    protected globalDispatcher: GlobalEventDispatcher;
+
+    protected construction(...args): void {
+        super.construction(...args);
+
+        this.globalDispatcher = getInstance(GlobalEventDispatcher);
+    }
+
+    dispatchEvent(event: string, ...args: any[]): void {
+        super.dispatchEvent(event, ...args);
+
+        // Redispatch event to the global level
+        this.globalDispatcher.dispatchEvent(event, ...args);
+    }
+
+}

package/src/base/data/BaseAppObjectWithStaticVO.ts

@@ -0,0 +1,15 @@
+import { BaseDataVO, GenericObjectsWithStaticTools, IGenericObjectVO, IGenericObjectWithStaticVO } from "@flashist/flibs";
+
+export class BaseAppObjectWithStaticVO<StaticDataType extends IGenericObjectVO = IGenericObjectVO>
+    extends BaseDataVO
+    implements IGenericObjectWithStaticVO<StaticDataType> {
+
+    staticId: string;
+    staticType: string;
+
+    staticData?: StaticDataType;
+
+    // get staticData(): StaticDataType {
+    //     return GenericObjectsWithStaticTools.getStaticObject<StaticDataType>(this);
+    // }
+}

package/src/base/managers/BaseAppManager.ts

@@ -0,0 +1,5 @@
+import {BaseObjectWithGlobalDispatcher} from "../BaseObjectWithGlobalDispatcher";
+
+export class BaseAppManager extends BaseObjectWithGlobalDispatcher {
+
+}

package/src/base/mediators/BaseAppMediator.ts

@@ -0,0 +1,24 @@
+import { IDefaultEventDispatcher, IEventListenerCallback } from "@flashist/fcore";
+import { IActivatee } from "@flashist/flibs";
+
+import { BaseObjectWithGlobalDispatcher } from "../BaseObjectWithGlobalDispatcher";
+
+export class BaseAppMediator<ActivatorType extends IDefaultEventDispatcher<any> = IDefaultEventDispatcher<any>> extends BaseObjectWithGlobalDispatcher implements IActivatee {
+    protected activator: ActivatorType;
+
+    onActivatorStart(activator: ActivatorType): void {
+        this.activator = activator;
+    }
+
+    onActivatorEnd(): void {
+        this.destruction();
+    }
+
+    public addActivatorListener(type: string, listener: IEventListenerCallback): void {
+        this.eventListenerHelper.addEventListener(
+            this.activator,
+            type,
+            listener
+        )
+    }
+}