@bigbinary/neeto-molecules 3.7.20 → 3.7.22

package/dist/InlineInput.js

@@ -16,7 +16,7 @@ import Close from '@bigbinary/neeto-icons/Close';
 import Button from '@bigbinary/neetoui/Button';
 import Input from '@bigbinary/neetoui/Input';
 import { t } from 'i18next';
-import { n } from './inject-css-c86de496.js';
+import { n } from './inject-css-DmrvuTKK.js';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 var TOOLTIP_PROPS = {

package/dist/IntegrationCard.js

@@ -17,7 +17,7 @@ import Tag from '@bigbinary/neetoui/Tag';
 import '@bigbinary/neeto-icons/MenuHorizontal';
 import '@bigbinary/neeto-icons/MenuVertical';
 import '@bigbinary/neetoui/Dropdown';
-import './inject-css-c86de496.js';
+import './inject-css-DmrvuTKK.js';
 
 var Dropdown = function Dropdown(_ref) {
   var customDropdown = _ref.customDropdown,

package/dist/IpRestriction.js

@@ -18,7 +18,7 @@ import Input from '@bigbinary/neetoui/formik/Input';
 import Select from '@bigbinary/neetoui/formik/Select';
 import { t } from 'i18next';
 import * as yup from 'yup';
-import { c as commonjsGlobal } from './_commonjsHelpers-1789f0cf.js';
+import { c as commonjsGlobal } from './_commonjsHelpers-BFTU3MAI.js';
 import { isNil, isNotNil, assoc } from 'ramda';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { useQuery } from '@tanstack/react-query';
@@ -370,7 +370,7 @@ function requireValidator () {
 	const IPv6Utils_1 = requireIPv6Utils();
 	const HexadecimalUtils_1 = requireHexadecimalUtils();
 	const HexadecimalUtils_2 = requireHexadecimalUtils();
-	class Validator$1 {
+	let Validator$1 = class Validator {
 	    /**
 	     * Checks if given ipNumber is in between the given lower and upper bound
 	     *
@@ -391,7 +391,7 @@ function requireValidator () {
 	     */
 	    static isValidAsnNumber(asnNumber) {
 	        let isValid = this.isWithinRange(asnNumber, 0n, this.THIRTY_TWO_BIT_SIZE);
-	        return [isValid, isValid ? [] : [Validator$1.invalidAsnRangeMessage]];
+	        return [isValid, isValid ? [] : [Validator.invalidAsnRangeMessage]];
 	    }
 	    /**
 	     * Checks if the given ASN number is a 16bit ASN number
@@ -401,8 +401,8 @@ function requireValidator () {
 	     * "valid" or an error message when value is invalid
 	     */
 	    static isValid16BitAsnNumber(asnNumber) {
-	        let isValid = Validator$1.isWithinRange(asnNumber, 0n, Validator$1.SIXTEEN_BIT_SIZE);
-	        return [isValid, isValid ? [] : [Validator$1.invalid16BitAsnRangeMessage]];
+	        let isValid = Validator.isWithinRange(asnNumber, 0n, Validator.SIXTEEN_BIT_SIZE);
+	        return [isValid, isValid ? [] : [Validator.invalid16BitAsnRangeMessage]];
 	    }
 	    /**
 	     * Checks if the number given is within the value considered valid for an IPv4 number
@@ -414,7 +414,7 @@ function requireValidator () {
 	    static isValidIPv4Number(ipv4Number) {
 	        ipv4Number = typeof ipv4Number === "bigint" ? ipv4Number : BigInt(ipv4Number);
 	        let isValid = this.isWithinRange(ipv4Number, 0n, this.THIRTY_TWO_BIT_SIZE);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidIPv4NumberMessage]];
+	        return isValid ? [isValid, []] : [isValid, [Validator.invalidIPv4NumberMessage]];
 	    }
 	    /**
 	     * Checks if the number given is within the value considered valid for an IPv6 number
@@ -425,7 +425,7 @@ function requireValidator () {
 	     */
 	    static isValidIPv6Number(ipv6Number) {
 	        let isValid = this.isWithinRange(ipv6Number, 0n, this.ONE_HUNDRED_AND_TWENTY_EIGHT_BIT_SIZE);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidIPv6NumberMessage]];
+	        return isValid ? [isValid, []] : [isValid, [Validator.invalidIPv6NumberMessage]];
 	    }
 	    /**
 	     * Checks if the number given is valid for an IPv4 octet
@@ -435,7 +435,7 @@ function requireValidator () {
 	     */
 	    static isValidIPv4Octet(octetNumber) {
 	        let withinRange = this.isWithinRange(octetNumber, 0n, this.EIGHT_BIT_SIZE);
-	        return [withinRange, withinRange ? [] : [Validator$1.invalidOctetRangeMessage]];
+	        return [withinRange, withinRange ? [] : [Validator.invalidOctetRangeMessage]];
 	    }
 	    /**
 	     * Checks if the number given is valid for an IPv6 hexadecatet
@@ -446,7 +446,7 @@ function requireValidator () {
 	     */
 	    static isValidIPv6Hexadecatet(hexadecatetNum) {
 	        let isValid = this.isWithinRange(hexadecatetNum, 0n, this.SIXTEEN_BIT_SIZE);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidHexadecatetMessage]];
+	        return isValid ? [isValid, []] : [isValid, [Validator.invalidHexadecatetMessage]];
 	    }
 	    /**
 	     * Checks if given string is a valid IPv4 value.
@@ -458,16 +458,16 @@ function requireValidator () {
 	    static isValidIPv4String(ipv4String) {
 	        let rawOctets = ipv4String.split(".");
 	        if (rawOctets.length != 4 || rawOctets.includes('')) {
-	            return [false, [Validator$1.invalidOctetCountMessage]];
+	            return [false, [Validator.invalidOctetCountMessage]];
 	        }
 	        let isValid = rawOctets.every(octet => {
-	            return Validator$1.isNumeric(octet) ? Validator$1.isValidIPv4Octet(BigInt(octet))[0] : false;
+	            return Validator.isNumeric(octet) ? Validator.isValidIPv4Octet(BigInt(octet))[0] : false;
 	        });
 	        if (!isValid) {
-	            return [false, [Validator$1.invalidOctetRangeMessage]];
+	            return [false, [Validator.invalidOctetRangeMessage]];
 	        }
-	        isValid = Validator$1.IPV4_PATTERN.test(ipv4String);
-	        return [isValid, isValid ? [] : [Validator$1.invalidIPv4PatternMessage]];
+	        isValid = Validator.IPV4_PATTERN.test(ipv4String);
+	        return [isValid, isValid ? [] : [Validator.invalidIPv4PatternMessage]];
 	    }
 	    /**
 	     * Checks if given string is a valid IPv6 value.
@@ -480,17 +480,17 @@ function requireValidator () {
 	        try {
 	            let hexadecimals = IPv6Utils_1.expandIPv6Number(ipv6String).split(":");
 	            if (hexadecimals.length != 8) {
-	                return [false, [Validator$1.invalidHexadecatetCountMessage]];
+	                return [false, [Validator.invalidHexadecatetCountMessage]];
 	            }
 	            let isValid = hexadecimals.every(hexadecimal => {
-	                return Validator$1.isHexadecatet(hexadecimal) ?
-	                    Validator$1.isValidIPv6Hexadecatet(BigInt(`0x${hexadecimal}`))[0] : false;
+	                return Validator.isHexadecatet(hexadecimal) ?
+	                    Validator.isValidIPv6Hexadecatet(BigInt(`0x${hexadecimal}`))[0] : false;
 	            });
 	            if (!isValid) {
-	                return [false, [Validator$1.invalidHexadecatetMessage]];
+	                return [false, [Validator.invalidHexadecatetMessage]];
 	            }
-	            isValid = Validator$1.IPV6_PATTERN.test(ipv6String);
-	            return [isValid, isValid ? [] : [Validator$1.invalidIPv6PatternMessage]];
+	            isValid = Validator.IPV6_PATTERN.test(ipv6String);
+	            return [isValid, isValid ? [] : [Validator.invalidIPv6PatternMessage]];
 	        }
 	        catch (error) {
 	            return [false, [error]];
@@ -505,14 +505,14 @@ function requireValidator () {
 	     */
 	    static isValidPrefixValue(prefixValue, ipNumType) {
 	        if ("IPv4" /* IPv4 */ === ipNumType) {
-	            let withinRange = Validator$1.isWithinRange(BigInt(prefixValue), 0n, 32n);
-	            return [withinRange, withinRange ? [] : [Validator$1.invalidPrefixValueMessage]];
+	            let withinRange = Validator.isWithinRange(BigInt(prefixValue), 0n, 32n);
+	            return [withinRange, withinRange ? [] : [Validator.invalidPrefixValueMessage]];
 	        }
 	        if ("IPv6" /* IPv6 */ === ipNumType) {
-	            let withinRange = Validator$1.isWithinRange(BigInt(prefixValue), 0n, 128n);
-	            return [withinRange, withinRange ? [] : [Validator$1.invalidPrefixValueMessage]];
+	            let withinRange = Validator.isWithinRange(BigInt(prefixValue), 0n, 128n);
+	            return [withinRange, withinRange ? [] : [Validator.invalidPrefixValueMessage]];
 	        }
-	        return [false, [Validator$1.invalidInetNumType]];
+	        return [false, [Validator.invalidInetNumType]];
 	    }
 	    /**
 	     * Checks if given string is a valid IPv4 mask
@@ -523,8 +523,8 @@ function requireValidator () {
 	     */
 	    static isValidIPv4Mask(ipv4MaskString) {
 	        let ipv4InBinary = BinaryUtils_1.dottedDecimalNotationToBinaryString(ipv4MaskString);
-	        let isValid = Validator$1.IPV4_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv4InBinary);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidMaskMessage]];
+	        let isValid = Validator.IPV4_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv4InBinary);
+	        return isValid ? [isValid, []] : [isValid, [Validator.invalidMaskMessage]];
 	    }
 	    /**
 	     * Checks if given string is a valid IPv6 mask
@@ -535,8 +535,8 @@ function requireValidator () {
 	     */
 	    static isValidIPv6Mask(ipv6MaskString) {
 	        let ipv6InBinary = HexadecimalUtils_2.hexadectetNotationToBinaryString(ipv6MaskString);
-	        let isValid = Validator$1.IPV6_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv6InBinary);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidMaskMessage]];
+	        let isValid = Validator.IPV6_CONTIGUOUS_MASK_BIT_PATTERN.test(ipv6InBinary);
+	        return isValid ? [isValid, []] : [isValid, [Validator.invalidMaskMessage]];
 	    }
 	    /**
 	     * Checks if the given string is a valid IPv4 range in Cidr notation
@@ -549,15 +549,15 @@ function requireValidator () {
 	    static isValidIPv4CidrNotation(ipv4RangeAsCidrString) {
 	        let cidrComponents = ipv4RangeAsCidrString.split("/");
 	        if (cidrComponents.length !== 2 || (cidrComponents[0].length === 0 || cidrComponents[1].length === 0)) {
-	            return [false, [Validator$1.invalidIPv4CidrNotationMessage]];
+	            return [false, [Validator.invalidIPv4CidrNotationMessage]];
 	        }
 	        let ip = cidrComponents[0];
 	        let range = cidrComponents[1];
 	        if (isNaN(Number(range))) {
-	            return [false, [Validator$1.invalidIPv4CidrNotationMessage]];
+	            return [false, [Validator.invalidIPv4CidrNotationMessage]];
 	        }
-	        let [validIpv4, invalidIpv4Message] = Validator$1.isValidIPv4String(ip);
-	        let [validPrefix, invalidPrefixMessage] = Validator$1.isValidPrefixValue(BigInt(range), "IPv4" /* IPv4 */);
+	        let [validIpv4, invalidIpv4Message] = Validator.isValidIPv4String(ip);
+	        let [validPrefix, invalidPrefixMessage] = Validator.isValidPrefixValue(BigInt(range), "IPv4" /* IPv4 */);
 	        let isValid = validIpv4 && validPrefix;
 	        let invalidMessage = invalidIpv4Message.concat(invalidPrefixMessage);
 	        return isValid ? [isValid, []] : [isValid, invalidMessage];
