@bigbinary/neeto-fields-frontend 1.1.7 → 1.1.8

package/dist/index.cjs.js

@@ -5285,7 +5285,7 @@ var titles = {
 	field_other: "Fields",
 	addField: "Add new field",
 	editField: "Edit field",
-	deleteField: "Delete field ?",
+	deleteField: "Delete field?",
 	fieldName: "Field name",
 	fieldKind: "Field type",
 	required: "Required",
@@ -5342,7 +5342,8 @@ var fields = {
 };
 var messages = {
 	noFields: "There are no {{title}} to show",
-	confirmDelete: "Are you sure want to delete the field? This action cannot be undone.",
+	confirmDelete: "You are permanently deleting the field <strong>{{name}}</strong>. This action can't be undone.",
+	confirmDeleteWithCount: "You are permanently deleting the field <strong>{{name}}</strong> which holds values for <strong>{{count}} {{resource}}</strong>. The values will be lost on deleting the field. This action can't be undone.",
 	manageFieldFor: "Manage fields for {{resource}}",
 	manageTitleForResource: "Manage {{title}} for {{resource}}",
 	titleForResource: "{{title}} for {{resource}}",
@@ -6402,6 +6403,7 @@ var FIELDS_URL = "".concat(NEETO_FIELDS_URL, "/fields");
 var FIELD_VALUES_URL = "".concat(NEETO_FIELDS_URL, "/field_values");
 var FIELD_VALUE_URL = "".concat(NEETO_FIELDS_URL, "/field_values/:fieldValueId");
 var FIELD_URL = "".concat(NEETO_FIELDS_URL, "/fields/:fieldId");
+var DEPENDENCIES_URL = "".concat(NEETO_FIELDS_URL, "/fields/:fieldId/dependencies");
 var FIELDS_REORDER_URL = "".concat(FIELDS_URL, "/reorder");
 var CONFIGS_URL = "".concat(NEETO_FIELDS_URL, "/configs");
 var SINGULAR = {
@@ -6431,6 +6433,11 @@ var fieldUrl = function fieldUrl(fieldId) {
     fieldId: fieldId
   });
 };
+var dependenciesUrl = function dependenciesUrl(fieldId) {
+  return utils.buildUrl(DEPENDENCIES_URL, {
+    fieldId: fieldId
+  });
+};
 var fetch$1 = function fetch(_ref) {
   var resourceType = _ref.resourceType,
     ownerId = _ref.ownerId,
@@ -6474,25 +6481,37 @@ var update$1 = function update(_ref4) {
 var reorder = function reorder(payload) {
   return axios__default["default"].patch(FIELDS_REORDER_URL, payload);
 };
+var dependencies = function dependencies(_ref5) {
+  var fieldId = _ref5.fieldId,
+    ownerId = _ref5.ownerId;
+  return axios__default["default"].get(dependenciesUrl(fieldId), {
+    params: {
+      ownerId: ownerId
+    }
+  });
+};
 var fieldsApi = {
   fetch: fetch$1,
   create: create$1,
   show: show,
   destroy: destroy$1,
   update: update$1,
-  reorder: reorder
+  reorder: reorder,
+  dependencies: dependencies
 };
 
 var QUERY_KEYS = {
   FIELDS: "fields",
   FIELD_VALUES: "field_values",
-  CONFIGS: "configurations"
+  CONFIGS: "configurations",
+  DEPENDENCIES: "dependencies"
 };
 var DEFAULT_STALE_TIME = 3600000; // 1 hour
 
 function ownKeys$8(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread$8(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$8(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$8(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var FIELDS = QUERY_KEYS.FIELDS;
+var FIELDS = QUERY_KEYS.FIELDS,
+  DEPENDENCIES = QUERY_KEYS.DEPENDENCIES;
 var useFetchFields = function useFetchFields(_ref, options) {
   var resourceType = _ref.resourceType,
     ownerId = _ref.ownerId,
@@ -6535,6 +6554,16 @@ var useShowField = function useShowField(_ref2, options) {
     });
   }, options);
 };
+var useFetchDependencies = function useFetchDependencies(_ref3, options) {
+  var fieldId = _ref3.fieldId,
+    ownerId = _ref3.ownerId;
+  return reactQuery.useQuery([DEPENDENCIES, fieldId], function () {
+    return fieldsApi.dependencies({
+      fieldId: fieldId,
+      ownerId: ownerId
+    });
+  }, options);
+};
 var useUpdateField = function useUpdateField(options) {
   var queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation(fieldsApi.update, _objectSpread$8(_objectSpread$8({}, options), {}, {
@@ -7045,6 +7074,517 @@ var FieldsPane = function FieldsPane(_ref) {
   }, props)));
 };
 
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var pluralize$1 = {exports: {}};
+
+/* global define */
+pluralize$1.exports;
+
+(function (module, exports) {
+	(function (root, pluralize) {
+	  /* istanbul ignore else */
+	  if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') {
+	    // Node.
+	    module.exports = pluralize();
+	  } else {
+	    // Browser global.
+	    root.pluralize = pluralize();
+	  }
+	})(commonjsGlobal, function () {
+	  // Rule storage - pluralize and singularize need to be run sequentially,
+	  // while other rules can be optimized using an object for instant lookups.
+	  var pluralRules = [];
+	  var singularRules = [];
+	  var uncountables = {};
+	  var irregularPlurals = {};
+	  var irregularSingles = {};
+
+	  /**
+	   * Sanitize a pluralization rule to a usable regular expression.
+	   *
+	   * @param  {(RegExp|string)} rule
+	   * @return {RegExp}
+	   */
+	  function sanitizeRule (rule) {
+	    if (typeof rule === 'string') {
+	      return new RegExp('^' + rule + '$', 'i');
+	    }
+
+	    return rule;
+	  }
+
+	  /**
+	   * Pass in a word token to produce a function that can replicate the case on
+	   * another word.
+	   *
+	   * @param  {string}   word
+	   * @param  {string}   token
+	   * @return {Function}
+	   */
+	  function restoreCase (word, token) {
+	    // Tokens are an exact match.
+	    if (word === token) return token;
+
+	    // Lower cased words. E.g. "hello".
+	    if (word === word.toLowerCase()) return token.toLowerCase();
+
+	    // Upper cased words. E.g. "WHISKY".
+	    if (word === word.toUpperCase()) return token.toUpperCase();
+
+	    // Title cased words. E.g. "Title".
+	    if (word[0] === word[0].toUpperCase()) {
+	      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+	    }
+
+	    // Lower cased words. E.g. "test".
+	    return token.toLowerCase();
+	  }
+
+	  /**
+	   * Interpolate a regexp string.
+	   *
+	   * @param  {string} str
+	   * @param  {Array}  args
+	   * @return {string}
+	   */
+	  function interpolate (str, args) {
+	    return str.replace(/\$(\d{1,2})/g, function (match, index) {
+	      return args[index] || '';
+	    });
+	  }
+
+	  /**
+	   * Replace a word using a rule.
+	   *
+	   * @param  {string} word
+	   * @param  {Array}  rule
+	   * @return {string}
+	   */
+	  function replace (word, rule) {
+	    return word.replace(rule[0], function (match, index) {
+	      var result = interpolate(rule[1], arguments);
+
+	      if (match === '') {
+	        return restoreCase(word[index - 1], result);
+	      }
+
+	      return restoreCase(match, result);
+	    });
+	  }
+
+	  /**
+	   * Sanitize a word by passing in the word and sanitization rules.
+	   *
+	   * @param  {string}   token
+	   * @param  {string}   word
+	   * @param  {Array}    rules
+	   * @return {string}
+	   */
+	  function sanitizeWord (token, word, rules) {
+	    // Empty string or doesn't need fixing.
+	    if (!token.length || uncountables.hasOwnProperty(token)) {
+	      return word;
+	    }
+
+	    var len = rules.length;
+
+	    // Iterate over the sanitization rules and use the first one to match.
+	    while (len--) {
+	      var rule = rules[len];
+
+	      if (rule[0].test(word)) return replace(word, rule);
+	    }
+
+	    return word;
+	  }
+
+	  /**
+	   * Replace a word with the updated word.
+	   *
+	   * @param  {Object}   replaceMap
+	   * @param  {Object}   keepMap
+	   * @param  {Array}    rules
+	   * @return {Function}
+	   */
+	  function replaceWord (replaceMap, keepMap, rules) {
+	    return function (word) {
+	      // Get the correct token and case restoration functions.
+	      var token = word.toLowerCase();
+
+	      // Check against the keep object map.
+	      if (keepMap.hasOwnProperty(token)) {
+	        return restoreCase(word, token);
+	      }
+
+	      // Check against the replacement map for a direct word replacement.
+	      if (replaceMap.hasOwnProperty(token)) {
+	        return restoreCase(word, replaceMap[token]);
+	      }
+
+	      // Run all the rules against the word.
+	      return sanitizeWord(token, word, rules);
+	    };
+	  }
+
+	  /**
+	   * Check if a word is part of the map.
+	   */
+	  function checkWord (replaceMap, keepMap, rules, bool) {
+	    return function (word) {
+	      var token = word.toLowerCase();
+
+	      if (keepMap.hasOwnProperty(token)) return true;
+	      if (replaceMap.hasOwnProperty(token)) return false;
+
+	      return sanitizeWord(token, token, rules) === token;
+	    };
+	  }
+
+	  /**
+	   * Pluralize or singularize a word based on the passed in count.
+	   *
+	   * @param  {string}  word      The word to pluralize
+	   * @param  {number}  count     How many of the word exist
+	   * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+	   * @return {string}
+	   */
+	  function pluralize (word, count, inclusive) {
+	    var pluralized = count === 1
+	      ? pluralize.singular(word) : pluralize.plural(word);
+
+	    return (inclusive ? count + ' ' : '') + pluralized;
+	  }
+
+	  /**
+	   * Pluralize a word.
+	   *
+	   * @type {Function}
+	   */
+	  pluralize.plural = replaceWord(
+	    irregularSingles, irregularPlurals, pluralRules
+	  );
+
+	  /**
+	   * Check if a word is plural.
+	   *
+	   * @type {Function}
+	   */
+	  pluralize.isPlural = checkWord(
+	    irregularSingles, irregularPlurals, pluralRules
+	  );
+
+	  /**
+	   * Singularize a word.
+	   *
+	   * @type {Function}
+	   */
+	  pluralize.singular = replaceWord(
+	    irregularPlurals, irregularSingles, singularRules
+	  );
+
+	  /**
+	   * Check if a word is singular.
+	   *
+	   * @type {Function}
+	   */
+	  pluralize.isSingular = checkWord(
+	    irregularPlurals, irregularSingles, singularRules
+	  );
+
+	  /**
+	   * Add a pluralization rule to the collection.
+	   *
+	   * @param {(string|RegExp)} rule
+	   * @param {string}          replacement
+	   */
+	  pluralize.addPluralRule = function (rule, replacement) {
+	    pluralRules.push([sanitizeRule(rule), replacement]);
+	  };
+
+	  /**
+	   * Add a singularization rule to the collection.
+	   *
+	   * @param {(string|RegExp)} rule
+	   * @param {string}          replacement
+	   */
+	  pluralize.addSingularRule = function (rule, replacement) {
+	    singularRules.push([sanitizeRule(rule), replacement]);
+	  };
+
+	  /**
+	   * Add an uncountable word rule.
+	   *
+	   * @param {(string|RegExp)} word
+	   */
+	  pluralize.addUncountableRule = function (word) {
+	    if (typeof word === 'string') {
+	      uncountables[word.toLowerCase()] = true;
+	      return;
+	    }
+
+	    // Set singular and plural references for the word.
+	    pluralize.addPluralRule(word, '$0');
+	    pluralize.addSingularRule(word, '$0');
+	  };
+
+	  /**
+	   * Add an irregular word definition.
+	   *
+	   * @param {string} single
+	   * @param {string} plural
+	   */
+	  pluralize.addIrregularRule = function (single, plural) {
+	    plural = plural.toLowerCase();
+	    single = single.toLowerCase();
+
+	    irregularSingles[single] = plural;
+	    irregularPlurals[plural] = single;
+	  };
+
+	  /**
+	   * Irregular rules.
+	   */
+	  [
+	    // Pronouns.
+	    ['I', 'we'],
+	    ['me', 'us'],
+	    ['he', 'they'],
+	    ['she', 'they'],
+	    ['them', 'them'],
+	    ['myself', 'ourselves'],
+	    ['yourself', 'yourselves'],
+	    ['itself', 'themselves'],
+	    ['herself', 'themselves'],
+	    ['himself', 'themselves'],
+	    ['themself', 'themselves'],
+	    ['is', 'are'],
+	    ['was', 'were'],
+	    ['has', 'have'],
+	    ['this', 'these'],
+	    ['that', 'those'],
+	    // Words ending in with a consonant and `o`.
+	    ['echo', 'echoes'],
+	    ['dingo', 'dingoes'],
+	    ['volcano', 'volcanoes'],
+	    ['tornado', 'tornadoes'],
+	    ['torpedo', 'torpedoes'],
+	    // Ends with `us`.
+	    ['genus', 'genera'],
+	    ['viscus', 'viscera'],
+	    // Ends with `ma`.
+	    ['stigma', 'stigmata'],
+	    ['stoma', 'stomata'],
+	    ['dogma', 'dogmata'],
+	    ['lemma', 'lemmata'],
+	    ['schema', 'schemata'],
+	    ['anathema', 'anathemata'],
+	    // Other irregular rules.
+	    ['ox', 'oxen'],
+	    ['axe', 'axes'],
+	    ['die', 'dice'],
+	    ['yes', 'yeses'],
+	    ['foot', 'feet'],
+	    ['eave', 'eaves'],
+	    ['goose', 'geese'],
+	    ['tooth', 'teeth'],
+	    ['quiz', 'quizzes'],
+	    ['human', 'humans'],
+	    ['proof', 'proofs'],
+	    ['carve', 'carves'],
+	    ['valve', 'valves'],
+	    ['looey', 'looies'],
+	    ['thief', 'thieves'],
+	    ['groove', 'grooves'],
+	    ['pickaxe', 'pickaxes'],
+	    ['passerby', 'passersby']
+	  ].forEach(function (rule) {
+	    return pluralize.addIrregularRule(rule[0], rule[1]);
+	  });
+
+	  /**
+	   * Pluralization rules.
+	   */
+	  [
+	    [/s?$/i, 's'],
+	    [/[^\u0000-\u007F]$/i, '$0'],
+	    [/([^aeiou]ese)$/i, '$1'],
+	    [/(ax|test)is$/i, '$1es'],
+	    [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],
+	    [/(e[mn]u)s?$/i, '$1s'],
+	    [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],
+	    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],
+	    [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'],
+	    [/(seraph|cherub)(?:im)?$/i, '$1im'],
+	    [/(her|at|gr)o$/i, '$1oes'],
+	    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],
+	    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],
+	    [/sis$/i, 'ses'],
+	    [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],
+	    [/([^aeiouy]|qu)y$/i, '$1ies'],
+	    [/([^ch][ieo][ln])ey$/i, '$1ies'],
+	    [/(x|ch|ss|sh|zz)$/i, '$1es'],
+	    [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],
+	    [/\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'],
+	    [/(pe)(?:rson|ople)$/i, '$1ople'],
+	    [/(child)(?:ren)?$/i, '$1ren'],
+	    [/eaux$/i, '$0'],
+	    [/m[ae]n$/i, 'men'],
+	    ['thou', 'you']
+	  ].forEach(function (rule) {
+	    return pluralize.addPluralRule(rule[0], rule[1]);
+	  });
+
+	  /**
+	   * Singularization rules.
+	   */
+	  [
+	    [/s$/i, ''],
+	    [/(ss)$/i, '$1'],
+	    [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, '$1fe'],
+	    [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'],
+	    [/ies$/i, 'y'],
+	    [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],
+	    [/\b(mon|smil)ies$/i, '$1ey'],
+	    [/\b((?:tit)?m|l)ice$/i, '$1ouse'],
+	    [/(seraph|cherub)im$/i, '$1'],
+	    [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],
+	    [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],
+	    [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'],
+	    [/(test)(?:is|es)$/i, '$1is'],
+	    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],
+	    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],
+	    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],
+	    [/(alumn|alg|vertebr)ae$/i, '$1a'],
+	    [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],
+	    [/(matr|append)ices$/i, '$1ix'],
+	    [/(pe)(rson|ople)$/i, '$1rson'],
+	    [/(child)ren$/i, '$1'],
+	    [/(eau)x?$/i, '$1'],
+	    [/men$/i, 'man']
+	  ].forEach(function (rule) {
+	    return pluralize.addSingularRule(rule[0], rule[1]);
+	  });
+
+	  /**
+	   * Uncountable rules.
+	   */
+	  [
+	    // Singular words with no plurals.
+	    'adulthood',
+	    'advice',
+	    'agenda',
+	    'aid',
+	    'aircraft',
+	    'alcohol',
+	    'ammo',
+	    'analytics',
+	    'anime',
+	    'athletics',
+	    'audio',
+	    'bison',
+	    'blood',
+	    'bream',
+	    'buffalo',
+	    'butter',
+	    'carp',
+	    'cash',
+	    'chassis',
+	    'chess',
+	    'clothing',
+	    'cod',
+	    'commerce',
+	    'cooperation',
+	    'corps',
+	    'debris',
+	    'diabetes',
+	    'digestion',
+	    'elk',
+	    'energy',
+	    'equipment',
+	    'excretion',
+	    'expertise',
+	    'firmware',
+	    'flounder',
+	    'fun',
+	    'gallows',
+	    'garbage',
+	    'graffiti',
+	    'hardware',
+	    'headquarters',
+	    'health',
+	    'herpes',
+	    'highjinks',
+	    'homework',
+	    'housework',
+	    'information',
+	    'jeans',
+	    'justice',
+	    'kudos',
+	    'labour',
+	    'literature',
+	    'machinery',
+	    'mackerel',
+	    'mail',
+	    'media',
+	    'mews',
+	    'moose',
+	    'music',
+	    'mud',
+	    'manga',
+	    'news',
+	    'only',
+	    'personnel',
+	    'pike',
+	    'plankton',
+	    'pliers',
+	    'police',
+	    'pollution',
+	    'premises',
+	    'rain',
+	    'research',
+	    'rice',
+	    'salmon',
+	    'scissors',
+	    'series',
+	    'sewage',
+	    'shambles',
+	    'shrimp',
+	    'software',
+	    'species',
+	    'staff',
+	    'swine',
+	    'tennis',
+	    'traffic',
+	    'transportation',
+	    'trout',
+	    'tuna',
+	    'wealth',
+	    'welfare',
+	    'whiting',
+	    'wildebeest',
+	    'wildlife',
+	    'you',
+	    /pok[eé]mon$/i,
+	    // Regexes.
+	    /[^aeiou]ese$/i, // "chinese", "japanese"
+	    /deer$/i, // "deer", "reindeer"
+	    /fish$/i, // "fish", "blowfish", "angelfish"
+	    /measles$/i,
+	    /o[iu]s$/i, // "carnivorous"
+	    /pox$/i, // "chickpox", "smallpox"
+	    /sheep$/i
+	  ].forEach(pluralize.addUncountableRule);
+
+	  return pluralize;
+	}); 
+} (pluralize$1, pluralize$1.exports));
+
+var pluralizeExports = pluralize$1.exports;
+var pluralize = /*@__PURE__*/getDefaultExportFromCjs(pluralizeExports);
+
 var Menu = neetoui.Dropdown.Menu,
   MenuItem = neetoui.Dropdown.MenuItem;
 var buildDefaultColumns = function buildDefaultColumns(_ref) {
@@ -7166,32 +7706,38 @@ var renderMenuBarFilters = function renderMenuBarFilters(_ref3) {
     })
   }));
 };
