fontastic 0.1.3

package/app/core/FontFinder.ts

@@ -0,0 +1,96 @@
+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++;
+    }
+  }
+}

package/app/core/FontInstaller.js

@@ -0,0 +1,67 @@
+"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 command_1 = require("../helpers/command");
+const path = require("path");
+class FontInstaller {
+    constructor(systemManager, connectionManager) {
+        this.systemManager = systemManager;
+        this.connectionManager = connectionManager;
+    }
+    activate(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fonts = (args.files && args.files.length) ? args.files : [];
+            const temporary = (args.temporary && args.temporary === true) ? true : false;
+            const activate = (args.activate && args.activate === true) ? 1 : 0;
+            if (args.collectionId) {
+                let collectionId = parseInt(args.collectionId);
+                let results = yield this.connectionManager.getStore().find({ where: { collection_id: collectionId } });
+                return yield this.run({ files: results, activate, temporary }).then(() => {
+                    if (temporary) {
+                        this.connectionManager.getStoreRepository().temporaryCollection(collectionId, activate);
+                    }
+                    else {
+                        this.connectionManager.getStoreRepository().activateCollection(collectionId, activate);
+                    }
+                });
+            }
+            else {
+                return yield this.run(args).then(() => {
+                    let ids = fonts.map((item) => item.id);
+                    if (temporary) {
+                        this.connectionManager.getStoreRepository().temporaryByIds(ids, activate);
+                    }
+                    else {
+                        this.connectionManager.getStoreRepository().activateByIds(ids, activate);
+                    }
+                });
+            }
+        });
+    }
+    run(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = this.systemManager.getPlatform();
+            const executable = this.systemManager.getExecutable();
+            const activate = (args.activate) ? 'install' : 'uninstall';
+            const temporary = (platform === "win" && args.temporary && args.temporary === true) ? '--temporary=true' : '--temporary=false';
+            const files = args.files.map((item) => `"${path.normalize(item.file_path)}"`).join(" ");
+            const command = `${executable} ${activate} ${temporary} ${files}`;
+            if (platform === 'win') {
+                return (0, command_1.prompt)(command, { name: "Font Activation" });
+            }
+            else {
+                return (0, command_1.execute)(command);
+            }
+        });
+    }
+}
+exports.default = FontInstaller;
+//# sourceMappingURL=FontInstaller.js.map

package/app/core/FontInstaller.ts

@@ -0,0 +1,63 @@
+import SystemManager from "./SystemManager";
+import ConnectionManager from "./ConnectionManager";
+import { prompt, execute } from "../helpers/command"
+
+const path = require("path");
+
+export default class FontInstaller {
+
+  systemManager: SystemManager;
+  connectionManager: ConnectionManager;
+
+  constructor(
+    systemManager: SystemManager,
+    connectionManager: ConnectionManager
+  ) {
+    this.systemManager = systemManager;
+    this.connectionManager = connectionManager;
+  }
+
+  async activate(args: any) {
+    const fonts = (args.files && args.files.length) ? args.files : [];
+    const temporary = (args.temporary && args.temporary === true) ? true : false;
+    const activate = (args.activate && args.activate === true) ? 1 : 0;
+
+    if (args.collectionId) {
+      let collectionId = parseInt(args.collectionId);
+      let results = await this.connectionManager.getStore().find({ where: { collection_id: collectionId } });
+      return await this.run({ files: results, activate, temporary }).then(() => {
+        if (temporary) {
+          this.connectionManager.getStoreRepository().temporaryCollection(collectionId, activate);
+        } else {
+          this.connectionManager.getStoreRepository().activateCollection(collectionId, activate);
+        }
+      });
+    } else {
+      return await this.run(args).then(() => {
+        let ids = fonts.map((item: any) => item.id);
+        if (temporary) {
+          this.connectionManager.getStoreRepository().temporaryByIds(ids, activate);
+        } else {
+          this.connectionManager.getStoreRepository().activateByIds(ids, activate);
+        }
+      });
+    }
+  }
+
+  async run(args: any) {
+    const platform = this.systemManager.getPlatform();
+    const executable = this.systemManager.getExecutable();
+
+    const activate = (args.activate) ? 'install' : 'uninstall';
+    const temporary = (platform === "win" && args.temporary && args.temporary === true) ? '--temporary=true' : '--temporary=false';
+    const files = args.files.map((item: any) => `"${path.normalize(item.file_path)}"`).join(" ");
+
+    const command = `${executable} ${activate} ${temporary} ${files}`;
+
+    if (platform === 'win') {
+      return prompt(command, { name: "Font Activation" });
+    } else {
+      return execute(command);
+    }
+  }
+}

package/app/core/FontManager.js

@@ -0,0 +1,165 @@
+"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;
+//# sourceMappingURL=FontManager.js.map

package/app/core/FontManager.ts

