font-range 0.2.1 → 1.0.0

package/build/main.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontPipe = exports.fontSubset = exports.fontRange = exports.defaultArgs = exports.parseCSS = exports.targets = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const piscina_1 = tslib_1.__importDefault(require("piscina"));
+const node_fetch_1 = tslib_1.__importStar(require("@esm2cjs/node-fetch"));
+const css_tree_1 = require("css-tree");
+class Worker {
+    constructor() { }
+    static getInstance() {
+        if (!Worker.instance) {
+            Worker.instance = new piscina_1.default({
+                filename: (0, path_1.join)(__dirname, "../", "build", "worker.js")
+            });
+        }
+        return Worker.instance;
+    }
+}
+exports.targets = {
+    weston: "https://fonts.googleapis.com/css2?family=Noto+Sans&display=swap",
+    korean: "https://fonts.googleapis.com/css2?family=Noto+Sans+KR&display=swap",
+    japanese: "https://fonts.googleapis.com/css2?family=Noto+Sans+JP&display=swap",
+    chinese: "https://fonts.googleapis.com/css2?family=Noto+Sans+SC&display=swap",
+    chinese_traditional: "https://fonts.googleapis.com/css2?family=Noto+Sans+TC&display=swap",
+};
+function getFontName(url) {
+    const encodedURL = decodeURI(url);
+    const urlObj = new URL(encodedURL);
+    const urlParams = urlObj.searchParams;
+    const fontName = urlParams.get("family");
+    return fontName;
+}
+function validURL(str) {
+    const pattern = new RegExp("^(https?:\\/\\/)?" +
+        "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" +
+        "((\\d{1,3}\\.){3}\\d{1,3}))" +
+        "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" +
+        "(\\?[;&a-z\\d%_.~+=-]*)?" +
+        "(\\#[-a-z\\d_]*)?$", "i");
+    return !!pattern.test(str);
+}
+function getCSSPath(dirPath, url) {
+    if (validURL(url)) {
+        const fontName = getFontName(url);
+        const cssPath = (0, path_1.join)(dirPath, fontName + ".css");
+        return cssPath;
+    }
+    if (!(0, fs_1.existsSync)(url)) {
+        throw new Error("Not vaild URL or PATH: " + url);
+    }
+    return url;
+}
+function saveCSS(path, url) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const version = "109.0";
+        const headers = new node_fetch_1.Headers({
+            "Accept": "text/html,application/xhtml+xml,application/xml;",
+            "User-Agent": `Mozilla/5.0 (Windows NT 10.0; rv:${version}) Gecko/20100101 Firefox/${version}`
+        });
+        const res = yield (0, node_fetch_1.default)(url, {
+            method: "GET",
+            headers: headers
+        });
+        if (res.status !== 200) {
+            throw new Error("Not vaild URL: " + url);
+        }
+        return new Promise((resolve, reject) => {
+            const fileStream = (0, fs_1.createWriteStream)(path);
+            res.body.pipe(fileStream);
+            res.body.on("error", (err) => {
+                console.log("File write Error.");
+                reject(err);
+            });
+            res.body.on("close", () => {
+                fileStream.close();
+            });
+            fileStream.on("close", () => {
+                resolve();
+            });
+        });
+    });
+}
+function readCSS(path) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const readData = [];
+            (0, fs_1.createReadStream)(path)
+                .on("data", (data) => {
+                readData.push(data);
+            })
+                .on("end", () => {
+                const css = readData.join("");
+                resolve(css);
+            })
+                .on("error", reject);
+        });
+    });
+}
+const parseOptions = {
+    parseAtrulePrelude: false,
+    parseRulePrelude: false,
+    parseValue: false
+};
+function loadAST(dirPath, url = exports.targets.korean, parseOption = parseOptions) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const cssPath = getCSSPath(dirPath, url);
+        if (!(0, fs_1.existsSync)(dirPath)) {
+            yield (0, promises_1.mkdir)(dirPath);
+        }
+        if (!(0, fs_1.existsSync)(cssPath)) {
+            yield saveCSS(cssPath, url);
+        }
+        const css = yield readCSS(cssPath);
+        return (0, css_tree_1.parse)(css, parseOption);
+    });
+}
+function setBlock(block, elem, property) {
+    if (elem.property === property) {
+        if (elem.value.type === "Raw") {
+            block[property] = elem.value.value;
+        }
+    }
+}
+function parseCSS(dirPath = "src", url = exports.targets.korean) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const ast = yield loadAST(dirPath, url);
+        const parsed = [];
+        (0, css_tree_1.walk)(ast, { visit: "Atrule", enter(node) {
+                if (node.name === "font-face") {
+                    const block = {
+                        src: "",
+                        unicodes: ""
+                    };
+                    (0, css_tree_1.walk)(node, { visit: "Declaration", enter(elem) {
+                            setBlock(block, elem, "src");
+                            setBlock(block, elem, "unicode-range");
+                        } });
+                    if (block.src !== "" || block.unicodes !== "") {
+                        parsed.push(block);
+                    }
+                }
+            } });
+        return parsed;
+    });
+}
+exports.parseCSS = parseCSS;
+exports.defaultArgs = [
+    "--layout-features=*",
+    "--glyph-names",
+    "--symbol-cmap",
+    "--legacy-cmap",
+    "--notdef-glyph",
+    "--notdef-outline",
+    "--recommended-glyphs",
+    "--name-legacy",
+    "--drop-tables=",
+    "--name-IDs=*",
+    "--name-languages=*"
+];
+function getDefaultOptions() {
+    return {
+        format: "woff2",
+        nameFormat: "{NAME}_{INDEX}{EXT}",
+        logFormat: "Convert {ORIGIN} -> {OUTPUT}",
+        defaultArgs: exports.defaultArgs,
+        etcArgs: []
+    };
+}
+function getFormat(format) {
+    switch (format) {
+        case "otf": return "otf";
+        case "ttf": return "ttf";
+        case "woff2": return "woff2";
+        case "woff": return "woff";
+        case "woff-zopfli": return "woff";
+    }
+}
+function formatOption(format) {
+    const formatName = getFormat(format);
+    if (format === "otf" || format === "ttf")
+        return [""];
+    return [
+        "--flavor=" + formatName,
+        (format === "woff-zopfli") ? "--with-zopfli" : ""
+    ];
+}
+function fileNameInit(nameFormat, fontName, fontExt) {
+    return nameFormat
+        .replace("{NAME}", fontName)
+        .replace("{EXT}", fontExt);
+}
+function getFileName(initName, index) {
+    return initName
+        .replace("{INDEX}", (typeof index === "number")
+        ? index.toString()
+        : (typeof index === "string")
+            ? index
+            : "");
+}
+function getConsoleLog(logFormat, origin, output) {
+    return logFormat
+        .replace("{ORIGIN}", origin)
+        .replace("{OUTPUT}", output);
+}
+function getOptionInfos(fontPath = "", fontOption, indexIndicate = "") {
+    const options = Object.assign({ fromCSS: "default" }, getDefaultOptions(), typeof (fontOption) === "string"
+        ? { saveDir: fontOption }
+        : fontOption);
+    const format = options.format;
+    const pathInfo = (0, path_1.parse)(fontPath);
+    const fontDir = pathInfo.dir;
+    const fontBase = pathInfo.base;
+    const fontName = pathInfo.name;
+    const fontExt = "." + getFormat(format);
+    const dirPath = Object.prototype.hasOwnProperty.call(options, "saveDir") ? options["saveDir"] : fontDir;
+    const nameFormat = options.nameFormat;
+    const logFormat = options.logFormat;
+    const initName = fileNameInit(nameFormat, fontName, fontExt);
+    const output = getFileName(initName, indexIndicate);
+    const logMsg = getConsoleLog(logFormat, fontBase, output);
+    const convertOption = formatOption(format);
+    const defaultOption = options.defaultArgs;
+    const etcOption = options.etcArgs;
+    const baseOption = [
+        ...convertOption,
+        ...defaultOption,
+        ...etcOption
+    ].filter(option => option !== "");
+    const worker = Worker.getInstance();
+    return {
+        dirPath,
+        initName,
+        logMsg,
+        baseOption,
+        worker,
+        fromCSS: options.fromCSS
+    };
+}
+function getSrcInfo(src) {
+    const first = src.split(",").find((str) => {
+        return str.indexOf("url(") === 0;
+    });
+    if (typeof first === "undefined")
+        return {
+            base: "",
+            index: 0
+        };
+    const reStr = "url\\(";
+    const reMdl = "(.+?)";
+    const reEnd = "\\)";
+    const quote = "(\\\\?['\"])?";
+    const regex = new RegExp(reStr + quote + reMdl + quote + reEnd);
+    const urlContent = first.match(regex)[2];
+    const parsedURL = (0, path_1.parse)(urlContent);
+    return {
+        base: parsedURL.base,
+        index: parseInt(parsedURL.name.split(".").pop())
+    };
+}
+function getSaveOption(dirPath, initName, index) {
+    const fileName = getFileName(initName, index);
+    return ("--output-file=" + (0, path_1.join)(dirPath, fileName));
+}
+function getSubsetOption(fontSubsetOption) {
+    if (typeof fontSubsetOption !== "undefined" &&
+        typeof fontSubsetOption !== "string") {
+        if ("textFile" in fontSubsetOption) {
+            return ("--text-file=" + fontSubsetOption.textFile);
+        }
+        if ("text" in fontSubsetOption) {
+            return ("--text=" + fontSubsetOption.text);
+        }
+    }
+    return "--glyphs=*";
+}
+function fontRange(fontPath = "", url = exports.targets.korean, fontRangeOption) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { dirPath, initName, logMsg, baseOption, worker, fromCSS } = getOptionInfos(fontPath, fontRangeOption, "n");
+        const ranges = yield parseCSS(dirPath, url);
+        const result = ranges.map(({ src, unicodes }, i) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const srcInfo = getSrcInfo(src);
+            const saveOption = getSaveOption(dirPath, (fromCSS === "srcName" && srcInfo.base !== "")
+                ? srcInfo.base
+                : initName, (fromCSS === "srcIndex" && srcInfo.base !== "")
+                ? srcInfo.index
+                : i);
+            const unicodeRanges = unicodes.split(", ").join(",");
+            const unicodeOption = "--unicodes=" + unicodeRanges;
+            const options = [fontPath, saveOption, unicodeOption, ...baseOption];
+            const logInfo = (i === 0) ? logMsg : "";
+            const result = yield worker.run({ options, log: logInfo });
+            return result;
+        }));
+        return yield Promise.all(result);
+    });
+}
+exports.fontRange = fontRange;
+function fontSubset(fontPath = "", fontSubsetOption) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { dirPath, initName, logMsg, baseOption, worker } = getOptionInfos(fontPath, fontSubsetOption);
+        if (!(0, fs_1.existsSync)(dirPath))
+            yield (0, promises_1.mkdir)(dirPath);
+        const subsetOption = getSubsetOption(fontSubsetOption);
+        const saveOption = getSaveOption(dirPath, initName);
+        const options = [fontPath, saveOption, subsetOption, ...baseOption];
+        const result = yield worker.run({ options, log: logMsg });
+        return result;
+    });
+}
+exports.fontSubset = fontSubset;
+function fontPipeExec(subsetTarget) {
+    const { fontPath, option } = subsetTarget;
+    return ((typeof option !== "undefined") &&
+        (typeof option.cssFile !== "undefined"))
+        ? fontRange(fontPath, option.cssFile, option)
+        : fontSubset(fontPath, option);
+}
+function shardNum(shardStr, content) {
+    const num = Math.abs(parseInt(shardStr, 10));
+    if (isNaN(num) || num <= 0) {
+        throw new Error("<" + content + "> must be a positive number");
+    }
+    return num;
+}
+function getShardInfo(shardEnv) {
+    const [indexStr, totalStr] = shardEnv.split("/");
+    const index = shardNum(indexStr, "index");
+    const total = shardNum(totalStr, "total");
+    if (index > total) {
+        throw new Error("<index> must be less then <total>");
+    }
+    return [index, total];
+}
+function fontPipe(subsetList, shard) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const shardEnv = (typeof shard === "object" && typeof shard.shard === "string")
+            ? shard.shard
+            : (typeof shard === "object" || typeof shard === "undefined")
+                ? process.env.SHARD || "1/1"
+                : shard;
+        const shardFormat = (typeof shard === "object" && typeof shard.shardFormat === "string")
+            ? shard.shardFormat
+            : "== {START}/{END} ==========";
+        const [index, total] = getShardInfo(shardEnv);
+        const shardSize = Math.ceil(subsetList.length / total);
+        const shardStart = shardSize * (index - 1);
+        const shardEnd = shardSize * index;
+        if (shardEnv !== "1/1") {
+            const shardMsg = shardFormat
+                .replace("{START}", index.toString())
+                .replace("{END}", total.toString());
+            console.log(shardMsg);
+        }
+        const result = subsetList
+            .slice(shardStart, shardEnd)
+            .map(fontPipeExec);
+        return yield Promise.all(result);
+    });
+}
+exports.fontPipe = fontPipe;

