@player-ui/common-types-plugin 0.8.0--canary.307.9621 → 0.8.0-next.0

package/src/validators/index.ts

@@ -1,6 +1,5 @@
-import type { Expression } from '@player-ui/types';
-import { resolveDataRefs } from '@player-ui/player';
-import type { ValidatorFunction } from '@player-ui/player';
+import { resolveDataRefs } from "@player-ui/player";
+import type { ValidatorFunction, Expression } from "@player-ui/player";
 
 // Shamelessly lifted from Scott Gonzalez via the Bassistance Validation plugin http://projects.scottsplayground.com/email_address_validation/
 
@@ -11,7 +10,7 @@ const ZIP_REGEX = /^\d{5}(-\d{4})?$/;
 
 /** Skip any null or undefined value when running the validator */
 function skipNullish<T>(
-  validationFn: ValidatorFunction<T>
+  validationFn: ValidatorFunction<T>,
 ): ValidatorFunction<T> {
   return (context, value, options) => {
     if (value === null || value === undefined) {
@@ -24,11 +23,11 @@ function skipNullish<T>(
 
 /** Checks to see if the data-type is a string */
 export const string: ValidatorFunction = skipNullish((context, value) => {
-  if (typeof value !== 'string') {
+  if (typeof value !== "string") {
     const message = context.constants.getConstants(
-      'validation.string',
-      'constants',
-      'Value must be a string'
+      "validation.string",
+      "constants",
+      "Value must be a string",
     ) as string;
 
     return {
@@ -43,9 +42,9 @@ export const string: ValidatorFunction = skipNullish((context, value) => {
 /** Validation for a non-mutable property */
 export const readonly: ValidatorFunction = (context) => {
   const message = context.constants.getConstants(
-    'validation.readonly',
-    'constants',
-    'Value cannot be modified'
+    "validation.readonly",
+    "constants",
+    "Value cannot be modified",
   ) as string;
 
   return { message };
@@ -55,9 +54,9 @@ export const readonly: ValidatorFunction = (context) => {
 export const collection: ValidatorFunction = skipNullish((context, value) => {
   if (!Array.isArray(value)) {
     const message = context.constants.getConstants(
-      'validation.collection',
-      'constants',
-      'Cannot set collection to non-array'
+      "validation.collection",
+      "constants",
+      "Cannot set collection to non-array",
     ) as string;
 
     return { message };
@@ -68,15 +67,15 @@ export const collection: ValidatorFunction = skipNullish((context, value) => {
 export const integer: ValidatorFunction = skipNullish((context, value) => {
   if (
     value &&
-    (typeof value !== 'number' ||
+    (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'
+      "validation.integer",
+      "constants",
+      "Value must be an integer",
     ) as string;
 
     return {
@@ -99,9 +98,9 @@ export const oneOf: ValidatorFunction<{
   }
 
   const message = context.constants.getConstants(
-    'validation.oneOf',
-    'constants',
-    'Invalid entry'
+    "validation.oneOf",
+    "constants",
+    "Invalid entry",
   ) as string;
 
   return { message };
@@ -116,7 +115,7 @@ export const expression: ValidatorFunction<{
   exp: Expression;
 }> = (context, value, options?) => {
   if (options?.exp === undefined) {
-    context.logger.warn('No expression defined for validation');
+    context.logger.warn("No expression defined for validation");
 
     return;
   }
@@ -125,9 +124,9 @@ export const expression: ValidatorFunction<{
 
   if (!result) {
     const message = context.constants.getConstants(
-      'validation.expression',
-      'constants',
-      'Expression evaluation failed'
+      "validation.expression",
+      "constants",
+      "Expression evaluation failed",
     ) as string;
 
     return { message };
@@ -150,14 +149,14 @@ export const required: ValidatorFunction<{
     return;
   }
 
-  if (value === undefined || value === null || value === '') {
+  if (value === undefined || value === null || value === "") {
     const message = context.constants.getConstants(
-      'validation.required',
-      'constants',
-      'A value is required'
+      "validation.required",
+      "constants",
+      "A value is required",
     ) as string;
 
-    return { message, severity: 'error' };
+    return { message, severity: "error" };
   }
 };
 
@@ -172,8 +171,8 @@ export const regex: ValidatorFunction<{
   if (
     value === undefined ||
     value === null ||
-    value === '' ||
-    typeof options?.regex !== 'string'
+    value === "" ||
+    typeof options?.regex !== "string"
   ) {
     return;
   }
@@ -188,9 +187,9 @@ export const regex: ValidatorFunction<{
 
   if (!regexp.test(value)) {
     const message = context.constants.getConstants(
-      'validation.regex',
-      'constants',
-      'Invalid entry'
+      "validation.regex",
+      "constants",
+      "Invalid entry",
     ) as string;
 
     return { message };
@@ -211,31 +210,31 @@ export const length: ValidatorFunction<
       exact: number;
     }
 > = skipNullish((context, value, options) => {
-  if (typeof options !== 'object') {
-    context.logger.warn('Missing comparison in length validation');
+  if (typeof options !== "object") {
+    context.logger.warn("Missing comparison in length validation");
 
     return;
   }
 
   let valLength: number | undefined;
-  let itemName = 'items';
+  let itemName = "items";
 
-  if (typeof value === 'string') {
+  if (typeof value === "string") {
     valLength = value.length;
-    itemName = 'characters';
-  } else if (typeof value === 'object' && value !== null) {
+    itemName = "characters";
+  } else if (typeof value === "object" && value !== null) {
     valLength = Object.keys(value).length;
   }
 
   if (valLength === undefined) {
     context.logger.warn(
-      `Unable to determine a length for value of type: ${value}`
+      `Unable to determine a length for value of type: ${value}`,
     );
 
     return;
   }
 
-  if ('exact' in options) {
+  if ("exact" in options) {
     if (valLength !== options.exact) {
       return {
         message: `Must be exactly ${options.exact} ${itemName} long`,
@@ -250,9 +249,9 @@ export const length: ValidatorFunction<
 
   if (options.min !== undefined && valLength < options.min) {
     const message = context.constants.getConstants(
-      'validation.length.minimum',
-      'constants',
-      `At least ${options.min} ${itemName} needed`
+      "validation.length.minimum",
+      "constants",
+      `At least ${options.min} ${itemName} needed`,
     ) as string;
 
     return {
@@ -265,9 +264,9 @@ export const length: ValidatorFunction<
 
   if (options.max !== undefined && valLength > options.max) {
     const message = context.constants.getConstants(
-      'validation.length.maximum',
-      'constants',
-      `Up to ${options.max} ${itemName} allowed`
+      "validation.length.maximum",
+      "constants",
+      `Up to ${options.max} ${itemName} allowed`,
     ) as string;
 
     return {
@@ -286,15 +285,15 @@ export const min: ValidatorFunction<{
   /** The minimum value */
   value: number;
 }> = skipNullish((context, value, options) => {
-  if (typeof value !== 'number' || options?.value === undefined) {
+  if (typeof value !== "number" || options?.value === undefined) {
     return;
   }
 
   if (value < options.value) {
     const message = context.constants.getConstants(
-      'validation.min',
-      'constants',
-      `Must be at least ${options.value}`
+      "validation.min",
+      "constants",
+      `Must be at least ${options.value}`,
     ) as string;
 
     return { message };
@@ -308,15 +307,15 @@ export const max: ValidatorFunction<{
   /** The minimum value */
   value: number;
 }> = skipNullish((context, value, options) => {
-  if (typeof value !== 'number' || options?.value === undefined) {
+  if (typeof value !== "number" || options?.value === undefined) {
     return;
   }
 
   if (value > options.value) {
     const message = context.constants.getConstants(
-      'validation.max',
-      'constants',
-      `Cannot exceed ${options.value}`
+      "validation.max",
+      "constants",
+      `Cannot exceed ${options.value}`,
     ) as string;
 
     return { message };
@@ -327,18 +326,18 @@ export const max: ValidatorFunction<{
 const stringRegexValidator = (
   test: RegExp,
   messagePath: string,
-  invalidMessage: string
+  invalidMessage: string,
 ): ValidatorFunction => {
   return skipNullish((context, value) => {
-    if (typeof value === 'string' && value === '') {
+    if (typeof value === "string" && value === "") {
       return;
     }
 
-    if (typeof value !== 'string' || !test.test(value)) {
+    if (typeof value !== "string" || !test.test(value)) {
       const message = context.constants.getConstants(
         messagePath,
-        'constants',
-        invalidMessage
+        "constants",
+        invalidMessage,
       ) as string;
 
       return { message };
@@ -349,20 +348,20 @@ const stringRegexValidator = (
 /** Checks that the given value represents an email */
 export const email = stringRegexValidator(
   EMAIL_REGEX,
-  'validation.email',
-  'Improper email format'
+  "validation.email",
+  "Improper email format",
 );
 
 /** Checks that the given value represents a phone number */
 export const phone = stringRegexValidator(
   PHONE_REGEX,
-  'validation.phone',
-  'Invalid phone number'
+  "validation.phone",
+  "Invalid phone number",
 );
 
 /** Checks that the given value represents a phone number */
 export const zip = stringRegexValidator(
   ZIP_REGEX,
-  'validation.regex',
-  'Invalid zip code'
+  "validation.regex",
+  "Invalid zip code",
 );

package/types/data-types/types.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from "@player-ui/player";
+export declare const BooleanType: Schema.DataType<boolean>;
+export declare const IntegerType: Schema.DataType<number>;
+export declare const IntegerPosType: Schema.DataType<number>;
+export declare const IntegerNNType: Schema.DataType<number>;
+export declare const StringType: Schema.DataType<string>;
+export declare const CollectionType: Schema.DataType<Array<unknown>>;
+export declare const DateType: Schema.DataType<string>;
+export declare const PhoneType: Schema.DataType<string>;
+//# sourceMappingURL=types.d.ts.map

package/types/formats/index.d.ts

@@ -0,0 +1,24 @@
+import type { FormatType } from "@player-ui/player";
+/**
+ * Converts an integer to and from a string for display
+ */
+export declare const integer: FormatType<number, string>;
+/** Converts a number to/from a comma separated version */
+export declare const commaNumber: FormatType<number, string, {
+    /** The number of decimal places to show */
+    precision?: number;
+}>;
+export declare const date: FormatType<string, string, {
+    /** The mask to use to format the date */
+    mask?: string;
+}>;
+export declare const currency: FormatType<number, string, {
+    /** The symbol to use for currency */
+    currencySymbol?: string;
+    /** Use parenthesis instead of a - sign for negative values */
+    useParensForNeg?: boolean;
+    /** The number of decimal places to show */
+    precision?: number;
+}>;
+export declare const phone: FormatType<string>;
+//# sourceMappingURL=index.d.ts.map

package/types/formats/utils.d.ts

@@ -0,0 +1,41 @@
+import type { FormatType } from "@player-ui/player";
+export declare const PLACEHOLDER = "#";
+/**
+ * Remove any formatting characters in the 'mask' from 'value'
+ *
+ * @param value - The string to remove the control characters from
+ * @param mask - The mask to use and test against
+ * @param reserved - The reserved _slots_ (these are the chars that you expect new values to be subbed into)
+ *
+ * @example
+ * removeFormatCharactersFromMaskedString('123-456', '###-###', ['#']) => '123456'
+ */
+export declare const removeFormatCharactersFromMaskedString: (value: string, mask: string, reserved?: string[]) => string;
+/**
+ * Format the given string using one of the accepted values
+ * Optionally, the value can be choose to ignore case when formatting, or to autocomplete if only 1 option is viable
+ * If no such option is viable, undefined is returned
+ */
+export declare const formatAsEnum: (value: string, acceptedValues: string[], options?: {
+    /** Ignore the case of the provided value when comparing to the acceptedValues */
+    ignoreCase?: boolean;
+    /** If only 1 option is viable, autocomplete the value to the accepted one */
+    autocomplete?: boolean;
+}) => string | undefined;
+/**
+ * Format the given value using the mask + match
+ *
+ * @param value - The string value to format
+ * @param valueCharMaskMatch - A regular expression that matches characters to substitute in the match. This is typically `/\d/g` or `/\w/g`
+ * @param mask - The mask to format against. Use # as a placeholder for
+ */
+export declare const formatAsMasked: (value: string | number, valueCharMaskMatch: RegExp, mask: string) => string;
+/**
+ * Creates a format definition with the given mask
+ * Use the `#` char as a placeholder for a number
+ */
+export declare const createMaskedNumericFormatter: (name: string, mask: string) => FormatType<string, string, {
+    /** An enum of values that are also acceptable, and don't fall under the mask */
+    exceptions?: Array<string>;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,27 @@
+import type { Player, ExtendedPlayerPlugin } from "@player-ui/player";
+import * as validators from "./validators";
+import * as dataTypes from "./data-types/types";
+import * as formats from "./formats";
+import type { BooleanType, IntegerType, IntegerPosType, IntegerNNType, StringType, CollectionType, DateType, PhoneType } from "./data-types/types";
+export { validators, dataTypes, formats };
+export * from "./formats/utils";
+/**
+ * Exposes a lot of common DataTypes, validations, and formats to Player instance.
+ */
+export declare class CommonTypesPlugin implements ExtendedPlayerPlugin<[
+], [
+], [
+], [
+    typeof BooleanType,
+    typeof IntegerType,
+    typeof IntegerPosType,
+    typeof IntegerNNType,
+    typeof StringType,
+    typeof CollectionType,
+    typeof DateType,
+    typeof PhoneType
+]> {
+    name: string;
+    apply(player: Player): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/validators/index.d.ts

@@ -0,0 +1,68 @@
+import type { ValidatorFunction, Expression } from "@player-ui/player";
+/** Checks to see if the data-type is a string */
+export declare const string: ValidatorFunction;
+/** Validation for a non-mutable property */
+export declare const readonly: ValidatorFunction;
+/** Check to see if the value represents an array of items */
+export declare const collection: ValidatorFunction;
+/** Checks to see if the value is an integer */
+export declare const integer: ValidatorFunction;
+/** An enum check to see if the value is in a provided list of acceptable options */
+export declare const oneOf: ValidatorFunction<{
+    /** The enum values that are acceptable  */
+    options: Array<unknown>;
+}>;
+/** A validator that evaluates an expression for validation */
+export declare const expression: ValidatorFunction<{
+    /**
+     * The expression to evaluate.
+     * Falsy values indicate an invalid response
+     */
+    exp: Expression;
+}>;
+/** A validator that requires a non-null value */
+export declare const required: ValidatorFunction<{
+    /** An optional expression to limit the required check only if true */
+    if?: Expression;
+    /** An optional expression to limit the required check only if false */
+    ifNot?: Expression;
+}>;
+/** A validator that uses a regular expression */
+export declare const regex: ValidatorFunction<{
+    /**
+     * The regular expression to test: /pattern/
+     * Can optionally include flags after the pattern: /pattern/flags
+     */
+    regex: string;
+}>;
+/** Checks the length of a value  */
+export declare const length: ValidatorFunction<{
+    /** The minimum length to check against  */
+    min?: number;
+    /** The maximum length to check against  */
+    max?: number;
+} | {
+    /** The exact length to match against */
+    exact: number;
+}>;
+/**
+ * Checks that the given value is at least the expected one
+ */
+export declare const min: ValidatorFunction<{
+    /** The minimum value */
+    value: number;
+}>;
+/**
+ * Checks that the given value is at least the expected one
+ */
+export declare const max: ValidatorFunction<{
+    /** The minimum value */
+    value: number;
+}>;
+/** Checks that the given value represents an email */
+export declare const email: ValidatorFunction;
+/** Checks that the given value represents a phone number */
+export declare const phone: ValidatorFunction;
+/** Checks that the given value represents a phone number */
+export declare const zip: ValidatorFunction;
+//# sourceMappingURL=index.d.ts.map