@rpcbase/ui 0.158.0 → 0.160.0

package/dist/index186.js

@@ -1,367 +1,253 @@
-import g from "./index197.js";
-import c from "./index198.js";
-import y from "./index199.js";
-import C from "./index187.js";
-import b from "./index200.js";
-import v from "./index201.js";
-import p from "./index202.js";
-import N from "./index203.js";
-import { DIGIT_PLACEHOLDER as P } from "./index188.js";
-function f(n) {
-  "@babel/helpers - typeof";
-  return f = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
-    return typeof e;
-  } : function(e) {
-    return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
-  }, f(n);
-}
-function S(n, e) {
-  return A(n) || _(n, e) || k(n, e) || T();
-}
-function T() {
-  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
-}
-function k(n, e) {
-  if (n) {
-    if (typeof n == "string") return h(n, e);
-    var t = {}.toString.call(n).slice(8, -1);
-    return t === "Object" && n.constructor && (t = n.constructor.name), t === "Map" || t === "Set" ? Array.from(n) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? h(n, e) : void 0;
+import h from "./index185.js";
+import f from "./index306.js";
+import { isString as v, DIRECTION as o, objectIncludes as V, forceDirection as I } from "./index304.js";
+import _ from "./index184.js";
+class p {
+  /** */
+  /** */
+  /** Transforms value before mask processing */
+  /** Transforms each char before mask processing */
+  /** Validates if value is acceptable */
+  /** Does additional processing at the end of editing */
+  /** Format typed value to string */
+  /** Parse string to get typed value */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(t) {
+    this._value = "", this._update({
+      ...p.DEFAULTS,
+      ...t
+    }), this._initialized = !0;
   }
-}
-function h(n, e) {
-  (e == null || e > n.length) && (e = n.length);
-  for (var t = 0, i = Array(e); t < e; t++) i[t] = n[t];
-  return i;
-}
-function _(n, e) {
-  var t = n == null ? null : typeof Symbol < "u" && n[Symbol.iterator] || n["@@iterator"];
-  if (t != null) {
-    var i, a, o, r, u = [], l = !0, s = !1;
-    try {
-      if (o = (t = t.call(n)).next, e !== 0) for (; !(l = (i = o.call(t)).done) && (u.push(i.value), u.length !== e); l = !0) ;
-    } catch (d) {
-      s = !0, a = d;
-    } finally {
-      try {
-        if (!l && t.return != null && (r = t.return(), Object(r) !== r)) return;
-      } finally {
-        if (s) throw a;
-      }
-    }
-    return u;
+  /** Sets and applies new options */
+  updateOptions(t) {
+    this.optionsIsChanged(t) && this.withValueRefresh(this._update.bind(this, t));
   }
-}
-function A(n) {
-  if (Array.isArray(n)) return n;
-}
-function I(n, e) {
-  if (!(n instanceof e)) throw new TypeError("Cannot call a class as a function");
-}
-function F(n, e) {
-  for (var t = 0; t < e.length; t++) {
-    var i = e[t];
-    i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(n, x(i.key), i);
+  /** Sets new options */
+  _update(t) {
+    Object.assign(this, t);
   }
-}
-function w(n, e, t) {
-  return e && F(n.prototype, e), Object.defineProperty(n, "prototype", { writable: !1 }), n;
-}
-function x(n) {
-  var e = j(n, "string");
-  return f(e) == "symbol" ? e : e + "";
-}
-function j(n, e) {
-  if (f(n) != "object" || !n) return n;
-  var t = n[Symbol.toPrimitive];
-  if (t !== void 0) {
-    var i = t.call(n, e);
-    if (f(i) != "object") return i;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return String(n);
-}
-var H = /* @__PURE__ */ (function() {
-  function n(e, t) {
-    I(this, n), this.metadata = new g(t);
-    var i = this.getCountryAndCallingCode(e), a = S(i, 2), o = a[0], r = a[1];
-    this.defaultCountry = o, this.defaultCallingCode = r, this.reset();
-  }
-  return w(n, [{
-    key: "getCountryAndCallingCode",
-    value: function(t) {
-      var i, a;
-      return t && (N(t) ? (i = t.defaultCountry, a = t.defaultCallingCode) : i = t), i && !this.metadata.hasCountry(i) && (i = void 0), [i, a];
-    }
-    /**
-     * Inputs "next" phone number characters.
-     * @param  {string} text
-     * @return {string} Formatted phone number characters that have been input so far.
-     */
-  }, {
-    key: "input",
-    value: function(t) {
-      var i = this.parser.input(t, this.state), a = i.digits, o = i.justLeadingPlus;
-      if (o)
-        this.formattedOutput = "+";
-      else if (a) {
-        this.determineTheCountryIfNeeded(), this.state.nationalSignificantNumber && this.formatter.narrowDownMatchingFormats(this.state);
-        var r;
-        if (this.metadata.hasSelectedNumberingPlan() && (r = this.formatter.format(a, this.state)), r === void 0 && this.parser.reExtractNationalSignificantNumber(this.state)) {
-          this.determineTheCountryIfNeeded();
-          var u = this.state.getNationalDigits();
-          u && (r = this.formatter.format(u, this.state));
-        }
-        this.formattedOutput = r ? this.getFullNumber(r) : this.getNonFormattedNumber();
-      }
-      return this.formattedOutput;
-    }
-  }, {
-    key: "reset",
-    value: function() {
-      var t = this;
-      return this.state = new y({
-        onCountryChange: function(a) {
-          t.country = a;
-        },
-        onCallingCodeChange: function(a, o) {
-          t.metadata.selectNumberingPlan(o, a), t.formatter.reset(t.metadata.numberingPlan, t.state), t.parser.reset(t.metadata.numberingPlan);
-        }
-      }), this.formatter = new C({
-        state: this.state,
-        metadata: this.metadata
-      }), this.parser = new b({
-        defaultCountry: this.defaultCountry,
-        defaultCallingCode: this.defaultCallingCode,
-        metadata: this.metadata,
-        state: this.state,
-        onNationalSignificantNumberChange: function() {
-          t.determineTheCountryIfNeeded(), t.formatter.reset(t.metadata.numberingPlan, t.state);
-        }
-      }), this.state.reset({
-        country: this.defaultCountry,
-        callingCode: this.defaultCallingCode
-      }), this.formattedOutput = "", this;
-    }
-    /**
-     * Returns `true` if the phone number is being input in international format.
-     * In other words, returns `true` if and only if the parsed phone number starts with a `"+"`.
-     * @return {boolean}
-     */
-  }, {
-    key: "isInternational",
-    value: function() {
-      return this.state.international;
-    }
-    /**
-     * Returns the "calling code" part of the phone number when it's being input
-     * in an international format.
-     * If no valid calling code has been entered so far, returns `undefined`.
-     * @return {string} [callingCode]
-     */
-  }, {
-    key: "getCallingCode",
-    value: function() {
-      if (this.isInternational())
-        return this.state.callingCode;
-    }
-    // A legacy alias.
-  }, {
-    key: "getCountryCallingCode",
-    value: function() {
-      return this.getCallingCode();
-    }
-    /**
-     * Returns a two-letter country code of the phone number.
-     * Returns `undefined` for "non-geographic" phone numbering plans.
-     * Returns `undefined` if no phone number has been input yet.
-     * @return {string} [country]
-     */
-  }, {
-    key: "getCountry",
-    value: function() {
-      var t = this.state.digits;
-      if (t)
-        return this._getCountry();
-    }
-    /**
-     * Returns a two-letter country code of the phone number.
-     * Returns `undefined` for "non-geographic" phone numbering plans.
-     * @return {string} [country]
-     */
-  }, {
-    key: "_getCountry",
-    value: function() {
-      var t = this.state.country;
-      return t;
-    }
-  }, {
-    key: "determineTheCountryIfNeeded",
-    value: function() {
-      (!this.state.country || this.isCountryCallingCodeAmbiguous()) && this.determineTheCountry();
-    }
-    // Prepends `+CountryCode ` in case of an international phone number
-  }, {
-    key: "getFullNumber",
-    value: function(t) {
-      var i = this;
-      if (this.isInternational()) {
-        var a = function(u) {
-          return i.formatter.getInternationalPrefixBeforeCountryCallingCode(i.state, {
-            spacing: !!u
-          }) + u;
-        }, o = this.state.callingCode;
-        return a(o ? t ? "".concat(o, " ").concat(t) : o : "".concat(this.state.getDigitsWithoutInternationalPrefix()));
-      }
-      return t;
-    }
-  }, {
-    key: "getNonFormattedNationalNumberWithPrefix",
-    value: function() {
-      var t = this.state, i = t.nationalSignificantNumber, a = t.prefixBeforeNationalSignificantNumberThatIsNotNationalPrefix, o = t.nationalPrefix, r = i, u = a || o;
-      return u && (r = u + r), r;
-    }
-  }, {
-    key: "getNonFormattedNumber",
-    value: function() {
-      var t = this.state.nationalSignificantNumberIsModified;
-      return this.getFullNumber(t ? this.state.getNationalDigits() : this.getNonFormattedNationalNumberWithPrefix());
-    }
-  }, {
-    key: "getNonFormattedTemplate",
-    value: function() {
-      var t = this.getNonFormattedNumber();
-      if (t)
-        return t.replace(/[\+\d]/g, P);
-    }
-  }, {
-    key: "isCountryCallingCodeAmbiguous",
-    value: function() {
-      var t = this.state.callingCode, i = this.metadata.getCountryCodesForCallingCode(t);
-      return i && i.length > 1;
-    }
-    // Determines the exact country of the phone number
-    // entered so far based on the country phone code
-    // and the national phone number.
-  }, {
-    key: "determineTheCountry",
-    value: function() {
-      this.state.setCountry(v(this.isInternational() ? this.state.callingCode : this.defaultCallingCode, {
-        nationalNumber: this.state.nationalSignificantNumber,
-        metadata: this.metadata
-      }));
-    }
-    /**
-     * Returns a E.164 phone number value for the user's input.
-     *
-     * For example, for country `"US"` and input `"(222) 333-4444"`
-     * it will return `"+12223334444"`.
-     *
-     * For international phone number input, it will also auto-correct
-     * some minor errors such as using a national prefix when writing
-     * an international phone number. For example, if the user inputs
-     * `"+44 0 7400 000000"` then it will return an auto-corrected
-     * `"+447400000000"` phone number value.
-     *
-     * Will return `undefined` if no digits have been input,
-     * or when inputting a phone number in national format and no
-     * default country or default "country calling code" have been set.
-     *
-     * @return {string} [value]
-     */
-  }, {
-    key: "getNumberValue",
-    value: function() {
-      var t = this.state, i = t.digits, a = t.callingCode, o = t.country, r = t.nationalSignificantNumber;
-      if (i) {
-        if (this.isInternational())
-          return a ? "+" + a + r : "+" + i;
-        if (o || a) {
-          var u = o ? this.metadata.countryCallingCode() : a;
-          return "+" + u + r;
+  /** Mask state */
+  get state() {
+    return {
+      _value: this.value,
+      _rawInputValue: this.rawInputValue
+    };
+  }
+  set state(t) {
+    this._value = t._value;
+  }
+  /** Resets value */
+  reset() {
+    this._value = "";
+  }
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    this.resolve(t, {
+      input: !0
+    });
+  }
+  /** Resolve new value */
+  resolve(t, e) {
+    e === void 0 && (e = {
+      input: !0
+    }), this.reset(), this.append(t, e, ""), this.doCommit();
+  }
+  get unmaskedValue() {
+    return this.value;
+  }
+  set unmaskedValue(t) {
+    this.resolve(t, {});
+  }
+  get typedValue() {
+    return this.parse ? this.parse(this.value, this) : this.unmaskedValue;
+  }
+  set typedValue(t) {
+    this.format ? this.value = this.format(t, this) : this.unmaskedValue = String(t);
+  }
+  /** Value that includes raw user input */
+  get rawInputValue() {
+    return this.extractInput(0, this.displayValue.length, {
+      raw: !0
+    });
+  }
+  set rawInputValue(t) {
+    this.resolve(t, {
+      raw: !0
+    });
+  }
+  get displayValue() {
+    return this.value;
+  }
+  get isComplete() {
+    return !0;
+  }
+  get isFilled() {
+    return this.isComplete;
+  }
+  /** Finds nearest input position in direction */
+  nearestInputPos(t, e) {
+    return t;
+  }
+  totalInputPositions(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), Math.min(this.displayValue.length, e - t);
+  }
+  /** Extracts value in range considering flags */
+  extractInput(t, e, i) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), this.displayValue.slice(t, e);
+  }
+  /** Extracts tail in range */
+  extractTail(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), new f(this.extractInput(t, e), t);
+  }
+  /** Appends tail */
+  appendTail(t) {
+    return v(t) && (t = new f(String(t))), t.appendTo(this);
+  }
+  /** Appends char */
+  _appendCharRaw(t, e) {
+    return t ? (this._value += t, new h({
+      inserted: t,
+      rawInserted: t
+    })) : new h();
+  }
+  /** Appends char */
+  _appendChar(t, e, i) {
+    e === void 0 && (e = {});
+    const s = this.state;
+    let a;
+    if ([t, a] = this.doPrepareChar(t, e), t && (a = a.aggregate(this._appendCharRaw(t, e)), !a.rawInserted && this.autofix === "pad")) {
+      const n = this.state;
+      this.state = s;
+      let r = this.pad(e);
+      const l = this._appendCharRaw(t, e);
+      r = r.aggregate(l), l.rawInserted || r.equals(a) ? a = r : this.state = n;
+    }
+    if (a.inserted) {
+      let n, r = this.doValidate(e) !== !1;
+      if (r && i != null) {
+        const l = this.state;
+        if (this.overwrite === !0) {
+          n = i.state;
+          for (let d = 0; d < a.rawInserted.length; ++d)
+            i.unshift(this.displayValue.length - a.tailShift);
         }
-      }
-    }
-    /**
-     * Returns an instance of `PhoneNumber` class.
-     * Will return `undefined` if no national (significant) number
-     * digits have been entered so far, or if no `defaultCountry` has been
-     * set and the user enters a phone number not in international format.
-     */
-  }, {
-    key: "getNumber",
-    value: function() {
-      var t = this.state, i = t.nationalSignificantNumber, a = t.carrierCode, o = t.callingCode, r = this._getCountry();
-      if (i && !(!r && !o)) {
-        if (r && r === this.defaultCountry) {
-          var u = new g(this.metadata.metadata);
-          u.selectNumberingPlan(r);
-          var l = u.numberingPlan.callingCode(), s = this.metadata.getCountryCodesForCallingCode(l);
-          if (s.length > 1) {
-            var d = p(i, {
-              countries: s,
-              metadata: this.metadata.metadata
-            });
-            d && (r = d);
-          }
+        let u = this.appendTail(i);
+        if (r = u.rawInserted.length === i.toString().length, !(r && u.inserted) && this.overwrite === "shift") {
+          this.state = l, n = i.state;
+          for (let d = 0; d < a.rawInserted.length; ++d)
+            i.shift();
+          u = this.appendTail(i), r = u.rawInserted.length === i.toString().length;
         }
-        var m = new c(r || o, i, this.metadata.metadata);
-        return a && (m.carrierCode = a), m;
+        r && u.inserted && (this.state = l);
       }
+      r || (a = new h(), this.state = s, i && n && (i.state = n));
     }
-    /**
-     * Returns `true` if the phone number is "possible".
-     * Is just a shortcut for `PhoneNumber.isPossible()`.
-     * @return {boolean}
-     */
-  }, {
-    key: "isPossible",
-    value: function() {
-      var t = this.getNumber();
-      return t ? t.isPossible() : !1;
-    }
-    /**
-     * Returns `true` if the phone number is "valid".
-     * Is just a shortcut for `PhoneNumber.isValid()`.
-     * @return {boolean}
-     */
-  }, {
-    key: "isValid",
-    value: function() {
-      var t = this.getNumber();
-      return t ? t.isValid() : !1;
-    }
-    /**
-     * @deprecated
-     * This method is used in `react-phone-number-input/source/input-control.js`
-     * in versions before `3.0.16`.
-     */
-  }, {
-    key: "getNationalNumber",
-    value: function() {
-      return this.state.nationalSignificantNumber;
-    }
-    /**
-     * Returns the phone number characters entered by the user.
-     * @return {string}
-     */
-  }, {
-    key: "getChars",
-    value: function() {
-      return (this.state.international ? "+" : "") + this.state.digits;
-    }
-    /**
-     * Returns the template for the formatted phone number.
-     * @return {string}
-     */
-  }, {
-    key: "getTemplate",
-    value: function() {
-      return this.formatter.getTemplate(this.state) || this.getNonFormattedTemplate() || "";
-    }
-  }]);
-})();
+    return a;
+  }
+  /** Appends optional placeholder at the end */
+  _appendPlaceholder() {
+    return new h();
+  }
+  /** Appends optional eager placeholder at the end */
+  _appendEager() {
+    return new h();
+  }
+  /** Appends symbols considering flags */
+  append(t, e, i) {
+    if (!v(t)) throw new Error("value should be string");
+    const s = v(i) ? new f(String(i)) : i;
+    e != null && e.tail && (e._beforeTailState = this.state);
+    let a;
+    [t, a] = this.doPrepare(t, e);
+    for (let n = 0; n < t.length; ++n) {
+      const r = this._appendChar(t[n], e, s);
+      if (!r.rawInserted && !this.doSkipInvalid(t[n], e, s)) break;
+      a.aggregate(r);
+    }
+    return (this.eager === !0 || this.eager === "append") && e != null && e.input && t && a.aggregate(this._appendEager()), s != null && (a.tailShift += this.appendTail(s).tailShift), a;
+  }
+  remove(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), this._value = this.displayValue.slice(0, t) + this.displayValue.slice(e), new h();
+  }
+  /** Calls function and reapplies current value */
+  withValueRefresh(t) {
+    if (this._refreshing || !this._initialized) return t();
+    this._refreshing = !0;
+    const e = this.rawInputValue, i = this.value, s = t();
+    return this.rawInputValue = e, this.value && this.value !== i && i.indexOf(this.value) === 0 && (this.append(i.slice(this.displayValue.length), {}, ""), this.doCommit()), delete this._refreshing, s;
+  }
+  runIsolated(t) {
+    if (this._isolated || !this._initialized) return t(this);
+    this._isolated = !0;
+    const e = this.state, i = t(this);
+    return this.state = e, delete this._isolated, i;
+  }
+  doSkipInvalid(t, e, i) {
+    return !!this.skipInvalid;
+  }
+  /** Prepares string before mask processing */
+  doPrepare(t, e) {
+    return e === void 0 && (e = {}), h.normalize(this.prepare ? this.prepare(t, this, e) : t);
+  }
+  /** Prepares each char before mask processing */
+  doPrepareChar(t, e) {
+    return e === void 0 && (e = {}), h.normalize(this.prepareChar ? this.prepareChar(t, this, e) : t);
+  }
+  /** Validates if value is acceptable */
+  doValidate(t) {
+    return (!this.validate || this.validate(this.value, this, t)) && (!this.parent || this.parent.doValidate(t));
+  }
+  /** Does additional processing at the end of editing */
+  doCommit() {
+    this.commit && this.commit(this.value, this);
+  }
+  splice(t, e, i, s, a) {
+    i === void 0 && (i = ""), s === void 0 && (s = o.NONE), a === void 0 && (a = {
+      input: !0
+    });
+    const n = t + e, r = this.extractTail(n), l = this.eager === !0 || this.eager === "remove";
+    let u;
+    l && (s = I(s), u = this.extractInput(0, n, {
+      raw: !0
+    }));
+    let d = t;
+    const g = new h();
+    if (s !== o.NONE && (d = this.nearestInputPos(t, e > 1 && t !== 0 && !l ? o.NONE : s), g.tailShift = d - t), g.aggregate(this.remove(d)), l && s !== o.NONE && u === this.rawInputValue)
+      if (s === o.FORCE_LEFT) {
+        let w;
+        for (; u === this.rawInputValue && (w = this.displayValue.length); )
+          g.aggregate(new h({
+            tailShift: -1
+          })).aggregate(this.remove(w - 1));
+      } else s === o.FORCE_RIGHT && r.unshift();
+    return g.aggregate(this.append(i, a, r));
+  }
+  maskEquals(t) {
+    return this.mask === t;
+  }
+  optionsIsChanged(t) {
+    return !V(this, t);
+  }
+  typedValueEquals(t) {
+    const e = this.typedValue;
+    return t === e || p.EMPTY_VALUES.includes(t) && p.EMPTY_VALUES.includes(e) || (this.format ? this.format(t, this) === this.format(this.typedValue, this) : !1);
+  }
+  pad(t) {
+    return new h();
+  }
+}
+p.DEFAULTS = {
+  skipInvalid: !0
+};
+p.EMPTY_VALUES = [void 0, null, ""];
+_.Masked = p;
 export {
-  H as default
+  p as default
 };
 //# sourceMappingURL=index186.js.map