@bigbinary/neeto-fields-frontend 2.0.0 → 2.2.0

package/dist/DeleteAlert-b92f7c05.js

@@ -0,0 +1,763 @@
+import { slugify, humanize, findBy, isPresent, isNotEmpty } from '@bigbinary/neeto-cist';
+import Alert from '@bigbinary/neetoui/Alert';
+import { Trans, useTranslation } from 'react-i18next';
+import { f as useFetchDependencies } from './useFieldsApi-5c114bac.js';
+import { t } from 'i18next';
+import MenuBar from '@bigbinary/neeto-molecules/MenuBar';
+import MoreDropdown from '@bigbinary/neeto-molecules/MoreDropdown';
+import Tab from '@bigbinary/neetoui/Tab';
+import Typography from '@bigbinary/neetoui/Typography';
+import Button from '@bigbinary/neetoui/Button';
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers-1789f0cf.js';
+import { not } from 'ramda';
+import { a as DISPLAY_KINDS, F as FIELD_STATES, M as MENU_ITEMS } from './constants-0e6017ea.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+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 getMenuItems = function getMenuItems(_ref) {
+  var field = _ref.field,
+    onDeleteClick = _ref.onDeleteClick,
+    onEditClick = _ref.onEditClick;
+  return [{
+    key: MENU_ITEMS.EDIT,
+    "data-cy": "edit-menu-item-button",
+    label: t("neetoFields.labels.edit"),
+    onClick: function onClick() {
+      return onEditClick(field);
+    }
+  }, {
+    key: MENU_ITEMS.DELETE,
+    "data-cy": "delete-menu-item-button",
+    label: t("neetoFields.labels.delete"),
+    isVisible: not(field.isSystem),
+    onClick: function onClick() {
+      return onDeleteClick(field);
+    }
+  }];
+};
+var buildDefaultColumns = function buildDefaultColumns(_ref2) {
+  var onDeleteClick = _ref2.onDeleteClick,
+    onEditClick = _ref2.onEditClick;
+  return [{
+    key: "name",
+    dataIndex: "name",
+    title: t("neetoFields.titles.fieldName"),
+    width: 300,
+    render: function render(name, field) {
+      return /*#__PURE__*/jsxs("div", {
+        className: "flex items-center justify-between gap-x-3",
+        children: [/*#__PURE__*/jsx(Typography, {
+          style: "body2",
+          children: name
+        }), /*#__PURE__*/jsx(MoreDropdown, {
+          dropdownProps: {
+            strategy: "fixed"
+          },
+          menuItems: getMenuItems({
+            field: field,
+            onDeleteClick: onDeleteClick,
+            onEditClick: onEditClick
+          }),
+          dropdownButtonProps: {
+            className: "flex-shrink-0",
+            "data-cy": "neeto-fields-options-dropdown"
+          }
+        })]
+      });
+    }
+  }, {
+    key: "kind",
+    dataIndex: "kind",
+    title: t("neetoFields.titles.fieldKind"),
+    render: function render(kind) {
+      return DISPLAY_KINDS[kind];
+    },
+    width: 180
+  }, {
+    key: "isRequired",
+    dataIndex: "isRequired",
+    title: t("neetoFields.titles.required"),
+    width: 140,
+    render: function render(boolVal) {
+      return boolVal ? t("neetoFields.common.yes") : t("neetoFields.common.no");
+    }
+  }];
+};
+var renderMenuBarItems = function renderMenuBarItems(_ref3) {
+  var items = _ref3.items,
+    isOwnerBased = _ref3.isOwnerBased,
+    selectedMenu = _ref3.selectedMenu,
+    handleBlockClick = _ref3.handleBlockClick,
+    nameAliases = _ref3.nameAliases,
+    title = _ref3.title;
+  title = title.toLocaleLowerCase();
+  if (isOwnerBased) {
+    return items.map(function (item) {
+      return /*#__PURE__*/jsx(MenuBar.Item, {
+        active: selectedMenu === item.id,
+        "data-cy": "menubar-".concat(slugify(item.name), "-menu-item"),
+        label: humanize(item.name),
+        description: t("neetoFields.messages.manageTitleForResource", {
+          title: title,
+          resource: humanize(item.name)
+        }),
+        onClick: handleBlockClick({
+          resource: item.id
+        })
+      }, item.id);
+    });
+  }
+  return items.length > 1 && items.map(function (_ref4) {
+    var label = _ref4.label,
+      value = _ref4.value;
+    var itemLabel = nameAliases[label] || humanize(label);
+    return /*#__PURE__*/jsx(MenuBar.Item, {
+      active: selectedMenu === value,
+      "data-cy": "neeto-fields-".concat(slugify(itemLabel), "-menu-item"),
+      label: itemLabel,
+      description: t("neetoFields.messages.manageTitleForResource", {
+        title: title,
+        resource: itemLabel
+      }),
+      onClick: handleBlockClick({
+        resource: value
+      })
+    }, label);
+  });
+};
+var renderStateFilterTabs = function renderStateFilterTabs(_ref5) {
+  var selectedState = _ref5.selectedState,
+    fieldStatesTaxonomy = _ref5.fieldStatesTaxonomy,
+    activeFieldsCount = _ref5.activeFieldsCount,
+    inactiveFieldsCount = _ref5.inactiveFieldsCount,
+    handleBlockClick = _ref5.handleBlockClick;
+  return /*#__PURE__*/jsxs(Tab, {
+    className: "mb-4",
+    children: [/*#__PURE__*/jsxs(Tab.Item, {
+      active: selectedState === FIELD_STATES.active,
+      "data-cy": "menubar-active-block",
+      onClick: handleBlockClick({
+        state: FIELD_STATES.active
+      }),
+      children: [fieldStatesTaxonomy.active, "(", activeFieldsCount, ")"]
+    }), /*#__PURE__*/jsxs(Tab.Item, {
+      active: selectedState === FIELD_STATES.inactive,
+      "data-cy": "menubar-inactive-block",
+      onClick: handleBlockClick({
+        state: FIELD_STATES.inactive
+      }),
+      children: [fieldStatesTaxonomy.inactive, "(", inactiveFieldsCount, ")"]
+    })]
+  });
+};
+var getResourceName = function getResourceName(_ref6) {
+  var _findBy2;
+  var isOwnerBased = _ref6.isOwnerBased,
+    menuItems = _ref6.menuItems,
+    selectedVal = _ref6.selectedVal,
+    nameAliases = _ref6.nameAliases;
+  if (isOwnerBased) {
+    var _findBy;
+    return (_findBy = findBy({
+      id: selectedVal
+    }, menuItems)) === null || _findBy === void 0 ? void 0 : _findBy.name;
+  }
+  var selectedName = (_findBy2 = findBy({
+    value: selectedVal
+  }, menuItems)) === null || _findBy2 === void 0 ? void 0 : _findBy2.label;
+  return nameAliases[selectedName] || selectedName;
+};
+var getDashBoardTitle = function getDashBoardTitle(_ref7) {
+  var resourceName = _ref7.resourceName,
+    isSingleResource = _ref7.isSingleResource,
+    title = _ref7.title;
+  var displayTitle = !isSingleResource && isPresent(resourceName) ? t("neetoFields.messages.titleForResource", {
+    title: title,
+    resource: resourceName
+  }) : title;
+  return humanize(displayTitle);
+};
+var renderNoDataHelpText = function renderNoDataHelpText(title, url) {
+  return /*#__PURE__*/jsx(Trans, {
+    i18nKey: "neetoFields.helpTexts.noData",
+    values: {
+      title: title
+    },
+    components: {
+      a: /*#__PURE__*/jsx(Button, {
+        "data-cy": "no-data-help-text-link",
+        style: "link",
+        target: "_blank",
+        to: {
+          pathname: url
+        }
+      })
+    }
+  });
+};
+var getDeletionConfirmationMessage = function getDeletionConfirmationMessage(_ref8) {
+  var resource = _ref8.resource,
+    fieldName = _ref8.fieldName,
+    affectedResourcesCount = _ref8.affectedResourcesCount;
+  return affectedResourcesCount > 0 ? /*#__PURE__*/jsx(Trans, {
+    i18nKey: "neetoFields.messages.confirmDeleteWithCount",
+    values: {
+      resource: pluralize(resource, affectedResourcesCount),
+      name: fieldName,
+      count: affectedResourcesCount
+    }
+  }) : /*#__PURE__*/jsx(Trans, {
+    i18nKey: "neetoFields.messages.confirmDelete",
+    values: {
+      name: fieldName
+    }
+  });
+};
+
+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 && isNotEmpty(selectedField)
+    }),
+    _useFetchDependencies2 = _useFetchDependencies.data,
+    _useFetchDependencies3 = _useFetchDependencies2 === void 0 ? {} : _useFetchDependencies2,
+    affectedResourcesCount = _useFetchDependencies3.affectedResourcesCount;
+  return /*#__PURE__*/jsx(Alert, {
+    affectedResourcesCount: affectedResourcesCount,
+    isOpen: isDeleteAlertOpen,
+    isSubmitting: isDeleting,
+    submitButtonLabel: t("neetoFields.labels.delete"),
+    title: t("neetoFields.titles.deleteField"),
+    message: getDeletionConfirmationMessage({
+      resource: resourceTypeName,
+      affectedResourcesCount: affectedResourcesCount,
+      fieldName: selectedField === null || selectedField === void 0 ? void 0 : selectedField.name
+    }),
+    onClose: handleAlertClose,
+    onSubmit: handleDelete
+  });
+};
+
+export { DeleteAlert as D, getDashBoardTitle as a, buildDefaultColumns as b, renderMenuBarItems as c, renderNoDataHelpText as d, getResourceName as g, renderStateFilterTabs as r };
+//# sourceMappingURL=DeleteAlert-b92f7c05.js.map