TypeScript source-mutation.createSetValueMutation函数代码示例

const diffElement = (oldElement: SlimElement, newElement: SlimElement, path: any[]): Mutation<any[]>[] => {
  const diffs: Mutation<any[]>[] = [];

  eachArrayValueMutation(
    diffArray(oldElement.attributes, newElement.attributes, (a, b) => {
      if (a.name === b.name) {
        return 0;
      }

      return -1;
    }),
    {
      insert({ index, value }) {
        diffs.push(
          createPropertyMutation(INSERT_ATTRIBUTE, path, value.name, value.value, null, null, index)
        );
      },
      delete({ index, value }) {
        diffs.push(createPropertyMutation(REMOVE_ATTRIBUTE, path, value.name, null, null, null, index));
      },
      update({ index, newValue, originalOldIndex, patchedOldIndex }) {
        const oldAttrValue = oldElement.attributes[originalOldIndex].value;
        if (index !== patchedOldIndex) {
          diffs.push(createMoveChildMutation(MOVE_ATTRIBUTE, path, null, index, patchedOldIndex));
        }
        if (!isEqual(newValue.value, oldAttrValue)) {
          diffs.push(createPropertyMutation(SET_ATTRIBUTE, path, newValue.name, newValue.value, null, null, index));
        }
      }
    }
  );

  if (oldElement.tagName === "style") {
    diffs.push(
      ...diffCSSRule((oldElement as SlimStyleElement).sheet, (newElement as SlimStyleElement).sheet, [...path, "sheet"])
    );
  }

  diffs.push(
    ...diffChildNodes(oldElement, newElement, path)
  );

  if (oldElement.shadow && newElement.shadow) {
    diffs.push(
      ...diffDocumentFragment(oldElement.shadow, newElement.shadow, [...path, "shadow"])
    );
  } else if (oldElement.shadow && !newElement.shadow) {
    diffs.push(
      createSetValueMutation(REMOVE_SHADOW, path, null)
    );
  } else if (!oldElement.shadow && newElement.shadow) {
    diffs.push(
      createSetValueMutation(ATTACH_SHADOW, path, compressRootNode(newElement.shadow))
    );
  }

  return diffs;
};

 return diffs.map(diff => {
   switch(diff.type) {
     case CSS_INSERT_RULE:
     case INSERT_CHILD_NODE: {
       const { type, target, index, child } = diff as InsertChildMutation<any, any>;
       let unzippedChild = uncompressRootNode(child);
       if (idSeed) {
         unzippedChild = setVMObjectIds(unzippedChild, idSeed, refCount);
         refCount = getRefCount(unzippedChild, idSeed);
       }
       return createInsertChildMutation(type, target, unzippedChild, index)
     }
     case ATTACH_SHADOW: {
       const { type, target, newValue } = diff as SetValueMutation<any>;
       let unzippedChild = uncompressRootNode(newValue);
       if (idSeed) {
         unzippedChild = setVMObjectIds(unzippedChild, idSeed, refCount);
         refCount = getRefCount(unzippedChild, idSeed);
       }
       return createSetValueMutation(type, target, unzippedChild);
     }
     default: {
       return diff;
     }
   }
 });

 yield call(updateSharedArtboards, styleRuleId, artboardId, true, (styleRule, hash, path, root) => {
   if (!newSelectorText) {
     const parentPath = path.slice(0, path.length - 1);
     return [
       createRemoveChildMutation(CSS_DELETE_RULE, parentPath, null, path[path.length - 1])
     ];
   }
   return [
     createSetValueMutation(CSS_SET_SELECTOR_TEXT, path, newSelectorText)
   ];
 });

const diffCSSAtRule = (oldRule: SlimCSSAtRule, newRule: SlimCSSAtRule, path: any[]) => {
  const diffs = [];
  if (oldRule.params !== newRule.params) {
    diffs.push(createSetValueMutation(CSS_AT_RULE_SET_PARAMS, path, newRule.params));
  }

  diffs.push(
    ...diffCSSGroupingRuleChildren(oldRule, newRule, path)
  );

  return diffs;
}

export const createUpdateValueNodeMutation = (oldNode: BasicValueNode, newValue: string) => {
  return createSetValueMutation(UPDATE_VALUE_NODE, oldNode, newValue);
};