Feat renderer pref and db

src/IPC/AppPathIPC.ts

@@ -0,0 +1,58 @@
+import {ipcMain, ipcRenderer} from 'electron';
+
+enum Channels {
+ appDataPath = 'AppPathIPC:appDataPath',
+ userDataPath = 'AppPathIPC:userDataPath',
+ prefDataDir = 'AppPathIPC:prefDataDir',
+ prefDataPath = 'AppPathIPC:prefDataPath',
+ absPath = 'AppPathIPC:absPath',
+}
+
+class _AppPathIPC {
+ // app data path
+ async getAppDataPath(): Promise<string> {
+ return ipcRenderer.invoke(Channels.appDataPath);
+ }
+
+ onGetAppDataPath(handler: () => Promise<string>) {
+ return ipcMain.handle(Channels.appDataPath, (_ev) => handler());
+ }
+
+ // user data path
+ async getUserDataPath(): Promise<string> {
+ return ipcRenderer.invoke(Channels.userDataPath);
+ }
+
+ onGetUserDataPath(handler: () => Promise<string>) {
+ return ipcMain.handle(Channels.userDataPath, (_ev) => handler());
+ }
+
+ // pref path
+ async getPrefPath(): Promise<string> {
+ return ipcRenderer.invoke(Channels.prefDataPath);
+ }
+
+ onGetPrefPath(handler: () => Promise<string>) {
+ return ipcMain.handle(Channels.prefDataPath, (_ev) => handler());
+ }
+
+ // pref dir
+ async getPrefDir(): Promise<string> {
+ return ipcRenderer.invoke(Channels.prefDataDir);
+ }
+
+ onGetPrefDir(handler: () => Promise<string>) {
+ return ipcMain.handle(Channels.prefDataDir, (_ev) => handler());
+ }
+
+ // abs path
+ async getAbsPath(path: string, currentFilePath: string): Promise<string> {
+ return ipcRenderer.invoke(Channels.absPath, path, currentFilePath);
+ }
+
+ onGetAbsPath(handler: (path: string, currentFilePath: string) => Promise<string>) {
+ return ipcMain.handle(Channels.absPath, (_ev, path, parent) => handler(path, parent));
+ }
+}
+
+export const AppPathIPC = new _AppPathIPC();

src/IPC/FSIPC.ts

@@ -0,0 +1,68 @@
+import {ipcMain, ipcRenderer} from 'electron';
+
+enum Channels {
+ exist = 'FSIPC:exist',
+ mkdir = 'FSIPC:mkdir',
+ rmdir = 'FSIPC:rmdir',
+ rm = 'FSIPC:rm',
+ write = 'FSIPC:write',
+ read = 'FSIPC:read',
+}
+
+class _FSIPC {
+ // exist
+ async exist(path: string): Promise<boolean> {
+ return ipcRenderer.invoke(Channels.exist, path);
+ }
+
+ onExist(handler: (path: string) => Promise<boolean>) {
+ return ipcMain.handle(Channels.exist, (_ev, path) => handler(path));
+ }
+
+ // mkdir
+ async mkdir(path: string): Promise<void> {
+ return ipcRenderer.invoke(Channels.mkdir, path);
+ }
+
+ onMkdir(handler: (path: string) => Promise<void>) {
+ return ipcMain.handle(Channels.mkdir, (_ev, path) => handler(path));
+ }
+
+ // rmdir
+ async rmdir(path: string): Promise<boolean> {
+ return ipcRenderer.invoke(Channels.rmdir, path);
+ }
+
+ onRmdir(handler: (path: string) => Promise<boolean>) {
+ return ipcMain.handle(Channels.rmdir, (_ev, path) => handler(path));
+ }
+
+ // rm
+ async rm(path: string): Promise<void> {
+ return ipcRenderer.invoke(Channels.rm, path);
+ }
+
+ onRm(handler: (path: string) => Promise<void>) {
+ return ipcMain.handle(Channels.rm, (_ev, path) => handler(path));
+ }
+
+ // write
+ async write(path: string, text: string): Promise<void> {
+ return ipcRenderer.invoke(Channels.write, path, text);
+ }
+
+ onWrite(handler: (path: string, text: string) => Promise<void>) {
+ return ipcMain.handle(Channels.write, (_ev, path, text) => handler(path, text));
+ }
+
+ // read
+ async read(path: string): Promise<string> {
+ return ipcRenderer.invoke(Channels.read, path);
+ }
+
+ onRead(handler: (path: string) => Promise<string>) {
+ return ipcMain.handle(Channels.read, (_ev, path) => handler(path));
+ }
+}
+
+export const FSIPC = new _FSIPC();

src/IPC/DBIPC.ts → src/IPC/SQLiteIPC.ts

@@ -27,14 +27,11 @@ type SQLRowReturn<T> = {
  error?: Error;
 };
 
