Top 10 Examples of "libphonenumber-js in functional component" in JavaScript

handleSubscribe = (evt: Object) => {
    evt.preventDefault();

    const { allowSMS, recipient, country } = this.state;
    const { sendToGA, getWindowLocation, fromFeatured, experiment } = this.props;
    const basketMsgId = `txp-${this.props.experiment.slug}`;
    const source = "" + getWindowLocation();

    // return early and show errors if submit attempt fails
    if (!this.validateRecipient(recipient)) return this.setState({submitAttempted: true, isError: true});

    if (allowSMS && isValidNumber(recipient, country)) {
      sendToGA("event", {
        eventCategory: "SMS Modal Interactions",
        eventAction: "mobile link request",
        eventLabel: "sms",
        dimension11: experiment.slug,
        dimension13: fromFeatured ? "Featured Experiment" : "Experiment Detail"
      });
      // country, lang, msgId
      return subscribeToBasketSMS(recipient, country, basketMsgId).then(response => {
        sendToGA("event", {
          eventCategory: "SMS Modal Interactions",
          eventAction: "request handled",
          eventLabel: response.ok ? "success" : "error",
          dimension11: experiment.slug,
          dimension13: fromFeatured ? "Featured Experiment" : "Experiment Detail"
        });

_onSubmit() {

        // hack for issue with phonenumber lib - https://github.com/bl00mber/react-phone-input-2/issues/10	
        let phone = this.phoneNumber.state.formattedNumber;

        // remove formatting from phone number
        phone = "+" + phone.replace(/\D+/g, "");


        // get dial code from phone number
        const formatter = new asYouType();
        formatter.input(phone);
        const phoneCode = formatter.country_phone_code;
	
        //format balance
        let balance;
        const web3 = web3Service.getWeb3();
        if (this.props.balanceUnformatted) {
            balance = web3.fromWei(this.props.balanceUnformatted, 'ether').toNumber();
	}

        // check that phone number is valid
	const isValidNumber = (phone || "").length >= 9;
        if (!isValidNumber) {
            this.setState({ fetching: false, errorMessage: "Phone number is invalid", phoneError: true });
            return;
        };

_onSubmit() {

        // hack for issue with phonenumber lib - https://github.com/bl00mber/react-phone-input-2/issues/10	
        let phone = this.phoneNumber.state.formattedNumber;

        // remove formatting from phone number
        phone = "+" + phone.replace(/\D+/g, "");

        // get dial code from phone number
        const formatter = new asYouType();
        formatter.input(phone);
        const phoneCode = formatter.country_phone_code;

        //format balance
        let balance;
        const web3 = web3Service.getWeb3();
        if (this.props.balanceUnformatted) {
        balance = web3.fromWei(this.props.balanceUnformatted, 'ether').toNumber();
    }

        // check that phone number is valid
        if (!isValidPhoneNumber(phone) && phone !== "+71111111111") {
            this.setState({ fetching: false, errorMessage: "Phone number is invalid", phoneError: true });
            return;
        };

if (!country_code)
	{
		return undefined
	}

	// The phone number is being input in a country-specific format

	const partial_national_number = parse_partial_number(value, country_code).national_number

	if (!partial_national_number)
	{
		return undefined
	}

	// The value is converted to international plaintext
	return format(partial_national_number, country_code, 'International_plaintext', metadata)
}

constructor(props) {
        super(props);

        const queryParams = qs.parse(props.location.search.substring(1));

        // parse phone params
        let phone = queryParams.phone || queryParams.p;
        const secretCode = (queryParams.code || queryParams.c);
        this.networkId = queryParams.chainId || queryParams.n || "1";
        phone = `+${phone}`;
        const formatter = new asYouType();
        formatter.input(phone);
        this.phoneParams = {
            phone,
            phoneCode: formatter.country_phone_code,
            phoneFormatted: "+" + formatter.country_phone_code + " " + format(phone, 'National')
        };


        this.state = {
            errorMessage: "",
            firstLoading: true,
            fetching: false,
            transfer: null,
            hasCode: false,
            secretCode,
            codeFromUrl: (secretCode && secretCode.length > 10)
        };


    }

const CompletedSentScreen = ({transfer}) => {

    const etherscanLink = getEtherscanLink({txHash: transfer.txHash, networkId: transfer.networkId});    
    const formattedPhone = format(transfer.receiverPhone, 'International');

    return (
	<div>
	  <div style="{styles.stepsBar}">
            
	  </div>
	  <div>
	    <div style="{styles.titleContainer}">
	      
	      { transfer.status === 'received' ?     
		  /* received status if user has received,
		   completed - if someone else */
		  <div></div></div></div></div>

}
			}

			// If switching to International from a country
			if (previous_country_code && !country_code)
			{
				// If no leading `+` sign
				if (value[0] !== '+')
				{
					// Format the local phone number as an international one.
					// The phone number entered not necessarily even starts with
					// the previously selected country phone prefix.
					// Even if the phone number belongs to whole another country
					// it will still be parsed into some national phone number.
					const national_number = parse_partial_number(value, previous_country_code, metadata).national_number
					value = format(national_number, previous_country_code, 'International_plaintext', metadata)
				}
			}

			// Update the adjusted `<input>` `value`
			// and update `this.props.value` (in e.164 phone number format)
			// according to the new `this.state.value`.
			// (keep them in sync)
			this.on_change(value, country_code, true)
		}
		// Disabling this feature because if a user selects a country
		// then it means he doesn't know how to input his phone number
		// in international format therefore not forcing it
		// by prepending `+${getPhoneCode(country_code)}`.
		//
		// else
		// {

{
			return
		}

		// If the country code is specified
		if (country_code)
		{
			// and the phone is in international format
			// and should convert to national phone number
			if (value[0] === '+' && convertToNational)
			{
				// If it's a fully-entered phone number
				// that converts into a valid national number for this country
				// then the value is set to be that national number.

				const parsed = parse(value, metadata)

				if (parsed.country === country_code)
				{
					const input_value = format(parsed.phone, country_code, 'National', metadata)
					return this.format(input_value, country_code).text
				}
			}
		}
		// The country is not set.
		// Must be an international phone number then.
		else if (value[0] !== '+')
		{
			// The following causes the caret to move the end of the input field
			// but it's unlikely any sane person would like to erase the `+` sign
			// while inputting an international phone number without any country selected.
			return '+' + value

status: 409
    });
  }

  // It does not: strip out inert characters and continue.
  number = number.replace(/[^0-9]/g,'');

  // Ensure we a country code, 1 way or another ;).
  if (number.length === 10) {
    number = "1" + number;
  }

  number = "+" + number;

  const locale = callInformation.locale || '';
  const parsed = parseNumber(number);

  // Verify that the number we've been given is a proper number
  // for whatever country the country code said it was for.
  if (!parsed.phone) {
    return res.status(409).send({
      'call_placed': false,
      error: 'Phone number does not match the format required based on country code.',
      status: 409
    });
  }

  var form = new FormData();
  form.append('userPhone', number);
  form.append('userLocation', zip);
  form.append('userCountry', parsed.country);
  form.append('campaignId', COPYRIGHT_CAMPAIGN_ID);

// This is an optimization, it's like `shouldComponentUpdate()`.
			// This is supposed to save some CPU cycles, maybe not much, I didn't check.
			// Or maybe there was some other reason for this I don't remember now.
			if (new_props.value !== this.state.value_property)
			{
				// Update the `value` because it was externally set

				// Country code gets updated too
				let country_code = this.state.country_code

				// Autodetect country if `value` is set
				// and is international (which it should be)
				if (new_props.value && new_props.value[0] === '+')
				{
					// `parse().country` will be `undefined` in case of non-detection
					country_code = parse(new_props.value).country || country_code
				}

				this.setState
				({
					country_code,
					value: this.get_input_value_depending_on_the_country_selected(new_props.value, country_code),
					// `this.state.value_property` is the `this.props.value`
					// which corresponding to `this.state.value`.
					// It is being compared in `componentWillReceiveProps()`
					// against `newProps.value` to find out if the new `value` property
					// needs `this.state.value` recalculation.
					value_property: new_props.value
				})
			}
		}
	}