@webstudio-is/fonts 0.1.0 → 0.2.0

package/lib/cjs/constants.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FONT_MIME_TYPES = exports.FONT_FORMATS = exports.DEFAULT_FONT_FALLBACK = exports.SYSTEM_FONTS = void 0;
+exports.SYSTEM_FONTS = new Map([
+    ["Arial", ["sans-serif"]],
+    ["Times New Roman", ["sans"]],
+    ["Courier New", ["monospace"]],
+    ["system-ui", []],
+]);
+exports.DEFAULT_FONT_FALLBACK = "sans-serif";
+exports.FONT_FORMATS = new Map([
+    ["woff", "woff"],
+    ["woff2", "woff2"],
+    ["ttf", "truetype"],
+    ["otf", "opentype"],
+]);
+exports.FONT_MIME_TYPES = Array.from(exports.FONT_FORMATS.keys())
+    .map((format) => `.${format}`)
+    .join(", ");

package/lib/cjs/constants.d.ts

@@ -0,0 +1,6 @@
+import type { FontFormat } from "./types";
+export declare const SYSTEM_FONTS: Map<string, string[]>;
+export declare const DEFAULT_FONT_FALLBACK = "sans-serif";
+export declare const FONT_FORMATS: Map<FontFormat, string>;
+export declare const FONT_MIME_TYPES: string;
+//# sourceMappingURL=constants.d.ts.map

package/lib/cjs/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,eAAO,MAAM,YAAY,uBAKvB,CAAC;AAEH,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAElD,eAAO,MAAM,YAAY,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAK/C,CAAC;AAEH,eAAO,MAAM,eAAe,QAEf,CAAC"}

package/lib/cjs/font-data.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFontData = exports.normalizeFamily = exports.parseSubfamily = exports.styles = void 0;
+const fontkit_1 = require("fontkit");
+const font_weights_1 = require("./font-weights");
+exports.styles = ["normal", "italic", "oblique"];
+const parseSubfamily = (subfamily) => {
+    const subfamilyLow = subfamily.toLowerCase();
+    let style = "normal";
+    for (const possibleStyle of exports.styles) {
+        if (subfamilyLow.includes(possibleStyle)) {
+            style = possibleStyle;
+            break;
+        }
+    }
+    let weight = "400";
+    for (weight in font_weights_1.fontWeights) {
+        const { name } = font_weights_1.fontWeights[weight];
+        const { alt } = font_weights_1.fontWeights[weight];
+        if (subfamilyLow.includes(name) || subfamilyLow.includes(alt)) {
+            break;
+        }
+    }
+    return { style, weight: Number(weight) };
+};
+exports.parseSubfamily = parseSubfamily;
+const splitAndTrim = (string) => string
+    .split(" ")
+    .map((part) => part.trim())
+    .filter(Boolean);
+// Family name can contain additional information like "Roboto Black" or "Roboto Bold", though we need pure family name "Roboto", because the rest is already encoded in weight and style.
+// We need a name we can reference in CSS font-family property, while CSS matches it with the right font-face considering the weight and style.
+const normalizeFamily = (family, subfamily) => {
+    const familyParts = splitAndTrim(family);
+    const subfamilyParts = splitAndTrim(subfamily.toLowerCase());
+    const familyPartsNormalized = familyParts.filter((familyPart) => subfamilyParts.includes(familyPart.toLowerCase()) === false);
+    return familyPartsNormalized.join(" ");
+};
+exports.normalizeFamily = normalizeFamily;
+const getFontData = (data) => {
+    const font = (0, fontkit_1.create)(data);
+    const format = font.type.toLowerCase();
+    const originalFamily = font.getName("fontFamily");
+    const subfamily = font.getName("preferredSubfamily") ?? font.getName("fontSubfamily");
+    const parsedSubfamily = (0, exports.parseSubfamily)(subfamily);
+    const family = (0, exports.normalizeFamily)(originalFamily, subfamily);
+    return {
+        format,
+        family,
+        ...parsedSubfamily,
+    };
+};
+exports.getFontData = getFontData;

package/lib/cjs/font-data.d.ts

@@ -0,0 +1,23 @@
+import type { FontFormat } from "./types";
+declare module "fontkit" {
+    interface Font {
+        type: string;
+        getName: (name: string) => string;
+    }
+}
+export declare const styles: readonly ["normal", "italic", "oblique"];
+declare type Style = typeof styles[number];
+export declare const parseSubfamily: (subfamily: string) => {
+    style: "normal" | "italic" | "oblique";
+    weight: number;
+};
+export declare const normalizeFamily: (family: string, subfamily: string) => string;
+declare type FontData = {
+    format: FontFormat;
+    family: string;
+    style: Style;
+    weight: number;
+};
+export declare const getFontData: (data: Uint8Array) => FontData;
+export {};
+//# sourceMappingURL=font-data.d.ts.map

