@routevn/creator-model 1.3.7 → 1.4.1

package/package.json

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

package/src/index.js

@@ -1,6 +1,7 @@
 export {
   replayCommands,
   SCHEMA_VERSION,
+  normalizeState,
   processCommand,
   validateAgainstState,
   validatePayload,

package/src/model.js

@@ -45,6 +45,7 @@ const createEmptyCollectionState = () => ({
   items: {},
   tree: [],
 });
+const VALID_VARIABLE_ITEM_TYPES = new Set(["folder", "variable"]);
 const TAG_SCOPE_BASE_KEYS = [
   "images",
   "sounds",
@@ -113,6 +114,123 @@ const normalizeTagsState = (tags) => {
   return nextTags;
 };
 
+const filterVariableTreeNodes = ({ nodes, unsupportedItemIds }) => {
+  if (!Array.isArray(nodes)) {
+    return {
+      nodes,
+      changed: false,
+      removedIds: new Set(),
+    };
+  }
+
+  const filteredNodes = [];
+  const removedIds = new Set();
+  let changed = false;
+
+  for (const node of nodes) {
+    if (!isPlainObject(node)) {
+      filteredNodes.push(node);
+      continue;
+    }
+
+    if (unsupportedItemIds.has(node.id)) {
+      changed = true;
+      collectVariableTreeIds([node], removedIds);
+      continue;
+    }
+
+    const childrenResult = filterVariableTreeNodes({
+      nodes: node.children,
+      unsupportedItemIds,
+    });
+    for (const removedId of childrenResult.removedIds) {
+      removedIds.add(removedId);
+    }
+
+    if (childrenResult.changed) {
+      changed = true;
+      filteredNodes.push({
+        ...node,
+        children: childrenResult.nodes,
+      });
+      continue;
+    }
+
+    filteredNodes.push(node);
+  }
+
+  if (filteredNodes.length !== nodes.length) {
+    changed = true;
+  }
+
+  return {
+    nodes: changed ? filteredNodes : nodes,
+    changed,
+    removedIds,
+  };
+};
+
+const collectVariableTreeIds = (nodes, ids = new Set()) => {
+  if (!Array.isArray(nodes)) {
+    return ids;
+  }
+
+  for (const node of nodes) {
+    if (!isPlainObject(node) || !isNonEmptyString(node.id)) {
+      continue;
+    }
+
+    ids.add(node.id);
+    collectVariableTreeIds(node.children, ids);
+  }
+
+  return ids;
+};
+
+const normalizeVariablesCollection = (variables) => {
+  if (!isPlainObject(variables) || !isPlainObject(variables.items)) {
+    return variables;
+  }
+
+  const unsupportedItemIds = new Set();
+  const nextItems = {};
+  let didFilterItems = false;
+
+  for (const [itemId, item] of Object.entries(variables.items)) {
+    if (!VALID_VARIABLE_ITEM_TYPES.has(item?.type)) {
+      unsupportedItemIds.add(itemId);
+      didFilterItems = true;
+      continue;
+    }
+
+    nextItems[itemId] = item;
+  }
+
+  const treeResult = filterVariableTreeNodes({
+    nodes: variables.tree,
+    unsupportedItemIds,
+  });
+  const nextTree = treeResult.nodes;
+  const didFilterTree = treeResult.changed;
+
+  for (const removedId of treeResult.removedIds) {
+    if (Object.hasOwn(nextItems, removedId)) {
+      delete nextItems[removedId];
+      didFilterItems = true;
+    }
+  }
+
+  if (!didFilterItems && !didFilterTree) {
+    return variables;
+  }
+
+  return {
+    ...variables,
+    items: nextItems,
+    tree: nextTree,
+  };
+};
+
 const normalizeStateCollections = (state) => {
   if (!isPlainObject(state)) {
     return state;
@@ -125,8 +243,14 @@ const normalizeStateCollections = (state) => {
   ].filter((key) => state[key] === undefined);
   const normalizedTags = normalizeTagsState(state.tags);
   const hasNormalizedTags = normalizedTags !== state.tags;
+  const normalizedVariables = normalizeVariablesCollection(state.variables);
+  const hasNormalizedVariables = normalizedVariables !== state.variables;
 
-  if (missingCollectionKeys.length === 0 && !hasNormalizedTags) {
+  if (
+    missingCollectionKeys.length === 0 &&
+    !hasNormalizedTags &&
+    !hasNormalizedVariables
+  ) {
     return state;
   }
 
@@ -141,6 +265,9 @@ const normalizeStateCollections = (state) => {
   if (hasNormalizedTags) {
     nextState.tags = normalizedTags;
   }
+  if (hasNormalizedVariables) {
+    nextState.variables = normalizedVariables;
+  }
 
   return nextState;
 };
@@ -249,7 +376,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",
@@ -2313,6 +2440,9 @@ const validateTransformItems = ({ items, path, errorFactory }) => {
                 "anchorX",
                 "anchorY",
                 "rotation",
+                "thumbnailFileId",
+                "previewFileId",
+                "preview",
               ],
         path: itemPath,
         errorFactory,
@@ -2351,6 +2481,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,
@@ -2646,15 +2797,13 @@ const validateVariableEnumMetadata = ({
 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'`,
       );
     }
 
@@ -2662,11 +2811,12 @@ 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",
@@ -2712,7 +2862,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,
@@ -4398,7 +4555,7 @@ const applyVariableEnumMetadata = ({ item, data }) => {
   }
 
   const enumEnabled =
-    item.type === "string" &&
+    item.variableType === "string" &&
     data.isEnum !== false &&
     (data.isEnum === true ||
       data.enumValues !== undefined ||
@@ -4714,6 +4871,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}`;
@@ -5892,6 +6121,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");
@@ -6401,6 +6662,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,
@@ -7106,6 +7403,8 @@ const runValidateState = ({ state }) => {
 
 export const validateState = ({ state }) => runValidateState({ state });
 
+export const normalizeState = ({ state }) => normalizeStateCollections(state);
+
 const validatePlacementFields = ({ payload, errorFactory }) => {
   if (
     payload.index !== undefined &&
@@ -8973,6 +9272,9 @@ const validateTransformCreateData = ({ data, errorFactory }) => {
               "anchorX",
               "anchorY",
               "rotation",
+              "thumbnailFileId",
+              "previewFileId",
+              "preview",
             ],
       path: "payload.data",
       errorFactory,
@@ -8997,6 +9299,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,
@@ -9267,6 +9590,9 @@ const validateTransformUpdateData = ({ data, errorFactory }) => {
         "anchorX",
         "anchorY",
         "rotation",
+        "thumbnailFileId",
+        "previewFileId",
+        "preview",
       ],
       path: "payload.data",
       errorFactory,
@@ -9297,6 +9623,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,
@@ -9334,10 +9681,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'",
     );
   }
 
@@ -9349,6 +9696,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
           ? ["type", "name", "description"]
           : [
               "type",
+              "variableType",
               "name",
               "description",
               "tagIds",
@@ -9380,7 +9728,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,
@@ -9396,7 +9751,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     {
       const result = validateVariableEnumMetadata({
         data,
-        variableType: data.type,
+        variableType: data.variableType,
         path: "payload.data",
         errorFactory,
       });
@@ -9415,7 +9770,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     {
       const result = validateVariableTypedValue({
         value: data.default,
-        variableType: data.type,
+        variableType: data.variableType,
         path: "payload.data.default",
         errorFactory,
       });
@@ -9426,7 +9781,7 @@ const validateVariableCreateData = ({ data, errorFactory }) => {
     {
       const result = validateVariableTypedValue({
         value: data.value,
-        variableType: data.type,
+        variableType: data.variableType,
         path: "payload.data.value",
         errorFactory,
       });
@@ -11610,6 +11965,24 @@ const findReferencedFileUsage = ({ state, fileId }) => {
     }
   }
 
+  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,
   )) {
@@ -15911,6 +16284,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;
     },
@@ -15924,6 +16306,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,
@@ -15947,6 +16353,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,
@@ -16013,7 +16443,7 @@ const COMMAND_DEFINITIONS = [
       }
 
       if (
-        currentItem.type !== "string" &&
+        currentItem.variableType !== "string" &&
         (payload.data.isEnum !== undefined ||
           payload.data.enumValues !== undefined)
       ) {
@@ -16042,7 +16472,7 @@ const COMMAND_DEFINITIONS = [
           {
             const result = validateVariableTypedValue({
               value: payload.data.default,
-              variableType: currentItem.type,
+              variableType: currentItem.variableType,
               path: "payload.data.default",
               errorFactory: createPreconditionValidationError,
             });
@@ -16056,7 +16486,7 @@ const COMMAND_DEFINITIONS = [
           {
             const result = validateVariableTypedValue({
               value: payload.data.value,
-              variableType: currentItem.type,
+              variableType: currentItem.variableType,
               path: "payload.data.value",
               errorFactory: createPreconditionValidationError,
             });