@commercetools/sync-actions 8.0.1 → 8.2.0

package/dist/commercetools-sync-actions.esm.js

@@ -32,12 +32,14 @@ __export(index_exports, {
   createSyncOrders: () => orders_default,
   createSyncProductDiscounts: () => product_discounts_default,
   createSyncProductSelections: () => product_selections_default,
+  createSyncProductTailoring: () => product_tailoring_default,
   createSyncProductTypes: () => product_types_default,
   createSyncProducts: () => products_default,
   createSyncProjects: () => projects_default,
   createSyncRecurringOrders: () => recurring_orders_default,
   createSyncShippingMethods: () => shipping_methods_default,
   createSyncStandalonePrices: () => prices_default,
+  createSyncStandaloneVariants: () => createSyncStandaloneVariants,
   createSyncStates: () => states_default,
   createSyncStores: () => stores_default,
   createSyncSubscriptions: () => subscriptions_default,
@@ -967,9 +969,15 @@ function findMatchingPairs(diff2, before = [], now = [], identifier = "id") {
   return result;
 }
 
-// src/products/product-actions.ts
+// src/utils/array-actions-utils.ts
 var REGEX_NUMBER3 = new RegExp(/^\d+$/);
 var REGEX_UNDERSCORE_NUMBER3 = new RegExp(/^_\d+$/);
+var getIsAddAction = (key, resource) => REGEX_NUMBER3.test(key) && Array.isArray(resource) && resource.length;
+var getIsUpdateAction = (key, resource) => REGEX_NUMBER3.test(key) && Object.keys(resource).length;
+var getIsRemoveAction = (key, resource) => REGEX_UNDERSCORE_NUMBER3.test(key) && Number(resource[2]) === 0;
+var getIsItemMovedAction = (key, resource) => REGEX_UNDERSCORE_NUMBER3.test(key) && Number(resource[2]) === 3;
+
+// src/products/product-actions.ts
 var baseActionsList4 = [
   { action: "changeName", key: "name" },
   { action: "changeSlug", key: "slug" },
@@ -994,10 +1002,6 @@ var referenceActionsList4 = [
   { action: "setTaxCategory", key: "taxCategory" },
   { action: "transitionState", key: "state" }
 ];
-var getIsAddAction = (key, resource) => REGEX_NUMBER3.test(key) && Array.isArray(resource) && resource.length;
-var getIsUpdateAction = (key, resource) => REGEX_NUMBER3.test(key) && Object.keys(resource).length;
-var getIsRemoveAction = (key, resource) => REGEX_UNDERSCORE_NUMBER3.test(key) && Number(resource[2]) === 0;
-var getIsItemMovedAction = (key, resource) => REGEX_UNDERSCORE_NUMBER3.test(key) && Number(resource[2]) === 3;
 function _buildSkuActions(variantDiff, oldVariant) {
   if ({}.hasOwnProperty.call(variantDiff, "sku")) {
     const newValue = getDeltaValue(variantDiff.sku);
@@ -3495,170 +3499,768 @@ var product_selections_default = (actionGroupList) => {
   return { buildActions };
 };
 
-// src/prices/prices-actions.ts
+// src/product-tailoring/product-tailoring-actions.ts
+import forEach5 from "lodash.foreach";
+import uniqWith2 from "lodash.uniqwith";
+import intersection2 from "lodash.intersection";
+import without2 from "lodash.without";
 var baseActionsList21 = [
-  { action: "changeValue", key: "value" },
-  { action: "setDiscountedPrice", key: "discounted" },
-  // TODO: Later add more accurate actions `addPriceTier`, `removePriceTier`
-  { action: "setPriceTiers", key: "tiers" },
-  { action: "setKey", key: "key" },
-  { action: "setValidFrom", key: "validFrom" },
-  { action: "setValidUntil", key: "validUntil" },
-  { action: "changeActive", key: "active" }
+  { action: "setName", key: "name" },
+  { action: "setSlug", key: "slug" },
+  { action: "setDescription", key: "description" }
 ];
-function actionsMapBase21(diff2, oldObj, newObj, config = {}) {
-  return buildBaseAttributesActions({
-    actions: baseActionsList21,
-    diff: diff2,
-    oldObj,
-    newObj,
-    shouldOmitEmptyString: config.shouldOmitEmptyString,
-    shouldUnsetOmittedProperties: config.shouldUnsetOmittedProperties,
-    shouldPreventUnsettingRequiredFields: config.shouldPreventUnsettingRequiredFields
-  });
+var metaActionsList3 = [
+  { action: "setMetaTitle", key: "metaTitle" },
+  { action: "setMetaDescription", key: "metaDescription" },
+  { action: "setMetaKeywords", key: "metaKeywords" }
+];
+var baseAssetActionsList2 = [
+  { action: "setAssetKey", key: "key", actionKey: "assetKey" },
+  { action: "changeAssetName", key: "name" },
+  { action: "setAssetDescription", key: "description" },
+  { action: "setAssetTags", key: "tags" },
+  { action: "setAssetSources", key: "sources" }
+];
+function _buildAttributeValue2(diffedValue, oldAttributeValue, newAttributeValue) {
+  let value;
+  if (Array.isArray(diffedValue))
+    value = getDeltaValue(diffedValue, oldAttributeValue);
+  else if (typeof diffedValue === "string")
+    value = getDeltaValue(diffedValue, oldAttributeValue);
+  else if (diffedValue.centAmount || diffedValue.currencyCode)
+    value = {
+      centAmount: diffedValue.centAmount ? getDeltaValue(diffedValue.centAmount) : newAttributeValue.centAmount,
+      currencyCode: diffedValue.currencyCode ? getDeltaValue(diffedValue.currencyCode) : newAttributeValue.currencyCode
+    };
+  else if (diffedValue.key) value = getDeltaValue(diffedValue.key);
+  else if (typeof diffedValue === "object")
+    if ({}.hasOwnProperty.call(diffedValue, "_t") && diffedValue._t === "a") {
+      value = newAttributeValue;
+    } else {
+      const updatedValue = Object.keys(diffedValue).reduce(
+        (acc, lang) => {
+          const patchedValue = getDeltaValue(
+            diffedValue[lang],
+            acc[lang]
+          );
+          return Object.assign(acc, { [lang]: patchedValue });
+        },
+        { ...oldAttributeValue }
+      );
+      value = updatedValue;
+    }
+  return value;
 }
-
-// src/prices/prices.ts
-function createPriceMapActions(mapActionGroup, syncActionConfig) {
-  return function doMapActions(diff2, newObj, oldObj) {
-    const baseActions = mapActionGroup(
-      "base",
-      () => actionsMapBase21(diff2, oldObj, newObj, syncActionConfig)
-    );
-    const customActions = mapActionGroup(
-      "custom",
-      () => actionsMapCustom(diff2, newObj, oldObj)
-    );
-    return combineValidityActions([...baseActions, ...customActions]);
+function _buildNewSetAttributeAction2(variantId, attr, sameForAllAttributeNames) {
+  const attributeName = attr && attr.name;
+  if (!attributeName) return void 0;
+  let action = {
+    action: "setAttribute",
+    variantId,
+    name: attributeName,
+    value: attr.value
   };
+  if (sameForAllAttributeNames.indexOf(attributeName) !== -1) {
+    action = { ...action, action: "setAttributeInAllVariants" };
+    delete action.variantId;
+  }
+  return action;
 }
-var prices_default = (actionGroupList, syncActionConfig) => {
-  const mapActionGroup = createMapActionGroup(actionGroupList);
-  const doMapActions = createPriceMapActions(mapActionGroup, syncActionConfig);
-  const buildActions = createBuildActions(
-    diff,
-    doMapActions
+function _buildSetAttributeAction2(diffedValue, oldVariant, attribute, sameForAllAttributeNames) {
+  if (!attribute || !diffedValue) return void 0;
+  let action = {
+    action: "setAttribute",
+    variantId: oldVariant.id,
+    name: attribute.name,
+    value: null
+  };
+  const oldAttribute = (oldVariant.attributes || []).find(
+    (a) => a.name === attribute.name
   );
-  return { buildActions };
-};
-
-// src/attribute-groups/attribute-groups-actions.ts
-var hasAttribute = (attributes, newValue) => attributes.some((attribute) => attribute.key === newValue.key);
-var baseActionsList22 = [
-  { action: "changeName", key: "name" },
-  { action: "setKey", key: "key" },
-  { action: "setDescription", key: "description" }
-];
-function actionsMapBase22(diff2, oldObj, newObj, config = {}) {
-  return buildBaseAttributesActions({
-    actions: baseActionsList22,
-    diff: diff2,
-    oldObj,
-    newObj,
-    shouldOmitEmptyString: config.shouldOmitEmptyString,
-    shouldUnsetOmittedProperties: config.shouldUnsetOmittedProperties,
-    shouldPreventUnsettingRequiredFields: config.shouldPreventUnsettingRequiredFields
-  });
-}
-function actionsMapAttributes2(diff2, oldObj, newObj) {
-  const handler = createBuildArrayActions("attributes", {
-    [ADD_ACTIONS]: (newAttribute) => ({
-      action: "addAttribute",
-      attribute: newAttribute
-    }),
-    [REMOVE_ACTIONS]: (oldAttribute) => {
-      return !hasAttribute(newObj.attributes, oldAttribute) ? {
-        action: "removeAttribute",
-        attribute: oldAttribute
-      } : null;
-    },
-    [CHANGE_ACTIONS]: (oldAttribute, newAttribute) => {
-      const result = [];
-      if (!hasAttribute(newObj.attributes, oldAttribute))
-        result.push({
-          action: "removeAttribute",
-          attribute: oldAttribute
-        });
-      if (!hasAttribute(oldObj.attributes, newAttribute))
-        result.push({
-          action: "addAttribute",
-          attribute: newAttribute
-        });
-      return result;
-    }
-  });
-  return handler(diff2, oldObj, newObj);
+  if (sameForAllAttributeNames.indexOf(attribute.name) !== -1) {
+    action = { ...action, action: "setAttributeInAllVariants" };
+    delete action.variantId;
+  }
+  action.value = _buildAttributeValue2(
+    diffedValue,
+    oldAttribute?.value,
+    attribute.value
+  );
+  return action;
 }
-
-// src/attribute-groups/attribute-groups.ts
-function createAttributeGroupsMapActions(mapActionGroup, syncActionConfig) {
-  return function doMapActions(diff2, newObj, oldObj) {
-    const allActions = [];
-    allActions.push(
-      mapActionGroup(
-        "base",
-        () => actionsMapBase22(diff2, oldObj, newObj, syncActionConfig)
-      )
-    );
-    allActions.push(
-      mapActionGroup(
-        "attributes",
-        () => actionsMapAttributes2(
-          diff2,
-          oldObj,
-          newObj
-        )
-      ).flat()
-    );
-    return allActions.flat();
+function _buildNewSetProductAttributeAction2(attr) {
+  const attributeName = attr && attr.name;
+  if (!attributeName) return void 0;
+  return {
+    action: "setProductAttribute",
+    name: attributeName,
+    value: attr.value
   };
 }
-var attribute_groups_default = (actionGroupList, syncActionConfig) => {
-  const mapActionGroup = createMapActionGroup(actionGroupList);
-  const doMapActions = createAttributeGroupsMapActions(
-    mapActionGroup,
-    syncActionConfig
+function _buildSetProductAttributeAction2(diffedValue, oldProductData, newAttribute) {
+  if (!newAttribute || !diffedValue) return void 0;
+  const action = {
+    action: "setProductAttribute",
+    name: newAttribute.name,
+    value: null
+  };
+  const oldAttribute = (oldProductData.attributes || []).find(
+    (a) => a.name === newAttribute.name
+  ) || {};
+  action.value = _buildAttributeValue2(
+    diffedValue,
+    oldAttribute.value,
+    newAttribute.value
   );
-  const buildActions = createBuildActions(
-    diff,
-    doMapActions
+  return action;
+}
+function _buildVariantImagesAction2(diffedImages, oldVariant = {}, newVariant = {}) {
+  const actions = [];
+  const matchingImagePairs = findMatchingPairs(
+    diffedImages,
+    oldVariant.images,
+    newVariant.images,
+    "url"
   );
-  return { buildActions };
-};
-
-// src/api-extensions/api-extensions-actions.ts
-var baseActionsList23 = [
-  { action: "setKey", key: "key" },
-  { action: "changeTriggers", key: "triggers" },
-  { action: "setTimeoutInMs", key: "timeoutInMs" },
-  { action: "changeDestination", key: "destination" }
-];
-var actionsMapBase23 = (diff2, oldObj, newObj, config) => {
-  return buildBaseAttributesActions({
-    actions: baseActionsList23,
-    diff: diff2,
-    oldObj,
-    newObj,
-    shouldOmitEmptyString: config?.shouldOmitEmptyString
-  });
-};
-
-// src/api-extensions/api-extensions.ts
-var createApiExtensionsMapActions = (mapActionGroup, syncActionConfig) => {
-  return function doMapActions(diff2, newObj, oldObj) {
-    const allActions = [];
-    allActions.push(
-      mapActionGroup(
-        "base",
-        () => actionsMapBase23(diff2, oldObj, newObj, syncActionConfig)
-      )
+  forEach5(diffedImages, (image, key) => {
+    const { oldObj, newObj } = extractMatchingPairs(
+      matchingImagePairs,
+      key,
+      oldVariant.images,
+      newVariant.images
     );
-    return allActions.flat();
-  };
-};
-var api_extensions_default = (actionGroupList, syncActionConfig) => {
-  const mapActionGroup = createMapActionGroup(actionGroupList);
-  const doMapActions = createApiExtensionsMapActions(
+    if (REGEX_NUMBER3.test(key)) {
+      if (Array.isArray(image) && image.length)
+        actions.push({
+          action: "addExternalImage",
+          variantId: oldVariant.id,
+          image: getDeltaValue(image)
+        });
+      else if (typeof image === "object") {
+        if ({}.hasOwnProperty.call(image, "url") && image.url.length === 2) {
+          actions.push({
+            action: "removeImage",
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url
+          });
+          actions.push({
+            action: "addExternalImage",
+            variantId: oldVariant.id,
+            image: newObj
+          });
+        } else if ({}.hasOwnProperty.call(image, "label") && (image.label.length === 1 || image.label.length === 2))
+          actions.push({
+            action: "setImageLabel",
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url,
+            label: getDeltaValue(image.label)
+          });
+      }
+    } else if (REGEX_UNDERSCORE_NUMBER3.test(key)) {
+      if (Array.isArray(image) && image.length === 3) {
+        if (Number(image[2]) === 3)
+          actions.push({
+            action: "moveImageToPosition",
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url,
+            position: Number(image[1])
+          });
+        else if (Number(image[2]) === 0)
+          actions.push({
+            action: "removeImage",
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url
+          });
+      }
+    }
+  });
+  return actions;
+}
+function toAssetIdentifier3(asset) {
+  return asset.id ? { assetId: asset.id } : { assetKey: asset.key };
+}
+function toVariantIdentifier2(variant) {
+  const { id, sku } = variant;
+  return id ? { variantId: id } : { sku };
+}
+function _buildVariantChangeAssetOrderAction2(diffAssets, oldVariant, newVariant) {
+  const isAssetOrderChanged = Object.entries(diffAssets).find(
+    (entry) => getIsItemMovedAction(entry[0], entry[1])
+  );
+  if (!isAssetOrderChanged) return [];
+  const assetIdsBefore = (oldVariant.assets || []).map((_) => _.id);
+  const assetIdsCurrent = (newVariant.assets || []).map((_) => _.id).filter((_) => _ !== void 0);
+  const assetIdsToKeep = intersection2(assetIdsCurrent, assetIdsBefore);
+  const assetIdsToRemove = without2(assetIdsBefore, ...assetIdsToKeep);
+  return [
+    {
+      action: "changeAssetOrder",
+      assetOrder: assetIdsToKeep.concat(assetIdsToRemove),
+      ...toVariantIdentifier2(oldVariant)
+    }
+  ];
+}
+function _buildVariantAssetsActions2(diffAssets, oldVariant, newVariant) {
+  const assetActions = [];
+  const matchingAssetPairs = findMatchingPairs(
+    diffAssets,
+    oldVariant.assets,
+    newVariant.assets
+  );
+  forEach5(diffAssets, (asset, key) => {
+    const { oldObj: oldAsset, newObj: newAsset } = extractMatchingPairs(
+      matchingAssetPairs,
+      key,
+      oldVariant.assets,
+      newVariant.assets
+    );
+    if (getIsAddAction(key, asset)) {
+      const action = {
+        action: "addAsset",
+        asset: getDeltaValue(asset),
+        ...toVariantIdentifier2(newVariant)
+      };
+      const actionWithPosition = {
+        ...action,
+        position: Number(key)
+      };
+      assetActions.push(oldVariant.assets ? actionWithPosition : action);
+      return;
+    }
+    if (getIsUpdateAction(key, asset)) {
+      const basicActions = buildBaseAttributesActions({
+        actions: baseAssetActionsList2,
+        diff: asset,
+        oldObj: oldAsset,
+        newObj: newAsset
+      }).map((action) => {
+        if (action.action === "setAssetKey") {
+          return {
+            ...action,
+            ...toVariantIdentifier2(oldVariant),
+            assetId: oldAsset.id
+          };
+        }
+        return {
+          ...action,
+          ...toVariantIdentifier2(oldVariant),
+          ...toAssetIdentifier3(oldAsset)
+        };
+      });
+      assetActions.push(...basicActions);
+      if (asset.custom) {
+        const customActions = actionsMapCustom(asset, newAsset, oldAsset, {
+          actions: {
+            setCustomType: "setAssetCustomType",
+            setCustomField: "setAssetCustomField"
+          },
+          ...toVariantIdentifier2(oldVariant),
+          ...toAssetIdentifier3(oldAsset)
+        });
+        assetActions.push(...customActions);
+      }
+      return;
+    }
+    if (getIsRemoveAction(key, asset)) {
+      assetActions.push({
+        action: "removeAsset",
+        ...toAssetIdentifier3(oldAsset),
+        ...toVariantIdentifier2(oldVariant)
+      });
+    }
+  });
+  const changedAssetOrderAction = _buildVariantChangeAssetOrderAction2(
+    diffAssets,
+    oldVariant,
+    newVariant
+  );
+  return [...changedAssetOrderAction, ...assetActions];
+}
+function _buildVariantAttributesActions2(attributes, oldVariant, newVariant, sameForAllAttributeNames) {
+  const actions = [];
+  if (!attributes) return actions;
+  forEach5(attributes, (value, key) => {
+    if (REGEX_NUMBER3.test(key)) {
+      if (Array.isArray(value)) {
+        const { id } = oldVariant;
+        const deltaValue = getDeltaValue(value);
+        const setAction = _buildNewSetAttributeAction2(
+          id,
+          deltaValue,
+          sameForAllAttributeNames
+        );
+        if (setAction) actions.push(setAction);
+      } else if (newVariant.attributes) {
+        const setAction = _buildSetAttributeAction2(
+          value.value,
+          oldVariant,
+          newVariant.attributes[key],
+          sameForAllAttributeNames
+        );
+        if (setAction) actions.push(setAction);
+      }
+    } else if (REGEX_UNDERSCORE_NUMBER3.test(key))
+      if (Array.isArray(value)) {
+        if (value.length === 3 && value[2] === 3) return;
+        const { id } = oldVariant;
+        let deltaValue = getDeltaValue(value);
+        if (!deltaValue)
+          if (value[0] && value[0].name) deltaValue = { name: value[0].name };
+          else deltaValue = void 0;
+        const setAction = _buildNewSetAttributeAction2(
+          id,
+          deltaValue,
+          sameForAllAttributeNames
+        );
+        if (setAction) actions.push(setAction);
+      } else {
+        const index = key.substring(1);
+        if (newVariant.attributes) {
+          const setAction = _buildSetAttributeAction2(
+            value.value,
+            oldVariant,
+            newVariant.attributes[index],
+            sameForAllAttributeNames
+          );
+          if (setAction) actions.push(setAction);
+        }
+      }
+  });
+  return actions;
+}
+function _buildProductAttributesActions2(diffedAttributes, oldProductData, newProductData) {
+  const actions = [];
+  if (!diffedAttributes) return actions;
+  forEach5(diffedAttributes, (value, key) => {
+    if (REGEX_NUMBER3.test(key)) {
+      if (Array.isArray(value)) {
+        const setAction = _buildNewSetProductAttributeAction2(
+          getDeltaValue(value)
+        );
+        if (setAction) actions.push(setAction);
+      } else if (newProductData.attributes) {
+        const setAction = _buildSetProductAttributeAction2(
+          value["value"],
+          oldProductData,
+          newProductData.attributes[key]
+        );
+        if (setAction) actions.push(setAction);
+      }
+    } else if (REGEX_UNDERSCORE_NUMBER3.test(key)) {
+      if (Array.isArray(value)) {
+        if (value.length === 3 && value[2] === 3) return;
+        let deltaValue = getDeltaValue(value);
+        if (!deltaValue)
+          if (value[0] && value[0].name) deltaValue = { name: value[0].name };
+          else deltaValue = void 0;
+        const setAction = _buildNewSetProductAttributeAction2(
+          deltaValue
+        );
+        if (setAction) actions.push(setAction);
+      } else {
+        const index = key.substring(1);
+        if (newProductData.attributes) {
+          const setAction = _buildSetProductAttributeAction2(
+            value["value"],
+            oldProductData,
+            newProductData.attributes[index]
+          );
+          if (setAction) actions.push(setAction);
+        }
+      }
+    }
+  });
+  return actions;
+}
+function actionsMapBase21(diff2, oldObj, newObj, config = {}) {
+  return buildBaseAttributesActions({
+    actions: baseActionsList21,
+    diff: diff2,
+    oldObj,
+    newObj,
+    shouldOmitEmptyString: config.shouldOmitEmptyString,
+    shouldUnsetOmittedProperties: config.shouldUnsetOmittedProperties
+  });
+}
+function actionsMapMeta3(diff2, oldObj, newObj, config = {}) {
+  return buildBaseAttributesActions({
+    actions: metaActionsList3,
+    diff: diff2,
+    oldObj,
+    newObj,
+    shouldOmitEmptyString: config.shouldOmitEmptyString,
+    shouldUnsetOmittedProperties: config.shouldUnsetOmittedProperties
+  });
+}
+function actionsMapAddVariants2(diff2, oldObj, newObj) {
+  const handler = createBuildArrayActions("variants", {
+    [ADD_ACTIONS]: (newObject) => ({
+      ...newObject,
+      action: "addVariant"
+    })
+  });
+  return handler(diff2, oldObj, newObj);
+}
+function actionsMapRemoveVariants2(diff2, oldObj, newObj) {
+  const handler = createBuildArrayActions("variants", {
+    [REMOVE_ACTIONS]: ({ id, sku }) => ({
+      action: "removeVariant",
+      ...id ? { id } : { sku }
+    })
+  });
+  return handler(diff2, oldObj, newObj);
+}
+function actionsMapImages2(diff2, oldObj, newObj, variantHashMap) {
+  let actions = [];
+  const { variants } = diff2;
+  if (variants)
+    forEach5(variants, (variant, key) => {
+      const { oldObj: oldVariant, newObj: newVariant } = extractMatchingPairs(
+        variantHashMap,
+        key,
+        oldObj.variants,
+        newObj.variants
+      );
+      if (REGEX_UNDERSCORE_NUMBER3.test(key) || REGEX_NUMBER3.test(key)) {
+        const vActions = _buildVariantImagesAction2(
+          variant.images,
+          oldVariant,
+          newVariant
+        );
+        actions = actions.concat(vActions);
+      }
+    });
+  return actions;
+}
+function actionsMapAssets3(diff2, oldObj, newObj, variantHashMap) {
+  let allAssetsActions = [];
+  const { variants } = diff2;
+  if (variants)
+    forEach5(variants, (variant, key) => {
+      const { oldObj: oldVariant, newObj: newVariant } = extractMatchingPairs(
+        variantHashMap,
+        key,
+        oldObj.variants,
+        newObj.variants
+      );
+      if (variant.assets && (REGEX_UNDERSCORE_NUMBER3.test(key) || REGEX_NUMBER3.test(key))) {
+        const assetActions = _buildVariantAssetsActions2(
+          variant.assets,
+          oldVariant,
+          newVariant
+        );
+        allAssetsActions = allAssetsActions.concat(assetActions);
+      }
+    });
+  return allAssetsActions;
+}
+function actionsMapProductAttributes2(diff2, oldObj, newObj) {
+  return _buildProductAttributesActions2(diff2.attributes, oldObj, newObj);
+}
+function actionsMapVariantAttributes(diff2, oldObj, newObj, sameForAllAttributeNames = [], variantHashMap) {
+  let actions = [];
+  const { variants } = diff2;
+  if (variants)
+    forEach5(variants, (variant, key) => {
+      const { oldObj: oldVariant, newObj: newVariant } = extractMatchingPairs(
+        variantHashMap,
+        key,
+        oldObj.variants,
+        newObj.variants
+      );
+      if (REGEX_NUMBER3.test(key) && !Array.isArray(variant)) {
+        const { attributes } = variant;
+        const attrActions = _buildVariantAttributesActions2(
+          attributes,
+          oldVariant,
+          newVariant,
+          sameForAllAttributeNames
+        );
+        actions = actions.concat(attrActions);
+      }
+    });
+  return uniqWith2(
+    actions,
+    (a, b) => a.action === b.action && a.name === b.name && a.variantId === b.variantId
+  );
+}
+
+// src/product-tailoring/product-tailoring.ts
+function createProductTailoringMapActions(mapActionGroup, syncActionConfig) {
+  return function doMapActions(diff2, newObj, oldObj, options = {}) {
+    const allActions = [];
+    const { publish, staged } = newObj;
+    const variantHashMap = findMatchingPairs(
+      diff2.variants,
+      oldObj.variants,
+      newObj.variants
+    );
+    const config = { ...syncActionConfig, ...options };
+    allActions.push(
+      mapActionGroup(
+        "base",
+        () => actionsMapBase21(diff2, oldObj, newObj, config)
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "meta",
+        () => actionsMapMeta3(diff2, oldObj, newObj, config)
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "variants",
+        () => actionsMapAddVariants2(diff2, oldObj, newObj)
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "variants",
+        () => actionsMapRemoveVariants2(diff2, oldObj, newObj)
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "images",
+        () => actionsMapImages2(
+          diff2,
+          oldObj,
+          newObj,
+          variantHashMap
+        )
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "assets",
+        () => actionsMapAssets3(
+          diff2,
+          oldObj,
+          newObj,
+          variantHashMap
+        )
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "attributes",
+        () => actionsMapProductAttributes2(
+          diff2,
+          oldObj,
+          newObj
+        )
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "attributes",
+        () => actionsMapVariantAttributes(
+          diff2,
+          oldObj,
+          newObj,
+          options.sameForAllAttributeNames || [],
+          variantHashMap
+        )
+      )
+    );
+    if (publish === true || staged === false)
+      return allActions.flat().map((action) => ({
+        ...action,
+        staged: false
+      }));
+    return allActions.flat();
+  };
+}
+function prepareVariantsForDiff(before, now) {
+  const [beforeCopy, nowCopy] = copyEmptyArrayProps(
+    before,
+    now
+  );
+  const ensureVariants = (obj) => ({
+    ...obj,
+    variants: obj?.variants || []
+  });
+  return [ensureVariants(beforeCopy), ensureVariants(nowCopy)];
+}
+var product_tailoring_default = (actionGroupList, syncActionConfig) => {
+  const mapActionGroup = createMapActionGroup(actionGroupList);
+  const doMapActions = createProductTailoringMapActions(
+    mapActionGroup,
+    syncActionConfig
+  );
+  const buildActions = createBuildActions(
+    diff,
+    doMapActions,
+    prepareVariantsForDiff
+  );
+  return { buildActions };
+};
+
+// src/prices/prices-actions.ts
+var baseActionsList22 = [
+  { action: "changeValue", key: "value" },
+  { action: "setDiscountedPrice", key: "discounted" },
+  // TODO: Later add more accurate actions `addPriceTier`, `removePriceTier`
+  { action: "setPriceTiers", key: "tiers" },
+  { action: "setKey", key: "key" },
+  { action: "setValidFrom", key: "validFrom" },
+  { action: "setValidUntil", key: "validUntil" },
+  { action: "changeActive", key: "active" }
+];
+function actionsMapBase22(diff2, oldObj, newObj, config = {}) {
+  return buildBaseAttributesActions({
+    actions: baseActionsList22,
+    diff: diff2,
+    oldObj,
+    newObj,
+    shouldOmitEmptyString: config.shouldOmitEmptyString,
+    shouldUnsetOmittedProperties: config.shouldUnsetOmittedProperties,
+    shouldPreventUnsettingRequiredFields: config.shouldPreventUnsettingRequiredFields
+  });
+}
+
+// src/prices/prices.ts
+function createPriceMapActions(mapActionGroup, syncActionConfig) {
+  return function doMapActions(diff2, newObj, oldObj) {
+    const baseActions = mapActionGroup(
+      "base",
+      () => actionsMapBase22(diff2, oldObj, newObj, syncActionConfig)
+    );
+    const customActions = mapActionGroup(
+      "custom",
+      () => actionsMapCustom(diff2, newObj, oldObj)
+    );
+    return combineValidityActions([...baseActions, ...customActions]);
+  };
+}
+var prices_default = (actionGroupList, syncActionConfig) => {
+  const mapActionGroup = createMapActionGroup(actionGroupList);
+  const doMapActions = createPriceMapActions(mapActionGroup, syncActionConfig);
+  const buildActions = createBuildActions(
+    diff,
+    doMapActions
+  );
+  return { buildActions };
+};
+
+// src/attribute-groups/attribute-groups-actions.ts
+var hasAttribute = (attributes, newValue) => attributes.some((attribute) => attribute.key === newValue.key);
+var baseActionsList23 = [
+  { action: "changeName", key: "name" },
+  { action: "setKey", key: "key" },
+  { action: "setDescription", key: "description" }
+];
+function actionsMapBase23(diff2, oldObj, newObj, config = {}) {
+  return buildBaseAttributesActions({
+    actions: baseActionsList23,
+    diff: diff2,
+    oldObj,
+    newObj,
+    shouldOmitEmptyString: config.shouldOmitEmptyString,
+    shouldUnsetOmittedProperties: config.shouldUnsetOmittedProperties,
+    shouldPreventUnsettingRequiredFields: config.shouldPreventUnsettingRequiredFields
+  });
+}
+function actionsMapAttributes2(diff2, oldObj, newObj) {
+  const handler = createBuildArrayActions("attributes", {
+    [ADD_ACTIONS]: (newAttribute) => ({
+      action: "addAttribute",
+      attribute: newAttribute
+    }),
+    [REMOVE_ACTIONS]: (oldAttribute) => {
+      return !hasAttribute(newObj.attributes, oldAttribute) ? {
+        action: "removeAttribute",
+        attribute: oldAttribute
+      } : null;
+    },
+    [CHANGE_ACTIONS]: (oldAttribute, newAttribute) => {
+      const result = [];
+      if (!hasAttribute(newObj.attributes, oldAttribute))
+        result.push({
+          action: "removeAttribute",
+          attribute: oldAttribute
+        });
+      if (!hasAttribute(oldObj.attributes, newAttribute))
+        result.push({
+          action: "addAttribute",
+          attribute: newAttribute
+        });
+      return result;
+    }
+  });
+  return handler(diff2, oldObj, newObj);
+}
+
+// src/attribute-groups/attribute-groups.ts
+function createAttributeGroupsMapActions(mapActionGroup, syncActionConfig) {
+  return function doMapActions(diff2, newObj, oldObj) {
+    const allActions = [];
+    allActions.push(
+      mapActionGroup(
+        "base",
+        () => actionsMapBase23(diff2, oldObj, newObj, syncActionConfig)
+      )
+    );
+    allActions.push(
+      mapActionGroup(
+        "attributes",
+        () => actionsMapAttributes2(
+          diff2,
+          oldObj,
+          newObj
+        )
+      ).flat()
+    );
+    return allActions.flat();
+  };
+}
+var attribute_groups_default = (actionGroupList, syncActionConfig) => {
+  const mapActionGroup = createMapActionGroup(actionGroupList);
+  const doMapActions = createAttributeGroupsMapActions(
+    mapActionGroup,
+    syncActionConfig
+  );
+  const buildActions = createBuildActions(
+    diff,
+    doMapActions
+  );
+  return { buildActions };
+};
+
+// src/api-extensions/api-extensions-actions.ts
+var baseActionsList24 = [
+  { action: "setKey", key: "key" },
+  { action: "changeTriggers", key: "triggers" },
+  { action: "setTimeoutInMs", key: "timeoutInMs" },
+  { action: "changeDestination", key: "destination" }
+];
+var actionsMapBase24 = (diff2, oldObj, newObj, config) => {
+  return buildBaseAttributesActions({
+    actions: baseActionsList24,
+    diff: diff2,
+    oldObj,
+    newObj,
+    shouldOmitEmptyString: config?.shouldOmitEmptyString
+  });
+};
+
+// src/api-extensions/api-extensions.ts
+var createApiExtensionsMapActions = (mapActionGroup, syncActionConfig) => {
+  return function doMapActions(diff2, newObj, oldObj) {
+    const allActions = [];
+    allActions.push(
+      mapActionGroup(
+        "base",
+        () => actionsMapBase24(diff2, oldObj, newObj, syncActionConfig)
+      )
+    );
+    return allActions.flat();
+  };
+};
+var api_extensions_default = (actionGroupList, syncActionConfig) => {
+  const mapActionGroup = createMapActionGroup(actionGroupList);
+  const doMapActions = createApiExtensionsMapActions(
     mapActionGroup,
     syncActionConfig
   );
@@ -3667,7 +4269,7 @@ var api_extensions_default = (actionGroupList, syncActionConfig) => {
 };
 
 // src/business-units/business-units-actions.ts
-var baseActionsList24 = [
+var baseActionsList25 = [
   {
     action: "setStores",
     key: "stores"
@@ -3703,9 +4305,9 @@ var actionsMapAssociates = (diff2, oldObj, newObj) => {
   });
   return handler(diff2, oldObj, newObj);
 };
-var actionsMapBase24 = (diff2, oldObj, newObj, config) => {
+var actionsMapBase25 = (diff2, oldObj, newObj, config) => {
   return buildBaseAttributesActions({
-    actions: baseActionsList24,
+    actions: baseActionsList25,
     diff: diff2,
     oldObj,
     newObj,
@@ -3720,7 +4322,7 @@ var createCustomerMapActions2 = (mapActionGroup, syncActionConfig) => {
     allActions.push(
       mapActionGroup(
         "base",
-        () => actionsMapBase24(
+        () => actionsMapBase25(
           diff2,
           oldObj,
           newObj,
@@ -3795,15 +4397,15 @@ var business_units_default = (actionGroupList, syncActionConfig) => {
 };
 
 // src/subscriptions/subscriptions-actions.ts
-var baseActionsList25 = [
+var baseActionsList26 = [
   { action: "setKey", key: "key" },
   { action: "setMessages", key: "messages" },
   { action: "setChanges", key: "changes" },
   { action: "changeDestination", key: "destination" }
 ];
-var actionsMapBase25 = (diff2, oldObj, newObj, config) => {
+var actionsMapBase26 = (diff2, oldObj, newObj, config) => {
   return buildBaseAttributesActions({
-    actions: baseActionsList25,
+    actions: baseActionsList26,
     diff: diff2,
     oldObj,
     newObj,
@@ -3818,7 +4420,7 @@ var createSubscriptionsMapActions = (mapActionGroup, syncActionConfig) => {
     allActions.push(
       mapActionGroup(
         "base",
-        () => actionsMapBase25(
+        () => actionsMapBase26(
           diff2,
           oldObj,
           newObj,
@@ -3842,6 +4444,142 @@ var subscriptions_default = (actionGroupList, syncActionConfig = {}) => {
   return { buildActions };
 };
 
+// src/standalone-variants/standalone-variant-actions.ts
+function convertAttributeToUpdateActionShape(attribute) {
+  const { name, value } = attribute;
+  return {
+    name,
+    ...typeof value !== "undefined" ? {
+      value: JSON.stringify(value)
+    } : {}
+  };
+}
+function _buildStagedAction(actionName, payload, config = {}) {
+  const action = {
+    action: actionName,
+    ...payload
+  };
+  if (config.staged !== false) {
+    action.staged = true;
+  }
+  return action;
+}
+function _buildKeyAction(variantDiff, oldVariant) {
+  if ({}.hasOwnProperty.call(variantDiff, "key")) {
+    const newValue = getDeltaValue(
+      variantDiff.key
+    );
+    if (!newValue && !oldVariant.key) return null;
+    return {
+      action: "setKey",
+      key: newValue || void 0
+    };
+  }
+  return null;
+}
+function _buildSkuAction(variantDiff, oldVariant, config = {}) {
+  if ({}.hasOwnProperty.call(variantDiff, "sku")) {
+    const newValue = getDeltaValue(
+      variantDiff.sku
+    );
+    if (!newValue && !oldVariant.sku) return null;
+    return _buildStagedAction("setSku", { sku: newValue || void 0 }, config);
+  }
+  return null;
+}
+function _buildPublishAction(oldVariant, newVariant) {
+  if (oldVariant.published !== true && newVariant.published === true) {
+    return { action: "publish" };
+  }
+  if (oldVariant.published === true && newVariant.published !== true) {
+    return { action: "unpublish" };
+  }
+  return null;
+}
+function actionsMapBase27(diff2, oldVariant, newVariant, config = {}) {
+  const actions = [];
+  if (!oldVariant || !diff2) {
+    return actions;
+  }
+  const keyAction = _buildKeyAction(diff2, oldVariant);
+  if (keyAction) {
+    actions.push(keyAction);
+  }
+  const skuAction = _buildSkuAction(diff2, oldVariant, config);
+  if (skuAction) {
+    actions.push(skuAction);
+  }
+  const publishAction = _buildPublishAction(oldVariant, newVariant);
+  if (publishAction) {
+    actions.push(publishAction);
+  }
+  return actions;
+}
+function actionsMapAttributes3(diff2, _oldVariant, newVariant, config = {}) {
+  if (!diff2?.attributes) {
+    return [];
+  }
+  const attributes = (newVariant.attributes || []).map(
+    convertAttributeToUpdateActionShape
+  );
+  return [_buildStagedAction("setAttributes", { attributes }, config)];
+}
+function actionsMapImages3(diff2, _oldVariant, newVariant, config = {}) {
+  if (!diff2?.images) {
+    return [];
+  }
+  const images = newVariant.images || [];
+  return [_buildStagedAction("setImages", { images }, config)];
+}
+function actionsMapAssets4(diff2, _oldVariant, newVariant, config = {}) {
+  if (!diff2?.assets) {
+    return [];
+  }
+  const assets = newVariant.assets || [];
+  return [_buildStagedAction("setAssets", { assets }, config)];
+}
+
+// src/standalone-variants/standalone-variants.ts
+function createStandaloneVariantsMapActions(mapActionGroup, syncActionConfig) {
+  return function doMapActions(diff2, newObj, oldObj) {
+    const allActions = [];
+    allActions.push(
+      ...mapActionGroup(
+        "base",
+        () => actionsMapBase27(diff2, oldObj, newObj, syncActionConfig)
+      )
+    );
+    allActions.push(
+      ...mapActionGroup(
+        "attributes",
+        () => actionsMapAttributes3(diff2, oldObj, newObj, syncActionConfig)
+      )
+    );
+    allActions.push(
+      ...mapActionGroup(
+        "images",
+        () => actionsMapImages3(diff2, oldObj, newObj, syncActionConfig)
+      )
+    );
+    allActions.push(
+      ...mapActionGroup(
+        "assets",
+        () => actionsMapAssets4(diff2, oldObj, newObj, syncActionConfig)
+      )
+    );
+    return allActions;
+  };
+}
+function createSyncStandaloneVariants(actionGroupList, syncActionConfig = {}) {
+  const mapActionGroup = createMapActionGroup(actionGroupList);
+  const doMapActions = createStandaloneVariantsMapActions(
+    mapActionGroup,
+    syncActionConfig
+  );
+  const buildActions = createBuildActions(diff, doMapActions);
+  return { buildActions };
+}
+
 // src/utils/types.ts
 var types_exports = {};
 __reExport(types_exports, platform_sdk_star);
@@ -3863,12 +4601,14 @@ export {
   orders_default as createSyncOrders,
   product_discounts_default as createSyncProductDiscounts,
   product_selections_default as createSyncProductSelections,
+  product_tailoring_default as createSyncProductTailoring,
   product_types_default as createSyncProductTypes,
   products_default as createSyncProducts,
   projects_default as createSyncProjects,
   recurring_orders_default as createSyncRecurringOrders,
   shipping_methods_default as createSyncShippingMethods,
   prices_default as createSyncStandalonePrices,
+  createSyncStandaloneVariants,
   states_default as createSyncStates,
   stores_default as createSyncStores,
   subscriptions_default as createSyncSubscriptions,