ee-core 2.12.0 → 4.0.0

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/application.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const debug = require('debug')('ee-core:app:appliaction');
+const { loadController } = require('../controller');
+const { eventBus, Ready } = require('./events');
+const { loadSocket } = require('../socket');
+const { loadElectron } = require('../electron');
+
+class Appliaction {
+  constructor() {
+
+  }
+
+  register(eventName, handler) {
+    return eventBus.register(eventName, handler);
+  }
+
+  run() {
+    loadController();
+    loadSocket();
+    eventBus.emitLifecycle(Ready);
+    loadElectron();
+  }
+}
+
+const app = new Appliaction();
+
+module.exports = {
+  Appliaction,
+  app,
+};

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

@@ -0,0 +1,74 @@
+'use strict';
+
+const debug = require('debug')('ee-core:app:boot');
+const path = require('path');
+const { loadException } = require('../exception');
+const { electronApp } = require('../electron/app');
+const { getArgumentByName, getBundleDir } = require('../ps');
+const { loadConfig } = require('../config');
+const { loadLog } = require('../log');
+const { app } = require('./application');
+const { loadDir } = require('./dir');
+
+class ElectronEgg {
+  constructor() {
+    const baseDir = electronApp.getAppPath();
+    const { env } = process;
+    const environmet = getArgumentByName('env') || 'prod';
+
+    const options = {
+      env: environmet,
+      baseDir,
+      electronDir: getBundleDir(baseDir),
+      appName: electronApp.getName(),
+      userHome: electronApp.getPath('home'),
+      appData: electronApp.getPath('appData'),
+      appUserData: electronApp.getPath('userData'),
+      appVersion: electronApp.getVersion(),
+      isPackaged: electronApp.isPackaged,
+      execDir: baseDir,
+    }
+
+    // exec directory (exe dmg dep) for prod
+    if (environmet == 'prod' && options.isPackaged) {
+      options.execDir = path.dirname(electronApp.getPath('exe'));
+    }
+
+    // normalize env
+    env.EE_ENV = environmet;
+    env.EE_APP_NAME = options.appName;
+    env.EE_APP_VERSION = options.appVersion;
+    env.EE_BASE_DIR = options.baseDir;
+    env.EE_ELECTRON_DIR = options.electronDir;
+    env.EE_USER_HOME = options.userHome;
+    env.EE_APP_DATA = options.appData;
+    env.EE_APP_USER_DATA = options.appUserData;
+    env.EE_EXEC_DIR = options.execDir;
+    env.EE_IS_PACKAGED = options.isPackaged;
+    env.EE_SOCKET_PORT = null;
+    env.EE_HTTP_PORT = null;
+    debug('[constructor] options:%j', options)
+
+    this.init();
+  }
+
+  init() {
+    // basic functions
+    loadException();
+    loadConfig();
+    loadDir();
+    loadLog();
+  }
+
+  register(eventName, handler) {
+    return app.register(eventName, handler);
+  }
+
+  run() {
+    app.run();
+  }
+}
+
+module.exports = {
+  ElectronEgg,
+};

package/app/dir.d.ts

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

package/app/dir.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const fs = require('fs');
+const { getUserHomeHiddenAppDir, getLogDir, getDataDir } = require('../ps');
+const { mkdir } = require('../utils/helper');
+function loadDir() {
+  initDir();
+}
+
+function initDir() {
+  const homeHiddenAppDir = getUserHomeHiddenAppDir();
+  if (!fs.existsSync(homeHiddenAppDir)) {
+    mkdir(homeHiddenAppDir, { mode: 0o755 });
+  }
+  const dataDir = getDataDir();
+  if (!fs.existsSync(dataDir)) {
+    mkdir(dataDir, { mode: 0o755 });
+  }
+  const logDir = getLogDir();
+  if (!fs.existsSync(logDir)) {
+    mkdir(logDir, { mode: 0o755 });
+  }
+}
+
+module.exports = {
+  loadDir
+};

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/events.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Ready = "ready";
+const ElectronAppReady = "electron-app-ready";
+const WindowReady = "window-ready";
+const BeforeClose = "before-close";
+const Preload = "preload";
+
+class EventBus {
+  constructor() {
+    this.lifecycleEvents = {};
+    this.eventsMap = {};
+  }
+
+  // add lifecycle event
+  register(eventName, handler) {
+    if (!this.lifecycleEvents[eventName]) {
+      this.lifecycleEvents[eventName] = handler;
+    }
+  }
+
+  // call lifecycle event
+  emitLifecycle(eventName, ...args) {
+    const eventFn = this.lifecycleEvents[eventName];
+    if (eventFn) {
+      eventFn(...args);
+    }
+  } 
+
+  // add listener
+  on(eventName, handler) {
+    if (!this.eventsMap[eventName]) {
+      this.eventsMap[eventName] = handler;
+    }
+  }
+
+  // emit listener
+  emit(eventName, ...args) {
+    const eventFn = this.eventsMap[eventName];
+    if (eventFn) {
+      eventFn(...args);
+    }
+  }
+}
+
+const eventBus = new EventBus();
+
+module.exports = {
+  EventBus,
+  eventBus,
+  Ready,
+  ElectronAppReady,
+  WindowReady,
+  Preload,
+  BeforeClose
+};