@@ -0,0 +1,172 @@
+import { app, dialog, BrowserWindow, shell } from 'electron';
+
+import SystemManager from './SystemManager';
+import ConfigManager from './ConfigManager';
+import ConnectionManager from './ConnectionManager';
+
+import FontCatalog from './FontCatalog';
+import FontFinder from './FontFinder';
+import FontInstaller from './FontInstaller';
+
+import { execute } from '../helpers/command';
+import { randNumber } from '../helpers/random';
+
+import { StorageType } from '../enums/StorageType';
+
+import * as path from 'path';
+
+const fetch = require('node-fetch');
+
+export default class FontManager {
+
+  systemManager: SystemManager;
+  configManager: ConfigManager;
+  connectionManager: ConnectionManager;
+
+  constructor(systemManager: SystemManager, configManager: ConfigManager, connectionManager: ConnectionManager) {
+    this.systemManager = systemManager;
+    this.configManager = configManager;
+    this.connectionManager = connectionManager;
+  }
+
+  async fetchLatestNews(args: any) {
+    const response = await fetch(args.endpoint);
+    return await response.json();
+  }
+
+  async systemAuthenticate(args: any) {
+    args.status = 'ok';
+    this.configManager.set(StorageType.User, args);
+    return this.configManager.get(StorageType.User);
+  }
+
+  async executeCommand(args: any) {
+    try {
+      return await execute(args.cmd, args.options);
+    } catch (err) {
+      return err;
+    }
+  }
+
+  scanFiles(files: string[], options: any) {
+    return new Promise((resolve, reject) => {
+      let finder = new FontFinder(this.connectionManager);
+      finder.scanFiles(files, options, (err: any) => {
+        if (err) { return reject(err); }
+        return resolve({});
+      });
+    });
+  }
+
+  scanFolders(dir: any, options: any) {
+    return new Promise((resolve, reject) => {
+      let finder = new FontFinder(this.connectionManager);
+      finder.scanFolders(dir, options, (err: any) => {
+        if (err) { return reject(err); }
+        return resolve({});
+      });
+    });
+  }
+
+  fontInstaller(options: any) {
+    let installer = new FontInstaller(this.systemManager, this.connectionManager);
+    return installer.activate(options);
+  }
+
+  /**
+   * @todo
+   */
+  folderInstaller(options: any) {
+    let installer = new FontInstaller(this.systemManager, this.connectionManager);
+    return installer.activate(options);
+  }
+
+  getMapFilePaths(files: string[], dest: string) {
+    return files.map((file: string) => dest + path.sep + path.basename(file));
+  }
+
+  getSourceFolder(sourceFolder: string) {
+    return path.normalize(sourceFolder);
+  }
+
+  getDestinationFolder() {
+    return path.normalize(this.systemManager.getCatalogPath() + path.sep + Date.now() + randNumber(7));
+  }
+
+  getSourceDestinationFolders(sourceFolder: string) {
+    const src = this.getSourceFolder(sourceFolder);
+    const dest = this.getDestinationFolder();
+    return { src, dest }
+  }
+
+  createCatalog(folder: string) {
+    const catalog = new FontCatalog(this.systemManager);
+    return catalog.createCatalog(folder);
+  }
+
+  async copyFiles(files: string[], dest: string) {
+    return new Promise((resolve, reject) => {
+      const catalog = new FontCatalog(this.systemManager);
+      catalog.copyFiles(files, dest, (err: any, stdout: any) => {
+        if (err) { return reject(err); }
+        return resolve({});
+      });
+    });
+  }
+
+  async copyFolders(src: string, dest: string) {
+    return new Promise((resolve, reject) => {
+      const catalog = new FontCatalog(this.systemManager);
+      catalog.copyFolders(src, dest, (err: any, stdout: any) => {
+        if (err) { return reject(err); }
+        return resolve({});
+      });
+    });
+  }
+
+  showMessageBox(options: any) {
+    return dialog.showMessageBox(null, options);
+  }
+
+  showOpenDialog(options: any) {
+    return dialog.showOpenDialog(options);
+  }
+
+  beep() {
+    return shell.beep()
+  }
+
+  openPath(path: string) {
+    shell.openPath(path)
+  }
+
+  openExternal(url: string) {
+    shell.openExternal(url)
+  }
+
+  showItemInFolder(fullPath: string) {
+    shell.showItemInFolder(fullPath);
+  }
+
+  reLaunch() {
+    app.relaunch();
+    app.quit();
+  }
+
+  exit() {
+    app.exit();
+  }
+
+  quit() {
+    app.quit();
+  }
+
+  reloadWindow() {
+    const windows = BrowserWindow.getAllWindows();
+    if (windows && windows.length) {
+      for (const win of windows) {
+        win.webContents.reloadIgnoringCache();
+      }
+    }
+  }
+}

