@webstudio-is/fonts 0.90.0 → 0.92.0

package/lib/constants.js

@@ -1,20 +1,16 @@
-const SYSTEM_FONTS = /* @__PURE__ */ new Map([
+"use strict";
+export const SYSTEM_FONTS = /* @__PURE__ */ new Map([
   ["Arial", ["Roboto", "sans-serif"]],
   ["Times New Roman", ["sans"]],
   ["Courier New", ["monospace"]],
   ["system-ui", []]
 ]);
-const DEFAULT_FONT_FALLBACK = "sans-serif";
-const FONT_FORMATS = /* @__PURE__ */ new Map([
+export const DEFAULT_FONT_FALLBACK = "sans-serif";
+export const FONT_FORMATS = /* @__PURE__ */ new Map([
   ["woff", "woff"],
   ["woff2", "woff2"],
   ["ttf", "truetype"],
   ["otf", "opentype"]
 ]);
-const FONT_MIME_TYPES = Array.from(FONT_FORMATS.keys()).map((format) => `.${format}`).join(", ");
-export {
-  DEFAULT_FONT_FALLBACK,
-  FONT_FORMATS,
-  FONT_MIME_TYPES,
-  SYSTEM_FONTS
-};
+export const FONT_MIME_TYPES = Array.from(FONT_FORMATS.keys()).map((format) => `.${format}`).join(", ");
+export const FONT_STYLES = ["normal", "italic", "oblique"];

package/lib/font-weights.js

@@ -1,4 +1,5 @@
-const fontWeights = {
+"use strict";
+export const fontWeights = {
   "100": {
     label: "Thin",
     names: ["thin", "hairline"]
@@ -36,6 +37,3 @@ const fontWeights = {
     names: ["black", "heavy"]
   }
 };
-export {
-  fontWeights
-};

package/lib/get-font-faces.js

@@ -1,3 +1,4 @@
+"use strict";
 import { FONT_FORMATS } from "./constants";
 const formatFace = (asset, format, url) => {
   if ("variationAxes" in asset.meta) {
@@ -25,7 +26,7 @@ const getKey = (asset) => {
   }
   return asset.meta.family + asset.meta.style + asset.meta.weight;
 };
-const getFontFaces = (assets, options) => {
+export const getFontFaces = (assets, options) => {
   const { assetBaseUrl } = options;
   const faces = /* @__PURE__ */ new Map();
   for (const asset of assets) {
@@ -45,6 +46,3 @@ const getFontFaces = (assets, options) => {
   }
   return Array.from(faces.values());
 };
-export {
-  getFontFaces
-};

package/{src/get-font-faces.test.ts → lib/get-font-faces.test.js}

@@ -1,87 +1,84 @@
+"use strict";
 import { describe, test, expect } from "@jest/globals";
-import { getFontFaces, type PartialFontAsset } from "./get-font-faces";
-
+import { getFontFaces } from "./get-font-faces";
 describe("getFontFaces()", () => {
   test("different formats", () => {
-    const assets: Array<PartialFontAsset> = [
+    const assets = [
       {
         format: "woff",
         meta: {
           family: "Roboto",
           style: "normal",
-          weight: 400,
+          weight: 400
         },
-        name: "roboto.woff",
+        name: "roboto.woff"
       },
       {
         format: "ttf",
         meta: {
           family: "Roboto",
           style: "normal",
-          weight: 400,
+          weight: 400
         },
-        name: "roboto.ttf",
-      },
+        name: "roboto.ttf"
+      }
     ];
     expect(getFontFaces(assets, { assetBaseUrl: "/fonts/" })).toMatchSnapshot();
   });
-
   test("different style", () => {
-    const assets: Array<PartialFontAsset> = [
+    const assets = [
       {
         format: "ttf",
         meta: {
           family: "Roboto",
           style: "normal",
-          weight: 400,
+          weight: 400
         },
-        name: "roboto.ttf",
+        name: "roboto.ttf"
       },
       {
         format: "ttf",
         meta: {
           family: "Roboto",
           style: "italic",
-          weight: 400,
+          weight: 400
         },
-        name: "roboto-italic.ttf",
-      },
+        name: "roboto-italic.ttf"
+      }
     ];
     expect(getFontFaces(assets, { assetBaseUrl: "/fonts/" })).toMatchSnapshot();
   });
-
   test("different weight", () => {
-    const assets: Array<PartialFontAsset> = [
+    const assets = [
       {
         format: "ttf",
         meta: {
           family: "Roboto",
           style: "normal",
-          weight: 400,
+          weight: 400
         },
-        name: "roboto.ttf",
+        name: "roboto.ttf"
       },
       {
         format: "ttf",
         meta: {
           family: "Roboto",
           style: "normal",
-          weight: 500,
+          weight: 500
         },
-        name: "roboto-bold.ttf",
-      },
+        name: "roboto-bold.ttf"
+      }
     ];
     expect(getFontFaces(assets, { assetBaseUrl: "/fonts/" })).toMatchSnapshot();
   });
-
   test("variable font", () => {
-    const assets: Array<PartialFontAsset> = [
+    const assets = [
       {
         format: "ttf",
         meta: {
           family: "Inter",
           variationAxes: {
-            wght: { name: "wght", min: 100, default: 400, max: 1000 },
+            wght: { name: "wght", min: 100, default: 400, max: 1e3 },
             wdth: { name: "wdth", min: 25, default: 100, max: 151 },
             opsz: { name: "opsz", min: 8, default: 14, max: 144 },
             GRAD: { name: "GRAD", min: -200, default: 0, max: 150 },
@@ -93,11 +90,11 @@ describe("getFontFaces()", () => {
             YTUC: { name: "YTUC", min: 528, default: 712, max: 760 },
             YTAS: { name: "YTAS", min: 649, default: 750, max: 854 },
             YTDE: { name: "YTDE", min: -305, default: -203, max: -98 },
-            YTFI: { name: "YTFI", min: 560, default: 738, max: 788 },
-          },
+            YTFI: { name: "YTFI", min: 560, default: 738, max: 788 }
+          }
         },
-        name: "inter.ttf",
-      },
+        name: "inter.ttf"
+      }
     ];
     expect(getFontFaces(assets, { assetBaseUrl: "/fonts/" })).toMatchSnapshot();
   });

package/lib/index.js

@@ -1,3 +1,4 @@
+"use strict";
 export * from "./constants";
 export * from "./get-font-faces";
 export * from "./schema";

package/lib/schema.js

@@ -1,6 +1,7 @@
+"use strict";
 import { z } from "zod";
-import { styles } from "./font-data";
-const FontFormat = z.union([
+import { FONT_STYLES } from "./constants";
+export const FontFormat = z.union([
   z.literal("ttf"),
   z.literal("woff"),
   z.literal("woff2"),
@@ -31,18 +32,13 @@ const VariationAxes = z.record(
     max: z.number()
   })
 );
-const FontMetaStatic = z.object({
+export const FontMetaStatic = z.object({
   family: z.string(),
-  style: z.enum(styles),
+  style: z.enum(FONT_STYLES),
   weight: z.number()
 });
 const FontMetaVariable = z.object({
   family: z.string(),
   variationAxes: VariationAxes
 });
-const FontMeta = z.union([FontMetaStatic, FontMetaVariable]);
-export {
-  FontFormat,
-  FontMeta,
-  FontMetaStatic
-};
+export const FontMeta = z.union([FontMetaStatic, FontMetaVariable]);

package/lib/types/constants.d.ts

@@ -3,3 +3,5 @@ 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;
+export declare const FONT_STYLES: readonly ["normal", "italic", "oblique"];
+export type FontStyle = (typeof FONT_STYLES)[number];

package/lib/types/schema.d.ts

@@ -23,13 +23,13 @@ export declare const FontMetaStatic: z.ZodObject<{
     style: z.ZodEnum<["normal", "italic", "oblique"]>;
     weight: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
+    family: string;
     style: "normal" | "italic" | "oblique";
     weight: number;
-    family: string;
 }, {
+    family: string;
     style: "normal" | "italic" | "oblique";
     weight: number;
-    family: string;
 }>;
 export type FontMetaStatic = z.infer<typeof FontMetaStatic>;
 export declare const FontMeta: z.ZodUnion<[z.ZodObject<{
@@ -37,13 +37,13 @@ export declare const FontMeta: z.ZodUnion<[z.ZodObject<{
     style: z.ZodEnum<["normal", "italic", "oblique"]>;
     weight: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
+    family: string;
     style: "normal" | "italic" | "oblique";
     weight: number;
-    family: string;
 }, {
+    family: string;
     style: "normal" | "italic" | "oblique";
     weight: number;
-    family: string;
 }>, z.ZodObject<{
     family: z.ZodString;
     variationAxes: z.ZodRecord<z.ZodEnum<["wght", "wdth", "slnt", "opsz", "ital", "GRAD", "XTRA", "XOPQ", "YOPQ", "YTLC", "YTUC", "YTAS", "YTDE", "YTFI"]>, z.ZodObject<{
@@ -63,21 +63,21 @@ export declare const FontMeta: z.ZodUnion<[z.ZodObject<{
         max: number;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    family: string;
     variationAxes: Partial<Record<"wght" | "wdth" | "slnt" | "opsz" | "ital" | "GRAD" | "XTRA" | "XOPQ" | "YOPQ" | "YTLC" | "YTUC" | "YTAS" | "YTDE" | "YTFI", {
         name: string;
         min: number;
         default: number;
         max: number;
     }>>;
-    family: string;
 }, {
+    family: string;
     variationAxes: Partial<Record<"wght" | "wdth" | "slnt" | "opsz" | "ital" | "GRAD" | "XTRA" | "XOPQ" | "YOPQ" | "YTLC" | "YTUC" | "YTAS" | "YTDE" | "YTFI", {
         name: string;
         min: number;
         default: number;
         max: number;
     }>>;
-    family: string;
 }>]>;
 export type FontMeta = z.infer<typeof FontMeta>;
 export {};

package/package.json

@@ -1,44 +1,29 @@
 {
   "name": "@webstudio-is/fonts",
-  "version": "0.90.0",
+  "version": "0.92.0",
   "description": "Fonts utils",
   "author": "Webstudio <github@webstudio.is>",
   "homepage": "https://webstudio.is",
   "type": "module",
-  "dependencies": {
-    "fontkit": "^2.0.2"
-  },
   "devDependencies": {
-    "@jest/globals": "^29.6.2",
-    "@types/fontkit": "^2.0.1",
-    "jest": "^29.6.2",
-    "typescript": "5.1.6",
+    "@jest/globals": "^29.6.4",
+    "jest": "^29.6.4",
+    "typescript": "5.2.2",
     "zod": "^3.21.4",
-    "@webstudio-is/design-system": "^0.90.0",
     "@webstudio-is/jest-config": "^1.0.7",
-    "@webstudio-is/scripts": "^0.0.0",
     "@webstudio-is/tsconfig": "^1.0.7"
   },
   "peerDependencies": {
     "zod": "^3.19.1"
   },
   "exports": {
-    ".": {
-      "source": "./src/index.ts",
-      "types": "./lib/types/index.d.ts",
-      "import": "./lib/index.js",
-      "require": "./lib/cjs/index.js"
-    },
-    "./index.server": {
-      "source": "./src/index.server.ts",
-      "types": "./lib/types/index.server.d.ts",
-      "import": "./lib/index.server.js"
-    }
+    "source": "./src/index.ts",
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/index.js"
   },
   "files": [
     "lib/*",
-    "src/*",
-    "!*.test.*"
+    "!*.{test,stories}.*"
   ],
   "license": "AGPL-3.0-or-later",
   "private": false,
@@ -47,8 +32,8 @@
     "typecheck": "tsc",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "checks": "pnpm typecheck && pnpm test",
-    "dev": "build-package --watch",
-    "build": "build-package",
+    "dev": "pnpm build --watch",
+    "build": "rm -rf lib && esbuild 'src/**/*.ts' 'src/**/*.tsx' --outdir=lib",
     "dts": "tsc --project tsconfig.dts.json"
   }
 }

package/lib/cjs/constants.js

@@ -1,40 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constants_exports = {};
-__export(constants_exports, {
-  DEFAULT_FONT_FALLBACK: () => DEFAULT_FONT_FALLBACK,
-  FONT_FORMATS: () => FONT_FORMATS,
-  FONT_MIME_TYPES: () => FONT_MIME_TYPES,
-  SYSTEM_FONTS: () => SYSTEM_FONTS
-});
-module.exports = __toCommonJS(constants_exports);
-const SYSTEM_FONTS = /* @__PURE__ */ new Map([
-  ["Arial", ["Roboto", "sans-serif"]],
-  ["Times New Roman", ["sans"]],
-  ["Courier New", ["monospace"]],
-  ["system-ui", []]
-]);
-const DEFAULT_FONT_FALLBACK = "sans-serif";
-const FONT_FORMATS = /* @__PURE__ */ new Map([
-  ["woff", "woff"],
-  ["woff2", "woff2"],
-  ["ttf", "truetype"],
-  ["otf", "opentype"]
-]);
-const FONT_MIME_TYPES = Array.from(FONT_FORMATS.keys()).map((format) => `.${format}`).join(", ");

package/lib/cjs/font-data.js

@@ -1,76 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var font_data_exports = {};
-__export(font_data_exports, {
-  getFontData: () => getFontData,
-  normalizeFamily: () => normalizeFamily,
-  parseSubfamily: () => parseSubfamily,
-  styles: () => styles
-});
-module.exports = __toCommonJS(font_data_exports);
-var import_fontkit = require("fontkit");
-var import_font_weights = require("./font-weights");
-const styles = ["normal", "italic", "oblique"];
-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 import_font_weights.fontWeights) {
-    const { names } = import_font_weights.fontWeights[weight];
-    if (names.some((name) => subfamilyLow.includes(name))) {
-      break;
-    }
-  }
-  return { style, weight: Number(weight) };
-};
-const splitAndTrim = (string) => string.split(" ").map((part) => part.trim()).filter(Boolean);
-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(" ");
-};
-const getFontData = (data) => {
-  const font = (0, import_fontkit.create)(data);
-  const format = font.type.toLowerCase();
-  const originalFamily = font.getName("fontFamily");
-  const subfamily = font.getName("preferredSubfamily") ?? font.getName("fontSubfamily");
-  const family = normalizeFamily(originalFamily, subfamily);
-  const isVariable = Object.keys(font.variationAxes).length !== 0;
-  if (isVariable) {
-    return {
-      format,
-      family,
-      variationAxes: font.variationAxes
-    };
-  }
-  return {
-    format,
-    family,
-    ...parseSubfamily(subfamily)
-  };
-};

package/lib/cjs/font-weights.js

@@ -1,61 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var font_weights_exports = {};
-__export(font_weights_exports, {
-  fontWeights: () => fontWeights
-});
-module.exports = __toCommonJS(font_weights_exports);
-const fontWeights = {
-  "100": {
-    label: "Thin",
-    names: ["thin", "hairline"]
-  },
-  "200": {
-    label: "Extra Light",
-    names: ["extra light", "extralight", "ultra light", "ultralight"]
-  },
-  "300": {
-    label: "Light",
-    names: ["light"]
-  },
-  "400": {
-    label: "Normal",
-    names: ["normal", "regular"]
-  },
-  "500": {
-    label: "Medium",
-    names: ["medium"]
-  },
-  "600": {
-    label: "Semi Bold",
-    names: ["semi bold", "semibold", "demi bold", "demibold"]
-  },
-  "700": {
-    label: "Bold",
-    names: ["bold", "bold"]
-  },
-  "800": {
-    label: "Extra Bold",
-    names: ["extra bold", "extrabold", "ultra bold", "ultrabold"]
-  },
-  "900": {
-    label: "Black",
-    names: ["black", "heavy"]
-  }
-};

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

@@ -1,70 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var get_font_faces_exports = {};
-__export(get_font_faces_exports, {
-  getFontFaces: () => getFontFaces
-});
-module.exports = __toCommonJS(get_font_faces_exports);
-var import_constants = require("./constants");
-const formatFace = (asset, format, url) => {
-  if ("variationAxes" in asset.meta) {
-    const { wght, wdth } = asset.meta?.variationAxes ?? {};
-    return {
-      fontFamily: asset.meta.family,
-      fontStyle: "normal",
-      fontDisplay: "swap",
-      src: `url('${url}') format('${format}')`,
-      fontStretch: wdth ? `${wdth.min}% ${wdth.max}%` : void 0,
-      fontWeight: wght ? `${wght.min} ${wght.max}` : void 0
-    };
-  }
-  return {
-    fontFamily: asset.meta.family,
-    fontStyle: asset.meta.style,
-    fontWeight: asset.meta.weight,
-    fontDisplay: "swap",
-    src: `url('${url}') format('${format}')`
-  };
-};
-const getKey = (asset) => {
-  if ("variationAxes" in asset.meta) {
-    return asset.meta.family + Object.values(asset.meta.variationAxes).join("");
-  }
-  return asset.meta.family + asset.meta.style + asset.meta.weight;
-};
-const getFontFaces = (assets, options) => {
-  const { assetBaseUrl } = options;
-  const faces = /* @__PURE__ */ new Map();
-  for (const asset of assets) {
-    const url = `${assetBaseUrl}${asset.name}`;
-    const assetKey = getKey(asset);
-    const face = faces.get(assetKey);
-    const format = import_constants.FONT_FORMATS.get(asset.format);
-    if (format === void 0) {
-      continue;
-    }
-    if (face === void 0) {
-      const face2 = formatFace(asset, format, url);
-      faces.set(assetKey, face2);
-      continue;
-    }
-    face.src += `, url('${url}') format('${format}')`;
-  }
-  return Array.from(faces.values());
-};

package/lib/cjs/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./constants"), module.exports);
-__reExport(src_exports, require("./get-font-faces"), module.exports);
-__reExport(src_exports, require("./schema"), module.exports);
-__reExport(src_exports, require("./font-weights"), module.exports);

package/lib/cjs/index.server.js

@@ -1,24 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_server_exports = {};
-__export(index_server_exports, {
-  getFontData: () => import_font_data.getFontData
-});
-module.exports = __toCommonJS(index_server_exports);
-var import_font_data = require("./font-data");

package/lib/cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}

package/lib/cjs/schema.js

@@ -1,68 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var schema_exports = {};
-__export(schema_exports, {
-  FontFormat: () => FontFormat,
-  FontMeta: () => FontMeta,
-  FontMetaStatic: () => FontMetaStatic
-});
-module.exports = __toCommonJS(schema_exports);
-var import_zod = require("zod");
-var import_font_data = require("./font-data");
-const FontFormat = import_zod.z.union([
-  import_zod.z.literal("ttf"),
-  import_zod.z.literal("woff"),
-  import_zod.z.literal("woff2"),
-  import_zod.z.literal("otf")
-]);
-const AxisName = import_zod.z.enum([
-  "wght",
-  "wdth",
-  "slnt",
-  "opsz",
-  "ital",
-  "GRAD",
-  "XTRA",
-  "XOPQ",
-  "YOPQ",
-  "YTLC",
-  "YTUC",
-  "YTAS",
-  "YTDE",
-  "YTFI"
-]);
-const VariationAxes = import_zod.z.record(
-  AxisName,
-  import_zod.z.object({
-    name: import_zod.z.string(),
-    min: import_zod.z.number(),
-    default: import_zod.z.number(),
-    max: import_zod.z.number()
-  })
-);
-const FontMetaStatic = import_zod.z.object({
-  family: import_zod.z.string(),
-  style: import_zod.z.enum(import_font_data.styles),
-  weight: import_zod.z.number()
-});
-const FontMetaVariable = import_zod.z.object({
-  family: import_zod.z.string(),
-  variationAxes: VariationAxes
-});
-const FontMeta = import_zod.z.union([FontMetaStatic, FontMetaVariable]);

package/lib/font-data.js

@@ -1,56 +0,0 @@
-import { create as createFontKit } from "fontkit";
-import { fontWeights } from "./font-weights";
-const styles = ["normal", "italic", "oblique"];
-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 { names } = fontWeights[weight];
-    if (names.some((name) => subfamilyLow.includes(name))) {
-      break;
-    }
-  }
-  return { style, weight: Number(weight) };
-};
-const splitAndTrim = (string) => string.split(" ").map((part) => part.trim()).filter(Boolean);
-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(" ");
-};
-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 family = normalizeFamily(originalFamily, subfamily);
-  const isVariable = Object.keys(font.variationAxes).length !== 0;
-  if (isVariable) {
-    return {
-      format,
-      family,
-      variationAxes: font.variationAxes
-    };
-  }
-  return {
-    format,
-    family,
-    ...parseSubfamily(subfamily)
-  };
-};
-export {
-  getFontData,
-  normalizeFamily,
-  parseSubfamily,
-  styles
-};

package/lib/index.server.js

@@ -1,4 +0,0 @@
-import { getFontData } from "./font-data";
-export {
-  getFontData
-};

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

@@ -1,29 +0,0 @@
-import type { FontFormat, VariationAxes } from "./schema";
-declare module "fontkit" {
-    interface Font {
-        type: string;
-        getName: (name: string) => string;
-        variationAxes: VariationAxes;
-    }
-}
-export declare const styles: readonly ["normal", "italic", "oblique"];
-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;
-type FontDataStatic = {
-    format: FontFormat;
-    family: string;
-    style: Style;
-    weight: number;
-};
-type FontDataVariable = {
-    format: FontFormat;
-    family: string;
-    variationAxes: VariationAxes;
-};
-type FontData = FontDataStatic | FontDataVariable;
-export declare const getFontData: (data: Uint8Array) => FontData;
-export {};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export { getFontData } from "./font-data";

package/src/__snapshots__/get-font-faces.test.ts.snap

@@ -1,64 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`getFontFaces() different formats 1`] = `
-[
-  {
-    "fontDisplay": "swap",
-    "fontFamily": "Roboto",
-    "fontStyle": "normal",
-    "fontWeight": 400,
-    "src": "url('/fonts/roboto.woff') format('woff'), url('/fonts/roboto.ttf') format('truetype')",
-  },
-]
-`;
-
-exports[`getFontFaces() different style 1`] = `
-[
-  {
-    "fontDisplay": "swap",
-    "fontFamily": "Roboto",
-    "fontStyle": "normal",
-    "fontWeight": 400,
-    "src": "url('/fonts/roboto.ttf') format('truetype')",
-  },
-  {
-    "fontDisplay": "swap",
-    "fontFamily": "Roboto",
-    "fontStyle": "italic",
-    "fontWeight": 400,
-    "src": "url('/fonts/roboto-italic.ttf') format('truetype')",
-  },
-]
-`;
-
-exports[`getFontFaces() different weight 1`] = `
-[
-  {
-    "fontDisplay": "swap",
-    "fontFamily": "Roboto",
-    "fontStyle": "normal",
-    "fontWeight": 400,
-    "src": "url('/fonts/roboto.ttf') format('truetype')",
-  },
-  {
-    "fontDisplay": "swap",
-    "fontFamily": "Roboto",
-    "fontStyle": "normal",
-    "fontWeight": 500,
-    "src": "url('/fonts/roboto-bold.ttf') format('truetype')",
-  },
-]
-`;
-
-exports[`getFontFaces() variable font 1`] = `
-[
-  {
-    "fontDisplay": "swap",
-    "fontFamily": "Inter",
-    "fontStretch": "25% 151%",
-    "fontStyle": "normal",
-    "fontWeight": "100 1000",
-    "src": "url('/fonts/inter.ttf') format('truetype')",
-  },
-]
-`;

package/src/constants.ts

@@ -1,21 +0,0 @@
-import type { FontFormat } from "./schema";
-
-export const SYSTEM_FONTS = new Map([
-  ["Arial", ["Roboto", "sans-serif"]],
-  ["Times New Roman", ["sans"]],
-  ["Courier New", ["monospace"]],
-  ["system-ui", []],
-]);
-
-export const DEFAULT_FONT_FALLBACK = "sans-serif";
-
-export const FONT_FORMATS: Map<FontFormat, string> = new Map([
-  ["woff", "woff"],
-  ["woff2", "woff2"],
-  ["ttf", "truetype"],
-  ["otf", "opentype"],
-]);
-
-export const FONT_MIME_TYPES = Array.from(FONT_FORMATS.keys())
-  .map((format) => `.${format}`)
-  .join(", ");

package/src/font-data.test.ts

@@ -1,70 +0,0 @@
-import { describe, test, expect } from "@jest/globals";
-import { parseSubfamily, normalizeFamily } from "./font-data";
-
-describe("font-data", () => {
-  describe("parseSubfamily()", () => {
-    test("Black Italic", () => {
-      expect(parseSubfamily("Black Italic")).toEqual({
-        style: "italic",
-        weight: 900,
-      });
-    });
-    test("Bold", () => {
-      expect(parseSubfamily("Bold")).toEqual({
-        style: "normal",
-        weight: 700,
-      });
-    });
-    test("Demi Bold Italic", () => {
-      expect(parseSubfamily("Demi Bold Italic")).toEqual({
-        style: "italic",
-        weight: 600,
-      });
-    });
-    test("Light", () => {
-      expect(parseSubfamily("Light")).toEqual({
-        style: "normal",
-        weight: 300,
-      });
-    });
-    test("Extra Light", () => {
-      expect(parseSubfamily("Extra Light")).toEqual({
-        style: "normal",
-        weight: 200,
-      });
-    });
-    test("Extra Light Italic", () => {
-      expect(parseSubfamily("Extra Light Italic")).toEqual({
-        style: "italic",
-        weight: 200,
-      });
-    });
-    test("Heavy Italic", () => {
-      expect(parseSubfamily("Heavy Italic")).toEqual({
-        style: "italic",
-        weight: 900,
-      });
-    });
-    test("Medium Italic", () => {
-      expect(parseSubfamily("Medium Italic")).toEqual({
-        style: "italic",
-        weight: 500,
-      });
-    });
-  });
-
-  describe("normalizeFamily()", () => {
-    test("basic", () => {
-      expect(normalizeFamily("Roboto Black", "Black")).toBe("Roboto");
-      expect(normalizeFamily("Roboto Light", "Light Italic")).toBe("Roboto");
-      expect(normalizeFamily("Robolder Bold", "Bold")).toBe("Robolder");
-      expect(normalizeFamily(" Roboto X Bold ", "Bold")).toBe("Roboto X");
-      expect(normalizeFamily(" 'Roboto X' Bold ", "Bold")).toBe("'Roboto X'");
-      expect(normalizeFamily(` "Roboto X" Bold `, "Bold")).toBe(`"Roboto X"`);
-      expect(normalizeFamily(`"Roboto Bold"`, "Bold")).toBe(`"Roboto Bold"`);
-      expect(normalizeFamily(`"Roboto Bold" Bold`, "Bold")).toBe(
-        `"Roboto Bold"`
-      );
-    });
-  });
-});

package/src/font-data.ts

@@ -1,88 +0,0 @@
-import type { FontFormat, VariationAxes } from "./schema";
-import { create as createFontKit } from "fontkit";
-import { type FontWeight, fontWeights } from "./font-weights";
-
-// @todo sumbit this to definitely typed, they are not up to date
-declare module "fontkit" {
-  export interface Font {
-    type: string;
-    getName: (name: string) => string;
-    variationAxes: VariationAxes;
-  }
-}
-
-export const styles = ["normal", "italic", "oblique"] as const;
-type Style = (typeof styles)[number];
-
-export const parseSubfamily = (subfamily: string) => {
-  const subfamilyLow = subfamily.toLowerCase();
-  let style: Style = "normal";
-  for (const possibleStyle of styles) {
-    if (subfamilyLow.includes(possibleStyle)) {
-      style = possibleStyle;
-      break;
-    }
-  }
-  let weight: FontWeight = "400";
-  for (weight in fontWeights) {
-    const { names } = fontWeights[weight];
-    if (names.some((name) => subfamilyLow.includes(name))) {
-      break;
-    }
-  }
-  return { style, weight: Number(weight) };
-};
-
-const splitAndTrim = (string: 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: string, subfamily: string) => {
-  const familyParts = splitAndTrim(family);
-  const subfamilyParts = splitAndTrim(subfamily.toLowerCase());
-  const familyPartsNormalized = familyParts.filter(
-    (familyPart) => subfamilyParts.includes(familyPart.toLowerCase()) === false
-  );
-  return familyPartsNormalized.join(" ");
-};
-
-type FontDataStatic = {
-  format: FontFormat;
-  family: string;
-  style: Style;
-  weight: number;
-};
-type FontDataVariable = {
-  format: FontFormat;
-  family: string;
-  variationAxes: VariationAxes;
-};
-type FontData = FontDataStatic | FontDataVariable;
-
-export const getFontData = (data: Uint8Array): FontData => {
-  const font = createFontKit(data as Buffer);
-  const format = font.type.toLowerCase() as FontData["format"];
-  const originalFamily = font.getName("fontFamily");
-  const subfamily =
-    font.getName("preferredSubfamily") ?? font.getName("fontSubfamily");
-  const family = normalizeFamily(originalFamily, subfamily);
-  const isVariable = Object.keys(font.variationAxes).length !== 0;
-
-  if (isVariable) {
-    return {
-      format,
-      family,
-      variationAxes: font.variationAxes,
-    };
-  }
-
-  return {
-    format,
-    family,
-    ...parseSubfamily(subfamily),
-  };
-};

package/src/font-weights.ts

@@ -1,40 +0,0 @@
-export const fontWeights = {
-  "100": {
-    label: "Thin",
-    names: ["thin", "hairline"],
-  },
-  "200": {
-    label: "Extra Light",
-    names: ["extra light", "extralight", "ultra light", "ultralight"],
-  },
-  "300": {
-    label: "Light",
-    names: ["light"],
-  },
-  "400": {
-    label: "Normal",
-    names: ["normal", "regular"],
-  },
-  "500": {
-    label: "Medium",
-    names: ["medium"],
-  },
-  "600": {
-    label: "Semi Bold",
-    names: ["semi bold", "semibold", "demi bold", "demibold"],
-  },
-  "700": {
-    label: "Bold",
-    names: ["bold", "bold"],
-  },
-  "800": {
-    label: "Extra Bold",
-    names: ["extra bold", "extrabold", "ultra bold", "ultrabold"],
-  },
-  "900": {
-    label: "Black",
-    names: ["black", "heavy"],
-  },
-} as const;
-
-export type FontWeight = keyof typeof fontWeights;

package/src/get-font-faces.ts

@@ -1,79 +0,0 @@
-import { FONT_FORMATS } from "./constants";
-import type { FontMeta, FontFormat, FontMetaStatic } from "./schema";
-
-export type PartialFontAsset = {
-  format: FontFormat;
-  meta: FontMeta;
-  name: string;
-};
-
-export type FontFace = {
-  fontFamily: string;
-  fontDisplay: "swap" | "auto" | "block" | "fallback" | "optional";
-  src: string;
-  fontStyle?: FontMetaStatic["style"];
-  fontWeight?: number | string;
-  fontStretch?: string;
-};
-
-const formatFace = (
-  asset: PartialFontAsset,
-  format: string,
-  url: string
-): FontFace => {
-  if ("variationAxes" in asset.meta) {
-    const { wght, wdth } = asset.meta?.variationAxes ?? {};
-    return {
-      fontFamily: asset.meta.family,
-      fontStyle: "normal",
-      fontDisplay: "swap",
-      src: `url('${url}') format('${format}')`,
-      fontStretch: wdth ? `${wdth.min}% ${wdth.max}%` : undefined,
-      fontWeight: wght ? `${wght.min} ${wght.max}` : undefined,
-    };
-  }
-  return {
-    fontFamily: asset.meta.family,
-    fontStyle: asset.meta.style,
-    fontWeight: asset.meta.weight,
-    fontDisplay: "swap",
-    src: `url('${url}') format('${format}')`,
-  };
-};
-
-const getKey = (asset: PartialFontAsset) => {
-  if ("variationAxes" in asset.meta) {
-    return asset.meta.family + Object.values(asset.meta.variationAxes).join("");
-  }
-  return asset.meta.family + asset.meta.style + asset.meta.weight;
-};
-
-export const getFontFaces = (
-  assets: Array<PartialFontAsset>,
-  options: {
-    assetBaseUrl: string;
-  }
-): Array<FontFace> => {
-  const { assetBaseUrl } = options;
-  const faces = new Map();
-  for (const asset of assets) {
-    const url = `${assetBaseUrl}${asset.name}`;
-    const assetKey = getKey(asset);
-    const face = faces.get(assetKey);
-    const format = 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, url);
-      faces.set(assetKey, face);
-      continue;
-    }
-
-    // We already have that font face, so we need to add the new src
-    face.src += `, url('${url}') format('${format}')`;
-  }
-  return Array.from(faces.values());
-};

package/src/index.server.ts

@@ -1 +0,0 @@
-export { getFontData } from "./font-data";

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./constants";
-export * from "./get-font-faces";
-export * from "./schema";
-export * from "./font-weights";

package/src/schema.ts

@@ -1,56 +0,0 @@
-import { z } from "zod";
-import { styles } from "./font-data";
-
-export const FontFormat = z.union([
-  z.literal("ttf"),
-  z.literal("woff"),
-  z.literal("woff2"),
-  z.literal("otf"),
-]);
-export type FontFormat = z.infer<typeof FontFormat>;
-
-const AxisName = z.enum([
-  "wght",
-  "wdth",
-  "slnt",
-  "opsz",
-  "ital",
-  "GRAD",
-  "XTRA",
-  "XOPQ",
-  "YOPQ",
-  "YTLC",
-  "YTUC",
-  "YTAS",
-  "YTDE",
-  "YTFI",
-]);
-
-const VariationAxes = z.record(
-  AxisName,
-  z.object({
-    name: z.string(),
-    min: z.number(),
-    default: z.number(),
-    max: z.number(),
-  })
-);
-
-export type VariationAxes = z.infer<typeof VariationAxes>;
-
-export const FontMetaStatic = z.object({
-  family: z.string(),
-  style: z.enum(styles),
-  weight: z.number(),
-});
-
-export type FontMetaStatic = z.infer<typeof FontMetaStatic>;
-
-const FontMetaVariable = z.object({
-  family: z.string(),
-  variationAxes: VariationAxes,
-});
-
-export const FontMeta = z.union([FontMetaStatic, FontMetaVariable]);
-
-export type FontMeta = z.infer<typeof FontMeta>;