@routevn/creator-model 1.10.3 → 1.10.4

package/README.md

@@ -106,6 +106,35 @@ Design rules:
 - random ids across RouteVN should use `nanoid` with the RouteVN base58 variant;
   deterministic derived tokens such as partition hashes are a separate case
 
+## Font Weight Metadata
+
+Font resources may store extracted weight capabilities in three flat fields:
+
+```js
+{
+  minWeight: 100,
+  defaultWeight: 400,
+  maxWeight: 900,
+}
+```
+
+The fields are optional for compatibility with existing font resources. When
+one is present, all three are required and must satisfy
+`1 <= minWeight <= defaultWeight <= maxWeight <= 1000`. Static fonts store the
+same value in all three fields; variable fonts store their `fvar` `wght` axis
+range and default.
+
+## Text Style Font References
+
+`textStyle.fontId` accepts either one font ID or a non-empty array of unique
+font IDs. Both forms are persisted as supplied, and every ID must reference an
+existing non-folder font:
+
+```js
+{ fontId: "font-primary" }
+{ fontId: ["font-primary", "font-fallback"] }
+```
+
 ## File Structure
 
 ```text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routevn/creator-model",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "private": false,
   "type": "module",
   "license": "MIT",

package/src/model.js

@@ -42,6 +42,7 @@ const LINE_UPDATE_ACTIONS_PRESERVE_PATHS_SET = new Set(
   LINE_UPDATE_ACTIONS_PRESERVE_PATHS,
 );
 const CURRENT_LAYOUT_SCHEMA_VERSION = 2;
+const FONT_WEIGHT_KEYS = ["minWeight", "defaultWeight", "maxWeight"];
 const isPositiveFiniteNumber = (value) => isFiniteNumber(value) && value > 0;
 const normalizeLayoutSchemaVersion = (value) =>
   Number.isInteger(value) && value >= 1 ? value : 1;
@@ -2388,6 +2389,41 @@ const validateAnimationItems = ({ items, path, errorFactory }) => {
   }
 };
 
+const validateFontWeightFields = ({ value, path, errorFactory }) => {
+  const presentKeys = FONT_WEIGHT_KEYS.filter((key) =>
+    Object.hasOwn(value, key),
+  );
+  if (presentKeys.length === 0) {
+    return;
+  }
+
+  if (presentKeys.length !== FONT_WEIGHT_KEYS.length) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must include minWeight, defaultWeight, and maxWeight together`,
+    );
+  }
+
+  for (const key of FONT_WEIGHT_KEYS) {
+    if (!isFiniteNumber(value[key]) || value[key] < 1 || value[key] > 1000) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.${key} must be a finite number between 1 and 1000`,
+      );
+    }
+  }
+
+  if (
+    value.minWeight > value.defaultWeight ||
+    value.defaultWeight > value.maxWeight
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must satisfy minWeight <= defaultWeight <= maxWeight`,
+    );
+  }
+};
+
 const validateFontItems = ({ items, path, errorFactory }) => {
   for (const [itemId, item] of Object.entries(items)) {
     const itemPath = `${path}.${itemId}`;
@@ -2413,6 +2449,7 @@ const validateFontItems = ({ items, path, errorFactory }) => {
                 "tagIds",
                 "fileId",
                 "fontFamily",
+                ...FONT_WEIGHT_KEYS,
               ],
         path: itemPath,
         errorFactory,
@@ -2476,6 +2513,17 @@ const validateFontItems = ({ items, path, errorFactory }) => {
           `${itemPath}.fontFamily must be a non-empty string`,
         );
       }
+
+      {
+        const result = validateFontWeightFields({
+          value: item,
+          path: itemPath,
+          errorFactory,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
     }
   }
 };
@@ -3216,11 +3264,15 @@ const validateTextStyleItems = ({ items, path, errorFactory }) => {
         }
       }
 