package/build/worker.d.ts

@@ -0,0 +1,5 @@
+export interface SubsetI {
+    options: string[];
+    log?: string;
+}
+export default function subset({ options, log }: SubsetI): import("@esm2cjs/execa").ExecaSyncReturnValue<string>;

package/build/worker.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const execa_1 = require("@esm2cjs/execa");
+function subset({ options, log = "" }) {
+    if (log !== "") {
+        console.log(log);
+    }
+    return (0, execa_1.execaSync)("pyftsubset", options);
+}
+exports.default = subset;

package/jest.config.js

@@ -1,7 +1,7 @@
 /** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
 module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
+  preset: "ts-jest",
+  testEnvironment: "node",
   transform: {
     "^.+\\.tsx?$": "ts-jest"
   },
@@ -13,10 +13,10 @@ module.exports = {
     "json",
     "node",
   ],
-  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(ts|js)x?$',
+  testRegex: "/__tests__/.*\.(test|spec)\.(ts|js)x?$",
   coverageDirectory: 'coverage',
   collectCoverageFrom: [
-    'src/**/*.{ts,tsx,js,jsx}',
-    '!src/**/*.d.ts',
+    "src/**/*.{ts,tsx,js,jsx}",
+    "!src/**/*.d.ts"
   ],
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "font-range",
   "description": " Font subset with google font's ML result.",
