fodec 1.0.1 → 1.0.3

package/bin/fodec.js

@@ -2,14 +2,4 @@
 
 const {app} = require("../lib/cli/index.js");
 
-app.run(process.argv).then((res) => {
-    if(!res) {
-        return;
-    }
-
-    process.stdout.write(res);
-    process.stdout.write("\n");
-}).catch((err) => {
-    process.stderr.write(err.message);
-    process.stdout.write("\n");
-});
+app.run();

package/lib/Fodec.d.ts

@@ -1,8 +1,7 @@
 export declare class Fodec {
-    protected key: string;
+    protected readonly key: string;
     constructor(key: string);
     transformText(str: string): string;
     transformJson(data: any): Promise<any>;
-    transformFont(fontPath: string): Promise<string | ArrayBuffer | undefined>;
-    transformFontV1(fontPath: string): Promise<string | ArrayBuffer | undefined>;
+    transformFont(fontPath: string): Promise<import("fonteditor-core").FontEditor.FontOutput | null>;
 }

package/lib/Fodec.js

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fodec = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
-const fonteditor_core_1 = require("fonteditor-core");
+const encodeFont_1 = require("./utils/encodeFont");
 class Fodec {
     constructor(key) {
         this.key = key;
@@ -17,59 +26,15 @@ class Fodec {
             return index !== -1 ? this.key.charAt(index + 1 + (this.key.length - 1) / 2) : char;
         }).join("");
     }
-    async transformJson(data) {
-        return data;
-    }
-    async transformFont(fontPath) {
-        return this.transformFontV1(fontPath);
-    }
-    async transformFontV1(fontPath) {
-        const ext = path_1.default.extname(fontPath).slice(1);
-        if (ext !== "ttf") {
-            return;
-        }
-        const font = fonteditor_core_1.Font.create(await fs_1.promises.readFile(fontPath), {
-            type: ext
+    transformJson(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return data;
         });
-        const { glyf: list, } = font.get();
-        const glyphs = [];
-        for (let i = 0; i < list.length; i++) {
-            const glyph = list[i];
-            const char = glyph.unicode
-                ? String.fromCharCode(glyph.unicode[0])
-                : null;
-            if (!char) {
-                glyphs.push(glyph);
-                continue;
-            }
-            if (this.key.indexOf(char) === -1) {
-                glyphs.push(glyph);
-                continue;
-            }
-            const index = this.key.indexOf(char);
-            const transformUnicode = this.key.charCodeAt((this.key.length - 1) / 2 + 1 + index);
-            const rand = list.find((item) => {
-                if (!item.unicode) {
-                    return;
-                }
-                return item.unicode[0] === transformUnicode;
-            });
-            if (!rand) {
-                glyphs.push(glyph);
-                continue;
-            }
-            glyphs.push({
-                ...glyph,
-                name: rand.name,
-                unicode: rand.unicode
-            });
-        }
-        font.set({
-            ...font.get(),
-            glyf: glyphs
-        });
-        return font.write({
-            type: ext
+    }
+    transformFont(fontPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield fs_1.promises.readFile(fontPath), ext = path_1.default.extname(fontPath).slice(1);
+            return (0, encodeFont_1.encodeFont)(this.key, file, ext);
         });
     }
 }

package/lib/cli/App.d.ts

@@ -8,5 +8,5 @@ export declare class App {
     init(): Promise<void>;
     generate(): Promise<void>;
     build(): Promise<void>;
-    run(): Promise<string | void>;
+    run(): Promise<void>;
 }

package/lib/cli/App.js

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -14,6 +23,9 @@ class App {
     constructor() {
         this.cli = new cli_1.Cli();
         this.cli.command("completion")
+            .help({
+            disabled: true
+        })
             .action(() => {
             return this.cli.completionScript();
         });
@@ -27,90 +39,112 @@ class App {
         this.cli.command("build")
             .action(() => this.build());
     }
-    async getConfig() {
-        const configPath = "fodec.json";
-        if (!(0, fs_1.existsSync)(configPath)) {
-            throw new Error("Config not found");
-        }
-        const res = await fs_1.promises.readFile(configPath);
-        return JSON.parse(res.toString());
-    }
-    async getKey() {
-        const res = await fs_1.promises.readFile("fodec.key");
-        return res.toString();
+    getConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configPath = "fodec.json";
+            if (!(0, fs_1.existsSync)(configPath)) {
+                throw new Error("Config not found");
+            }
+            const res = yield fs_1.promises.readFile(configPath);
+            return JSON.parse(res.toString());
+        });
     }
