@webstudio-is/fonts 0.289.0 → 0.291.0

package/lib/index.js

@@ -251,58 +251,75 @@ var getFontFormat = (asset) => {
   const extension = asset.name.slice(asset.name.lastIndexOf(".") + 1);
   return FONT_FORMATS.has(extension) ? FONT_FORMATS.get(extension) ?? asset.format : FONT_FORMATS.get(asset.format) ?? asset.format;
 };
-var formatFace = (asset, format, url) => {
+var formatFace = ({ asset, format, style, url }) => {
+  const face = {
+    fontFamily: asset.meta.family,
+    fontStyle: style,
+    fontDisplay: "swap",
+    src: `url(${sanitizeCssUrl(url)}) format("${format}")`
+  };
   if ("variationAxes" in asset.meta) {
-    const { wght, wdth } = asset.meta?.variationAxes ?? {};
+    const { wght, wdth } = asset.meta.variationAxes;
     return {
-      fontFamily: asset.meta.family,
-      fontStyle: "normal",
-      fontDisplay: "swap",
-      src: `url(${sanitizeCssUrl(url)}) format("${format}")`,
+      ...face,
       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(${sanitizeCssUrl(url)}) format("${format}")`
+    ...face,
+    fontWeight: asset.meta.weight
   };
 };
-var getKey = (asset) => {
+var getKey = (asset, style) => {
   if ("variationAxes" in asset.meta) {
-    return asset.meta.family + Object.values(asset.meta.variationAxes).join("");
+    const { wght, wdth } = asset.meta.variationAxes;
+    return JSON.stringify([asset.meta.family, style, wght, wdth]);
+  }
+  return JSON.stringify([asset.meta.family, style, asset.meta.weight]);
+};
+var getStyles = (meta) => {
+  const styles = /* @__PURE__ */ new Set([meta.style]);
+  if ("variationAxes" in meta) {
+    const { ital, slnt } = meta.variationAxes;
+    if (ital !== void 0 && ital.min <= 0 && ital.max >= 1) {
+      styles.add("normal");
+      styles.add("italic");
+    }
+    if (slnt !== void 0 && slnt.min < slnt.max && slnt.min <= 0 && slnt.max >= 0) {
+      styles.add("normal");
+      styles.add("oblique");
+    }
   }
-  return asset.meta.family + asset.meta.style + asset.meta.weight;
+  return Array.from(styles);
 };
 var getFontFaces = (assets, options) => {
   const { assetBaseUrl } = options;
   const faces = /* @__PURE__ */ new Map();
-  const seenUrls = /* @__PURE__ */ new Set();
+  const seenSources = /* @__PURE__ */ new Set();
   for (const asset of assets) {
     const url = `${assetBaseUrl}${asset.name}`;
-    const assetKey = getKey(asset);
-    if (seenUrls.has(url)) {
-      continue;
+    for (const style of getStyles(asset.meta)) {
+      const sourceKey = JSON.stringify([url, style]);
+      if (seenSources.has(sourceKey)) {
+        continue;
+      }
+      seenSources.add(sourceKey);
+      const assetKey = getKey(asset, style);
+      const format = getFontFormat(asset);
+      const sources = faces.get(assetKey) ?? /* @__PURE__ */ new Map();
+      const existing = sources.get(format);
+      if (existing === void 0 || url < existing.url) {
+        sources.set(format, { asset, format, style, url });
+      }
+      faces.set(assetKey, sources);
     }
-    seenUrls.add(url);
-    const format = getFontFormat(asset);
-    const sources = faces.get(assetKey) ?? /* @__PURE__ */ new Map();
-    const existing = sources.get(format);
-    if (existing === void 0 || url < existing.url) {
-      sources.set(format, { asset, format, url });
-    }
-    faces.set(assetKey, sources);
   }
   return Array.from(faces.values(), (sources) => {
-    const [{ asset, format, url }, ...fallbacks] = Array.from(
-      sources.values()
-    ).sort(
+    const [source, ...fallbacks] = Array.from(sources.values()).sort(
       (left, right) => fontFormatOrder.indexOf(left.format) - fontFormatOrder.indexOf(right.format)
     );
-    const face = formatFace(asset, format, url);
+    const face = formatFace(source);
     face.src += fallbacks.map(
       ({ format: fallbackFormat, url: fallbackUrl }) => `, url(${sanitizeCssUrl(fallbackUrl)}) format("${fallbackFormat}")`
     ).join("");
@@ -312,27 +329,13 @@ var getFontFaces = (assets, options) => {
 
 // src/schema.ts
 import { z } from "zod";
+var fontStyle = z.enum(FONT_STYLES);
 var fontFormat = z.union([
   z.literal("ttf"),
   z.literal("woff"),
   z.literal("woff2")
 ]);
-var axisName = z.enum([
-  "wght",
-  "wdth",
-  "slnt",
-  "opsz",
-  "ital",
-  "GRAD",
-  "XTRA",
-  "XOPQ",
-  "YOPQ",
-  "YTLC",
-  "YTUC",
-  "YTAS",
-  "YTDE",
-  "YTFI"
-]);
+var axisName = z.string().regex(/^[A-Za-z][A-Za-z0-9]* *$/).length(4);
 var variationAxes = z.partialRecord(
   axisName,
   z.object({
@@ -344,18 +347,46 @@ var variationAxes = z.partialRecord(
 );
 var fontMetaStatic = z.object({
   family: z.string(),
-  style: z.enum(FONT_STYLES),
+  style: fontStyle,
   weight: z.number()
 });
 var fontMetaVariable = z.object({
   family: z.string(),
+  style: fontStyle.default("normal"),
   variationAxes
 });
 var fontMeta = z.union([fontMetaStatic, fontMetaVariable]);
 var fontMetaUpdate = z.union([
   fontMetaStatic.partial().strict(),
-  fontMetaVariable.partial().strict()
+  z.object({
+    family: fontMetaVariable.shape.family.optional(),
+    style: fontStyle.optional(),
+    variationAxes: fontMetaVariable.shape.variationAxes.optional()
+  }).strict()
 ]);
+var mergeFontMeta = (current, override) => {
+  const result = fontMetaUpdate.safeParse(override);
+  if (result.success === false) {
+    return;
+  }
+  const { family, style } = result.data;
+  if ("variationAxes" in current) {
+    const variationAxes2 = "variationAxes" in result.data ? result.data.variationAxes : void 0;
+    return {
+      ...current,
+      ...family === void 0 ? {} : { family },
+      ...style === void 0 ? {} : { style },
+      ...variationAxes2 === void 0 ? {} : { variationAxes: variationAxes2 }
+    };
+  }
+  const weight = "weight" in result.data ? result.data.weight : void 0;
+  return {
+    ...current,
+    ...family === void 0 ? {} : { family },
+    ...style === void 0 ? {} : { style },
+    ...weight === void 0 ? {} : { weight }
+  };
+};
 
 // src/font-weights.ts
 var fontWeights = {
@@ -415,5 +446,6 @@ export {
   fontMetaVariable,
   fontWeightNames,
   fontWeights,
-  getFontFaces
+  getFontFaces,
+  mergeFontMeta
 };

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

@@ -1,4 +1,5 @@
-import type { FontMeta, FontFormat, FontMetaStatic } from "./schema";
+import { type FontStyle } from "./constants";
+import type { FontMeta, FontFormat } from "./schema";
 export type PartialFontAsset = {
     format: FontFormat;
     meta: FontMeta;
@@ -8,7 +9,7 @@ export type FontFace = {
     fontFamily: string;
     fontDisplay: "swap" | "auto" | "block" | "fallback" | "optional";
     src: string;
-    fontStyle?: FontMetaStatic["style"];
+    fontStyle?: FontStyle;
     fontWeight?: number | string;
     fontStretch?: string;
 };

package/lib/types/schema.d.ts

@@ -1,22 +1,7 @@
 import { z } from "zod";
 export declare const fontFormat: z.ZodUnion<readonly [z.ZodLiteral<"ttf">, z.ZodLiteral<"woff">, z.ZodLiteral<"woff2">]>;
 export type FontFormat = z.infer<typeof fontFormat>;
-declare const variationAxes: z.ZodRecord<z.ZodEnum<{
-    GRAD: "GRAD";
-    XOPQ: "XOPQ";
-    XTRA: "XTRA";
-    YOPQ: "YOPQ";
-    YTAS: "YTAS";
-    YTDE: "YTDE";
-    YTFI: "YTFI";
-    YTLC: "YTLC";
-    YTUC: "YTUC";
-    ital: "ital";
-    opsz: "opsz";
-    slnt: "slnt";
-    wdth: "wdth";
-    wght: "wght";
-}> & z.core.$partial, z.ZodObject<{
+declare const variationAxes: z.ZodRecord<z.ZodString & z.core.$partial, z.ZodObject<{
     name: z.ZodString;
     min: z.ZodNumber;
     default: z.ZodNumber;
@@ -35,22 +20,12 @@ export declare const fontMetaStatic: z.ZodObject<{
 export type FontMetaStatic = z.infer<typeof fontMetaStatic>;
 export declare const fontMetaVariable: z.ZodObject<{
     family: z.ZodString;
-    variationAxes: z.ZodRecord<z.ZodEnum<{
-        GRAD: "GRAD";
-        XOPQ: "XOPQ";
-        XTRA: "XTRA";
-        YOPQ: "YOPQ";
-        YTAS: "YTAS";
-        YTDE: "YTDE";
-        YTFI: "YTFI";
-        YTLC: "YTLC";
-        YTUC: "YTUC";
-        ital: "ital";
-        opsz: "opsz";
-        slnt: "slnt";
-        wdth: "wdth";
-        wght: "wght";
-    }> & z.core.$partial, z.ZodObject<{
+    style: z.ZodDefault<z.ZodEnum<{
+        italic: "italic";
+        normal: "normal";
+        oblique: "oblique";
+    }>>;
+    variationAxes: z.ZodRecord<z.ZodString & z.core.$partial, z.ZodObject<{
         name: z.ZodString;
         min: z.ZodNumber;
         default: z.ZodNumber;
@@ -67,22 +42,12 @@ export declare const fontMeta: z.ZodUnion<readonly [z.ZodObject<{
     weight: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     family: z.ZodString;
-    variationAxes: z.ZodRecord<z.ZodEnum<{
-        GRAD: "GRAD";
-        XOPQ: "XOPQ";
-        XTRA: "XTRA";
-        YOPQ: "YOPQ";
-        YTAS: "YTAS";
-        YTDE: "YTDE";
-        YTFI: "YTFI";
-        YTLC: "YTLC";
-        YTUC: "YTUC";
-        ital: "ital";
-        opsz: "opsz";
-        slnt: "slnt";
-        wdth: "wdth";
-        wght: "wght";
-    }> & z.core.$partial, z.ZodObject<{
+    style: z.ZodDefault<z.ZodEnum<{
+        italic: "italic";
+        normal: "normal";
+        oblique: "oblique";
+    }>>;
+    variationAxes: z.ZodRecord<z.ZodString & z.core.$partial, z.ZodObject<{
         name: z.ZodString;
         min: z.ZodNumber;
         default: z.ZodNumber;
@@ -99,22 +64,12 @@ export declare const fontMetaUpdate: z.ZodUnion<readonly [z.ZodObject<{
     weight: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     family: z.ZodOptional<z.ZodString>;
-    variationAxes: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
-        GRAD: "GRAD";
-        XOPQ: "XOPQ";
-        XTRA: "XTRA";
-        YOPQ: "YOPQ";
-        YTAS: "YTAS";
-        YTDE: "YTDE";
-        YTFI: "YTFI";
-        YTLC: "YTLC";
-        YTUC: "YTUC";
-        ital: "ital";
-        opsz: "opsz";
-        slnt: "slnt";
-        wdth: "wdth";
-        wght: "wght";
-    }> & z.core.$partial, z.ZodObject<{
+    style: z.ZodOptional<z.ZodEnum<{
+        italic: "italic";
+        normal: "normal";
+        oblique: "oblique";
+    }>>;
+    variationAxes: z.ZodOptional<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodObject<{
         name: z.ZodString;
         min: z.ZodNumber;
         default: z.ZodNumber;
@@ -122,4 +77,5 @@ export declare const fontMetaUpdate: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strict>]>;
 export type FontMeta = z.infer<typeof fontMeta>;
+export declare const mergeFontMeta: (current: FontMeta, override: unknown) => FontMeta | undefined;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webstudio-is/fonts",
-  "version": "0.289.0",
+  "version": "0.291.0",
   "description": "Fonts utils",
   "author": "Webstudio <github@webstudio.is>",
   "homepage": "https://webstudio.is",