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

package/dist/index.d.ts

@@ -0,0 +1,250 @@
+import { PlayerPlugin, Player } from '@player-ui/player';
+import { Expression, Schema, Language } from '@player-ui/types';
+import { ValidatorFunction } from '@player-ui/validator';
+import { FormatType } from '@player-ui/schema';
+
+/** Checks to see if the data-type is a string */
+declare const string: ValidatorFunction;
+/** Validation for a non-mutable property */
+declare const readonly: ValidatorFunction;
+/** Check to see if the value represents an array of items */
+declare const collection: ValidatorFunction;
+/** Checks to see if the value is an integer */
+declare const integer$1: ValidatorFunction;
+/** An enum check to see if the value is in a provided list of acceptable options */
+declare const oneOf: ValidatorFunction<{
+    /** The enum values that are acceptable  */
+    options: Array<unknown>;
+}>;
+/** A validator that evaluates an expression for validation */
+declare const expression: ValidatorFunction<{
+    /**
+     * The expression to evaluate.
+     * Falsy values indicate an invalid response
+     */
+    exp: Expression;
+}>;
+/** A validator that requires a non-null value */
+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 */
+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  */
+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
+ */
+declare const min: ValidatorFunction<{
+    /** The minimum value */
+    value: number;
+}>;
+/**
+ * Checks that the given value is at least the expected one
+ */
+declare const max: ValidatorFunction<{
+    /** The minimum value */
+    value: number;
+}>;
+/** Checks that the given value represents an email */
+declare const email: ValidatorFunction<unknown>;
+/** Checks that the given value represents a phone number */
+declare const phone$1: ValidatorFunction<unknown>;
+/** Checks that the given value represents a phone number */
+declare const zip: ValidatorFunction<unknown>;
+
+declare const index$1_string: typeof string;
+declare const index$1_readonly: typeof readonly;
+declare const index$1_collection: typeof collection;
+declare const index$1_oneOf: typeof oneOf;
+declare const index$1_expression: typeof expression;
+declare const index$1_required: typeof required;
+declare const index$1_regex: typeof regex;
+declare const index$1_length: typeof length;
+declare const index$1_min: typeof min;
+declare const index$1_max: typeof max;
+declare const index$1_email: typeof email;
+declare const index$1_zip: typeof zip;
+declare namespace index$1 {
+  export {
+    index$1_string as string,
+    index$1_readonly as readonly,
+    index$1_collection as collection,
+    integer$1 as integer,
+    index$1_oneOf as oneOf,
+    index$1_expression as expression,
+    index$1_required as required,
+    index$1_regex as regex,
+    index$1_length as length,
+    index$1_min as min,
+    index$1_max as max,
+    index$1_email as email,
+    phone$1 as phone,
+    index$1_zip as zip,
+  };
+}
+
+declare const BooleanType: Schema.DataType<boolean>;
+declare const IntegerType: Schema.DataType<number>;
+declare const IntegerPosType: Schema.DataType<number>;
+declare const IntegerNNType: Schema.DataType<number>;
+declare const StringType: Schema.DataType<string>;
+declare const CollectionType: Schema.DataType<Array<unknown>>;
+declare const DateType: Schema.DataType<string>;
+declare const PhoneType: Schema.DataType<string>;
+
+declare const types_BooleanType: typeof BooleanType;
+declare const types_IntegerType: typeof IntegerType;
+declare const types_IntegerPosType: typeof IntegerPosType;
+declare const types_IntegerNNType: typeof IntegerNNType;
+declare const types_StringType: typeof StringType;
+declare const types_CollectionType: typeof CollectionType;
+declare const types_DateType: typeof DateType;
+declare const types_PhoneType: typeof PhoneType;
+declare namespace types {
+  export {
+    types_BooleanType as BooleanType,
+    types_IntegerType as IntegerType,
+    types_IntegerPosType as IntegerPosType,
+    types_IntegerNNType as IntegerNNType,
+    types_StringType as StringType,
+    types_CollectionType as CollectionType,
+    types_DateType as DateType,
+    types_PhoneType as PhoneType,
+  };
+}
+
+declare const BooleanTypeRef: Language.DataTypeRef;
+declare const IntegerTypeRef: Language.DataTypeRef;
+declare const IntegerPosTypeRef: Language.DataTypeRef;
+declare const IntegerNNTypeRef: Language.DataTypeRef;
+declare const StringTypeRef: Language.DataTypeRef;
+declare const CollectionTypeRef: Language.DataTypeRef;
+declare const DateTypeRef: Language.DataTypeRef;
+declare const PhoneTypeRef: Language.DataTypeRef;
+
+declare const refs_BooleanTypeRef: typeof BooleanTypeRef;
+declare const refs_IntegerTypeRef: typeof IntegerTypeRef;
+declare const refs_IntegerPosTypeRef: typeof IntegerPosTypeRef;
+declare const refs_IntegerNNTypeRef: typeof IntegerNNTypeRef;
+declare const refs_StringTypeRef: typeof StringTypeRef;
+declare const refs_CollectionTypeRef: typeof CollectionTypeRef;
+declare const refs_DateTypeRef: typeof DateTypeRef;
+declare const refs_PhoneTypeRef: typeof PhoneTypeRef;
+declare namespace refs {
+  export {
+    refs_BooleanTypeRef as BooleanTypeRef,
+    refs_IntegerTypeRef as IntegerTypeRef,
+    refs_IntegerPosTypeRef as IntegerPosTypeRef,
+    refs_IntegerNNTypeRef as IntegerNNTypeRef,
+    refs_StringTypeRef as StringTypeRef,
+    refs_CollectionTypeRef as CollectionTypeRef,
+    refs_DateTypeRef as DateTypeRef,
+    refs_PhoneTypeRef as PhoneTypeRef,
+  };
+}
+
+/**
+ * Converts an integer to and from a string for display
+ */
+declare const integer: FormatType<number, string>;
+/** Converts a number to/from a comma separated version */
+declare const commaNumber: FormatType<number, string, {
+    /** The number of decimal places to show */
+    precision?: number;
+}>;
+declare const date: FormatType<string, string, {
+    /** The mask to use to format the date */
+    mask?: string;
+}>;
+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;
+}>;
+declare const phone: FormatType<string>;
+
+declare const index_integer: typeof integer;
+declare const index_commaNumber: typeof commaNumber;
+declare const index_date: typeof date;
+declare const index_currency: typeof currency;
+declare const index_phone: typeof phone;
+declare namespace index {
+  export {
+    index_integer as integer,
+    index_commaNumber as commaNumber,
+    index_date as date,
+    index_currency as currency,
+    index_phone as phone,
+  };
+}
+
+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'
+ */
+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
+ */
+declare const formatAsEnum: (value: string, acceptedValues: string[], options?: {
+    /** Ignore the case of the provided value when comparing to the acceptedValues */
+    ignoreCase?: boolean | undefined;
+    /** If only 1 option is viable, autocomplete the value to the accepted one */
+    autocomplete?: boolean | undefined;
+} | undefined) => 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
+ */
+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
+ */
+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>;
+}>;
+
+/**
+ * Exposes a lot of common DataTypes, validations, and formats to Player instance.
+ */
+declare class CommonTypesPlugin implements PlayerPlugin {
+    name: string;
+    apply(player: Player): void;
+}
+
+export { CommonTypesPlugin, PLACEHOLDER, createMaskedNumericFormatter, refs as dataRefs, types as dataTypes, formatAsEnum, formatAsMasked, index as formats, removeFormatCharactersFromMaskedString, index$1 as validators };