@player-ui/common-types-plugin 0.0.1-next.1

package/dist/index.esm.js

@@ -0,0 +1,743 @@
+import { TypesProviderPlugin } from '@player-ui/types-provider-plugin';
+
+const EMAIL_REGEX = /^((([a-z]|\d|[!#$%&'*+\-/=?^_`{|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#$%&'*+-/=?^_`{|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i;
+const PHONE_REGEX = /^\+?[1]?[- ]?\(?\d{3}[)\- ]?\s?\d{3}[ -]?\d{4}$/;
+const ZIP_REGEX = /^\d{5}(-\d{4})?$/;
+function skipNullish(validationFn) {
+  return (context, value, options) => {
+    if (value === null || value === void 0) {
+      return;
+    }
+    return validationFn(context, value, options);
+  };
+}
+const string = skipNullish((context, value) => {
+  if (typeof value !== "string") {
+    const message = context.constants.getConstants("validation.string", "constants", "Value must be a string");
+    return {
+      message,
+      parameters: {
+        type: typeof value
+      }
+    };
+  }
+});
+const readonly = (context) => {
+  const message = context.constants.getConstants("validation.readonly", "constants", "Value cannot be modified");
+  return { message };
+};
+const collection = skipNullish((context, value) => {
+  if (!Array.isArray(value)) {
+    const message = context.constants.getConstants("validation.collection", "constants", "Cannot set collection to non-array");
+    return { message };
+  }
+});
+const integer$1 = skipNullish((context, value) => {
+  if (value && (typeof value !== "number" || Math.floor(value) !== value || Number(value) > Number.MAX_SAFE_INTEGER || Number(value) < Number.MIN_SAFE_INTEGER)) {
+    const message = context.constants.getConstants("validation.integer", "constants", "Value must be an integer");
+    return {
+      message,
+      parameters: {
+        type: typeof value,
+        flooredValue: Math.floor(value)
+      }
+    };
+  }
+});
+const oneOf = skipNullish((context, value, options) => {
+  var _a;
+  if ((options == null ? void 0 : options.options) === void 0 || ((_a = options.options) == null ? void 0 : _a.includes(value))) {
+    return;
+  }
+  const message = context.constants.getConstants("validation.oneOf", "constants", "Invalid entry");
+  return { message };
+});
+const expression = (context, value, options) => {
+  if ((options == null ? void 0 : options.exp) === void 0) {
+    context.logger.warn("No expression defined for validation");
+    return;
+  }
+  const result = context.evaluate(options.exp);
+  if (!result) {
+    const message = context.constants.getConstants("validation.expression", "constants", "Expression evaluation failed");
+    return { message };
+  }
+};
+const required = (context, value, options) => {
+  if ((options == null ? void 0 : options.if) && !context.evaluate(options.if) || (options == null ? void 0 : options.ifNot) && context.evaluate(options.ifNot)) {
+    return;
+  }
+  if (value === void 0 || value === null || value === "") {
+    const message = context.constants.getConstants("validation.required", "constants", "A value is required");
+    return { message, severity: "error" };
+  }
+};
+const regex = skipNullish((context, value, options) => {
+  if (value === void 0 || value === null || value === "" || typeof (options == null ? void 0 : options.regex) !== "string") {
+    return;
+  }
+  const patternMatch = options.regex.match(/^\/(.*)\/(\w)*$/);
+  const regexp = patternMatch ? new RegExp(patternMatch[1], patternMatch[2]) : new RegExp(options.regex);
+  if (!regexp.test(value)) {
+    const message = context.constants.getConstants("validation.regex", "constants", "Invalid entry");
+    return { message };
+  }
+});
+const length = skipNullish((context, value, options) => {
+  if (typeof options !== "object") {
+    context.logger.warn("Missing comparison in length validation");
+    return;
+  }
+  let valLength;
+  let itemName = "items";
+  if (typeof value === "string") {
+    valLength = value.length;
+    itemName = "characters";
+  } else if (typeof value === "object" && value !== null) {
+    valLength = Object.keys(value).length;
+  }
+  if (valLength === void 0) {
+    context.logger.warn(`Unable to determine a length for value of type: ${value}`);
+    return;
+  }
+  if ("exact" in options) {
+    if (valLength !== options.exact) {
+      return {
+        message: `Must be exactly ${options.exact} ${itemName} long`,
+        parameters: {
+          validationLength: valLength
+        }
+      };
+    }
+    return;
+  }
+  if (options.min !== void 0 && valLength < options.min) {
+    const message = context.constants.getConstants("validation.length.minimum", "constants", `At least ${options.min} ${itemName} needed`);
+    return {
+      message,
+      parameters: {
+        validationLength: valLength
+      }
+    };
+  }
+  if (options.max !== void 0 && valLength > options.max) {
+    const message = context.constants.getConstants("validation.length.maximum", "constants", `Up to ${options.max} ${itemName} allowed`);
+    return {
+      message,
+      parameters: {
+        validationLength: valLength
+      }
+    };
+  }
+});
+const min = skipNullish((context, value, options) => {
+  if (typeof value !== "number" || (options == null ? void 0 : options.value) === void 0) {
+    return;
+  }
+  if (value < options.value) {
+    const message = context.constants.getConstants("validation.min", "constants", `Must be at least ${options.value}`);
+    return { message };
+  }
+});
+const max = skipNullish((context, value, options) => {
+  if (typeof value !== "number" || (options == null ? void 0 : options.value) === void 0) {
+    return;
+  }
+  if (value > options.value) {
+    const message = context.constants.getConstants("validation.max", "constants", `Cannot exceed ${options.value}`);
+    return { message };
+  }
+});
+const stringRegexValidator = (test, messagePath, invalidMessage) => {
+  return skipNullish((context, value) => {
+    if (typeof value === "string" && value === "") {
+      return;
+    }
+    if (typeof value !== "string" || !test.test(value)) {
+      const message = context.constants.getConstants(messagePath, "constants", invalidMessage);
+      return { message };
+    }
+  });
+};
+const email = stringRegexValidator(EMAIL_REGEX, "validation.email", "Improper email format");
+const phone$1 = stringRegexValidator(PHONE_REGEX, "validation.phone", "Invalid phone number");
+const zip = stringRegexValidator(ZIP_REGEX, "validation.regex", "Invalid zip code");
+
+var validators = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  string: string,
+  readonly: readonly,
+  collection: collection,
+  integer: integer$1,
+  oneOf: oneOf,
+  expression: expression,
+  required: required,
+  regex: regex,
+  length: length,
+  min: min,
+  max: max,
+  email: email,
+  phone: phone$1,
+  zip: zip
+});
+
+const BooleanTypeRef = {
+  type: "BooleanType"
+};
+const IntegerTypeRef = {
+  type: "IntegerType"
+};
+const IntegerPosTypeRef = {
+  type: "IntegerPosType"
+};
+const IntegerNNTypeRef = {
+  type: "IntegerNNType"
+};
+const StringTypeRef = {
+  type: "StringType"
+};
+const CollectionTypeRef = {
+  type: "CollectionType"
+};
+const DateTypeRef = {
+  type: "DateType"
+};
+const PhoneTypeRef = {
+  type: "PhoneType"
+};
+
+var refs = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  BooleanTypeRef: BooleanTypeRef,
+  IntegerTypeRef: IntegerTypeRef,
+  IntegerPosTypeRef: IntegerPosTypeRef,
+  IntegerNNTypeRef: IntegerNNTypeRef,
+  StringTypeRef: StringTypeRef,
+  CollectionTypeRef: CollectionTypeRef,
+  DateTypeRef: DateTypeRef,
+  PhoneTypeRef: PhoneTypeRef
+});
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const BooleanType = __spreadProps$1(__spreadValues$1({}, BooleanTypeRef), {
+  default: false,
+  validation: [
+    {
+      type: "oneOf",
+      message: "Value must be true or false",
+      options: [true, false]
+    }
+  ]
+});
+const IntegerType = __spreadProps$1(__spreadValues$1({}, IntegerTypeRef), {
+  validation: [
+    {
+      type: "integer"
+    }
+  ],
+  format: {
+    type: "integer"
+  }
+});
+const IntegerPosType = __spreadProps$1(__spreadValues$1({}, IntegerPosTypeRef), {
+  validation: [
+    {
+      type: "integer"
+    },
+    {
+      type: "min",
+      value: 1
+    }
+  ],
+  format: {
+    type: "integer"
+  }
+});
+const IntegerNNType = __spreadProps$1(__spreadValues$1({}, IntegerNNTypeRef), {
+  validation: [
+    {
+      type: "integer"
+    },
+    {
+      type: "min",
+      value: 0
+    }
+  ],
+  format: {
+    type: "integer"
+  }
+});
+const StringType = __spreadProps$1(__spreadValues$1({}, StringTypeRef), {
+  default: "",
+  validation: [
+    {
+      type: "string"
+    }
+  ],
+  format: {
+    type: "string"
+  }
+});
+const CollectionType = __spreadProps$1(__spreadValues$1({}, CollectionTypeRef), {
+  validation: [
+    {
+      type: "collection"
+    }
+  ]
+});
+const DateType = __spreadProps$1(__spreadValues$1({}, DateTypeRef), {
+  validation: [
+    {
+      type: "string"
+    }
+  ],
+  format: {
+    type: "date"
+  }
+});
+const PhoneType = __spreadProps$1(__spreadValues$1({}, PhoneTypeRef), {
+  validation: [
+    {
+      type: "phone"
+    }
+  ],
+  format: {
+    type: "phone"
+  }
+});
+
+var dataTypes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  BooleanType: BooleanType,
+  IntegerType: IntegerType,
+  IntegerPosType: IntegerPosType,
+  IntegerNNType: IntegerNNType,
+  StringType: StringType,
+  CollectionType: CollectionType,
+  DateType: DateType,
+  PhoneType: PhoneType
+});
+
+const PLACEHOLDER = "#";
+const removeFormatCharactersFromMaskedString = (value, mask, reserved = [PLACEHOLDER]) => {
+  return value.split("").reduce((newString, nextChar, nextIndex) => {
+    const maskedVal = mask[nextIndex];
+    if (reserved.includes(maskedVal)) {
+      return newString + nextChar;
+    }
+    return newString;
+  }, "");
+};
+const formatAsEnum = (value, acceptedValues, options) => {
+  const autoCompletionsByOverlapCount = acceptedValues.reduce((validCompletions, validValue) => {
+    let overlap = 0;
+    for (let charIndex = 0; charIndex < Math.min(validValue.length, value.length); charIndex++) {
+      const validChar = (options == null ? void 0 : options.ignoreCase) ? validValue[charIndex].toLowerCase() : validValue[charIndex];
+      const actualChar = (options == null ? void 0 : options.ignoreCase) ? value[charIndex].toLowerCase() : value[charIndex];
+      if (validChar !== actualChar) {
+        break;
+      }
+      overlap += 1;
+    }
+    if (overlap === 0) {
+      return validCompletions;
+    }
+    return [
+      ...validCompletions,
+      {
+        count: overlap,
+        target: validValue
+      }
+    ];
+  }, []).sort((e) => e.count);
+  if (autoCompletionsByOverlapCount.length === 0) {
+    return void 0;
+  }
+  if (autoCompletionsByOverlapCount.length === 1 && (options == null ? void 0 : options.autocomplete)) {
+    return autoCompletionsByOverlapCount[0].target;
+  }
+  return autoCompletionsByOverlapCount[0].target.substr(0, autoCompletionsByOverlapCount[0].count);
+};
+const formatAsMasked = (value, valueCharMaskMatch, mask) => {
+  const valStr = String(value);
+  let withMask = mask;
+  if (valStr.trim() === "") {
+    return "";
+  }
+  valStr.replace(valueCharMaskMatch, (match) => {
+    withMask = withMask.replace(PLACEHOLDER, match);
+    return match;
+  });
+  return withMask.split(PLACEHOLDER)[0];
+};
+const createMaskedNumericFormatter = (name, mask) => {
+  return {
+    name,
+    format: (value, options) => {
+      if (typeof value !== "string") {
+        return value;
+      }
+      if ((options == null ? void 0 : options.exceptions) && options.exceptions.length > 0) {
+        const formattedUsingExceptions = formatAsEnum(value, options.exceptions, {
+          autocomplete: true,
+          ignoreCase: true
+        });
+        if (formattedUsingExceptions !== void 0) {
+          return formattedUsingExceptions;
+        }
+      }
+      return formatAsMasked(value, /\d/g, mask);
+    },
+    deformat: (value, options) => {
+      if (typeof value !== "string") {
+        return value;
+      }
+      if ((options == null ? void 0 : options.exceptions) && options.exceptions.length > 0) {
+        const usingExceptions = formatAsEnum(value, options.exceptions, {
+          autocomplete: false,
+          ignoreCase: false
+        });
+        if (usingExceptions !== void 0) {
+          return usingExceptions;
+        }
+      }
+      return removeFormatCharactersFromMaskedString(value, mask);
+    }
+  };
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const LENGTH_OF_MAX_INT = String(Number.MAX_SAFE_INTEGER).split("").length;
+const integer = {
+  name: "integer",
+  format: (value) => {
+    var _a, _b;
+    if (value === "-") {
+      return value;
+    }
+    const formatted = (_b = (_a = integer.deformat) == null ? void 0 : _a.call(integer, value)) != null ? _b : value;
+    if (typeof formatted === "number") {
+      return String(formatted);
+    }
+    return "";
+  },
+  deformat: (value) => {
+    if (typeof value === "number") {
+      return Math.floor(value) + 0;
+    }
+    if (typeof value !== "string") {
+      return;
+    }
+    const isNeg = value.replace(/[^0-9.-]/g, "").charAt(0) === "-";
+    let digits = value.replace(/[^0-9.]/g, "");
+    const decimalPlace = digits.indexOf(".");
+    if (decimalPlace > -1) {
+      digits = digits.substring(0, decimalPlace);
+    }
+    if (digits.length === 0) {
+      return;
+    }
+    digits = digits.substr(0, LENGTH_OF_MAX_INT);
+    const num = Number(`${isNeg ? "-" : ""}${digits}`);
+    return Math.floor(num) + 0;
+  }
+};
+const commaNumber = {
+  name: "commaNumber",
+  format: (_value, options) => {
+    if (_value === void 0 || _value === "") {
+      return _value;
+    }
+    if (typeof _value !== "string" && typeof _value !== "number") {
+      return "";
+    }
+    const value = String(_value);
+    const isNeg = value.replace(/[^0-9.-]/g, "").charAt(0) === "-";
+    let digitAndDecimal = value.replace(/[^0-9.]/g, "");
+    digitAndDecimal = digitAndDecimal.replace(/^(0*)((0.)?\d)/g, "$2");
+    const firstDecimal = digitAndDecimal.indexOf(".");
+    const digitsOnly = digitAndDecimal.replace(/[^0-9]/g, "");
+    let preDecDigits = digitsOnly;
+    let postDecDigits = "";
+    if (firstDecimal >= 0) {
+      preDecDigits = digitsOnly.substring(0, firstDecimal).substr(0, LENGTH_OF_MAX_INT);
+      postDecDigits = digitsOnly.substring(firstDecimal);
+    } else {
+      preDecDigits = preDecDigits.substr(0, LENGTH_OF_MAX_INT);
+    }
+    if ((options == null ? void 0 : options.precision) !== void 0) {
+      postDecDigits = postDecDigits.substring(0, options.precision).padEnd(options.precision, "0");
+    }
+    preDecDigits = preDecDigits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    if (preDecDigits === "" && firstDecimal === 0) {
+      preDecDigits = "0";
+    }
+    let retVal = preDecDigits;
+    if (isNeg) {
+      retVal = `-${retVal}`;
+    }
+    if (firstDecimal >= 0 || (options == null ? void 0 : options.precision) !== void 0) {
+      retVal += `.${postDecDigits}`;
+    }
+    return retVal;
+  },
+  deformat: (value) => {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const strValue = value.replace(/,/g, "");
+    if (strValue === "") {
+      return void 0;
+    }
+    const number = Number(strValue);
+    return isNaN(number) || number > Number.MAX_SAFE_INTEGER || number < Number.MIN_SAFE_INTEGER ? void 0 : number;
+  }
+};
+const date = {
+  name: "date",
+  format: (_value, options) => {
+    var _a, _b;
+    let value = typeof _value === "number" ? String(_value) : _value;
+    if (_value === void 0) {
+      return void 0;
+    }
+    if (typeof value !== "string" || value === "") {
+      return "";
+    }
+    if (value.match(/^\d{4}[-]\d{1,2}[-]\d{1,2}$/)) {
+      const tempVal = value.split("-");
+      value = `${tempVal[1]}/${tempVal[2]}/${tempVal[0]}`;
+    }
+    const dateFormat = (_b = (_a = options == null ? void 0 : options.mask) == null ? void 0 : _a.toUpperCase()) != null ? _b : "MM/DD/YYYY";
+    const delimiter = dateFormat.replace(/[^/.-]/g, "").charAt(0);
+    const formatParts = dateFormat.split(delimiter);
+    const valueParts = value.split(delimiter);
+    const processedValueParts = [];
+    let lastMatchIsFull = true;
+    for (let index = 0; index < valueParts.length; index++) {
+      let part = valueParts[index];
+      if (lastMatchIsFull && index < formatParts.length) {
+        part = part.replace(/[^0-9]/g, "");
+        const isLastExpectedField = formatParts.length - 1 === index;
+        const hasDelimiterAfter = valueParts.length - 1 > index;
+        const curFormat = formatParts[index];
+        if (curFormat === "YYYY") {
+          if (part.length > 4) {
+            valueParts[index + 1] = [
+              "*",
+              part.substring(4),
+              valueParts[index + 1]
+            ].join("");
+            part = part.substring(0, 4);
+          }
+          if (part.length === 4) {
+            lastMatchIsFull = true;
+            processedValueParts.push(part);
+          }
+          if (part.length === 3) {
+            if (isLastExpectedField || !hasDelimiterAfter) {
+              lastMatchIsFull = false;
+              processedValueParts.push(part);
+            } else {
+              valueParts[index + 1] = `*${part.substring(2)}${valueParts[index + 1]}`;
+              part = part.substring(0, 2);
+            }
+          }
+          if (part.length === 2) {
+            let autocomplete;
+            if (part.length === 2 && (hasDelimiterAfter || isLastExpectedField && part !== "19" && part !== "20")) {
+              autocomplete = `20${part}`;
+              if (part > (new Date().getFullYear() + 5).toString().substring(2)) {
+                autocomplete = `19${part}`;
+              }
+            }
+            if (autocomplete) {
+              lastMatchIsFull = true;
+              processedValueParts.push(autocomplete);
+            } else {
+              lastMatchIsFull = false;
+              processedValueParts.push(part);
+            }
+          }
+          if (part.length === 1 || part.length === 0) {
+            lastMatchIsFull = false;
+            processedValueParts.push(part);
+          }
+        } else if (curFormat === "YY") {
+          if (part.length > 2) {
+            valueParts[index + 1] = [
+              "*",
+              part.substring(2),
+              valueParts[index + 1]
+            ].join("");
+            part = part.substring(0, 2);
+          }
+          if (part.length === 2) {
+            lastMatchIsFull = true;
+            processedValueParts.push(part);
+          }
+          if (part.length === 1 || part.length === 0) {
+            lastMatchIsFull = false;
+            processedValueParts.push(part);
+          }
+        } else {
+          if (part.length > 2) {
+            valueParts[index + 1] = [
+              "*",
+              part.substring(2),
+              valueParts[index + 1]
+            ].join("");
+            part = part.substring(0, 2);
+          }
+          if (part.length === 2) {
+            if (part === "00" && !hasDelimiterAfter) {
+              lastMatchIsFull = false;
+              processedValueParts.push("0");
+            } else {
+              lastMatchIsFull = true;
+              processedValueParts.push(part);
+            }
+          }
+          if (part.length === 1) {
+            if (hasDelimiterAfter) {
+              lastMatchIsFull = true;
+              processedValueParts.push(`0${part}`);
+            } else {
+              lastMatchIsFull = false;
+              processedValueParts.push(part);
+            }
+          }
+          if (part.length === 0) {
+            lastMatchIsFull = false;
+            processedValueParts.push(part);
+          }
+        }
+      }
+    }
+    return processedValueParts.join(delimiter);
+  }
+};
+const currency = {
+  name: "currency",
+  format: (_value, options) => {
+    const value = typeof _value === "number" ? String(_value) : _value;
+    const {
+      currencySymbol = "",
+      useParensForNeg = false,
+      precision = 2
+    } = options != null ? options : {};
+    if (value === void 0 || value === "") {
+      return value;
+    }
+    if (typeof value !== "string") {
+      return value;
+    }
+    const sign = /^\s*-/.test(value) ? -1 : 1;
+    const dotIndex = value.indexOf(".");
+    let preDecimal;
+    let postDecimal;
+    if (dotIndex >= 0) {
+      preDecimal = value.substr(0, dotIndex).replace(/\D+/g, "");
+      postDecimal = value.substr(dotIndex + 1).replace(/\D+/g, "");
+    } else {
+      preDecimal = value.replace(/\D+/g, "");
+      postDecimal = "0";
+    }
+    const numericalValue = sign * Number(`${preDecimal}.${postDecimal}`);
+    const fixedString = numericalValue.toFixed(precision);
+    const prettyString = fixedString.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    if (prettyString.charAt(0) === "-") {
+      if (useParensForNeg) {
+        return `(${currencySymbol}${prettyString.substring(1)})`;
+      }
+      return `-${currencySymbol}${prettyString.substring(1)}`;
+    }
+    return currencySymbol + prettyString;
+  },
+  deformat: (value, options) => {
+    var _a;
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value !== "string") {
+      return void 0;
+    }
+    let deformatted = value;
+    if (options == null ? void 0 : options.currencySymbol) {
+      deformatted = value.replace(options.currencySymbol, "");
+    }
+    return (_a = commaNumber.deformat) == null ? void 0 : _a.call(commaNumber, deformatted);
+  }
+};
+const basePhoneFormatter = createMaskedNumericFormatter("phone", "(###) ###-####");
+const phone = __spreadProps(__spreadValues({}, basePhoneFormatter), {
+  deformat: (value) => {
+    var _a;
+    return (_a = basePhoneFormatter.deformat) == null ? void 0 : _a.call(basePhoneFormatter, value);
+  },
+  format: (value) => {
+    var _a, _b;
+    return (_b = (_a = basePhoneFormatter.format) == null ? void 0 : _a.call(basePhoneFormatter, value === "(" ? "" : value)) != null ? _b : value;
+  }
+});
+
+var formats = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  integer: integer,
+  commaNumber: commaNumber,
+  date: date,
+  currency: currency,
+  phone: phone
+});
+
+class CommonTypesPlugin {
+  constructor() {
+    this.name = "CommonTypes";
+  }
+  apply(player) {
+    player.registerPlugin(new TypesProviderPlugin({
+      types: Object.values(dataTypes),
+      formats: Object.values(formats),
+      validators: Object.entries(validators)
+    }));
+  }
+}
+
+export { CommonTypesPlugin, PLACEHOLDER, createMaskedNumericFormatter, refs as dataRefs, dataTypes, formatAsEnum, formatAsMasked, formats, removeFormatCharactersFromMaskedString, validators };
+//# sourceMappingURL=index.esm.js.map