-  "version": "0.2.1",
+  "version": "1.0.0",
   "author": "black7375 <alstjr7375@daum.net>",
   "license": "MIT",
   "keywords": [
@@ -24,26 +24,27 @@
   },
   "homepage": "https://github.com/black7375/font-range#readme",
   "engines": {
-    "node": ">= 12.13"
+    "node": ">= 16.16"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.0",
-    "@types/node": "^16.10.9",
-    "@typescript-eslint/eslint-plugin": "^5.10.1",
-    "@typescript-eslint/parser": "^5.10.1",
+    "@types/command-exists": "^1.2.0",
+    "@types/jest": "^29.2.5",
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.48.0",
+    "@typescript-eslint/parser": "^5.48.0",
     "command-exists": "^1.2.9",
-    "eslint": "~8.7.0",
-    "eslint-config-prettier": "~8.3.0",
-    "eslint-plugin-jest": "^26.0.0",
-    "jest": "^27.4.7",
-    "prettier": "^2.5.1",
-    "rimraf": "~3.0.2",
-    "ts-jest": "^27.1.3",
-    "tsutils": "~3.21.0",
-    "typescript": "^4.4.5"
+    "eslint": "^8.31.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-jest": "^27.2.1",
+    "jest": "^29.3.1",
+    "prettier": "^2.8.1",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.0.3",
+    "tsutils": "^3.21.0",
+    "typescript": "^4.9.4"
   },
