@nanawan/webfont 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  webfont: () => webfont
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/glyphsData.ts
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_metadata = __toESM(require("svgicons2svgfont/src/metadata.js"), 1);
+var import_xml2js = __toESM(require("xml2js"), 1);
+var getGlyphsData = (files, options) => {
+  const metadataProvider = options.metadataProvider || (0, import_metadata.default)({
+    prependUnicode: options.prependUnicode,
+    startUnicode: options.startUnicode
+  });
+  const xmlParser = new import_xml2js.default.Parser();
+  return Promise.all(
+    files.map(
+      (srcPath) => new Promise((resolve, reject) => {
+        const glyphContents = import_fs_extra.default.readFileSync(srcPath, "utf-8");
+        if (glyphContents.length === 0) {
+          reject(new Error(`Empty file ${srcPath}`));
+        }
+        xmlParser.parseString(glyphContents, (error) => {
+          if (error) {
+            reject(error);
+          }
+          const glyphData = {
+            contents: glyphContents,
+            srcPath
+          };
+          resolve(glyphData);
+        });
+      })
+    )
+  ).then((glyphsData) => {
+    const { ligatures } = options;
+    return Promise.all(
+      glyphsData.map(
+        (glyphData) => new Promise((resolve, reject) => {
+          metadataProvider(glyphData.srcPath, (error, metadata) => {
+            if (error) {
+              return reject(error);
+            }
+            if (ligatures) {
+              metadata.unicode.push(metadata.name.replace(/-/gu, "_"));
+            }
+            glyphData.metadata = metadata;
+            return resolve(glyphData);
+          });
+        })
+      )
+    );
+  });
+};
+
+// src/options.ts
+var getOptions = (initialOptions) => {
+  if (!initialOptions || !initialOptions.files) {
+    throw new Error("You must pass webfont a `files` glob");
+  }
+  return {
+    centerHorizontally: false,
+    descent: 0,
+    fixedWidth: false,
+    fontHeight: null,
+    fontId: null,
+    fontName: "webfont",
+    fontStyle: "",
+    fontWeight: "",
+    formats: ["svg", "ttf"],
+    formatsOptions: {
+      ttf: {
+        copyright: null,
+        ts: null,
+        version: null
+      }
+    },
+    glyphTransformFn: void 0,
+    ligatures: true,
+    maxConcurrency: 100,
+    metadata: null,
+    metadataProvider: null,
+    normalize: false,
+    prependUnicode: false,
+    round: 1e13,
+    startUnicode: 59905,
+    ...initialOptions
+  };
+};
+
+// src/index.ts
+var import_stream = require("stream");
+var import_shared = require("@nanawan/shared");
+var import_svgicons2svgfont = __toESM(require("svgicons2svgfont"), 1);
+var import_globby = __toESM(require("globby"), 1);
+var import_svg2ttf = __toESM(require("svg2ttf"), 1);
+var toSvg = (glyphsData, options) => {
+  let result = "";
+  return new Promise((resolve, reject) => {
+    const fontStream = new import_svgicons2svgfont.default({
+      ascent: options.ascent,
+      centerHorizontally: options.centerHorizontally,
+      descent: options.descent,
+      fixedWidth: options.fixedWidth,
+      fontHeight: options.fontHeight,
+      fontId: options.fontId,
+      fontName: options.fontName,
+      fontStyle: options.fontStyle,
+      fontWeight: options.fontWeight,
+      log: () => {
+      },
+      metadata: options.metadata,
+      normalize: options.normalize,
+      round: options.round
+    }).on("finish", () => resolve(result)).on("data", (data) => {
+      result += data;
+    }).on("error", (error) => reject(error));
+    glyphsData.forEach((glyphData) => {
+      const glyphStream = new import_stream.Readable();
+      glyphStream.push(glyphData.contents);
+      glyphStream.push(null);
+      glyphStream.metadata = glyphData.metadata;
+      fontStream.write(glyphStream);
+    });
+    fontStream.end();
+  });
+};
+var toTtf = (buffer, options) => Buffer.from((0, import_svg2ttf.default)(buffer, options).buffer);
+var webfont = async (initialOptions) => {
+  const options = getOptions(initialOptions);
+  const foundFiles = await (0, import_globby.default)((0, import_shared.normalizeToArray)(options.files));
+  if (foundFiles.length === 0) {
+    throw new Error("Files glob patterns specified did not match any files");
+  }
+  let glyphsData = await getGlyphsData(foundFiles, options);
+  if ((0, import_shared.isFunction)(options.glyphTransformFn)) {
+    const transformedGlyphs = glyphsData.map(async (glyphData) => {
+      const metadata = await options.glyphTransformFn(glyphData.metadata);
+      return {
+        ...glyphData,
+        metadata
+      };
+    });
+    glyphsData = await Promise.all(transformedGlyphs);
+  }
+  let ttfOptions = {};
+  if (options.formatsOptions && options.formatsOptions.ttf) {
+    ttfOptions = options.formatsOptions.ttf;
+  }
+  const svg = await toSvg(glyphsData, options);
+  const ttf = toTtf(svg, ttfOptions);
+  const result = {
+    glyphsData,
+    svg,
+    ttf
+  };
+  if (!options.formats.includes("svg")) {
+    delete result.svg;
+  }
+  if (!options.formats.includes("ttf")) {
+    delete result.ttf;
+  }
+  result.config = options;
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  webfont
+});

package/dist/index.js

