fontastic 0.1.7 → 0.2.0

package/app/core/FontFinder.ts

@@ -1,96 +1,75 @@
-import ConnectionManager from "./ConnectionManager";
-import FontObject from "./FontObject";
-import * as fs from "fs";
-import * as path from "path";
-import { installable } from "../config/mimes";
-
-const prettyBytes = require("pretty-bytes");
-const mime = require("mime");
-
-// https://stackoverflow.com/questions/10049557/reading-all-files-in-a-directory-store-them-in-objects-and-send-the-object
-
-export default class FileSystem {
-
-  connectionManager: ConnectionManager;
-
-  counter: number = 0;
-  errors: any[] = [];
-  found: any[] = [];
-
-  constructor(connectionManager: ConnectionManager) {
-    this.connectionManager = connectionManager;
-
-    this.counter = 0;
-    this.errors = [];
-  }
-
-  setCounter(count: number): void {
-    this.counter = count;
-  }
-
-  getCounter(): number {
-    return this.counter;
-  }
-
-  scanFolders(dir: any, options: any, done: any) {
-    fs.readdir(dir, (err: any, list: any) => {
-      if (err) return done(err);
-      let i = 0;
-      let next = () => {
-        let file = list[i++];
-        if (!file) return done(null, this);
-        let fp = path.resolve(dir, file);
-        fs.stat(fp, async (err: any, stat: any) => {
-          if (stat && stat.isDirectory()) {
-            this.scanFolders(fp, options, (err: any, res: any) => next());
-          } else {
-            this.fontInstall(fp, stat, options);
-            next();
-          }
-        });
-      };
-      next();
-    });
-  }
-
-  scanFiles(files: any, options: any, done: any) {
-    files.forEach(async (fp: any) => {
-      let stat = fs.statSync(fp);
-      if (stat.isFile()) {
-        this.fontInstall(fp, stat, options);
-      }
-    });
-
-    return done(null, this);
-  }
-
-  fontInstall(fp: any, stat: any, options: any) {
-    let font = new FontObject(fp);
-
-    if (font.hasError()) {
-      this.errors.push(font.getError());
-    } else {
-
-      let fileSize = stat.size;
-      let fileType = mime.getType(fp);
-
-      let data: any = {
-        file_path: fp,
-        file_name: path.basename(fp),
-        file_size: fileSize,
-        file_size_pretty: prettyBytes(fileSize),
-        file_type: fileType,
-        installable: installable.includes(fileType),
-        ...options
-      }
-
-      try {
-        this.connectionManager.getStoreRepository().create({ ...data, ...font.getNamesTable() });
-      } catch(err) {
-        this.errors.push(err.message);
-      }
-
-      this.counter++;
-    }
-  }
-}
+import ConnectionManager from "./ConnectionManager";
+import FontObject from "./FontObject";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { mimeTypes, installable } from "../config/mimes";
+
+const prettyBytes = require("pretty-bytes");
+const mime = require("mime");
+
+export default class FontFinder {
+
+  connectionManager: ConnectionManager;
+  errors: any[] = [];
+  counter: number = 0;
+
+  constructor(connectionManager: ConnectionManager) {
+    this.connectionManager = connectionManager;
+  }
+
+  private isFontFile(filePath: string): boolean {
+    const fileType = mime.getType(filePath);
+    return fileType && mimeTypes.includes(fileType);
+  }
+
+  async scanFiles(files: string[], options: any) {
+    for (const fp of files) {
+      if (this.isFontFile(fp)) {
+        const stat = await fs.stat(fp);
+        await this.processFont(fp, stat, options);
+      }
+    }
+  }
+
+  async scanFolder(dir: string, options: any) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fp = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.scanFolder(fp, options);
+      } else if (this.isFontFile(fp)) {
+        const stat = await fs.stat(fp);
+        await this.processFont(fp, stat, options);
+      }
+    }
+  }
+
+  private async processFont(fp: string, stat: any, options: any) {
+    const font = new FontObject(fp);
+
+    if (font.hasError()) {
+      this.errors.push(font.getError());
+      return;
+    }
+
+    const fileType = mime.getType(fp);
+
+    const data = {
+      file_path: fp,
+      file_name: path.basename(fp),
+      file_size: stat.size,
+      file_size_pretty: prettyBytes(stat.size),
+      file_type: fileType,
+      installable: installable.includes(fileType),
+      ...options,
+      ...font.getNamesTable(),
+    };
+
+    try {
+      await this.connectionManager.getStoreRepository().create(data);
+      this.counter++;
+    } catch (err) {
+      this.errors.push(err.message);
+    }
+  }
+}