-  "main": "build/src/main.js",
-  "typings": "build/src/main.d.ts",
+  "main": "build/main.js",
+  "typings": "build/main.d.ts",
   "scripts": {
     "clean": "rimraf coverage build tmp",
     "build": "tsc -p tsconfig.release.json",
@@ -53,14 +54,16 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@types/css-tree": "^1.0.7",
-    "@types/node-fetch": "^2.5.12",
-    "css-tree": "^2.0.4",
-    "node-fetch": "^2.6.7",
-    "tslib": "^2.3.1"
+    "@esm2cjs/execa": "^6.1.1-cjs.1",
+    "@esm2cjs/node-fetch": "^3.2.10",
+    "@types/css-tree": "^2.0.1",
+    "css-tree": "^2.3.1",
+    "piscina": "^3.2.0",
+    "tslib": "^2.4.1"
   },
   "volta": {
-    "node": "16.10.0",
-    "npm": "8.3.2"
-  }
-}
+    "node": "16.16.0",
+    "npm": "9.2.0"
+  },
+  "packageManager": "yarn@3.3.1"
+}

package/requirements.txt

@@ -2,9 +2,9 @@
 # https://pypi.org/project/pip-outdated/
 
 appdirs~=1.4.4
-six~=1.10
+six~=1.16.0
 fs<3,>=2.2.0
-pytz~=2021.1
-fonttools~=4.29.0
+pytz~=2022.7
+fonttools~=4.38.0
 Brotli~=1.0.9
-zopfli~=0.1.8
+zopfli~=0.2.2