package/lib/cjs/font-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-data.d.ts","sourceRoot":"","sources":["../../src/font-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAK1C,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAiB,IAAI;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;KACnC;CACF;AAED,eAAO,MAAM,MAAM,0CAA2C,CAAC;AAC/D,aAAK,KAAK,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;AAEnC,eAAO,MAAM,cAAc,cAAe,MAAM;;;CAmB/C,CAAC;AAUF,eAAO,MAAM,eAAe,WAAY,MAAM,aAAa,MAAM,WAOhE,CAAC;AAEF,aAAK,QAAQ,GAAG;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,UAAU,KAAG,QAa9C,CAAC"}

package/lib/cjs/font-data.test.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const font_data_1 = require("./font-data");
+describe("font-data", () => {
+    describe("parseSubfamily()", () => {
+        test("Black Italic", () => {
+            expect((0, font_data_1.parseSubfamily)("Black Italic")).toEqual({
+                style: "italic",
+                weight: 900,
+            });
+        });
+        test("Bold", () => {
+            expect((0, font_data_1.parseSubfamily)("Bold")).toEqual({
+                style: "normal",
+                weight: 700,
+            });
+        });
+        test("Demi Bold Italic", () => {
+            expect((0, font_data_1.parseSubfamily)("Demi Bold Italic")).toEqual({
+                style: "italic",
+                weight: 600,
+            });
+        });
+        test("Light", () => {
+            expect((0, font_data_1.parseSubfamily)("Light")).toEqual({
+                style: "normal",
+                weight: 300,
+            });
+        });
+        test("Extra Light", () => {
+            expect((0, font_data_1.parseSubfamily)("Extra Light")).toEqual({
+                style: "normal",
+                weight: 200,
+            });
+        });
+        test("Extra Light Italic", () => {
+            expect((0, font_data_1.parseSubfamily)("Extra Light Italic")).toEqual({
+                style: "italic",
+                weight: 200,
+            });
+        });
+        test("Heavy Italic", () => {
+            expect((0, font_data_1.parseSubfamily)("Heavy Italic")).toEqual({
+                style: "italic",
+                weight: 900,
+            });
+        });
+        test("Medium Italic", () => {
+            expect((0, font_data_1.parseSubfamily)("Medium Italic")).toEqual({
+                style: "italic",
+                weight: 500,
+            });
+        });
+    });
+    describe("normalizeFamily()", () => {
+        test("basic", () => {
+            expect((0, font_data_1.normalizeFamily)("Roboto Black", "Black")).toBe("Roboto");
+            expect((0, font_data_1.normalizeFamily)("Roboto Light", "Light Italic")).toBe("Roboto");
+            expect((0, font_data_1.normalizeFamily)("Robolder Bold", "Bold")).toBe("Robolder");
+            expect((0, font_data_1.normalizeFamily)(" Roboto X Bold ", "Bold")).toBe("Roboto X");
+            expect((0, font_data_1.normalizeFamily)(" 'Roboto X' Bold ", "Bold")).toBe("'Roboto X'");
+            expect((0, font_data_1.normalizeFamily)(` "Roboto X" Bold `, "Bold")).toBe(`"Roboto X"`);
+            expect((0, font_data_1.normalizeFamily)(`"Roboto Bold"`, "Bold")).toBe(`"Roboto Bold"`);
+            expect((0, font_data_1.normalizeFamily)(`"Roboto Bold" Bold`, "Bold")).toBe(`"Roboto Bold"`);
+        });
+    });
+});

package/lib/cjs/font-data.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=font-data.test.d.ts.map

package/lib/cjs/font-data.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-data.test.d.ts","sourceRoot":"","sources":["../../src/font-data.test.ts"],"names":[],"mappings":""}

package/lib/cjs/font-weights.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontWeights = void 0;
+exports.fontWeights = {
+    "100": {
+        label: "Thin",
+        name: "thin",
+        alt: "hairline",
+    },
+    "200": {
+        label: "Extra Light",
+        name: "extra light",
+        alt: "ultra light",
+    },
+    "300": {
+        label: "Light",
+        name: "light",
+        alt: "light",
+    },
+    "400": {
+        label: "Normal",
+        name: "normal",
+        alt: "normal",
+    },
+    "500": {
+        label: "Medium",
+        name: "medium",
+        alt: "medium",
+    },
+    "600": {
+        label: "Semi Bold",
+        name: "semi bold",
+        alt: "demi bold",
+    },
+    "700": {
+        label: "Bold",
+        name: "bold",
+        alt: "bold",
+    },
+    "800": {
+        label: "Extra Bold",
+        name: "extra bold",
+        alt: "ultra bold",
+    },
+    "900": {
+        label: "Black",
+        name: "black",
+        alt: "heavy",
+    },
+};

