@routevn/creator-model 1.3.4 → 1.3.7

package/package.json

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

package/src/model.js

@@ -211,6 +211,17 @@ const LAYOUT_TYPE_KEYS = [
 ];
 const LAYOUT_ELEMENT_TEXT_STYLE_ALIGN_KEYS = ["left", "center", "right"];
 const LAYOUT_TEXT_REVEAL_EFFECT_KEYS = ["typewriter", "softWipe", "none"];
+const CONTROL_KEYBOARD_KEYS = [
+  "enter",
+  "space",
+  "esc",
+  "ctrl",
+  "left",
+  "right",
+  "up",
+  "down",
+];
+const CONTROL_KEYBOARD_KEY_SET = new Set(CONTROL_KEYBOARD_KEYS);
 const LAYOUT_ELEMENT_BASE_TYPES = [
   "folder",
   "container",
@@ -1010,10 +1021,7 @@ const validateSpritesheetAnimationMap = ({
       );
     }
 
-    if (
-      animation.fps !== undefined &&
-      !isPositiveFiniteNumber(animation.fps)
-    ) {
+    if (animation.fps !== undefined && !isPositiveFiniteNumber(animation.fps)) {
       return invalidFromErrorFactory(
         errorFactory,
         `${animationPath}.fps must be a positive finite number when provided`,
@@ -2012,7 +2020,16 @@ const validateAnimationItems = ({ items, path, errorFactory }) => {
         allowedKeys:
           item.type === "folder"
             ? ["id", "type", "name", "description"]
-            : ["id", "type", "name", "description", "tagIds", "animation"],
+            : [
+                "id",
+                "type",
+                "name",
+                "description",
+                "tagIds",
+                "thumbnailFileId",
+                "preview",
+                "animation",
+              ],
         path: itemPath,
         errorFactory,
       });
@@ -2050,6 +2067,27 @@ const validateAnimationItems = ({ items, path, errorFactory }) => {
     }
 
     if (item.type === "animation") {
+      if (
+        item.thumbnailFileId !== undefined &&
+        !isNonEmptyString(item.thumbnailFileId)
+      ) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.thumbnailFileId must be a non-empty string when provided`,
+        );
+      }
+
+      {
+        const result = validatePreviewObject({
+          value: item.preview,
+          path: `${itemPath}.preview`,
+          errorFactory,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
       {
         const result = validateOptionalUniqueIdArray({
           value: item.tagIds,
@@ -2526,6 +2564,85 @@ const validateVariableTypedValue = ({
   }
 };
 
+const normalizeVariableEnumValues = (values = []) => {
+  const normalizedValues = Array.isArray(values) ? values : [];
+  const seen = new Set();
+  const result = [];
+
+  for (const value of normalizedValues) {
+    const stringValue = String(value ?? "").trim();
+    if (!stringValue || seen.has(stringValue)) {
+      continue;
+    }
+
+    seen.add(stringValue);
+    result.push(stringValue);
+  }
+
+  return result;
+};
+
+const validateVariableEnumValues = ({ value, path, errorFactory }) => {
+  if (value === undefined) {
+    return VALID_RESULT;
+  }
+
+  if (!Array.isArray(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be an array when provided`,
+    );
+  }
+
+  for (const [index, enumValue] of value.entries()) {
+    if (!isString(enumValue)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}[${index}] must be a string`,
+      );
+    }
+  }
+
+  return VALID_RESULT;
+};
+
+const validateVariableEnumMetadata = ({
+  data,
+  variableType,
+  path,
+  errorFactory,
+}) => {
+  if (data.isEnum !== undefined && typeof data.isEnum !== "boolean") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.isEnum must be a boolean when provided`,
+    );
+  }
+
+  {
+    const result = validateVariableEnumValues({
+      value: data.enumValues,
+      path: `${path}.enumValues`,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  if (
+    variableType !== "string" &&
+    (data.isEnum !== undefined || data.enumValues !== undefined)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.isEnum and ${path}.enumValues are only supported for string variables`,
+    );
+  }
+
+  return VALID_RESULT;
+};
+
 const validateVariableItems = ({ items, path, errorFactory }) => {
   for (const [itemId, item] of Object.entries(items)) {
     const itemPath = `${path}.${itemId}`;
@@ -2556,6 +2673,8 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
                 "scope",
                 "default",
                 "value",
+                "isEnum",
+                "enumValues",
               ],
         path: itemPath,
         errorFactory,
@@ -2606,6 +2725,18 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
         }
       }
 
+      {
+        const result = validateVariableEnumMetadata({
+          data: item,
+          variableType,
+          path: itemPath,
+          errorFactory,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
       if (!VARIABLE_SCOPE_KEYS.includes(item.scope)) {
         return invalidFromErrorFactory(
           errorFactory,
@@ -4261,6 +4392,44 @@ const applyCharacterUpdate = ({ currentItem, data }) => {
   return nextItem;
 };
 
+const applyVariableEnumMetadata = ({ item, data }) => {
+  if (!isPlainObject(item)) {
+    return item;
+  }
+
+  const enumEnabled =
+    item.type === "string" &&
+    data.isEnum !== false &&
+    (data.isEnum === true ||
+      data.enumValues !== undefined ||
+      (data.isEnum === undefined && item.isEnum === true));
+
+  if (!enumEnabled) {
+    delete item.isEnum;
+    delete item.enumValues;
+    return item;
+  }
+
+  item.isEnum = true;
+  item.enumValues = normalizeVariableEnumValues(
+    data.enumValues ?? item.enumValues,
+  );
+
+  return item;
+};
+
+const applyVariableUpdate = ({ currentItem, data }) => {
+  const nextItem = applyTagIdsUpdate({
+    currentItem,
+    data,
+  });
+
+  return applyVariableEnumMetadata({
+    item: nextItem,
+    data,
+  });
+};
+
 const stripDeletedTagIdsFromItem = ({ item, deletedTagIds }) => {
   if (!Array.isArray(item?.tagIds) || item.tagIds.length === 0) {
     return;
@@ -4512,6 +4681,13 @@ const validateKeyboardMap = ({ value, path, errorFactory }) => {
       );
     }
 
+    if (!CONTROL_KEYBOARD_KEY_SET.has(key)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.${key} must be one of: ${CONTROL_KEYBOARD_KEYS.map((value) => `'${value}'`).join(", ")}`,
+      );
+    }
+
     if (!isPlainObject(interaction)) {
       return invalidFromErrorFactory(
         errorFactory,
@@ -4697,6 +4873,7 @@ const validateControlItems = ({ items, path, errorFactory }) => {
                 "preview",
                 "elements",
                 "keyboard",
+                "keyup",
               ],
         path: itemPath,
         errorFactory,
@@ -4791,6 +4968,17 @@ const validateControlItems = ({ items, path, errorFactory }) => {
           return result;
         }
       }
+
+      {
+        const result = validateKeyboardMap({
+          value: item.keyup,
+          path: `${itemPath}.keyup`,
+          errorFactory,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
     }
   }
 };
@@ -6073,6 +6261,19 @@ export const assertInvariants = ({ state }) => {
       }
     }
 
+    if (animation.thumbnailFileId !== undefined) {
+      const fileResult = validateFileReference({
+        state,
+        fileId: animation.thumbnailFileId,
+        path: "animation.thumbnailFileId",
+        details: { animationId, thumbnailFileId: animation.thumbnailFileId },
+        errorFactory: createInvariantValidationError,
+      });
+      if (!fileResult.valid) {
+        return fileResult;
+      }
+    }
+
     const result = validateAnimationMaskImageReferences({
       state,
       animation: animation.animation,
@@ -8575,7 +8776,15 @@ const validateAnimationCreateData = ({ data, errorFactory }) => {
       allowedKeys:
         data.type === "folder"
           ? ["type", "name", "description"]
-          : ["type", "name", "description", "tagIds", "animation"],
+          : [
+              "type",
+              "name",
+              "description",
+              "tagIds",
+              "thumbnailFileId",
+              "preview",
+              "animation",
+            ],
       path: "payload.data",
       errorFactory,
     });
@@ -8599,6 +8808,27 @@ const validateAnimationCreateData = ({ data, errorFactory }) => {
   }
 
   if (data.type === "animation") {
+    if (
+      data.thumbnailFileId !== undefined &&
+      !isNonEmptyString(data.thumbnailFileId)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.thumbnailFileId must be a non-empty string when provided",
+      );
+    }
+
+    {
+      const result = validatePreviewObject({
+        value: data.preview,
+        path: "payload.data.preview",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
     {
       const result = validateOptionalUniqueIdArray({
         value: data.tagIds,
@@ -8627,7 +8857,14 @@ const validateAnimationUpdateData = ({ data, errorFactory }) => {
   {
     const result = validateAllowedKeys({
       value: data,
-      allowedKeys: ["name", "description", "tagIds", "animation"],
+      allowedKeys: [
+        "name",
+        "description",
+        "tagIds",
+        "thumbnailFileId",
+        "preview",
+        "animation",
+      ],
       path: "payload.data",
       errorFactory,
     });
@@ -8657,6 +8894,27 @@ const validateAnimationUpdateData = ({ data, errorFactory }) => {
     );
   }
 
+  if (
+    data.thumbnailFileId !== undefined &&
+    !isNonEmptyString(data.thumbnailFileId)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.thumbnailFileId must be a non-empty string when provided",
+    );
+  }
+
+  {
+    const result = validatePreviewObject({
+      value: data.preview,
+      path: "payload.data.preview",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
   {
     const result = validateOptionalUniqueIdArray({
       value: data.tagIds,
@@ -9097,6 +9355,8 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
               "scope",
               "default",
               "value",
+              "isEnum",
+              "enumValues",
             ],
       path: "payload.data",
       errorFactory,
@@ -9133,6 +9393,18 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
       }
     }
 
+    {
+      const result = validateVariableEnumMetadata({
+        data,
+        variableType: data.type,
+        path: "payload.data",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
     if (!VARIABLE_SCOPE_KEYS.includes(data.scope)) {
       return invalidFromErrorFactory(
         errorFactory,
@@ -9176,6 +9448,8 @@ const validateVariableUpdateData = ({ data, errorFactory }) => {
         "scope",
         "default",
         "value",
+        "isEnum",
+        "enumValues",
       ],
       path: "payload.data",
       errorFactory,
@@ -9206,6 +9480,24 @@ const validateVariableUpdateData = ({ data, errorFactory }) => {
     );
   }
 
+  if (data.isEnum !== undefined && typeof data.isEnum !== "boolean") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.isEnum must be a boolean when provided",
+    );
+  }
+
+  {
+    const result = validateVariableEnumValues({
+      value: data.enumValues,
+      path: "payload.data.enumValues",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
   if (data.scope !== undefined && !VARIABLE_SCOPE_KEYS.includes(data.scope)) {
     return invalidFromErrorFactory(
       errorFactory,
@@ -10054,6 +10346,7 @@ const validateControlCreateData = ({ data, errorFactory }) => {
               "preview",
               "elements",
               "keyboard",
+              "keyup",
             ],
       path: "payload.data",
       errorFactory,
@@ -10134,6 +10427,17 @@ const validateControlCreateData = ({ data, errorFactory }) => {
         return result;
       }
     }
+
+    {
+      const result = validateKeyboardMap({
+        value: data.keyup,
+        path: "payload.data.keyup",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
   }
 };
 
@@ -10146,6 +10450,7 @@ const validateControlUpdateData = ({ data, errorFactory }) => {
         "description",
         "tagIds",
         "keyboard",
+        "keyup",
         "thumbnailFileId",
         "preview",
       ],
@@ -10210,6 +10515,17 @@ const validateControlUpdateData = ({ data, errorFactory }) => {
     }
   }
 
+  {
+    const result = validateKeyboardMap({
+      value: data.keyup,
+      path: "payload.data.keyup",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
   {
     const result = validateOptionalUniqueIdArray({
       value: data.tagIds,
@@ -11278,6 +11594,22 @@ const findReferencedFileUsage = ({ state, fileId }) => {
     }
   }
 
+  for (const [animationId, animation] of Object.entries(
+    state.animations.items,
+  )) {
+    if (animation.type !== "animation") {
+      continue;
+    }
+
+    if (animation.thumbnailFileId === fileId) {
+      return {
+        kind: "animation",
+        field: "thumbnailFileId",
+        ownerId: animationId,
+      };
+    }
+  }
+
   for (const [characterId, character] of Object.entries(
     state.characters.items,
   )) {
@@ -14237,6 +14569,16 @@ const COMMAND_DEFINITIONS = [
           return result;
         }
 
+        const fileResult = validateReferencedFilesInData({
+          state,
+          data: payload.data,
+          fields: ["thumbnailFileId"],
+          details: { animationId: payload.animationId },
+        });
+        if (!fileResult.valid) {
+          return fileResult;
+        }
+
         return validateTagIdsAgainstScope({
           state,
           tagIds: payload.data.tagIds,
@@ -14264,6 +14606,12 @@ const COMMAND_DEFINITIONS = [
           target: nextAnimation,
           tagIds: payload.data.tagIds,
         });
+        if (payload.data.thumbnailFileId !== undefined) {
+          nextAnimation.thumbnailFileId = payload.data.thumbnailFileId;
+        }
+        if (payload.data.preview !== undefined) {
+          nextAnimation.preview = structuredClone(payload.data.preview);
+        }
         nextAnimation.animation = structuredClone(payload.data.animation);
       }
 
@@ -14346,6 +14694,16 @@ const COMMAND_DEFINITIONS = [
           }
         }
 
+        const fileResult = validateReferencedFilesInData({
+          state,
+          data: payload.data,
+          fields: ["thumbnailFileId"],
+          details: { animationId: payload.animationId },
+        });
+        if (!fileResult.valid) {
+          return fileResult;
+        }
+
         return validateTagIdsAgainstScope({
           state,
           tagIds: payload.data.tagIds,
@@ -15614,13 +15972,16 @@ const COMMAND_DEFINITIONS = [
         delete data.tagIds;
       }
 
-      return {
-        id: payload.variableId,
-        ...data,
-      };
+      return applyVariableEnumMetadata({
+        item: {
+          id: payload.variableId,
+          ...data,
+        },
+        data,
+      });
     },
     updateItem: ({ currentItem, payload }) =>
-      applyTagIdsUpdate({
+      applyVariableUpdate({
         currentItem,
         data: payload.data,
       }),
@@ -15651,6 +16012,16 @@ const COMMAND_DEFINITIONS = [
         );
       }
 
+      if (
+        currentItem.type !== "string" &&
+        (payload.data.isEnum !== undefined ||
+          payload.data.enumValues !== undefined)
+      ) {
+        return invalidPrecondition(
+          "variable enum fields can only update string variables",
+        );
+      }
+
       if (currentItem.type !== "folder") {
         {
           const result = validateTagIdsAgainstScope({