-    async init() {
-        const configPath = "./fodec-2.json";
-        if ((0, fs_1.existsSync)(configPath)) {
-            throw new Error("Config already exists");
-        }
-        let config = {};
-        config.basePath = await (0, utils_1.promptText)({
-            required: true,
-            type: "string",
-            message: "Base Path:",
-            default: "src"
+    getKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield fs_1.promises.readFile("fodec.key");
+            return res.toString();
         });
-        config.output = {
-            path: await (0, utils_1.promptText)({
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configPath = "./fodec-2.json";
+            if ((0, fs_1.existsSync)(configPath)) {
+                throw new Error("Config already exists");
+            }
+            let config = {};
+            config.basePath = yield (0, utils_1.promptText)({
                 required: true,
                 type: "string",
-                message: "Output path:",
-                default: "build"
-            })
-        };
-        config.alphabets = await (0, utils_1.promptSelect)({
-            multiple: true,
-            options: [
-                "cyrillic",
-                "latin"
-            ]
+                message: "Base Path:",
+                default: "src"
+            });
+            config.output = {
+                path: yield (0, utils_1.promptText)({
+                    required: true,
+                    type: "string",
+                    message: "Output path:",
+                    default: "build"
+                })
+            };
+            config.alphabets = (yield (0, utils_1.promptSelect)({
+                multiple: true,
+                options: [
+                    "cyrillic",
+                    "latin"
+                ]
+            }));
+            config.resources = [];
+            yield fs_1.promises.writeFile(configPath, JSON.stringify(config, null, 4));
         });
-        config.resources = [];
-        await fs_1.promises.writeFile(configPath, JSON.stringify(config, null, 4));
     }
-    async generate() {
-        const { alphabets } = await this.getConfig();
-        const key = (0, generateKey_1.generateKey)({
-            alphabets
+    generate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { alphabets } = yield this.getConfig();
+            const key = (0, generateKey_1.generateKey)({
+                alphabets
+            });
+            console.log(key);
+            yield fs_1.promises.writeFile("fodec.key", key);
         });
-        console.log(key);
-        await fs_1.promises.writeFile("fodec.key", key);
     }
-    async build() {
-        const key = await this.getKey();
-        const { basePath = "./", output: { path: outPath = "./build" } = {}, fonts, resources } = await this.getConfig();
-        const fodec = new Fodec_1.Fodec(key);
-        for (const resource of resources) {
-            let res;
-            if (resource.type === "font") {
-                const transformedFont = await fodec.transformFont(path_1.default.join(basePath, resource.path));
-                if (!transformedFont || transformedFont instanceof ArrayBuffer) {
-                    continue;
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.getKey();
+            const { basePath = "./", output: { path: outPath = "./build" } = {}, fonts, resources } = yield this.getConfig();
+            const fodec = new Fodec_1.Fodec(key);
+            for (const resource of resources) {
+                let res;
+                if (resource.type === "font") {
+                    const transformedFont = yield fodec.transformFont(path_1.default.join(basePath, resource.path));
+                    if (!transformedFont || transformedFont instanceof ArrayBuffer) {
+                        continue;
+                    }
+                    res = transformedFont;
+                }
+                else if (resource.type === "json") {
+                    const json = yield fs_1.promises.readFile(path_1.default.join(basePath, resource.path));
+                    const data = JSON.parse(json.toString());
+                    res = JSON.stringify(data, (key, value) => {
+                        if (typeof value === "string") {
+                            return fodec.transformText(value);
+                        }
+                        return value;
+                    }, 4);
+                }
+                if (res) {
+                    const outFullPath = path_1.default.join(outPath, path_1.default.dirname(resource.output || resource.path));
+                    (0, fs_1.mkdirSync)(outFullPath, {
+                        recursive: true
+                    });
+                    yield fs_1.promises.writeFile(path_1.default.join(outPath, resource.output || resource.path), res);
                 }
-                res = transformedFont;
             }
-            else if (resource.type === "json") {
-                const json = await fs_1.promises.readFile(path_1.default.join(basePath, resource.path));
-                const data = JSON.parse(json.toString());
-                res = JSON.stringify(data, (key, value) => {
-                    if (typeof value === "string") {
-                        return fodec.transformText(value);
-                    }
-                    return value;
-                }, 4);
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.cli.run(process.argv);
+                if (res) {
+                    process.stdout.write(res);
+                    process.stdout.write("\n");
+                }
             }
-            if (res) {
-                const outFullPath = path_1.default.join(outPath, path_1.default.dirname(resource.output || resource.path));
-                (0, fs_1.mkdirSync)(outFullPath, {
-                    recursive: true
-                });
-                await fs_1.promises.writeFile(path_1.default.join(outPath, resource.output || resource.path), res);
+            catch (err) {
+                process.stderr.write(err.message);
+                process.stdout.write("\n");
             }
-        }
-    }
-    async run() {
-        return this.cli.run(process.argv);
+        });
     }
 }
 exports.App = App;