@@ -0,0 +1,163 @@
+// src/glyphsData.ts
+import fse from "fs-extra";
+import getMetadataService from "svgicons2svgfont/src/metadata.js";
+import xml2js from "xml2js";
+var getGlyphsData = (files, options) => {
+  const metadataProvider = options.metadataProvider || getMetadataService({
+    prependUnicode: options.prependUnicode,
+    startUnicode: options.startUnicode
+  });
+  const xmlParser = new xml2js.Parser();
+  return Promise.all(
+    files.map(
+      (srcPath) => new Promise((resolve, reject) => {
+        const glyphContents = fse.readFileSync(srcPath, "utf-8");
+        if (glyphContents.length === 0) {
+          reject(new Error(`Empty file ${srcPath}`));
+        }
+        xmlParser.parseString(glyphContents, (error) => {
+          if (error) {
+            reject(error);
+          }
+          const glyphData = {
+            contents: glyphContents,
+            srcPath
+          };
+          resolve(glyphData);
+        });
+      })
+    )
+  ).then((glyphsData) => {
+    const { ligatures } = options;
+    return Promise.all(
+      glyphsData.map(
+        (glyphData) => new Promise((resolve, reject) => {
+          metadataProvider(glyphData.srcPath, (error, metadata) => {
+            if (error) {
+              return reject(error);
+            }
+            if (ligatures) {
+              metadata.unicode.push(metadata.name.replace(/-/gu, "_"));
+            }
+            glyphData.metadata = metadata;
+            return resolve(glyphData);
+          });
+        })
+      )
+    );
+  });
+};
+
+// src/options.ts
+var getOptions = (initialOptions) => {
+  if (!initialOptions || !initialOptions.files) {
+    throw new Error("You must pass webfont a `files` glob");
+  }
+  return {
+    centerHorizontally: false,
+    descent: 0,
+    fixedWidth: false,
+    fontHeight: null,
+    fontId: null,
+    fontName: "webfont",
+    fontStyle: "",
+    fontWeight: "",
+    formats: ["svg", "ttf"],
+    formatsOptions: {
+      ttf: {
+        copyright: null,
+        ts: null,
+        version: null
+      }
+    },
+    glyphTransformFn: void 0,
+    ligatures: true,
+    maxConcurrency: 100,
+    metadata: null,
+    metadataProvider: null,
+    normalize: false,
+    prependUnicode: false,
+    round: 1e13,
+    startUnicode: 59905,
+    ...initialOptions
+  };
+};
+
+// src/index.ts
+import { Readable } from "stream";
+import { isFunction, normalizeToArray } from "@nanawan/shared";
+import SVGIcons2SVGFontStream from "svgicons2svgfont";
+import globby from "globby";
+import svg2ttf from "svg2ttf";
+var toSvg = (glyphsData, options) => {
+  let result = "";
+  return new Promise((resolve, reject) => {
+    const fontStream = new SVGIcons2SVGFontStream({
+      ascent: options.ascent,
+      centerHorizontally: options.centerHorizontally,
+      descent: options.descent,
+      fixedWidth: options.fixedWidth,
+      fontHeight: options.fontHeight,
+      fontId: options.fontId,
+      fontName: options.fontName,
+      fontStyle: options.fontStyle,
+      fontWeight: options.fontWeight,
+      log: () => {
+      },
+      metadata: options.metadata,
+      normalize: options.normalize,
+      round: options.round
+    }).on("finish", () => resolve(result)).on("data", (data) => {
+      result += data;
+    }).on("error", (error) => reject(error));
+    glyphsData.forEach((glyphData) => {
+      const glyphStream = new Readable();
+      glyphStream.push(glyphData.contents);
+      glyphStream.push(null);
+      glyphStream.metadata = glyphData.metadata;
+      fontStream.write(glyphStream);
+    });
+    fontStream.end();
+  });
+};
+var toTtf = (buffer, options) => Buffer.from(svg2ttf(buffer, options).buffer);
+var webfont = async (initialOptions) => {
+  const options = getOptions(initialOptions);
+  const foundFiles = await globby(normalizeToArray(options.files));
+  if (foundFiles.length === 0) {
+    throw new Error("Files glob patterns specified did not match any files");
+  }
+  let glyphsData = await getGlyphsData(foundFiles, options);
+  if (isFunction(options.glyphTransformFn)) {
+    const transformedGlyphs = glyphsData.map(async (glyphData) => {
+      const metadata = await options.glyphTransformFn(glyphData.metadata);
+      return {
+        ...glyphData,
+        metadata
+      };
+    });
+    glyphsData = await Promise.all(transformedGlyphs);
+  }
+  let ttfOptions = {};
+  if (options.formatsOptions && options.formatsOptions.ttf) {
+    ttfOptions = options.formatsOptions.ttf;
+  }
+  const svg = await toSvg(glyphsData, options);
+  const ttf = toTtf(svg, ttfOptions);
+  const result = {
+    glyphsData,
+    svg,
+    ttf
+  };
+  if (!options.formats.includes("svg")) {
+    delete result.svg;
+  }
+  if (!options.formats.includes("ttf")) {
+    delete result.ttf;
+  }
+  result.config = options;
+  return result;
+};
+export {
+  webfont
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanawan/webfont",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Generator of fonts from svg icons, svg icons to svg font, svg font to ttf, ttf to eot, ttf to woff, ttf to woff2",
   "type": "module",
   "files": [
@@ -23,7 +23,7 @@
     }
   },
   "dependencies": {
-    "@nanawan/shared": "^3.18.4",
+    "@nanawan/shared": "^3.18.10",
     "fs-extra": "^11.2.0",
     "globby": "^11.0.0",
     "p-limit": "^3.1.0",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@types/fs-extra": "11.0.4",
     "@types/node": "15.14.9",
-    "@nanawan/release": "^2.2.4",
+    "@nanawan/release": "^2.2.8",
     "rimraf": "5.0.7",
     "tsup": "^8.0.1",
     "typescript": "^5.2.2"