@routevn/creator-model 1.3.5 → 1.4.0

package/package.json

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

package/src/model.js

@@ -249,7 +249,7 @@ const LAYOUT_ELEMENT_BASE_TYPES = [
   "container-ref-confirm-dialog-ok",
   "container-ref-confirm-dialog-cancel",
 ];
-export const SCHEMA_VERSION = 3;
+export const SCHEMA_VERSION = 4;
 const LAYOUT_CONTAINER_ELEMENT_TYPES = [
   "folder",
   "container",
@@ -2020,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,
       });
@@ -2058,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,
@@ -2283,6 +2313,9 @@ const validateTransformItems = ({ items, path, errorFactory }) => {
                 "anchorX",
                 "anchorY",
                 "rotation",
+                "thumbnailFileId",
+                "previewFileId",
+                "preview",
               ],
         path: itemPath,
         errorFactory,
@@ -2321,6 +2354,27 @@ const validateTransformItems = ({ items, path, errorFactory }) => {
     }
 
     if (item.type === "transform") {
+      for (const fieldName of ["thumbnailFileId", "previewFileId"]) {
+        const fileId = item[fieldName];
+        if (fileId !== undefined && !isNonEmptyString(fileId)) {
+          return invalidFromErrorFactory(
+            errorFactory,
+            `${itemPath}.${fieldName} must be a non-empty string when provided`,
+          );
+        }
+      }
+
+      {
+        const result = validateTransformPreviewObject({
+          value: item.preview,
+          path: `${itemPath}.preview`,
+          errorFactory,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
       {
         const result = validateOptionalUniqueIdArray({
           value: item.tagIds,
@@ -2534,18 +2588,95 @@ 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}`;
-    const variableType = item?.type;
+    const itemType = item?.type;
+    const variableType = item?.variableType;
 
-    if (
-      variableType !== "folder" &&
-      !VARIABLE_TYPE_KEYS.includes(variableType)
-    ) {
+    if (itemType !== "folder" && itemType !== "variable") {
       return invalidFromErrorFactory(
         errorFactory,
-        `${itemPath}.type must be 'folder', 'string', 'number', or 'boolean'`,
+        `${itemPath}.type must be 'folder' or 'variable'`,
       );
     }
 
@@ -2553,17 +2684,20 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
       const result = validateAllowedKeys({
         value: item,
         allowedKeys:
-          variableType === "folder"
+          itemType === "folder"
             ? ["id", "type", "name", "description"]
             : [
                 "id",
                 "type",
+                "variableType",
                 "name",
                 "description",
                 "tagIds",
                 "scope",
                 "default",
                 "value",
+                "isEnum",
+                "enumValues",
               ],
         path: itemPath,
         errorFactory,
@@ -2601,7 +2735,14 @@ const validateVariableItems = ({ items, path, errorFactory }) => {
       );
     }
 
-    if (variableType !== "folder") {
+    if (itemType === "variable") {
+      if (!VARIABLE_TYPE_KEYS.includes(variableType)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.variableType must be 'string', 'number', or 'boolean'`,
+        );
+      }
+
       {
         const result = validateOptionalUniqueIdArray({
           value: item.tagIds,
@@ -2614,6 +2755,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,
@@ -4269,6 +4422,44 @@ const applyCharacterUpdate = ({ currentItem, data }) => {
   return nextItem;
 };
 
+const applyVariableEnumMetadata = ({ item, data }) => {
+  if (!isPlainObject(item)) {
+    return item;
+  }
+
+  const enumEnabled =
+    item.variableType === "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;
@@ -4553,6 +4744,78 @@ const validatePreviewObject = ({ value, path, errorFactory }) => {
   return VALID_RESULT;
 };
 
+const validateTransformPreviewSlot = ({ value, path, errorFactory }) => {
+  if (value === undefined) {
+    return VALID_RESULT;
+  }
+
+  if (!isPlainObject(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be an object when provided`,
+    );
+  }
+
+  {
+    const result = validateAllowedKeys({
+      value,
+      allowedKeys: ["imageId"],
+      path,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  if (value.imageId !== undefined && !isNonEmptyString(value.imageId)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.imageId must be a non-empty string when provided`,
+    );
+  }
+
+  return VALID_RESULT;
+};
+
+const validateTransformPreviewObject = ({ value, path, errorFactory }) => {
+  if (value === undefined) {
+    return VALID_RESULT;
+  }
+
+  if (!isPlainObject(value)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be an object when provided`,
+    );
+  }
+
+  {
+    const result = validateAllowedKeys({
+      value,
+      allowedKeys: ["background", "target"],
+      path,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  for (const key of ["background", "target"]) {
+    const result = validateTransformPreviewSlot({
+      value: value[key],
+      path: `${path}.${key}`,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  return VALID_RESULT;
+};
+
 const validateLayoutItems = ({ items, path, errorFactory }) => {
   for (const [itemId, item] of Object.entries(items)) {
     const itemPath = `${path}.${itemId}`;
@@ -5731,6 +5994,38 @@ const validateAnimationMaskImageReferences = ({
   return VALID_RESULT;
 };
 
+const validateTransformPreviewImageReferences = ({
+  state,
+  preview,
+  path,
+  details = {},
+  errorFactory = createPreconditionValidationError,
+}) => {
+  if (!isPlainObject(preview)) {
+    return VALID_RESULT;
+  }
+
+  for (const slotKey of ["background", "target"]) {
+    const imageId = preview[slotKey]?.imageId;
+    const result = validateImageReference({
+      state,
+      imageId,
+      path: `${path}.${slotKey}.imageId`,
+      details: {
+        ...details,
+        slot: slotKey,
+        imageId,
+      },
+      errorFactory,
+    });
+    if (!result.valid) {
+      return result;
+    }
+  }
+
+  return VALID_RESULT;
+};
+
 export const assertInvariants = ({ state }) => {
   if (!isPlainObject(state)) {
     return invalidInvariant("state must be an object");
@@ -6100,6 +6395,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,
@@ -6227,6 +6535,42 @@ export const assertInvariants = ({ state }) => {
       continue;
     }
 
+    for (const fieldName of ["thumbnailFileId", "previewFileId"]) {
+      const fileId = transform[fieldName];
+      if (fileId === undefined) {
+        continue;
+      }
+
+      const fileResult = validateFileReference({
+        state,
+        fileId,
+        path: `transform.${fieldName}`,
+        details: {
+          transformId,
+          [fieldName]: fileId,
+        },
+        errorFactory: createInvariantValidationError,
+      });
+      if (!fileResult.valid) {
+        return fileResult;
+      }
+    }
+
+    {
+      const previewResult = validateTransformPreviewImageReferences({
+        state,
+        preview: transform.preview,
+        path: "transform.preview",
+        details: {
+          transformId,
+        },
+        errorFactory: createInvariantValidationError,
+      });
+      if (!previewResult.valid) {
+        return previewResult;
+      }
+    }
+
     {
       const result = validateTagIdsAgainstScope({
         state,
@@ -8602,7 +8946,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,
     });
@@ -8626,6 +8978,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,
@@ -8654,7 +9027,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,
     });
@@ -8684,6 +9064,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,
@@ -8742,6 +9143,9 @@ const validateTransformCreateData = ({ data, errorFactory }) => {
               "anchorX",
               "anchorY",
               "rotation",
+              "thumbnailFileId",
+              "previewFileId",
+              "preview",
             ],
       path: "payload.data",
       errorFactory,
@@ -8766,6 +9170,27 @@ const validateTransformCreateData = ({ data, errorFactory }) => {
   }
 
   if (data.type === "transform") {
+    for (const fieldName of ["thumbnailFileId", "previewFileId"]) {
+      const fileId = data[fieldName];
+      if (fileId !== undefined && !isNonEmptyString(fileId)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `payload.data.${fieldName} must be a non-empty string when provided`,
+        );
+      }
+    }
+
+    {
+      const result = validateTransformPreviewObject({
+        value: data.preview,
+        path: "payload.data.preview",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
     {
       const result = validateOptionalUniqueIdArray({
         value: data.tagIds,
@@ -9036,6 +9461,9 @@ const validateTransformUpdateData = ({ data, errorFactory }) => {
         "anchorX",
         "anchorY",
         "rotation",
+        "thumbnailFileId",
+        "previewFileId",
+        "preview",
       ],
       path: "payload.data",
       errorFactory,
@@ -9066,6 +9494,27 @@ const validateTransformUpdateData = ({ data, errorFactory }) => {
     );
   }
 
+  for (const fieldName of ["thumbnailFileId", "previewFileId"]) {
+    const fileId = data[fieldName];
+    if (fileId !== undefined && !isNonEmptyString(fileId)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `payload.data.${fieldName} must be a non-empty string when provided`,
+      );
+    }
+  }
+
+  {
+    const result = validateTransformPreviewObject({
+      value: data.preview,
+      path: "payload.data.preview",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
   {
     const result = validateOptionalUniqueIdArray({
       value: data.tagIds,
@@ -9103,10 +9552,10 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     );
   }
 
-  if (data.type !== "folder" && !VARIABLE_TYPE_KEYS.includes(data.type)) {
+  if (data.type !== "folder" && data.type !== "variable") {
     return invalidFromErrorFactory(
       errorFactory,
-      "payload.data.type must be 'folder', 'string', 'number', or 'boolean'",
+      "payload.data.type must be 'folder' or 'variable'",
     );
   }
 
@@ -9118,12 +9567,15 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
           ? ["type", "name", "description"]
           : [
               "type",
+              "variableType",
               "name",
               "description",
               "tagIds",
               "scope",
               "default",
               "value",
+              "isEnum",
+              "enumValues",
             ],
       path: "payload.data",
       errorFactory,
@@ -9147,7 +9599,14 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     );
   }
 
-  if (data.type !== "folder") {
+  if (data.type === "variable") {
+    if (!VARIABLE_TYPE_KEYS.includes(data.variableType)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.variableType must be 'string', 'number', or 'boolean'",
+      );
+    }
+
     {
       const result = validateOptionalUniqueIdArray({
         value: data.tagIds,
@@ -9160,6 +9619,18 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
       }
     }
 
+    {
+      const result = validateVariableEnumMetadata({
+        data,
+        variableType: data.variableType,
+        path: "payload.data",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
     if (!VARIABLE_SCOPE_KEYS.includes(data.scope)) {
       return invalidFromErrorFactory(
         errorFactory,
@@ -9170,7 +9641,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     {
       const result = validateVariableTypedValue({
         value: data.default,
-        variableType: data.type,
+        variableType: data.variableType,
         path: "payload.data.default",
         errorFactory,
       });
@@ -9181,7 +9652,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     {
       const result = validateVariableTypedValue({
         value: data.value,
-        variableType: data.type,
+        variableType: data.variableType,
         path: "payload.data.value",
         errorFactory,
       });
@@ -9203,6 +9674,8 @@ const validateVariableUpdateData = ({ data, errorFactory }) => {
         "scope",
         "default",
         "value",
+        "isEnum",
+        "enumValues",
       ],
       path: "payload.data",
       errorFactory,
@@ -9233,6 +9706,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,
@@ -11329,6 +11820,40 @@ 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 [transformId, transform] of Object.entries(
+    state.transforms.items,
+  )) {
+    if (transform.type !== "transform") {
+      continue;
+    }
+
+    for (const fieldName of ["thumbnailFileId", "previewFileId"]) {
+      if (transform[fieldName] === fileId) {
+        return {
+          kind: "transform",
+          field: fieldName,
+          ownerId: transformId,
+        };
+      }
+    }
+  }
+
   for (const [characterId, character] of Object.entries(
     state.characters.items,
   )) {
@@ -14288,6 +14813,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,
@@ -14315,6 +14850,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);
       }
 
@@ -14397,6 +14938,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,
@@ -15604,6 +16155,15 @@ const COMMAND_DEFINITIONS = [
         target: item,
         tagIds: payload.data.tagIds,
       });
+      if (payload.data.thumbnailFileId !== undefined) {
+        item.thumbnailFileId = payload.data.thumbnailFileId;
+      }
+      if (payload.data.previewFileId !== undefined) {
+        item.previewFileId = payload.data.previewFileId;
+      }
+      if (payload.data.preview !== undefined) {
+        item.preview = structuredClone(payload.data.preview);
+      }
 
       return item;
     },
@@ -15617,6 +16177,30 @@ const COMMAND_DEFINITIONS = [
         return;
       }
 
+      const fileResult = validateReferencedFilesInData({
+        state,
+        data: payload.data,
+        fields: ["thumbnailFileId", "previewFileId"],
+        details: {
+          transformId: payload.transformId,
+        },
+      });
+      if (!fileResult.valid) {
+        return fileResult;
+      }
+
+      const previewResult = validateTransformPreviewImageReferences({
+        state,
+        preview: payload.data.preview,
+        path: "payload.data.preview",
+        details: {
+          transformId: payload.transformId,
+        },
+      });
+      if (!previewResult.valid) {
+        return previewResult;
+      }
+
       return validateTagIdsAgainstScope({
         state,
         tagIds: payload.data.tagIds,
@@ -15640,6 +16224,30 @@ const COMMAND_DEFINITIONS = [
       }
 
       if (currentItem.type === "transform") {
+        const fileResult = validateReferencedFilesInData({
+          state,
+          data: payload.data,
+          fields: ["thumbnailFileId", "previewFileId"],
+          details: {
+            transformId: payload.transformId,
+          },
+        });
+        if (!fileResult.valid) {
+          return fileResult;
+        }
+
+        const previewResult = validateTransformPreviewImageReferences({
+          state,
+          preview: payload.data.preview,
+          path: "payload.data.preview",
+          details: {
+            transformId: payload.transformId,
+          },
+        });
+        if (!previewResult.valid) {
+          return previewResult;
+        }
+
         return validateTagIdsAgainstScope({
           state,
           tagIds: payload.data.tagIds,
@@ -15665,13 +16273,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,
       }),
@@ -15702,6 +16313,16 @@ const COMMAND_DEFINITIONS = [
         );
       }
 
+      if (
+        currentItem.variableType !== "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({
@@ -15722,7 +16343,7 @@ const COMMAND_DEFINITIONS = [
           {
             const result = validateVariableTypedValue({
               value: payload.data.default,
-              variableType: currentItem.type,
+              variableType: currentItem.variableType,
               path: "payload.data.default",
               errorFactory: createPreconditionValidationError,
             });
@@ -15736,7 +16357,7 @@ const COMMAND_DEFINITIONS = [
           {
             const result = validateVariableTypedValue({
               value: payload.data.value,
-              variableType: currentItem.type,
+              variableType: currentItem.variableType,
               path: "payload.data.value",
               errorFactory: createPreconditionValidationError,
             });