package/lib/utils/encodeFont.d.ts

@@ -0,0 +1 @@
+export declare const encodeFont: (key: string, file: string | Buffer, ext: string) => import("fonteditor-core").FontEditor.FontOutput | null;

package/lib/utils/encodeFont.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeFont = void 0;
+const fonteditor_core_1 = require("fonteditor-core");
+const encodeFont = (key, file, ext) => {
+    if (ext !== "ttf") {
+        return null;
+    }
+    if (typeof file === "string") {
+        file = Buffer.from(file);
+    }
+    const font = fonteditor_core_1.Font.create(file, {
+        type: ext
+    });
+    const { glyf: list } = font.get();
+    const glyphs = [];
+    for (let i = 0; i < list.length; i++) {
+        const glyph = list[i];
+        const char = glyph.unicode
+            ? String.fromCharCode(glyph.unicode[0])
+            : null;
+        if (!char) {
+            glyphs.push(glyph);
+            continue;
+        }
+        if (key.indexOf(char) === -1) {
+            glyphs.push(glyph);
+            continue;
+        }
+        const index = key.indexOf(char);
+        const transformUnicode = key.charCodeAt((key.length - 1) / 2 + 1 + index);
+        const rand = list.find((item) => {
+            if (!item.unicode) {
+                return;
+            }
+            return item.unicode[0] === transformUnicode;
+        });
+        if (!rand) {
+            glyphs.push(glyph);
+            continue;
+        }
+        glyphs.push(Object.assign(Object.assign({}, glyph), { name: rand.name, unicode: rand.unicode }));
+    }
+    font.set(Object.assign(Object.assign({}, font.get()), { glyf: glyphs }));
+    return font.write({
+        type: ext
+    });
+};
+exports.encodeFont = encodeFont;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fodec",
-    "version": "1.0.1",
+    "version": "1.0.3",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Font encoder",
     "license": "MIT",
@@ -13,9 +13,9 @@
         "fodec": "./bin/fodec.js"
     },
     "scripts": {
-        "prepare": "npm run build",
-        "build": "tsc --build",
-        "watch": "tsc --watch",
+        "prepublishOnly": "npm run build",
+        "build": "tsc --project tsconfig.build.json",
+        "watch": "tsc -w --project tsconfig.build.json",
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "homepage": "https://kearisp.github.io/fodec",
@@ -27,14 +27,12 @@
         "url": "https://github.com/kearisp/fodec/issues"
     },
     "dependencies": {
-        "@kearisp/cli": "^2.0.0",
+        "@kearisp/cli": "^2.0.4",
         "@wocker/utils": "^1.0.2",
-        "fonteditor-core": "^2.3.2",
-        "fs": "^0.0.1-security",
-        "path": "^0.12.7"
+        "fonteditor-core": "^2.3.2"
     },
     "devDependencies": {
-        "@types/node": "^20.11.5",
+        "@types/node": "^22.10.2",
         "typescript": "^5.3.3"
     }
 }