-var getDashBoardTitle = function getDashBoardTitle(_ref4) {
-  var _findBy;
+var getResourceName = function getResourceName(_ref4) {
   var isOwnerBased = _ref4.isOwnerBased,
     owners = _ref4.owners,
     selectedVal = _ref4.selectedVal,
-    nameAliases = _ref4.nameAliases,
-    isSingleResource = _ref4.isSingleResource,
-    showStateFilter = _ref4.showStateFilter,
-    selectedState = _ref4.selectedState,
-    title = _ref4.title;
-  var resource = isOwnerBased ? (_findBy = pure.findBy({
-    id: selectedVal
-  }, owners)) === null || _findBy === void 0 ? void 0 : _findBy.name : nameAliases[selectedVal] || selectedVal;
+    nameAliases = _ref4.nameAliases;
+  if (isOwnerBased) {
+    var _findBy;
+    return (_findBy = pure.findBy({
+      id: selectedVal
+    }, owners)) === null || _findBy === void 0 ? void 0 : _findBy.name;
+  }
+  return nameAliases[selectedVal] || selectedVal;
+};
+var getDashBoardTitle = function getDashBoardTitle(_ref5) {
+  var resourceName = _ref5.resourceName,
+    isSingleResource = _ref5.isSingleResource,
+    showStateFilter = _ref5.showStateFilter,
+    selectedState = _ref5.selectedState,
+    title = _ref5.title;
   var displayTitle = title;
   if (showStateFilter && !isSingleResource) {
     displayTitle = t$1("messages.stateTitleForResource", {
       state: selectedState,
       title: title,
-      resource: resource
+      resource: resourceName
     });
   } else if (showStateFilter && isSingleResource) {
     displayTitle = "".concat(selectedState, " ").concat(title);
   } else if (!showStateFilter && !isSingleResource) {
     displayTitle = t$1("messages.titleForResource", {
       title: title,
-      resource: resource
+      resource: resourceName
     });
   }
   return pure.humanize(displayTitle);
@@ -7214,6 +7760,24 @@ var renderNoDataHelpText = function renderNoDataHelpText(title, url) {
     }
   });
 };
