@truedat/df 8.7.0 → 8.7.1

package/src/templates/utils/flattenFields.js

@@ -3,6 +3,6 @@ import _ from "lodash/fp";
 export const flattenFields = _.flow(
   _.propOr([], "content"),
   _.flatMap(({ fields, name: group }) =>
-    _.map((f) => ({ ...f, group }))(fields)
-  )
+    _.map((f) => ({ ...f, group }))(fields),
+  ),
 );

package/src/templates/utils/formatLegacyContent.js

@@ -1,3 +1,4 @@
 import _ from "lodash/fp";
 
-export const formatLegacyContent = (content) => _.mapValues(value => ({ value, origin: "user" }))(content);
+export const formatLegacyContent = (content) =>
+  _.mapValues((value) => ({ value, origin: "user" }))(content);

package/src/templates/utils/parseFieldOptions.js

@@ -38,6 +38,7 @@ const buildGroupNameMap = (groups = []) =>
   groups.reduce((acc, group) => {
     const canonicalName = groupCanonicalName(group);
     groupNameCandidates(group).forEach((candidate) => {
+      // eslint-disable-next-line fp/no-mutation
       acc[candidate] = canonicalName;
     });
     return acc;
@@ -108,8 +109,8 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
     const tableColumns = _.flow(
       _.propOr([], "values.table_columns"),
       _.map((field) =>
-        doParseFieldOptions(formatMessage, content, selectedDomain, field)
-      )
+        doParseFieldOptions(formatMessage, content, selectedDomain, field),
+      ),
     )(field);
     return {
       ...field,
@@ -119,12 +120,12 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
   }
   const translateValues = _.flow(
     makeOptions(formatMessage, field?.label),
-    _.sortBy(accentInsensitivePathOrder("text"))
+    _.sortBy(accentInsensitivePathOrder("text")),
   );
   const parseSwitch = (values) => {
     const switchOn = _.prop("switch.on")(values);
     const switchedValues = _.prop(`switch.values.${content[switchOn].value}`)(
-      values
+      values,
     );
     return translateValues(switchedValues);
   };
@@ -135,7 +136,7 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
       [_.isArray, _.identity],
       [_.stubTrue, _.constant([])],
     ]),
-    translateValues
+    translateValues,
   );
   const parseRoleGroups = (values) => {
     const isGroupOnly = field?.type === "group";
@@ -148,7 +149,7 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
           text: groupDisplayName(group),
           icon: "group",
         };
-      })
+      }),
     )(values);
     if (isGroupOnly) return groups;
 
@@ -158,7 +159,7 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
         value: `user:${name}`,
         text: name,
         icon: "user",
-      }))
+      })),
     )(values);
 
     return _.concat(users, groups);
@@ -178,7 +179,7 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
           }) || [];
       return _.uniq(allValues);
     },
-    translateValues
+    translateValues,
   );
 
   const parsedValues = _.flow(
@@ -190,7 +191,7 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
       [_.has("role_users"), parseRoleUsers],
       [_.has("role_groups"), parseRoleGroups],
       [_.has("domain"), parseDomain],
-    ])
+    ]),
   )(field);
   const normalizedValue = _.flow(
     _.get("values"),
@@ -201,8 +202,8 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
           normalizeFieldValue(value, (rawValue) =>
             normalizeRoleUsersValue(
               rawValue,
-              _.getOr([], "values.processed_users")(field)
-            )
+              _.getOr([], "values.processed_users")(field),
+            ),
           ),
       ],
       [
@@ -212,12 +213,12 @@ const doParseFieldOptions = (formatMessage, content, selectedDomain, field) => {
             normalizeRoleGroupsValue(
               rawValue,
               field?.type,
-              _.get("values")(field)
-            )
+              _.get("values")(field),
+            ),
           ),
       ],
       [_.stubTrue, () => value],
-    ])
+    ]),
   )(field);
 
   return { ...field, value: normalizedValue, parsedValues };

package/src/templates/utils/parseGroups.js

@@ -31,7 +31,7 @@ export const parseGroups =
                 (hasDependentKeys(field) && checkDependency(field, content))) &&
               (!(field.values && "switch" in field.values) ||
                 _.prop(`${_.prop("values.switch.on")(field)}.value`)(content) in
-                _.prop("values.switch.values")(field)),
+                  _.prop("values.switch.values")(field)),
           ),
           _.map(parseFieldOptions(formatMessage)(content, selectedDomain)),
           _.map(enrichRequired(content)),
