@webstudio-is/fonts 0.1.1 → 0.3.0

package/lib/cjs/constants.cjs

@@ -0,0 +1,40 @@
+"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", ["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.cjs

@@ -0,0 +1,70 @@
+"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 { name } = import_font_weights.fontWeights[weight];
+    const { alt } = import_font_weights.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);
+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 parsedSubfamily = parseSubfamily(subfamily);
+  const family = normalizeFamily(originalFamily, subfamily);
+  return {
+    format,
+    family,
+    ...parsedSubfamily
+  };
+};

package/lib/cjs/font-weights.cjs

@@ -0,0 +1,70 @@
+"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",
+    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/get-font-faces.cjs

@@ -0,0 +1,51 @@
+"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) => {
+  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 = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const face = faces.get(getKey(asset));
+    const format = import_constants.FONT_FORMATS.get(asset.format);
+    if (format === void 0) {
+      continue;
+    }
+    if (face === void 0) {
+      const face2 = formatFace(asset, format);
+      faces.set(getKey(asset), face2);
+      continue;
+    }
+    face.src += `, url('${asset.path}') format('${format}')`;
+  }
+  return Array.from(faces.values());
+};

package/lib/cjs/index.cjs

@@ -0,0 +1,21 @@
+"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.cjs

@@ -0,0 +1,24 @@
+"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/schema.cjs

@@ -0,0 +1,37 @@
+"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
+});
+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 FontMeta = import_zod.z.object({
+  family: import_zod.z.string(),
+  style: import_zod.z.enum(import_font_data.styles),
+  weight: import_zod.z.number()
+});

package/lib/constants.js

@@ -1,19 +1,20 @@
-"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", []],
+const SYSTEM_FONTS = /* @__PURE__ */ 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"],
+const DEFAULT_FONT_FALLBACK = "sans-serif";
+const FONT_FORMATS = /* @__PURE__ */ new Map([
+  ["woff", "woff"],
+  ["woff2", "woff2"],
+  ["ttf", "truetype"],
+  ["otf", "opentype"]
 ]);
-exports.FONT_MIME_TYPES = Array.from(exports.FONT_FORMATS.keys())
-    .map((format) => `.${format}`)
-    .join(", ");
+const FONT_MIME_TYPES = Array.from(FONT_FORMATS.keys()).map((format) => `.${format}`).join(", ");
+export {
+  DEFAULT_FONT_FALLBACK,
+  FONT_FORMATS,
+  FONT_MIME_TYPES,
+  SYSTEM_FONTS
+};

package/lib/font-data.js

@@ -1,56 +1,50 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFontData = exports.normalizeFamily = exports.parseSubfamily = exports.styles = void 0;
-const fontkit_1 = __importDefault(require("fontkit"));
-const font_weights_1 = require("./font-weights");
-exports.styles = ["normal", "italic", "oblique"];
+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 exports.styles) {
-        if (subfamilyLow.includes(possibleStyle)) {
-            style = possibleStyle;
-            break;
-        }
+  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 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;
-        }
+  }
+  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) };
+  }
+  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 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 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 = fontkit_1.default.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,
-    };
+  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
+  };
+};
+export {
+  getFontData,
+  normalizeFamily,
+  parseSubfamily,
+  styles
 };
-exports.getFontData = getFontData;

package/lib/font-weights.js

@@ -1,50 +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",
-    },
+const 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"
+  }
+};
+export {
+  fontWeights
 };

package/lib/get-font-faces.js

@@ -1,34 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFontFaces = void 0;
-const constants_1 = require("./constants");
+import { FONT_FORMATS } from "./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}')`,
-    };
+  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}')`;
+  const faces = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const face = faces.get(getKey(asset));
+    const format = FONT_FORMATS.get(asset.format);
+    if (format === void 0) {
+      continue;
     }
-    return Array.from(faces.values());
+    if (face === void 0) {
+      const face2 = formatFace(asset, format);
+      faces.set(getKey(asset), face2);
+      continue;
+    }
+    face.src += `, url('${asset.path}') format('${format}')`;
+  }
+  return Array.from(faces.values());
+};
+export {
+  getFontFaces
 };
-exports.getFontFaces = getFontFaces;

package/lib/index.js

@@ -1,20 +1,4 @@
-"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);
+export * from "./constants";
+export * from "./get-font-faces";
+export * from "./schema";
+export * from "./font-weights";