package/app/index.d.ts

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

package/app/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { ElectronEgg } = require('./boot');
+
+module.exports = {
+  ElectronEgg,
+};

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/config_loader.js

@@ -2,15 +2,15 @@
 
 const debug = require('debug')('ee-core:config:config_loader');
 const path = require('path');
-const Ps = require('../ps');
-const extend = require('../utils/extend');
-const Timing = require('../core/lib/utils/timing');
-const Loader= require('../loader');
+const { appName, env, getElectronDir, getBaseDir, getRootDir } = require('../ps');
+const { extend } = require('../utils/extend');
+const { loadFile } = require('../loader');
+const { Timing } = require('../core/utils/timing');
+const defaultConfig = require('./default_config');
 
 class ConfigLoader {
   constructor() {
     this.timing = new Timing();
-    this.config = {};
   }
 
   /**
@@ -21,21 +21,24 @@ class ConfigLoader {
 
     // Load Application config
     const appConfig = this._AppConfig();
-    debug("[load] appConfig: %o", appConfig);
-    this.config = appConfig;
+    // debug("[load] appConfig: %O", appConfig);
+
+    const defaultConf = defaultConfig();
+    const config = extend(true, defaultConf, appConfig);
+    debug("[load] config: %o", config);
 
     this.timing.end('Load Config');
-    return this.config;
+    return config;
   }
 
   _AppConfig() {
     const names = [
       'config.default',
-      `config.${Ps.env()}`,
+      `config.${env()}`,
     ];
     const target = {};
     for (const filename of names) {
-      const config = this._loadConfig(Ps.getElectronDir(), filename);
+      const config = this._loadConfig(getElectronDir(), filename);
       extend(true, target, config);
     }
     return target;
@@ -43,21 +46,14 @@ class ConfigLoader {
 
   _loadConfig(dirpath, filename) {
     const appInfo = {
-      name: Ps.appName(),
-      baseDir: Ps.getElectronDir(),
-      electronDir: Ps.getElectronDir(),
-      env: Ps.env(),
-      home: Ps.getHomeDir(),
-      root: Ps.getRootDir(),
-      appUserDataDir: Ps.getAppUserDataDir(),
-      userHome: Ps.getUserHomeDir(),
-      appVersion: Ps.appVersion(),
-      isPackaged: Ps.isPackaged(),
-      isEncrypted: Ps.isEncrypted(),
-      execDir: Ps.getExecDir(),
+      name: appName(),
+      baseDir: getBaseDir(),
+      electronDir: getElectronDir(),
+      env: env(),
+      root: getRootDir(),
     }
     const filepath = path.join(dirpath, 'config', filename);
-    const config = Loader.loadOneFile(filepath, appInfo);
+    const config = loadFile(filepath, appInfo);
     debug("[_loadConfig] filepath: %s", filepath);
     if (!config) return null;
 

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

@@ -0,0 +1,111 @@
+'use strict';
+
+const path = require('path');
+const { env, getBaseDir, getLogDir } = require('../ps');
+const { SocketIO } = require('../const/channel');
+
+/**
+ * default
+ */
+module.exports = () => {
+  return {
+    openDevTools: false,
+    singleLock: true,
+    windowsOption: {
+      title: 'electron-egg',
+      width: 980,
+      height: 650,
+      minWidth: 400,
+      minHeight: 300,
+      webPreferences: {
+        //webSecurity: false,
+        contextIsolation: false, // false -> 可在渲染进程中使用electron的api，true->需要bridge.js(contextBridge)
+        nodeIntegration: true,
+        //preload: path.join(appInfo.electronDir, 'preload', 'bridge.js'),
+      },
+      frame: true,
+      show: false,
+      icon: path.join(getBaseDir(), 'public', 'images', 'logo-32.png'),
+    },
+    logger: {
+      type: 'application',
+      dir: getLogDir(),
+      encoding: 'utf8',
+      env: env(),
+      level: 'INFO',
+      consoleLevel: 'INFO',
+      disableConsoleAfterReady: env() !== 'local',
+      outputJSON: false,
+      buffer: true,
+      appLogName: `ee.log`,
+      coreLogName: 'ee-core.log',
+      agentLogName: 'ee-agent.log',
+      errorLogName: `ee-error.log`,
+      coreLogger: {},
+      allowDebugAtProd: false,
+      enablePerformanceTimer: false,
+      rotator: 'day',
+    },
+    socketServer: {
+      enable: false, // is it enabled
+      port: 7070, // default port (if the port is in use, randomly select one)
+      path: "/socket.io/", // path
+      connectTimeout: 45000, // client connection timeout
+      pingTimeout: 30000, // heartbeat detection timeout
+      pingInterval: 25000, // heartbeat detection interval
+      maxHttpBufferSize: 1e8, // the data size of each message 1M
+      transports: ["polling", "websocket"], // http polling or websocket
+      cors: {
+        origin: true, // http协议时，要设置跨域 类型 Boolean String RegExp Array Function
+      },
+      channel: SocketIO.partySoftware
+    },
+    httpServer: {
+      enable: false, // Is it enabled
+      https: {
+        enable: false,
+        key: '/public/ssl/localhost+1.key',
+        cert: '/public/ssl/localhost+1.pem'
+      },
+      protocol: 'http://',
+      host: '127.0.0.1',
+      port: 7071, // Default port (if the port is in use, randomly select one)
+      cors: {
+        origin: "*"
+      },
+      body: {
+        multipart: true,
+        formidable: {
+          keepExtensions: true
+        }
+      },
+      filterRequest: {
+        uris:  [
+          'favicon.ico'
+        ],
+        returnData: ''
+      }
+    },
+    remote: {
+      enable: false,
+      url: ''
+    },
+    mainServer: {
+      protocol: 'file://', // file://
+      indexPath: '/public/dist/index.html',
+      options: {},
+      takeover: '',
+      loadingPage: '',
+      channelSeparator: '/',
+    },
+    exception: {
+      mainExit: false,
+      childExit: false,
+      rendererExit: true,
+    },
+    jobs: {
+      messageLog: false
+    },
+    cross: {}
+  }
+}

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/config/index.js

@@ -1,42 +1,25 @@
-const ConfigCache = require('./cache');
+'use strict';
 
-const Cfg = {
+const { ConfigLoader } = require('./config_loader');
 
-  /**
-   * all
-   */
-  all() {
-    const cacheValue = ConfigCache.all();
-    return cacheValue;
-  },
-
-  /**
-   * getValue
-   */
-  getValue(key) {
-    const cacheValue = ConfigCache.getValue(key);
-    return cacheValue;
-  },  
+const Instance = {
+  config: null,
+};
 
-  /**
-   * isFileProtocol
-   */
-  isFileProtocol(config) {
-    if (config.protocol == 'file://') {
-      return true;
-    }
-    return false;
-  },
+function loadConfig() {
+  const configLoader = new ConfigLoader();
+  Instance["config"] = configLoader.load();
+  return Instance["config"];
+}
 
-  /**
-   * isWebProtocol
-   */
-  isWebProtocol(config) {
-    if (['http://', 'https://'].includes(config.protocol)) {
-      return true;
-    }
-    return false;
-  },   
-};
+function getConfig() {
+  if (!Instance["config"]) {
+    loadConfig();
+  };
+  return Instance["config"];
+}
 
-module.exports = Cfg;
+module.exports = {
+  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

@@ -1,18 +1,28 @@
+'use strict';
+
+const Processes = {
+  showException: 'ee#showException',
+  sendToMain: 'ee#sendToMain'
+}
+
+const SocketIO = {
+  partySoftware: 'socket-channel',
+}
+
+const Events = {
+  childProcessExit: 'ee#childProcess#exit',
+  childProcessError: 'ee#childProcess#error',
+}
+
+const Receiver = {
+  childJob: 'job',
+  forkProcess: 'task',
+  all: 'all'
+}
+
 module.exports = {
-  process: {
-    showException: 'ee#showException',
-    sendToMain: 'ee#sendToMain'
-  },
-  socketIo: {
-    partySoftware: 'c1',
-  },
-  events: {
-    childProcessExit: 'ee#childProcess#exit',
-    childProcessError: 'ee#childProcess#error',
-  },
-  receiver: {
-    childJob: 'job',
-    forkProcess: 'task',
-    all: 'all'
-  }
+  Processes,
+  SocketIO,
+  Events,
+  Receiver
 };