package/lib/cjs/font-weights.d.ts

@@ -0,0 +1,50 @@
+export declare const fontWeights: {
+    readonly "100": {
+        readonly label: "Thin";
+        readonly name: "thin";
+        readonly alt: "hairline";
+    };
+    readonly "200": {
+        readonly label: "Extra Light";
+        readonly name: "extra light";
+        readonly alt: "ultra light";
+    };
+    readonly "300": {
+        readonly label: "Light";
+        readonly name: "light";
+        readonly alt: "light";
+    };
+    readonly "400": {
+        readonly label: "Normal";
+        readonly name: "normal";
+        readonly alt: "normal";
+    };
+    readonly "500": {
+        readonly label: "Medium";
+        readonly name: "medium";
+        readonly alt: "medium";
+    };
+    readonly "600": {
+        readonly label: "Semi Bold";
+        readonly name: "semi bold";
+        readonly alt: "demi bold";
+    };
+    readonly "700": {
+        readonly label: "Bold";
+        readonly name: "bold";
+        readonly alt: "bold";
+    };
+    readonly "800": {
+        readonly label: "Extra Bold";
+        readonly name: "extra bold";
+        readonly alt: "ultra bold";
+    };
+    readonly "900": {
+        readonly label: "Black";
+        readonly name: "black";
+        readonly alt: "heavy";
+    };
+};
+export declare type FontWeight = keyof typeof fontWeights;
+export declare type FontWeightKeyword = typeof fontWeights[FontWeight]["name"] | typeof fontWeights[FontWeight]["alt"];
+//# sourceMappingURL=font-weights.d.ts.map

package/lib/cjs/font-weights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-weights.d.ts","sourceRoot":"","sources":["../../src/font-weights.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Cd,CAAC;AAEX,oBAAY,UAAU,GAAG,MAAM,OAAO,WAAW,CAAC;AAClD,oBAAY,iBAAiB,GACzB,OAAO,WAAW,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,GACtC,OAAO,WAAW,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC"}

package/lib/cjs/get-font-faces.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFontFaces = void 0;
+const constants_1 = require("./constants");
+const formatFace = (asset, format) => {
+    return {
+        fontFamily: asset.meta.family,
+        fontStyle: asset.meta.style,
+        fontWeight: asset.meta.weight,
+        fontDisplay: "swap",
+        src: `url('${asset.path}') format('${format}')`,
+    };
+};
+const getKey = (asset) => asset.meta.family + asset.meta.style + asset.meta.weight;
+const getFontFaces = (assets) => {
+    const faces = new Map();
+    for (const asset of assets) {
+        const face = faces.get(getKey(asset));
+        const format = constants_1.FONT_FORMATS.get(asset.format);
+        if (format === undefined) {
+            // Should never happen since we allow only uploading formats we support
+            continue;
+        }
+        if (face === undefined) {
+            const face = formatFace(asset, format);
+            faces.set(getKey(asset), face);
+            continue;
+        }
+        // We already have that font face, so we need to add the new src
+        face.src += `, url('${asset.path}') format('${format}')`;
+    }
+    return Array.from(faces.values());
+};
+exports.getFontFaces = getFontFaces;

package/lib/cjs/get-font-faces.d.ts

@@ -0,0 +1,16 @@
+import type { FontMeta } from "./schema";
+import type { FontFormat } from "./types";
+export declare type PartialFontAsset = {
+    format: FontFormat;
+    meta: FontMeta;
+    path: string;
+};
+export declare type FontFace = {
+    fontFamily: string;
+    fontStyle: FontMeta["style"];
+    fontWeight: number;
+    fontDisplay: "swap" | "auto" | "block" | "fallback" | "optional";
+    src: string;
+};
+export declare const getFontFaces: (assets: Array<PartialFontAsset>) => Array<FontFace>;
+//# sourceMappingURL=get-font-faces.d.ts.map

package/lib/cjs/get-font-faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-font-faces.d.ts","sourceRoot":"","sources":["../../src/get-font-faces.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,oBAAY,gBAAgB,GAAG;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,oBAAY,QAAQ,GAAG;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC;IACjE,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAeF,eAAO,MAAM,YAAY,WACf,MAAM,gBAAgB,CAAC,KAC9B,MAAM,QAAQ,CAoBhB,CAAC"}