-class _DBIPC {
+class _SQLiteIPC {
  // exec
  async exec(sql: SQLParams['sql'], params?: SQLParams['params']): Promise<SQLRunReturn> {
  const p: SQLParams = {sql, params};
- const t = Date.now();
- const res = await ipcRenderer.invoke(ChannelNames.exec, p);
- this.showLog(t, sql, params);
- return res;
+ return await ipcRenderer.invoke(ChannelNames.exec, p);
  }
 
  onExec(handler: (_ev, params: SQLParams) => Promise<SQLRunReturn>) {
@@ -44,10 +41,7 @@ class _DBIPC {
  // select
  async select<T = any>(sql: SQLParams['sql'], params?: SQLParams['params']): Promise<SQLRowsReturn<T>> {
  const p: SQLParams = {sql, params};
- const t = Date.now();
- const res = await ipcRenderer.invoke(ChannelNames.select, p);
- this.showLog(t, sql, params);
- return res;
+ return await ipcRenderer.invoke(ChannelNames.select, p);
  }
 
  onSelect(handler: (_ev, params: SQLParams) => Promise<SQLRowsReturn<any>>) {
@@ -57,36 +51,22 @@ class _DBIPC {
  // selectSingle
  async selectSingle<T = any>(sql: SQLParams['sql'], params?: SQLParams['params']): Promise<SQLRowReturn<T>> {
  const p: SQLParams = {sql, params};
- const t = Date.now();
- const res = await ipcRenderer.invoke(ChannelNames.selectSingle, p);
- this.showLog(t, sql, params);
- return res;
+ return await ipcRenderer.invoke(ChannelNames.selectSingle, p);
  }
 
  onSelectSingle(handler: (_ev, params: SQLParams) => Promise<SQLRowReturn<any>>) {
  ipcMain.handle(ChannelNames.selectSingle, handler);
  }
 
  // init
- async init(prefIndex: number): Promise<void> {
- return ipcRenderer.invoke(ChannelNames.init, prefIndex);
+ async init(dbPath: string): Promise<void> {
+ return ipcRenderer.invoke(ChannelNames.init, dbPath);
  }
 
- onInit(handler: (_ev, prefIndex: number) => Promise<void>) {
+ onInit(handler: (_ev, dbPath: string) => Promise<void>) {
  ipcMain.handle(ChannelNames.init, handler);
  }
 
- private showLog(startTime: number, sql: SQLParams['sql'], params: SQLParams['params']) {
- const isDev = process.env.JASPER === 'DEV';
- if (!isDev) return;
-
- const time = Date.now() - startTime;
- if (time > 33) {
- console.debug(`<span style="color: red">slow query ${time}</span>`, sql, params);
- } else {
- console.debug(time, sql, params);
- }
- }
 }
 
-export const DBIPC = new _DBIPC();
+export const SQLiteIPC = new _SQLiteIPC();

src/IPC/UserPrefIPC.ts

@@ -1,4 +1,4 @@
-import {UserPrefEntity} from '../Renderer/Type/UserPrefEntity';
+import {UserPrefEntity} from '../Renderer/Library/Type/UserPrefEntity';
 import {ipcMain, ipcRenderer} from 'electron';
 
 enum Channels {

src/Main/Bind/AppPathBind.ts

@@ -0,0 +1,56 @@
+import os from 'os';
+import process from 'process';
+import nodePath from "path";
+import {app} from 'electron';
+
+const MacSandboxPath = '/Library/Containers/io.jasperapp/data/Library/Application Support/jasper';
+
+class _AppPathBind {
+ // deleteUserData() {
+ // if (!FS.rmdir(this.getUserDataPath())) {
+ // FS.rmdir(this.getPrefDirPath());
+ // }
+ // }
+
+ getAppDataPath(): string {
+ // mac(no sign): ~/Library/Application Support/jasper
+ // mac(sign) : ~/Library/Containers/io.jasperapp/data/Library/Application Support/jasper
+ // win : ~\AppData\Roaming\jasper
+ return app.getPath('appData');
+ }
+
+ getUserDataPath(): string {
+ const userDataPath = app.getPath('userData');
+
+ // hack: Electron v6.0.3にしてから、app-sandboxを指定してcodesignしても、sandboxが有効にならない(原因不明)
+ // そのままだとデータのパスが変わってしまうので、非sandboxだけどデータのパスはsandboxのものを使う。
+ // 多分Electron側の問題だと思うので、それが直ったらこのhackも消す。
+ if (process.env.JASPER === 'DEV') {
+ // npm run electronで起動する場合、開発データとして使いたいので非sandboxのパスを使う
+ return userDataPath;
+ } else if (this.isMac() && !userDataPath.includes(MacSandboxPath)) {
+ const homePath = app.getPath('home');
+ return `${homePath}${MacSandboxPath}`;
+ } else {
+ return userDataPath;
+ }
+ }
+
+ getPrefDirPath(): string {
+ return `${this.getUserDataPath()}/io.jasperapp`;
+ }
+
+ getPrefPath(): string {
+ return `${this.getPrefDirPath()}/config.json`;
+ }
+
+ getAbsPath(targetPath: string, currentFilePath: string): string {
+ return nodePath.resolve(nodePath.dirname(currentFilePath), targetPath);
+ }
+
+ private isMac(): boolean {
+ return os.platform() === 'darwin';
+ }
+}
+
+export const AppPathBind = new _AppPathBind();

src/Main/Storage/FS.ts → src/Main/Bind/FSBind.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 
-class _FS {
+class _FSBind {
  exist(path: string): boolean {
  return fs.existsSync(path);
  }
@@ -35,19 +35,6 @@ class _FS {
  read(path): string {
  return fs.readFileSync(path).toString();
  }
-
- writeJSON<T>(path: string, json: T) {
- fs.writeFileSync(path, JSON.stringify(json, null, 2));
- }
-
- readJSON<T>(path: string): T {
- return JSON.parse(fs.readFileSync(path).toString()) as T;
- }
-
- copy(from: string, to: string) {
- const text = this.read(from);
- this.write(to, text);
- }
 }
 
-export const FS = new _FS();
+export const FSBind = new _FSBind();