-      if (!isNonEmptyString(item.fontId)) {
-        return invalidFromErrorFactory(
+      {
+        const result = validateRequiredStringOrUniqueIdArray({
+          value: item.fontId,
+          path: `${itemPath}.fontId`,
           errorFactory,
-          `${itemPath}.fontId must be a non-empty string`,
-        );
+        });
+        if (result?.valid === false) {
+          return result;
+        }
       }
 
       if (!isNonEmptyString(item.colorId)) {
@@ -7192,15 +7244,17 @@ export const assertInvariants = ({ state }) => {
       continue;
     }
 
-    const font = state.fonts.items[textStyle.fontId];
-    if (!isPlainObject(font) || font.type === "folder") {
-      return invalidInvariant(
-        "textStyle.fontId must reference an existing non-folder font",
-        {
-          textStyleId,
-          fontId: textStyle.fontId,
-        },
-      );
+    for (const fontId of toIdArray(textStyle.fontId)) {
+      const font = state.fonts.items[fontId];
+      if (!isPlainObject(font) || font.type === "folder") {
+        return invalidInvariant(
+          "textStyle.fontId must reference an existing non-folder font",
+          {
+            textStyleId,
+            fontId,
+          },
+        );
+      }
     }
 
     const color = state.colors.items[textStyle.colorId];
@@ -8689,6 +8743,27 @@ const validateRequiredUniqueIdArray = ({ value, path, errorFactory }) => {
   }
 };
 
+const validateRequiredStringOrUniqueIdArray = ({
+  value,
+  path,
+  errorFactory,
+}) => {
+  if (isNonEmptyString(value)) {
+    return VALID_RESULT;
+  }
+
+  if (!Array.isArray(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be a non-empty string or a non-empty array of strings`,
+    );
+  }
+
+  return validateRequiredUniqueIdArray({ value, path, errorFactory });
+};
+
+const toIdArray = (value) => (Array.isArray(value) ? value : [value]);
+
 const validateOptionalUniqueIdArray = ({
   value,
   path,
@@ -9978,7 +10053,15 @@ const validateFontCreateData = ({ data, errorFactory }) => {
       allowedKeys:
         data.type === "folder"
           ? ["type", "name", "description"]
-          : ["type", "name", "description", "tagIds", "fileId", "fontFamily"],
+          : [
+              "type",
+              "name",
+              "description",
+              "tagIds",
+              "fileId",
+              "fontFamily",
+              ...FONT_WEIGHT_KEYS,
+            ],
       path: "payload.data",
       errorFactory,
     });
@@ -10026,6 +10109,17 @@ const validateFontCreateData = ({ data, errorFactory }) => {
         "payload.data.fontFamily must be a non-empty string",
       );
     }
+
+    {
+      const result = validateFontWeightFields({
+        value: data,
+        path: "payload.data",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
   }
 };
 
@@ -10033,7 +10127,14 @@ const validateFontUpdateData = ({ data, errorFactory }) => {
   {
     const result = validateAllowedKeys({
       value: data,
-      allowedKeys: ["name", "description", "tagIds", "fileId", "fontFamily"],
+      allowedKeys: [
+        "name",
+        "description",
+        "tagIds",
+        "fileId",
+        "fontFamily",
+        ...FONT_WEIGHT_KEYS,
+      ],
       path: "payload.data",
       errorFactory,
     });
@@ -10087,6 +10188,17 @@ const validateFontUpdateData = ({ data, errorFactory }) => {
       "payload.data.fontFamily must be a non-empty string when provided",
     );
   }
+
+  {
+    const result = validateFontWeightFields({
+      value: data,
+      path: "payload.data",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
 };
 
 const validateFileCreateData = ({ data, errorFactory }) => {
@@ -11283,7 +11395,18 @@ const validateTextStyleUpdateData = ({ data, errorFactory }) => {
     }
   }
 
-  for (const key of ["fontId", "colorId", "strokeColorId"]) {
+  if (data.fontId !== undefined) {
+    const result = validateRequiredStringOrUniqueIdArray({
+      value: data.fontId,
+      path: "payload.data.fontId",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  for (const key of ["colorId", "strokeColorId"]) {
     if (data[key] !== undefined && !isNonEmptyString(data[key])) {
       return invalidFromErrorFactory(
         errorFactory,
@@ -17421,6 +17544,11 @@ const COMMAND_DEFINITIONS = [
         });
         nextFont.fileId = payload.data.fileId;
         nextFont.fontFamily = payload.data.fontFamily;
+        for (const key of FONT_WEIGHT_KEYS) {
+          if (payload.data[key] !== undefined) {
+            nextFont[key] = payload.data[key];
+          }
+        }
       }
 
       state.fonts.items[payload.fontId] = nextFont;
@@ -17481,7 +17609,8 @@ const COMMAND_DEFINITIONS = [
         currentFont.type === "folder" &&
         (payload.data.tagIds !== undefined ||
           payload.data.fileId !== undefined ||
-          payload.data.fontFamily !== undefined)
+          payload.data.fontFamily !== undefined ||
+          FONT_WEIGHT_KEYS.some((key) => payload.data[key] !== undefined))
       ) {
         return invalidPrecondition(
           "folder font items cannot update font fields",
@@ -18531,16 +18660,24 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      for (const field of ["fontId", "colorId", "strokeColorId"]) {
+      for (const fontId of toIdArray(data.fontId)) {
+        const item = state.fonts.items[fontId];
+        if (!isPlainObject(item) || item.type === "folder") {
+          return invalidPrecondition(
+            "payload.data.fontId must reference an existing non-folder font",
+          );
+        }
+      }
+
+      for (const field of ["colorId", "strokeColorId"]) {
         if (data[field] === undefined) {
           continue;
         }
 
-        const collectionKey = field === "fontId" ? "fonts" : "colors";
-        const item = state[collectionKey].items[data[field]];
+        const item = state.colors.items[data[field]];
         if (!isPlainObject(item) || item.type === "folder") {
           return invalidPrecondition(
-            `payload.data.${field} must reference an existing non-folder ${collectionKey.slice(0, -1)}`,
+            `payload.data.${field} must reference an existing non-folder color`,
           );
         }
       }
@@ -18583,16 +18720,26 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      for (const field of ["fontId", "colorId", "strokeColorId"]) {
+      if (payload.data.fontId !== undefined) {
+        for (const fontId of toIdArray(payload.data.fontId)) {
+          const item = state.fonts.items[fontId];
+          if (!isPlainObject(item) || item.type === "folder") {
+            return invalidPrecondition(
+              "payload.data.fontId must reference an existing non-folder font",
+            );
+          }
+        }
+      }
+
+      for (const field of ["colorId", "strokeColorId"]) {
         if (payload.data[field] === undefined) {
           continue;
         }
 
-        const collectionKey = field === "fontId" ? "fonts" : "colors";
-        const item = state[collectionKey].items[payload.data[field]];
+        const item = state.colors.items[payload.data[field]];
         if (!isPlainObject(item) || item.type === "folder") {
           return invalidPrecondition(
-            `payload.data.${field} must reference an existing non-folder ${collectionKey.slice(0, -1)}`,
+            `payload.data.${field} must reference an existing non-folder color`,
           );
         }
       }