package/lib/cjs/get-font-faces.test.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_font_faces_1 = require("./get-font-faces");
+describe("getFontFaces()", () => {
+    test("different formats", () => {
+        const assets = [
+            {
+                format: "woff",
+                meta: {
+                    family: "Roboto",
+                    style: "normal",
+                    weight: 400,
+                },
+                path: "/fonts/roboto.woff",
+            },
+            {
+                format: "ttf",
+                meta: {
+                    family: "Roboto",
+                    style: "normal",
+                    weight: 400,
+                },
+                path: "/fonts/roboto.ttf",
+            },
+        ];
+        expect((0, get_font_faces_1.getFontFaces)(assets)).toMatchSnapshot();
+    });
+    test("different style", () => {
+        const assets = [
+            {
+                format: "ttf",
+                meta: {
+                    family: "Roboto",
+                    style: "normal",
+                    weight: 400,
+                },
+                path: "/fonts/roboto.ttf",
+            },
+            {
+                format: "ttf",
+                meta: {
+                    family: "Roboto",
+                    style: "italic",
+                    weight: 400,
+                },
+                path: "/fonts/roboto-italic.ttf",
+            },
+        ];
+        expect((0, get_font_faces_1.getFontFaces)(assets)).toMatchSnapshot();
+    });
+    test("different weight", () => {
+        const assets = [
+            {
+                format: "ttf",
+                meta: {
+                    family: "Roboto",
+                    style: "normal",
+                    weight: 400,
+                },
+                path: "/fonts/roboto.ttf",
+            },
+            {
+                format: "ttf",
+                meta: {
+                    family: "Roboto",
+                    style: "normal",
+                    weight: 500,
+                },
+                path: "/fonts/roboto-bold.ttf",
+            },
+        ];
+        expect((0, get_font_faces_1.getFontFaces)(assets)).toMatchSnapshot();
+    });
+});

package/lib/cjs/get-font-faces.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-font-faces.test.d.ts.map

package/lib/cjs/get-font-faces.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-font-faces.test.d.ts","sourceRoot":"","sources":["../../src/get-font-faces.test.ts"],"names":[],"mappings":""}

package/lib/cjs/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./get-font-faces"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./font-weights"), exports);

package/lib/cjs/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./constants";
+export * from "./get-font-faces";
+export * from "./types";
+export * from "./font-weights";
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC"}

package/lib/cjs/index.server.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFontData = void 0;
+var font_data_1 = require("./font-data");
+Object.defineProperty(exports, "getFontData", { enumerable: true, get: function () { return font_data_1.getFontData; } });
+__exportStar(require("./schema"), exports);

package/lib/cjs/index.server.d.ts

@@ -0,0 +1,3 @@
+export { getFontData } from "./font-data";
+export * from "./schema";
+//# sourceMappingURL=index.server.d.ts.map

package/lib/cjs/index.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.server.d.ts","sourceRoot":"","sources":["../../src/index.server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,cAAc,UAAU,CAAC"}

package/lib/cjs/schema.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FontMeta = void 0;
+const zod_1 = require("zod");
+const font_data_1 = require("./font-data");
+exports.FontMeta = zod_1.z.object({
+    family: zod_1.z.string(),
+    style: zod_1.z.enum(font_data_1.styles),
+    weight: zod_1.z.number(),
+});

package/lib/cjs/schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const FontMeta: z.ZodObject<{
+    family: z.ZodString;
+    style: z.ZodEnum<["normal", "italic", "oblique"]>;
+    weight: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    family: string;
+    style: "normal" | "italic" | "oblique";
+    weight: number;
+}, {
+    family: string;
+    style: "normal" | "italic" | "oblique";
+    weight: number;
+}>;
+export declare type FontMeta = z.infer<typeof FontMeta>;
+//# sourceMappingURL=schema.d.ts.map

package/lib/cjs/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;EAInB,CAAC;AACH,oBAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/lib/cjs/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/types.d.ts

@@ -0,0 +1,2 @@
+export declare type FontFormat = "ttf" | "woff" | "woff2" | "otf";
+//# sourceMappingURL=types.d.ts.map

package/lib/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC"}

