Switch from coffee script to typescrit

- Better tooling support
- Stronger type checking
- Unit test with jest
- JSDocc support

src/core/pm.ts

@@ -0,0 +1,136 @@
+namespace OS {
+    export namespace PM {
+        export type ProcessType = application.BaseApplication | application.BaseService;
+        export type ProcessTypeClass = {
+            new <T extends BaseModel>(args: AppArgumentsType[]): T;
+        };
+        export var pidalloc: number = 0;
+        export var processes: GenericObject<BaseModel[]> = {};
+        /**
+         *
+         *
+         * @export
+         * @param {string} app
+         * @param {ProcessTypeClass} cls
+         * @param {GUI.AppArgumentsType[]} [args]
+         * @returns {Promise<ProcessType>}
+         */
+        export function createProcess(
+            app: string,
+            cls: ProcessTypeClass,
+            args?: AppArgumentsType[]
+        ): Promise<ProcessType> {
+            return new Promise(function (resolve, reject) {
+                let metaclass = (cls as any) as typeof BaseModel;
+                const f = function () {
+                    //if it is single ton
+                    // and a process is existing
+                    // just return it
+                    let obj: ProcessType;
+                    if (
+                        metaclass.singleton &&
+                        PM.processes[app] &&
+                        PM.processes[app].length === 1
+                    ) {
+                        obj = PM.processes[
+                            app
+                        ][0] as application.BaseApplication;
+                        obj.show();
+                    } else {
+                        if (!PM.processes[app]) {
+                            PM.processes[app] = [];
+                        }
+                        obj = new cls(args);
+                        obj.birth = new Date().getTime();
+                        PM.pidalloc++;
+                        obj.pid = PM.pidalloc;
+                        PM.processes[app].push(obj);
+                        if (metaclass.type === ModelType.Application) {
+                            GUI.dock(
+                                obj as application.BaseApplication,
+                                metaclass.meta
+                            );
+                        } else {
+                            GUI.attachservice(obj as application.BaseService);
+                        }
+                    }
+                    return obj;
+                };
+                if (metaclass.dependencies) {
+                    const libs = Array.from(metaclass.dependencies);
+                    return API.require(libs)
+                        .then(() => resolve(f()))
+                        .catch((e: Error) => reject(__e(e)));
+                } else {
+                    return resolve(f());
+                }
+            });
+        }
+
+        /**
+         *
+         *
+         * @export
+         * @param {number} pid
+         * @returns {BaseModel}
+         */
+        export function appByPid(pid: number): BaseModel {
+            let app = undefined;
+            const find = function (l: Array<any>) {
+                for (let a of Array.from(l)) {
+                    if (a.pid === pid) {
+                        return a;
+                    }
+                }
+            };
+            for (let k in PM.processes) {
+                const v = PM.processes[k];
+                app = find(v);
+                if (app) {
+                    break;
+                }
+            }
+            return app;
+        }
+
+        /**
+         *
+         *
+         * @export
+         * @param {OS.GUI.BaseModel} app
+         * @returns {void}
+         */
+        export function kill(app: BaseModel): void {
+            if (!app.name || !PM.processes[app.name]) {
+                return;
+            }
+
+            const i = PM.processes[app.name].indexOf(app);
+            if (i >= 0) {
+                if (application[app.name].type === ModelType.Application) {
+                    GUI.undock(app as application.BaseApplication);
+                } else {
+                    GUI.detachservice(app as application.BaseService);
+                }
+                announcer.unregister(app);
+                delete PM.processes[app.name][i];
+                PM.processes[app.name].splice(i, 1);
+            }
+        }
+
+        /**
+         *
+         *
+         * @export
+         * @param {string} app
+         * @param {boolean} force
+         * @returns {void}
+         */
+        export function killAll(app: string, force: boolean): void {
+            if (!PM.processes[app]) {
+                return;
+            }
+            Array.from(PM.processes[app]).map((a) => a.quit(force));
+        }
+    }
+}