package/app/core/FontManager.js

@@ -1,165 +1,129 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const electron_1 = require("electron");
-const FontCatalog_1 = require("./FontCatalog");
-const FontFinder_1 = require("./FontFinder");
-const FontInstaller_1 = require("./FontInstaller");
-const command_1 = require("../helpers/command");
-const random_1 = require("../helpers/random");
-const StorageType_1 = require("../enums/StorageType");
-const path = require("path");
-const fetch = require('node-fetch');
-class FontManager {
-    constructor(systemManager, configManager, connectionManager) {
-        this.systemManager = systemManager;
-        this.configManager = configManager;
-        this.connectionManager = connectionManager;
-    }
-    fetchLatestNews(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(args.endpoint);
-            return yield response.json();
-        });
-    }
-    systemAuthenticate(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            args.status = 'ok';
-            this.configManager.set(StorageType_1.StorageType.User, args);
-            return this.configManager.get(StorageType_1.StorageType.User);
-        });
-    }
-    executeCommand(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield (0, command_1.execute)(args.cmd, args.options);
-            }
-            catch (err) {
-                return err;
-            }
-        });
-    }
-    scanFiles(files, options) {
-        return new Promise((resolve, reject) => {
-            let finder = new FontFinder_1.default(this.connectionManager);
-            finder.scanFiles(files, options, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                return resolve({});
-            });
-        });
-    }
-    scanFolders(dir, options) {
-        return new Promise((resolve, reject) => {
-            let finder = new FontFinder_1.default(this.connectionManager);
-            finder.scanFolders(dir, options, (err) => {
-                if (err) {
-                    return reject(err);
-                }
-                return resolve({});
-            });
-        });
-    }
-    fontInstaller(options) {
-        let installer = new FontInstaller_1.default(this.systemManager, this.connectionManager);
-        return installer.activate(options);
-    }
-    /**
-     * @todo
-     */
-    folderInstaller(options) {
-        let installer = new FontInstaller_1.default(this.systemManager, this.connectionManager);
-        return installer.activate(options);
-    }
-    getMapFilePaths(files, dest) {
-        return files.map((file) => dest + path.sep + path.basename(file));
-    }
-    getSourceFolder(sourceFolder) {
-        return path.normalize(sourceFolder);
-    }
-    getDestinationFolder() {
-        return path.normalize(this.systemManager.getCatalogPath() + path.sep + Date.now() + (0, random_1.randNumber)(7));
-    }
-    getSourceDestinationFolders(sourceFolder) {
-        const src = this.getSourceFolder(sourceFolder);
-        const dest = this.getDestinationFolder();
-        return { src, dest };
-    }
-    createCatalog(folder) {
-        const catalog = new FontCatalog_1.default(this.systemManager);
-        return catalog.createCatalog(folder);
-    }
-    copyFiles(files, dest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const catalog = new FontCatalog_1.default(this.systemManager);
-                catalog.copyFiles(files, dest, (err, stdout) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    return resolve({});
-                });
-            });
-        });
-    }
-    copyFolders(src, dest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const catalog = new FontCatalog_1.default(this.systemManager);
-                catalog.copyFolders(src, dest, (err, stdout) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    return resolve({});
-                });
-            });
-        });
-    }
-    showMessageBox(options) {
-        return electron_1.dialog.showMessageBox(null, options);
-    }
-    showOpenDialog(options) {
-        return electron_1.dialog.showOpenDialog(options);
-    }
-    beep() {
-        return electron_1.shell.beep();
-    }
-    openPath(path) {
-        electron_1.shell.openPath(path);
-    }
-    openExternal(url) {
-        electron_1.shell.openExternal(url);
-    }
-    showItemInFolder(fullPath) {
-        electron_1.shell.showItemInFolder(fullPath);
-    }
-    reLaunch() {
-        electron_1.app.relaunch();
-        electron_1.app.quit();
-    }
-    exit() {
-        electron_1.app.exit();
-    }
-    quit() {
-        electron_1.app.quit();
-    }
-    reloadWindow() {
-        const windows = electron_1.BrowserWindow.getAllWindows();
-        if (windows && windows.length) {
-            for (const win of windows) {
-                win.webContents.reloadIgnoringCache();
-            }
-        }
-    }
-}
-exports.default = FontManager;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const FontCatalog_1 = require("./FontCatalog");
+const FontFinder_1 = require("./FontFinder");
+const command_1 = require("../helpers/command");
+const StorageType_1 = require("../enums/StorageType");
+const path = require("path");
+const fetch = require('node-fetch');
+class FontManager {
+    constructor(systemManager, configManager, connectionManager) {
+        this.systemManager = systemManager;
+        this.configManager = configManager;
+        this.connectionManager = connectionManager;
+    }
+    fetchLatestNews(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(args.endpoint);
+            const data = yield response.json();
+            if (data === null || data === void 0 ? void 0 : data.articles) {
+                this.configManager.set(StorageType_1.StorageType.News, Object.assign(Object.assign({}, this.configManager.get(StorageType_1.StorageType.News)), { articles: data.articles, ts: Date.now() }));
+            }
+            return data;
+        });
+    }
+    systemAuthenticate(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            args.status = 'ok';
+            this.configManager.set(StorageType_1.StorageType.User, args);
+            return this.configManager.get(StorageType_1.StorageType.User);
+        });
+    }
+    executeCommand(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (0, command_1.execute)(args.cmd, args.options);
+            }
+            catch (err) {
+                return err;
+            }
+        });
+    }
+    getDestinationFolder(collectionId) {
+        return path.join(this.systemManager.getCatalogPath(), String(collectionId));
+    }
+    copyFiles(files, collectionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dest = this.getDestinationFolder(collectionId);
+            console.log('[FontManager.copyFiles] dest:', dest, 'files:', files);
+            const catalog = new FontCatalog_1.default();
+            yield catalog.copyFiles(files, dest);
+            const catalogFiles = files.map((file) => path.join(dest, path.basename(file)));
+            console.log('[FontManager.copyFiles] catalogFiles:', catalogFiles);
+            return catalogFiles;
+        });
+    }
+    copyFolder(src, collectionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dest = this.getDestinationFolder(collectionId);
+            console.log('[FontManager.copyFolder] src:', src, 'dest:', dest);
+            const catalog = new FontCatalog_1.default();
+            yield catalog.copyFolder(src, dest);
+            return dest;
+        });
+    }
+    scanFiles(files, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[FontManager.scanFiles] files:', files, 'options:', options);
+            const finder = new FontFinder_1.default(this.connectionManager);
+            yield finder.scanFiles(files, options);
+            console.log('[FontManager.scanFiles] done, processed:', finder.counter, 'errors:', finder.errors);
+        });
+    }
+    scanFolder(dir, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[FontManager.scanFolder] dir:', dir, 'options:', options);
+            const finder = new FontFinder_1.default(this.connectionManager);
+            yield finder.scanFolder(dir, options);
+            console.log('[FontManager.scanFolder] done, processed:', finder.counter, 'errors:', finder.errors);
+        });
+    }
+    showMessageBox(options) {
+        return electron_1.dialog.showMessageBox(null, options);
+    }
+    showOpenDialog(options) {
+        return electron_1.dialog.showOpenDialog(options);
+    }
+    beep() {
+        return electron_1.shell.beep();
+    }
+    openPath(path) {
+        electron_1.shell.openPath(path);
+    }
+    openExternal(url) {
+        electron_1.shell.openExternal(url);
+    }
+    showItemInFolder(fullPath) {
+        electron_1.shell.showItemInFolder(fullPath);
+    }
+    reLaunch() {
+        electron_1.app.relaunch();
+        electron_1.app.quit();
+    }
+    exit() {
+        electron_1.app.exit();
+    }
+    quit() {
+        electron_1.app.quit();
+    }
+    reloadWindow() {
+        const windows = electron_1.BrowserWindow.getAllWindows();
+        if (windows && windows.length) {
+            for (const win of windows) {
+                win.webContents.reloadIgnoringCache();
+            }
+        }
+    }
+}
+exports.default = FontManager;
 //# sourceMappingURL=FontManager.js.map