ee-core 4.0.0-beta.1 → 4.0.1

package/app/application.d.ts

@@ -0,0 +1,5 @@
+export declare class Appliaction {
+    register(eventName: string, handler: Function): void;
+    run(): void;
+}
+export declare const app: Appliaction;

package/app/boot.d.ts

@@ -0,0 +1,5 @@
+export declare class ElectronEgg {
+    init(): void;
+    register(eventName: string, handler: Function): void;
+    run(): void;
+}

package/app/boot.js

@@ -9,14 +9,12 @@ const { loadConfig } = require('../config');
 const { loadLog } = require('../log');
 const { app } = require('./application');
 const { loadDir } = require('./dir');
-// const { isJsProject } = require('../utils');
 
 class ElectronEgg {
   constructor() {
     const baseDir = electronApp.getAppPath();
     const { env } = process;
     const environmet = getArgumentByName('env') || 'prod';
-    console.log('argv:', process.argv);
 
     const options = {
       env: environmet,
@@ -36,11 +34,6 @@ class ElectronEgg {
       options.execDir = path.dirname(electronApp.getPath('exe'));
     }
 
-    // js开发环境使用源码目录
-    // if (isJsProject(baseDir) && environmet !== 'prod' ) {
-    //   options.electronDir = path.join(baseDir, 'electron');
-    // }
-
     // normalize env
     env.EE_ENV = environmet;
     env.EE_APP_NAME = options.appName;

package/app/dir.d.ts

@@ -0,0 +1 @@
+export declare function loadDir(): void;

package/app/events.d.ts

@@ -0,0 +1,14 @@
+export declare class EventBus {
+    lifecycleEvents: {};
+    eventsMap: {};
+    register(eventName: string, handler: Function): void;
+    emitLifecycle(eventName: string, ...args: any[]): void;
+    on(eventName: string, handler: Function): void;
+    emit(eventName: string, ...args: any[]): void;
+}
+export declare const eventBus: EventBus;
+export declare const Ready: "ready";
+export declare const ElectronAppReady: "electron-app-ready";
+export declare const WindowReady: "window-ready";
+export declare const Preload: "preload";
+export declare const BeforeClose: "before-close";

package/app/index.d.ts

@@ -0,0 +1,2 @@
+export { ElectronEgg };
+import { ElectronEgg } from "./boot";

package/config/config_loader.d.ts

@@ -0,0 +1,13 @@
+import { Timing } from "../core/utils/timing";
+import { EEConfig } from "./default_config";
+export declare class ConfigLoader {
+    timing: Timing;
+    /**
+     * Load config/config.xxx.js
+     */
+    load(): EEConfig;
+    _AppConfig(): EEConfig;
+    _loadConfig(dirpath: string, filename: string): EEConfig;
+}
+
+

package/config/default_config.d.ts

@@ -0,0 +1,95 @@
+import { BrowserWindowConstructorOptions } from 'electron';
+
+export declare interface AppConfig {
+    openDevTools?: boolean | Object;
+    singleLock?: boolean;
+    windowsOption?: BrowserWindowConstructorOptions;
+    logger?: LoggerConfig;
+    socketServer?: SocketConfig;
+    httpServer?: HttpConfig;
+    remote?: RemoteConfig;
+    mainServer?: MainConfig;
+    exception?: ExceptionConfig;
+    job?: JobConfig;
+    cross?: CrossConfig;
+}
+export declare interface LoggerConfig {
+    type?: string;
+    dir?: string;
+    encoding?: string;
+    env?: string;
+    level?: string;
+    consoleLevel?: string;
+    disableConsoleAfterReady?: boolean;
+    outputJSON?: boolean;
+    buffer?: boolean;
+    appLogName: string;
+    coreLogName?: string;
+    agentLogName?: string;
+    errorLogName: string;
+    coreLogger?: {};
+    allowDebugAtProd?: boolean;
+    enablePerformanceTimer?: boolean;
+    rotator?: string;
+}
+export declare interface SocketConfig {
+    enable: boolean;
+    port: number;
+    path?: string;
+    connectTimeout?: number;
+    pingTimeout?: number;
+    pingInterval?: number;
+    maxHttpBufferSize?: number;
+    transports?: string[];
+    cors?: {
+        origin?: boolean;
+    };
+    channel?: string;
+}
+export declare interface HttpConfig {
+    enable: boolean;
+    https?: {
+        enable: boolean;
+        key: string;
+        cert: string;
+    };
+    protocol?: string;
+    host?: string;
+    port: number;
+    cors?: {
+        origin?: string;
+    };
+    body?: {
+        multipart?: boolean;
+        formidable?: {
+            keepExtensions?: boolean;
+        };
+    };
+    filterRequest?: {
+        uris?: string[];
+        returnData?: string;
+    };
+}
+export declare interface RemoteConfig {
+    enable: boolean;
+    url: string;
+}
+export declare interface MainConfig {
+    protocol?: string;
+    indexPath: string;
+    options?: {};
+    takeover?: string;
+    loadingPage?: string;
+    channelSeparator?: string;
+}
+export declare interface ExceptionConfig {
+    mainExit?: boolean;
+    childExit?: boolean;
+    rendererExit?: boolean;
+}
+export declare interface JobConfig {
+    messageLog: boolean;
+}
+export declare interface CrossConfig {}
+declare function config(): AppConfig;
+export = config;

package/config/default_config.js

@@ -96,10 +96,11 @@ module.exports = () => {
       options: {},
       takeover: '',
       loadingPage: '',
+      channelSeparator: '/',
     },
     exception: {
       mainExit: false,
-      childExit: true,
+      childExit: false,
       rendererExit: true,
     },
     jobs: {

package/config/index.d.ts

@@ -0,0 +1,28 @@
+import { 
+    AppConfig, 
+    WindowsConfig, 
+    LoggerConfig, 
+    SocketConfig, 
+    HttpConfig,
+    RemoteConfig,
+    MainConfig,
+    ExceptionConfig,
+    JobConfig,
+    CrossConfig 
+} from "./default_config";
+declare function loadConfig(): AppConfig;
+declare function getConfig(): AppConfig;
+export {
+    AppConfig, 
+    WindowsConfig, 
+    LoggerConfig, 
+    SocketConfig, 
+    HttpConfig,
+    RemoteConfig,
+    MainConfig,
+    ExceptionConfig,
+    JobConfig,
+    CrossConfig,
+    loadConfig,
+    getConfig
+}

package/const/channel.d.ts

@@ -0,0 +1,16 @@
+export declare namespace Processes {
+    let showException: string;
+    let sendToMain: string;
+}
+export declare namespace SocketIO {
+    let partySoftware: string;
+}
+export declare namespace Events {
+    let childProcessExit: string;
+    let childProcessError: string;
+}
+export declare namespace Receiver {
+    let childJob: string;
+    let forkProcess: string;
+    let all: string;
+}

package/const/channel.js

@@ -6,7 +6,7 @@ const Processes = {
 }
 
 const SocketIO = {
-  partySoftware: 'c1',
+  partySoftware: 'socket-channel',
 }
 
 const Events = {

package/controller/controller_loader.d.ts

@@ -0,0 +1,9 @@
+import { Timing } from "../core/utils/timing";
+export declare class ControllerLoader {
+    timing: Timing;
+    /**
+     * Load controller/xxx.js
+     */
+    load(): any;
+}
+

package/controller/index.d.ts

@@ -0,0 +1,2 @@
+export declare function loadController(): void;
+export declare function getController(): any;

package/core/index.d.ts

@@ -0,0 +1,2 @@
+import utils = require("./utils");
+export { EeLoader, BaseContextClass, utils };

package/core/loader/file_loader.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Load files from directory to target object.
+ */
+export declare class FileLoader {
+    /**
+     * @class
+     * @param {Object} options - options
+     * @param {String|Array} options.directory - directories to be loaded
+     * @param {Object} options.target - attach the target object from loaded files
+     * @param {String} options.match - match the files when load, support glob, default to all js files
+     * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+     * @param {Boolean} options.call - determine whether invoke when exports is function
+     * @param {Object} options.inject - an object that be the argument when invoke the function
+     * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+     */
+    constructor(options: {
+        directory: string | any[];
+        target: any;
+        match: string;
+        initializer: Function;
+        call: boolean;
+        inject: any;
+        caseStyle: string | Function;
+    });
+    options: {
+        directory: any;
+        target: any;
+        match: any;
+        caseStyle: string;
+        initializer: any;
+        call: boolean;
+        inject: any;
+    } & {
+        directory: string | any[];
+        target: any;
+        match: string;
+        initializer: Function;
+        call: boolean;
+        inject: any;
+        caseStyle: string | Function;
+    };
+    /**
+     * attach items to target object. Mapping the directory to properties.
+     * `xxx/group/repository.js` => `target.group.repository`
+     * @return {Object} target
+     */
+    load(): any;
+    /**
+     * Parse files from given directories, then return an items list, each item contains properties and exports.
+     * For example, parse `controller/group/repository.js`
+     * It returns a item
+     * ```
+     * {
+     *   fullpath: '',
+     *   properties: [ 'group', 'repository' ],
+     *   exports: { ... },
+     * }
+     * ```
+     * `Properties` is an array that contains the directory of a filepath.
+     * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+     * @return {Array} items
+     */
+    parse(): any[];
+}
+export declare const EXPORTS: unique symbol;
+export declare const FULLPATH: unique symbol;

package/core/utils/index.d.ts

@@ -0,0 +1,12 @@
+export declare const extensions: any;
+export declare function loadFile(filepath: any): any;
+export declare function callFn(fn: any, args: any, ctx: any): Promise<any>;
+export declare function getResolvedFilename(filepath: any, baseDir: any): any;
+/**
+ * 字节码类
+ */
+export declare function isBytecodeClass(exports: any): boolean;
+/**
+ * 文件类型
+ */
+export declare function filePatterns(): string[];

package/core/utils/timing.d.ts

@@ -0,0 +1,22 @@
+export declare class Timing {
+    _enable: boolean;
+    init(): void;
+    start(name: any, start: any): {
+        name: any;
+        start: any;
+        end: any;
+        duration: any;
+        pid: number;
+        index: number;
+    };
+    end(name: any): any;
+    enable(): void;
+    disable(): void;
+    clear(): void;
+    toJSON(): any[];
+    [MAP]: Map<any, any>;
+    [LIST]: any[];
+}
+declare const MAP: unique symbol;
+declare const LIST: unique symbol;
+export {};

package/cross/cross.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from 'node:events';
+import { CrossProcess } from "./crossProcess";
+import internal = require("stream");
+export declare class Cross {
+    emitter: EventEmitter<[never]>;
+    children: {};
+    childrenMap: {};
+    create(): Promise<void>;
+    run(service: string, opt?: {}): Promise<CrossProcess>;
+    killAll(): void;
+    kill(pid: string|number): void;
+    killByName(name: string): void;
+    getUrl(name: string): string;
+    getProcByName(name: string): CrossProcess;
+    getProc(pid: string|number): CrossProcess;
+    getPids(): string[];
+    _initEventEmitter(): void;
+}
+export declare let cross: Cross;

package/cross/cross.js

@@ -3,12 +3,12 @@
 const EventEmitter = require('events');
 const { getConfig } = require('../config');
 const { sleep, getValueFromArgv, replaceArgsValue } = require('../utils/helper');
-const { SpawnProcess } = require('./spawnProcess');
+const { CrossProcess } = require('./crossProcess');
 const { Events } = require('../const/channel');
 const { extend } = require('../utils/extend');
 const { getPort } = require('../utils/port');
 
-class CrossProcess {
+class Cross {
   constructor() {
     this.emitter = undefined;
 
@@ -62,7 +62,7 @@ class CrossProcess {
     }
 
     // 创建进程
-    const subProcess = new SpawnProcess(this, { targetConf, port: confPort });
+    const subProcess = new CrossProcess(this, { targetConf, port: confPort });
     let uniqueName = targetConf.name;
     if (this.childrenMap.hasOwnProperty(uniqueName)) {
       uniqueName = uniqueName + "-" + String(subProcess.pid);
@@ -147,6 +147,6 @@ class CrossProcess {
 }  
 
 module.exports = {
-  CrossProcess,
-  cross: new CrossProcess()
+  Cross,
+  cross: new Cross()
 };

package/cross/crossProcess.d.ts

@@ -0,0 +1,29 @@
+import EventEmitter = require("events");
+export declare class CrossProcess {
+    constructor(host: any, opt?: {});
+    emitter: EventEmitter<[never]>;
+    host: any;
+    child: any;
+    pid: number;
+    port: number;
+    name: string;
+    config: {};
+    /**
+     * 初始化子进程
+     */
+    _init(options?: {}): void;
+    /**
+     * kill
+     */
+    kill(timeout?: number): void;
+    getUrl(): string;
+    getArgsObj(): {
+        _: any[];
+    };
+    setPort(port: string|number): void;
+    _generateId(): string;
+    /**
+     * exit electron
+     */
+    _exitElectron(timeout?: number): void;
+}

package/cross/{spawnProcess.js → crossProcess.js}

@@ -10,8 +10,9 @@ const { getRandomString, getValueFromArgv } = require('../utils/helper');
 const { is } = require('../utils');
 const { parseArgv } = require('../utils/pargv');
 const { app: electronApp } = require('electron');
+const tkill = require('tree-kill');
 
-class SpawnProcess {
+class CrossProcess {
   constructor(host, opt = {}) {
     this.emitter = new EventEmitter();
     this.host = host;
@@ -116,11 +117,15 @@ class SpawnProcess {
    * kill
    */
   kill(timeout = 1000) {
-    this.child.kill('SIGINT');
-    setTimeout(() => {
-      if (this.child.killed) return;
-      this.child.kill('SIGKILL');
-    }, timeout)
+    tkill(this.pid, 'SIGINT', (err) => {
+      if (err) {
+        coreLogger.error(`[ee-core] [corss/process] kill cross-process, error: ${err}, pid:${this.pid}`);
+        tkill(this.pid, 'SIGKILL');
+      }
+      setTimeout(() => {
+        this._exitElectron();
+      }, timeout)
+    })
   }
 
   getUrl() {
@@ -164,5 +169,5 @@ class SpawnProcess {
 }
 
 module.exports = {
-  SpawnProcess
+  CrossProcess
 };

package/cross/index.d.ts

@@ -0,0 +1,2 @@
+import { Cross, cross } from "./cross";
+export { Cross, cross };

package/cross/index.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { CrossProcess, cross} = require('./cross');
+const { Cross, cross} = require('./cross');
 
 module.exports = {
-  CrossProcess,
+  Cross,
   cross
 };

package/electron/app/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 创建electron应用
+ */
+export declare function createElectron(): void;
+export { electronApp };

package/electron/index.d.ts

@@ -0,0 +1,3 @@
+import { getMainWindow, setCloseAndQuit, getCloseAndQuit } from "./window";
+export declare function loadElectron(): void;
+export { getMainWindow, setCloseAndQuit, getCloseAndQuit };

package/electron/window/index.d.ts

@@ -0,0 +1,6 @@
+export declare function getMainWindow(): any;
+export declare function createMainWindow(): any;
+export declare function restoreMainWindow(): void;
+export declare function setCloseAndQuit(flag: any): void;
+export declare function getCloseAndQuit(): boolean;
+export declare function loadServer(): Promise<void>;

package/exception/index.d.ts

@@ -0,0 +1,9 @@
+// Capture exceptions
+export declare function loadException(): void;
+// When an exception is thrown on a process without being caught, trigger the event and silence the exception
+export declare function uncaughtExceptionHandler(): void;
+// When the reject exception in the promise is not caught using catch in the synchronization task, it will trigger the event，
+// Even if catch is used in asynchronous situations, it will trigger the event
+export declare function unhandledRejectionHandler(): void;
+// This event is triggered when an exception is thrown on the process without being caught.
+export declare function uncaughtExceptionMonitorHandler(): void;

package/exception/index.js

@@ -5,17 +5,13 @@ const { isForkedChild, isRenderer, isDev, isMain } = require('../ps');
 const { getConfig } = require('../config');
 const { childMessage } = require('../message');
 
-/**
- * 捕获异常
- */
+// 捕获异常
 function loadException() {
   uncaughtExceptionHandler();
   unhandledRejectionHandler();
 }
 
-/**
- * 当进程上抛出异常而没有被捕获时触发该事件，并且使异常静默。
- */
+// 当进程上抛出异常而没有被捕获时触发该事件，并且使异常静默。
 function uncaughtExceptionHandler() {
   process.on('uncaughtException', function(err) {
     if (!(err instanceof Error)) {
@@ -34,9 +30,7 @@ function uncaughtExceptionHandler() {
   });
 }
 
-/**
- * 当进程上抛出异常而没有被捕获时触发该事件。
- */
+// 当进程上抛出异常而没有被捕获时触发该事件。
 function uncaughtExceptionMonitorHandler() {
   process.on('uncaughtExceptionMonitor', function(err, origin) {
     if (!(err instanceof Error)) {
@@ -46,10 +40,8 @@ function uncaughtExceptionMonitorHandler() {
   });
 }
 
-/**
- * 当promise中reject的异常在同步任务中没有使用catch捕获就会触发该事件，
- * 即便是在异步情况下使用了catch也会触发该事件
- */
+// 当promise中reject的异常在同步任务中没有使用catch捕获就会触发该事件，
+// 即便是在异步情况下使用了catch也会触发该事件
 function unhandledRejectionHandler() {
   process.on('unhandledRejection', function(err) {
     if (!(err instanceof Error)) {
@@ -71,18 +63,14 @@ function unhandledRejectionHandler() {
   });
 }
 
-/**
- * 如果是子进程，发送错误到主进程控制台
- */
+// 如果是子进程，发送错误到主进程控制台
 function _devError (err) {
   if (isForkedChild() && isDev()) {
     childMessage.sendErrorToTerminal(err);
   }
 }
 
-/**
- * 捕获异常后是否退出
- */
+// 捕获异常后是否退出
 function _exit () {
   const { mainExit, childExit, rendererExit  } = getConfig().exception;
 
@@ -97,9 +85,7 @@ function _exit () {
   }
 }
 
-/**
- * 捕获异常后是否退出
- */
+// 捕获异常后是否退出
 function _delayExit() {
   // 等待日志等异步写入完成
   setTimeout(() => {

package/html/index.d.ts

@@ -0,0 +1 @@
+export declare function getHtmlFilepath(name: string): string;

package/index.d.ts

@@ -0,0 +1,2 @@
+export { ElectronEgg };
+import { ElectronEgg } from "./app";

package/jobs/child/app.d.ts

@@ -0,0 +1 @@
+export {};

package/jobs/child/index.d.ts

@@ -0,0 +1,13 @@
+import EventEmitter = require("events");
+import { JobProcess } from "./jobProcess";
+export declare class ChildJob extends EventEmitter<[never]> {
+    constructor();
+    jobs: {};
+    config: any;
+    _initEvents(): void;
+    exec(filepath: string, params?: {}, opt?: {}): JobProcess;
+    createProcess(opt?: {}): JobProcess;
+    getPids(): string[];
+    execPromise(filepath: string, params?: {}, opt?: {}): Promise<JobProcess>;
+}
+

package/jobs/child/index.js

@@ -1,5 +1,5 @@
 const EventEmitter = require('events');
-const { ForkProcess } = require('./forkProcess');
+const { JobProcess } = require('./jobProcess');
 const { getFullpath } = require('../../loader');
 const { Events } = require('../../const/channel');
 const { getConfig } = require('../../config');
@@ -53,7 +53,7 @@ class ChildJob extends EventEmitter {
         type: 'childJob'
       }
     }, opt);
-    const proc = new ForkProcess(this, options);
+    const proc = new JobProcess(this, options);
     if (!proc) {
       let errorMessage = `[ee-core] [jobs/child] Failed to obtain the child process !`
       throw new Error(errorMessage);

package/jobs/child/jobProcess.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "events";
+import { ChildProcess } from "child_process";
+declare export class JobProcess {
+    constructor(host: any, opt?: {});
+    emitter: EventEmitter<[never]>;
+    host: any;
+    args: string[];
+    sleeping: boolean;
+    child: ChildProcess;
+    pid: number;
+    _init(): void;
+    _eventEmit(m: any): void;
+    dispatch(cmd: string, jobPath?: string, ...params: any[]): void;
+    callFunc(jobPath?: string, funcName?: string, ...params: any[]): void;
+    kill(timeout?: number): void;
+}