+var getDeletionConfirmationMessage = function getDeletionConfirmationMessage(_ref6) {
+  var resource = _ref6.resource,
+    fieldName = _ref6.fieldName,
+    affectedResourcesCount = _ref6.affectedResourcesCount;
+  return affectedResourcesCount > 0 ? /*#__PURE__*/React__default["default"].createElement(Trans, {
+    i18nKey: "messages.confirmDeleteWithCount",
+    values: {
+      resource: pluralize(resource, affectedResourcesCount),
+      name: fieldName,
+      count: affectedResourcesCount
+    }
+  }) : /*#__PURE__*/React__default["default"].createElement(Trans, {
+    i18nKey: "messages.confirmDelete",
+    values: {
+      name: fieldName
+    }
+  });
+};
 
 var fetchConfigs = function fetchConfigs() {
   return axios__default["default"].get(CONFIGS_URL);
@@ -7388,18 +7952,23 @@ var useFieldsDashboard = function useFieldsDashboard(_ref) {
   };
   var isSingleResource = menuItems.length === 1;
   var isMenuBarNeeded = showStateFilter || !isSingleResource;
-  var headerDisplayTitle = React.useMemo(function () {
-    return getDashBoardTitle({
+  var resourceName = React.useMemo(function () {
+    return getResourceName({
       isOwnerBased: isOwnerBased,
-      owners: menuItems,
-      selectedVal: resource,
       nameAliases: nameAliases,
+      owners: menuItems,
+      selectedVal: resource
+    });
+  }, [menuItems, resource]);
+  var headerDisplayTitle = React.useMemo(function () {
+    return getDashBoardTitle({
+      resourceName: resourceName,
       showStateFilter: showStateFilter,
       selectedState: state,
       isSingleResource: isSingleResource,
       title: title
     });
-  }, [resource, state, isSingleResource, menuItems]);
+  }, [state, isSingleResource, resourceName]);
   var menuBarFilters = React.useMemo(function () {
     return renderMenuBarFilters({
       selectedState: state,
@@ -7437,6 +8006,7 @@ var useFieldsDashboard = function useFieldsDashboard(_ref) {
     selectedState: state,
     selectedMenu: resource,
     // resource will be ownerId if showOwnersInMenu is true, else it will be resourceType
+    ownerId: ownerId,
     isFieldsFetching: isFieldsFetching,
     isFieldsLoading: isFieldsLoading,
     isDeleting: isDeleting,
@@ -7456,6 +8026,41 @@ var useFieldsDashboard = function useFieldsDashboard(_ref) {
   };
 };
 
+var DeleteAlert = function DeleteAlert(_ref) {
+  var selectedField = _ref.selectedField,
+    ownerId = _ref.ownerId,
+    isDeleteAlertOpen = _ref.isDeleteAlertOpen,
+    isDeleting = _ref.isDeleting,
+    resourceTypeName = _ref.resourceTypeName,
+    handleAlertClose = _ref.handleAlertClose,
+    handleDelete = _ref.handleDelete;
+  var _useTranslation = useTranslation(),
+    t = _useTranslation.t;
+  var _useFetchDependencies = useFetchDependencies({
+      fieldId: selectedField.id,
+      ownerId: ownerId
+    }, {
+      enabled: isDeleteAlertOpen && pure.isNotEmpty(selectedField)
+    }),
+    _useFetchDependencies2 = _useFetchDependencies.data,
+    _useFetchDependencies3 = _useFetchDependencies2 === void 0 ? {} : _useFetchDependencies2,
+    affectedResourcesCount = _useFetchDependencies3.affectedResourcesCount;
+  return /*#__PURE__*/React__default["default"].createElement(neetoui.Alert, {
+    affectedResourcesCount: affectedResourcesCount,
+    isOpen: isDeleteAlertOpen,
+    isSubmitting: isDeleting,
+    submitButtonLabel: t("labels.delete"),
+    title: t("titles.deleteField"),
+    message: getDeletionConfirmationMessage({
+      resource: resourceTypeName,
+      affectedResourcesCount: affectedResourcesCount,
+      fieldName: selectedField === null || selectedField === void 0 ? void 0 : selectedField.name
+    }),
+    onClose: handleAlertClose,
+    onSubmit: handleDelete
+  });
+};
+
 var FieldsTable = function FieldsTable(_ref) {
   var totalCount = _ref.totalCount,
     isLoading = _ref.isLoading,
@@ -11905,6 +12510,7 @@ var FieldsDashboard = function FieldsDashboard(_ref) {
     selectedField = _useFieldsDashboard.selectedField,
     selectedState = _useFieldsDashboard.selectedState,
     selectedMenu = _useFieldsDashboard.selectedMenu,
+    ownerId = _useFieldsDashboard.ownerId,
     isFieldsFetching = _useFieldsDashboard.isFieldsFetching,
     isFieldsLoading = _useFieldsDashboard.isFieldsLoading,
     isDeleting = _useFieldsDashboard.isDeleting,
@@ -11989,13 +12595,14 @@ var FieldsDashboard = function FieldsDashboard(_ref) {
     ownerId: isOwnerBased ? selectedMenu : "",
     onClose: handleReorderPaneClose,
     allFields: allFields
-  }), /*#__PURE__*/React__default["default"].createElement(neetoui.Alert, {
-    isOpen: isDeleteAlertOpen,
-    isSubmitting: isDeleting,
-    message: t("messages.confirmDelete"),
-    title: t("titles.deleteField"),
-    onClose: handleAlertClose,
-    onSubmit: handleDelete
+  }), /*#__PURE__*/React__default["default"].createElement(DeleteAlert, {
+    handleAlertClose: handleAlertClose,
+    handleDelete: handleDelete,
+    isDeleteAlertOpen: isDeleteAlertOpen,
+    isDeleting: isDeleting,
+    ownerId: ownerId,
+    selectedField: selectedField,
+    resourceTypeName: isOwnerBased ? resourceType : selectedMenu
   }));
 };