@@ -44,47 +44,47 @@ export const parseGroups =
 
 export const parseGroupsWithLangs =
   (formatMessage) =>
-    (template, i18nContent, fieldsToOmit, selectedDomain, requiredLangs = []) => {
-      return _.flow(
-        _.getOr([], "content"),
-        _.map((group) => {
-          const langs = _.flow(
-            _.toPairs,
-            _.map(([lang, langContent]) => {
-              const fields = _.flow(
-                _.get("fields"),
-                _.reject((field) => _.includes(fieldsToOmit)(field?.name)),
-                _.filter((field) => {
-                  return (
-                    (!("depends" in field) ||
-                      (hasDependentKeys(field) &&
-                        checkDependency(field, langContent))) &&
-                    (!(field.values && "switch" in field.values) ||
-                      _.prop(`${_.prop("values.switch.on")(field)}.value`)(
-                        langContent,
-                      ) in _.prop("values.switch.values")(field))
-                  );
-                }),
-                _.map(
-                  _.flow(
-                    parseFieldOptions(formatMessage)(langContent, selectedDomain),
-                    (field) => requiredLangs.includes(lang)
+  (template, i18nContent, fieldsToOmit, selectedDomain, requiredLangs = []) => {
+    return _.flow(
+      _.getOr([], "content"),
+      _.map((group) => {
+        const langs = _.flow(
+          _.toPairs,
+          _.map(([lang, langContent]) => {
+            const fields = _.flow(
+              _.get("fields"),
+              _.reject((field) => _.includes(fieldsToOmit)(field?.name)),
+              _.filter((field) => {
+                return (
+                  (!("depends" in field) ||
+                    (hasDependentKeys(field) &&
+                      checkDependency(field, langContent))) &&
+                  (!(field.values && "switch" in field.values) ||
+                    _.prop(`${_.prop("values.switch.on")(field)}.value`)(
+                      langContent,
+                    ) in _.prop("values.switch.values")(field))
+                );
+              }),
+              _.map(
+                _.flow(
+                  parseFieldOptions(formatMessage)(langContent, selectedDomain),
+                  (field) =>
+                    requiredLangs.includes(lang)
                       ? enrichRequired(langContent)(field)
-                      : { ...field, required: false }
-                    ,
-                    enrichIsSecret(_.get("is_secret")(group)),
-                  ),
+                      : { ...field, required: false },
+                  enrichIsSecret(_.get("is_secret")(group)),
                 ),
-              )(group);
-              return [lang, fields];
-            }),
-            _.fromPairs,
-          )(i18nContent);
-          return {
-            name: group.name,
-            langs,
-          };
-        }),
-        _.filter(({ langs }) => _.some((fields) => !_.isEmpty(fields))(langs)),
-      )(template);
-    };
+              ),
+            )(group);
+            return [lang, fields];
+          }),
+          _.fromPairs,
+        )(i18nContent);
+        return {
+          name: group.name,
+          langs,
+        };
+      }),
+      _.filter(({ langs }) => _.some((fields) => !_.isEmpty(fields))(langs)),
+    )(template);
+  };

package/src/templates/utils/validateContent.js

@@ -20,7 +20,7 @@ const isTableRequired = (field, content) => {
 
     return _.flow(
       _.pathOr([], "values.table_columns"),
-      _.any((nestedField) => _.includes(nestedField?.cardinality)(["1", "+"]))
+      _.any((nestedField) => _.includes(nestedField?.cardinality)(["1", "+"])),
     )(field);
   }
 
@@ -50,7 +50,7 @@ const isEmptyField = (field, content) => {
 
     const requiredErrors = _.flow(
       _.map((row) => _.flow(validateRequired(tableColumns), _.head)([[], row])),
-      _.flatten
+      _.flatten,
     )(rowValues);
 
     return !_.isEmpty(requiredErrors);
@@ -93,12 +93,12 @@ export const enrichRequired = (content) => (field) => {
   if (field?.type === "dynamic_table" && _.has("values.table_columns")(field)) {
     const tableColumns = _.flow(
       _.propOr([], "values.table_columns"),
-      _.map((field) => enrichRequired({})(field))
+      _.map((field) => enrichRequired({})(field)),
     )(field);
 
     return _.flow(
       _.set("values.table_columns", tableColumns),
-      _.set("required", required)
+      _.set("required", required),
     )(field);
   }