package/app/core/FontObject.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const opentype = require("opentype.js");
+class FontObject {
+    constructor(fp) {
+        try {
+            this.setFont(opentype.loadSync(fp));
+        }
+        catch (err) {
+            this.setError(fp, err.message);
+        }
+    }
+    setFont(font) {
+        this.font = font;
+    }
+    getFont() {
+        return this.font;
+    }
+    setError(file, message) {
+        this.error = { file, message };
+    }
+    getError() {
+        return this.error;
+    }
+    hasError() {
+        return this.error ? true : false;
+    }
+    getNamesTable() {
+        const names = (this.font && this.font.names) ? this.font.names : false;
+        let item = {};
+        item.compatible_full_name = (names && names.compatibleFullName) ? names.compatibleFullName.en : "";
+        item.copyright = (names && names.copyright) ? names.copyright.en : "";
+        item.description = (names && names.description) ? names.description.en : "";
+        item.designer = (names && names.designer) ? names.designer.en : "";
+        item.designer_url = (names && names.designerURL) ? names.designerURL.en : "";
+        item.font_family = (names && names.fontFamily) ? names.fontFamily.en : "";
+        item.font_subfamily = (names && names.fontSubfamily) ? names.fontSubfamily.en : "";
+        item.full_name = (names && names.fullName) ? names.fullName.en : "";
+        item.license = (names && names.license) ? names.license.en : "";
+        item.license_url = (names && names.licenseURL) ? names.licenseURL.en : "";
+        item.manufacturer = (names && names.manufacturer) ? names.manufacturer.en : "";
+        item.manufacturer_url = (names && names.manufacturerURL) ? names.manufacturerURL.en : "";
+        item.post_script_name = (names && names.postScriptName) ? names.postScriptName.en : "";
+        item.preferred_family = (names && names.preferredFamily) ? names.preferredFamily.en : "";
+        item.preferred_sub_family = (names && names.preferredSubfamily) ? names.preferredSubfamily.en : "";
+        item.sample_text = (names && names.sampleText) ? names.sampleText.en : "";
+        item.trademark = (names && names.trademark) ? names.trademark.en : "";
+        item.unique_id = (names && names.uniqueID) ? names.uniqueID.en : "";
+        item.version = (names && names.version) ? names.version.en : "";
+        return item;
+    }
+}
+exports.default = FontObject;
+//# sourceMappingURL=FontObject.js.map

package/app/core/FontObject.ts

@@ -0,0 +1,62 @@
+const opentype = require("opentype.js");
+
+export default class FontObject {
+
+  font: any;
+  error: any;
+
+  constructor(fp: string) {
+    try {
+      this.setFont(opentype.loadSync(fp));
+    } catch (err) {
+      this.setError(fp, err.message);
+    }
+  }
+
+  setFont(font: any) {
+    this.font = font;
+  }
+
+  getFont() {
+    return this.font;
+  }
+
+  setError(file: string, message: string) {
+    this.error = { file, message };
+  }
+
+  getError() {
+    return this.error;
+  }
+
+  hasError() {
+    return this.error ? true : false;
+  }
+
+  getNamesTable() {
+    const names = (this.font && this.font.names) ? this.font.names : false;
+
+    let item: any = {};
+    item.compatible_full_name = (names && names.compatibleFullName) ? names.compatibleFullName.en : "";
+    item.copyright = (names && names.copyright) ? names.copyright.en : "";
+    item.description = (names && names.description) ? names.description.en : "";
+    item.designer = (names && names.designer) ? names.designer.en : "";
+    item.designer_url = (names && names.designerURL) ? names.designerURL.en : "";
+    item.font_family = (names && names.fontFamily) ? names.fontFamily.en : "";
+    item.font_subfamily = (names && names.fontSubfamily) ? names.fontSubfamily.en : "";
+    item.full_name = (names && names.fullName) ? names.fullName.en : "";
+    item.license = (names && names.license) ? names.license.en : "";
+    item.license_url = (names && names.licenseURL) ? names.licenseURL.en : "";
+    item.manufacturer = (names && names.manufacturer) ? names.manufacturer.en : "";
+    item.manufacturer_url = (names && names.manufacturerURL) ? names.manufacturerURL.en : "";
+    item.post_script_name = (names && names.postScriptName) ? names.postScriptName.en : "";
+    item.preferred_family = (names && names.preferredFamily) ? names.preferredFamily.en : "";
+    item.preferred_sub_family = (names && names.preferredSubfamily) ? names.preferredSubfamily.en : "";
+    item.sample_text = (names && names.sampleText) ? names.sampleText.en : "";
+    item.trademark = (names && names.trademark) ? names.trademark.en : "";
+    item.unique_id = (names && names.uniqueID) ? names.uniqueID.en : "";
+    item.version = (names && names.version) ? names.version.en : "";
+
+    return item;
+  }
+}