@@ -572,7 +572,7 @@ function requireValidator () {
 	     * value contains [] or an array of error message when invalid
 	     */
 	    static isValidIPv4CidrRange(ipv4CidrNotation) {
-	        return Validator$1.isValidCidrRange(ipv4CidrNotation, Validator$1.isValidIPv4CidrNotation, BinaryUtils_1.dottedDecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv4" /* IPv4 */));
+	        return Validator.isValidCidrRange(ipv4CidrNotation, Validator.isValidIPv4CidrNotation, BinaryUtils_1.dottedDecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv4" /* IPv4 */));
 	    }
 	    /**
 	     *  Checks if the given string is a valid IPv6 range in Cidr notation, with the ip number in the cidr notation
@@ -584,7 +584,7 @@ function requireValidator () {
 	     * value contains [] or an array of error message when invalid
 	     */
 	    static isValidIPv6CidrRange(ipv6CidrNotation) {
-	        return Validator$1.isValidCidrRange(ipv6CidrNotation, Validator$1.isValidIPv6CidrNotation, HexadecimalUtils_1.colonHexadecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv6" /* IPv6 */));
+	        return Validator.isValidCidrRange(ipv6CidrNotation, Validator.isValidIPv6CidrNotation, HexadecimalUtils_1.colonHexadecimalNotationToBinaryString, (value) => BinaryUtils_2.cidrPrefixToMaskBinaryString(value, "IPv6" /* IPv6 */));
 	    }
 	    static isValidCidrRange(rangeString, cidrNotationValidator, toBinaryStringConverter, prefixFactory) {
 	        let validationResult = cidrNotationValidator(rangeString);
@@ -597,22 +597,22 @@ function requireValidator () {
 	        let ipNumber = BigInt(`0b${toBinaryStringConverter(ip)}`);
 	        let mask = BigInt(`0b${prefixFactory(parseInt(range))}`);
 	        let isValid = (ipNumber & (mask)) === (ipNumber);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.InvalidIPCidrRangeMessage]];
+	        return isValid ? [isValid, []] : [isValid, [Validator.InvalidIPCidrRangeMessage]];
 	    }
 	    static isValidIPv4RangeString(ipv4RangeString) {
 	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${BinaryUtils_1.dottedDecimalNotationToBinaryString(firstIP)}`)
 	            >= BigInt(`0b${BinaryUtils_1.dottedDecimalNotationToBinaryString(lastIP)}`);
-	        return this.isValidRange(ipv4RangeString, Validator$1.isValidIPv4String, firstLastValidator);
+	        return this.isValidRange(ipv4RangeString, Validator.isValidIPv4String, firstLastValidator);
 	    }
 	    static isValidIPv6RangeString(ipv6RangeString) {
 	        let firstLastValidator = (firstIP, lastIP) => BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(firstIP)}`)
 	            >= BigInt(`0b${HexadecimalUtils_2.hexadectetNotationToBinaryString(lastIP)}`);
-	        return this.isValidRange(ipv6RangeString, Validator$1.isValidIPv6String, firstLastValidator);
+	        return this.isValidRange(ipv6RangeString, Validator.isValidIPv6String, firstLastValidator);
 	    }
 	    static isValidRange(rangeString, validator, firstLastValidator) {
 	        let rangeComponents = rangeString.split("-").map(component => component.trim());
 	        if (rangeComponents.length !== 2 || (rangeComponents[0].length === 0 || rangeComponents[1].length === 0)) {
-	            return [false, [Validator$1.invalidRangeNotationMessage]];
+	            return [false, [Validator.invalidRangeNotationMessage]];
 	        }
 	        let firstIP = rangeComponents[0];
 	        let lastIP = rangeComponents[1];
@@ -620,7 +620,7 @@ function requireValidator () {
 	        let [validLastIP, invalidLastIPMessage] = validator(lastIP);
 	        let isValid = validFirstIP && validLastIP;
 	        if (isValid && firstLastValidator(firstIP, lastIP)) {
-	            return [false, [Validator$1.invalidRangeFirstNotGreaterThanLastMessage]];
+	            return [false, [Validator.invalidRangeFirstNotGreaterThanLastMessage]];
 	        }
 	        let invalidMessage = invalidFirstIPMessage.concat(invalidLastIPMessage);
 	        return isValid ? [isValid, []] : [isValid, invalidMessage];
@@ -636,8 +636,8 @@ function requireValidator () {
 	    // TODO change to be like isValidIPv4CidrNotation where validation is done on the component of the cidr notation
 	    // instead of a single regex check
 	    static isValidIPv6CidrNotation(ipv6RangeAsCidrString) {
-	        let isValid = Validator$1.IPV6_RANGE_PATTERN.test(ipv6RangeAsCidrString);
-	        return isValid ? [isValid, []] : [isValid, [Validator$1.invalidIPv6CidrNotationString]];
+	        let isValid = Validator.IPV6_RANGE_PATTERN.test(ipv6RangeAsCidrString);
+	        return isValid ? [isValid, []] : [isValid, [Validator.invalidIPv6CidrNotationString]];
 	    }
 	    /**
 	     * Checks if the given string is a binary string. That is contains only contiguous 1s and 0s
@@ -650,7 +650,7 @@ function requireValidator () {
 	            return [true, []];
 	        }
 	        else {
-	            return [false, [Validator$1.invalidBinaryStringErrorMessage]];
+	            return [false, [Validator.invalidBinaryStringErrorMessage]];
 	        }
 	    }
 	    static isNumeric(value) {
@@ -659,7 +659,7 @@ function requireValidator () {
 	    static isHexadecatet(value) {
 	        return /^[0-9A-Fa-f]{4}$/.test(value);
 	    }
-	}
+	};
 	Validator.Validator = Validator$1;
 	Validator$1.IPV4_PATTERN = new RegExp(/^(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.(0?[0-9]?[0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$/);
 	// source: https://community.helpsystems.com/forums/intermapper/miscellaneous-topics/5acc4fcf-fa83-e511-80cf-0050568460e4