package/lib/constants.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FONT_MIME_TYPES = exports.FONT_FORMATS = exports.DEFAULT_FONT_FALLBACK = exports.SYSTEM_FONTS = void 0;
-exports.SYSTEM_FONTS = new Map([
+export const SYSTEM_FONTS = new Map([
     ["Arial", ["sans-serif"]],
     ["Times New Roman", ["sans"]],
     ["Courier New", ["monospace"]],
     ["system-ui", []],
 ]);
-exports.DEFAULT_FONT_FALLBACK = "sans-serif";
-exports.FONT_FORMATS = new Map([
+export const DEFAULT_FONT_FALLBACK = "sans-serif";
+export const FONT_FORMATS = new Map([
     ["woff", "woff"],
     ["woff2", "woff2"],
     ["ttf", "truetype"],
     ["otf", "opentype"],
 ]);
-exports.FONT_MIME_TYPES = Array.from(exports.FONT_FORMATS.keys())
+export const FONT_MIME_TYPES = Array.from(FONT_FORMATS.keys())
     .map((format) => `.${format}`)
     .join(", ");

package/lib/font-data.d.ts

@@ -0,0 +1,23 @@
+import type { FontFormat } from "./types";
+declare module "fontkit" {
+    interface Font {
+        type: string;
+        getName: (name: string) => string;
+    }
+}
+export declare const styles: readonly ["normal", "italic", "oblique"];
+declare type Style = typeof styles[number];
+export declare const parseSubfamily: (subfamily: string) => {
+    style: "normal" | "italic" | "oblique";
+    weight: number;
+};
+export declare const normalizeFamily: (family: string, subfamily: string) => string;
+declare type FontData = {
+    format: FontFormat;
+    family: string;
+    style: Style;
+    weight: number;
+};
+export declare const getFontData: (data: Uint8Array) => FontData;
+export {};
+//# sourceMappingURL=font-data.d.ts.map

package/lib/font-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-data.d.ts","sourceRoot":"","sources":["../src/font-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAK1C,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAiB,IAAI;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;KACnC;CACF;AAED,eAAO,MAAM,MAAM,0CAA2C,CAAC;AAC/D,aAAK,KAAK,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;AAEnC,eAAO,MAAM,cAAc,cAAe,MAAM;;;CAmB/C,CAAC;AAUF,eAAO,MAAM,eAAe,WAAY,MAAM,aAAa,MAAM,WAOhE,CAAC;AAEF,aAAK,QAAQ,GAAG;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,UAAU,KAAG,QAa9C,CAAC"}

package/lib/font-data.js

@@ -0,0 +1,47 @@
+import { create as createFontKit } from "fontkit";
+import { fontWeights } from "./font-weights";
+export const styles = ["normal", "italic", "oblique"];
+export const parseSubfamily = (subfamily) => {
+    const subfamilyLow = subfamily.toLowerCase();
+    let style = "normal";
+    for (const possibleStyle of styles) {
+        if (subfamilyLow.includes(possibleStyle)) {
+            style = possibleStyle;
+            break;
+        }
+    }
+    let weight = "400";
+    for (weight in fontWeights) {
+        const { name } = fontWeights[weight];
+        const { alt } = fontWeights[weight];
+        if (subfamilyLow.includes(name) || subfamilyLow.includes(alt)) {
+            break;
+        }
+    }
+    return { style, weight: Number(weight) };
+};
+const splitAndTrim = (string) => string
+    .split(" ")
+    .map((part) => part.trim())
+    .filter(Boolean);
+// Family name can contain additional information like "Roboto Black" or "Roboto Bold", though we need pure family name "Roboto", because the rest is already encoded in weight and style.
+// We need a name we can reference in CSS font-family property, while CSS matches it with the right font-face considering the weight and style.
+export const normalizeFamily = (family, subfamily) => {
+    const familyParts = splitAndTrim(family);
+    const subfamilyParts = splitAndTrim(subfamily.toLowerCase());
+    const familyPartsNormalized = familyParts.filter((familyPart) => subfamilyParts.includes(familyPart.toLowerCase()) === false);
+    return familyPartsNormalized.join(" ");
+};
+export const getFontData = (data) => {
+    const font = createFontKit(data);
+    const format = font.type.toLowerCase();
+    const originalFamily = font.getName("fontFamily");
+    const subfamily = font.getName("preferredSubfamily") ?? font.getName("fontSubfamily");
+    const parsedSubfamily = parseSubfamily(subfamily);
+    const family = normalizeFamily(originalFamily, subfamily);
+    return {
+        format,
+        family,
+        ...parsedSubfamily,
+    };
+};

package/lib/font-data.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=font-data.test.d.ts.map

package/lib/font-data.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-data.test.d.ts","sourceRoot":"","sources":["../src/font-data.test.ts"],"names":[],"mappings":""}