@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/common/logging/spec.js

@@ -0,0 +1,45 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { useEffect } from 'react';
+import { useLogger, LogProvider } from '.';
+describe('Logging Provider', function () {
+    var TestChild = function () {
+        var log = useLogger();
+        useEffect(function () {
+            // eslint-disable-next-line testing-library/no-debugging-utils
+            log.debug('Deprecation advanced warning', 'Some description.');
+            log.info('Invalid schema or model', 'Some description.');
+            log.warning('Action supressed', 'Some description.');
+            log.error('Deprecated schema', 'This schema is no longer supported.');
+            log.critical('Deprecated schema', 'This schema is no longer supported.');
+        }, []);
+        return _jsx("span", { children: "info,error" });
+    };
+    describe('when provider is initialised with flowId and stepId', function () {
+        describe('and is called within a component', function () {
+            function renderComponent(onLog) {
+                render(_jsx(LogProvider, __assign({ flowId: "myFlowId", stepId: "myStepId", onLog: onLog }, { children: _jsx(TestChild, {}) })));
+            }
+            it('calls the onLog callback', function () {
+                var onLog = jest.fn();
+                renderComponent(onLog);
+                expect(onLog).toHaveBeenCalledWith('debug', 'Dynamic Flow debug - Deprecation advanced warning - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('info', 'Dynamic Flow info - Invalid schema or model - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('warning', 'Dynamic Flow warning - Action supressed - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('error', 'Dynamic Flow error - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('critical', 'Dynamic Flow critical - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+            });
+        });
+    });
+});

package/build/common/messages.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    required: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;

package/build/common/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    required: {
+        id: 'dynamicFlows.DefaultErrorMessages.required',
+        defaultMessage: 'Please fill out this field.',
+        description: 'Customer has left the required field empty'
+    }
+});

package/build/common/propsValues/dateMode.d.ts

@@ -0,0 +1,4 @@
+export declare const DateMode: {
+    DAY_MONTH_YEAR: string;
+    MONTH_YEAR: string;
+};

package/build/common/propsValues/dateMode.js

@@ -0,0 +1,4 @@
+export var DateMode = {
+    DAY_MONTH_YEAR: 'day-month-year',
+    MONTH_YEAR: 'month-year'
+};

package/build/common/propsValues/formControlType.d.ts

@@ -0,0 +1,17 @@
+export declare const FormControlType: {
+    RADIO: string;
+    CHECKBOX: string;
+    SELECT: string;
+    FILE: string;
+    DATE: string;
+    DATETIME: string;
+    DATELOOKUP: string;
+    TEL: string;
+    NUMBER: string;
+    HIDDEN: string;
+    PASSWORD: string;
+    TEXT: string;
+    TEXTAREA: string;
+    UPLOAD: string;
+    TAB: string;
+};

package/build/common/propsValues/formControlType.js

@@ -0,0 +1,17 @@
+export var FormControlType = {
+    RADIO: 'radio',
+    CHECKBOX: 'checkbox',
+    SELECT: 'select',
+    FILE: 'file',
+    DATE: 'date',
+    DATETIME: 'date-time',
+    DATELOOKUP: 'date-lookup',
+    TEL: 'tel',
+    NUMBER: 'number',
+    HIDDEN: 'hidden',
+    PASSWORD: 'password',
+    TEXT: 'text',
+    TEXTAREA: 'textarea',
+    UPLOAD: 'upload',
+    TAB: 'tab'
+};

package/build/common/propsValues/monthFormat.d.ts

@@ -0,0 +1,4 @@
+export declare const MonthFormat: {
+    SHORT: string;
+    LONG: string;
+};

package/build/common/propsValues/monthFormat.js

@@ -0,0 +1,4 @@
+export var MonthFormat = {
+    SHORT: 'short',
+    LONG: 'long'
+};

package/build/common/propsValues/size.d.ts

@@ -0,0 +1,7 @@
+export declare const Size: {
+    EXTRA_SMALL: string;
+    SMALL: string;
+    MEDIUM: string;
+    LARGE: string;
+    EXTRA_LARGE: string;
+};

package/build/common/propsValues/size.js

@@ -0,0 +1,7 @@
+export var Size = {
+    EXTRA_SMALL: 'xs',
+    SMALL: 'sm',
+    MEDIUM: 'md',
+    LARGE: 'lg',
+    EXTRA_LARGE: 'xl'
+};

package/build/common/requirements.d.ts

@@ -0,0 +1,10 @@
+import { FormControlType } from './propsValues/formControlType';
+type Field = {
+    hidden?: boolean;
+    control?: (typeof FormControlType)[keyof typeof FormControlType];
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'blob';
+    options: any[];
+    format: 'date' | 'phone' | 'base64url' | 'password' | 'email' | 'uri';
+};
+declare const getControlType_Legacy: (field: Field) => string;
+export { getControlType_Legacy };

package/build/common/requirements.js

@@ -0,0 +1,50 @@
+var getControlType_Legacy = function (field) {
+    if (field.control) {
+        return field.control.toLowerCase();
+    }
+    if (field.hidden) {
+        return 'hidden';
+    }
+    if (field.options && field.options.length > 0) {
+        return getSelectionType(field);
+    }
+    switch (field.type) {
+        case 'string':
+            return getControlForStringFormat(field.format);
+        case 'number':
+        case 'integer':
+            return 'number';
+        case 'boolean':
+            return 'checkbox';
+        default:
+            return 'text';
+    }
+};
+var getControlForStringFormat = function (format) {
+    switch (format) {
+        case 'date':
+            return 'date';
+        case 'base64url':
+            return 'file';
+        case 'password':
+            return 'password';
+        case 'uri':
+            return 'text'; // 'url'; - not implemented
+        case 'email':
+            return 'text'; // 'email'; - not implemented
+        case 'phone':
+            return 'tel';
+        default:
+            return 'text';
+    }
+};
+var getSelectionType = function (field) {
+    if (field.control) {
+        return field.control;
+    }
+    if (field.options) {
+        return field.options.length > 3 ? 'select' : 'radio';
+    }
+    return 'select';
+};
+export { getControlType_Legacy };

package/build/common/schemaTypes/schemaTypes.d.ts

@@ -0,0 +1,23 @@
+import { Schema, isAllOfSchema as isAllOfSchemaDF, isOneOfSchema as isOneOfSchemaDF } from '../../dynamic-flow-types';
+export declare const schemaType: {
+    READ_ONLY: string;
+    PERSIST_ASYNC: string;
+    VALIDATION_ASYNC: string;
+    OBJECT: string;
+    PROMOTED_ONE_OF: string;
+    ONE_OF: string;
+    ALL_OF: string;
+    BASIC: string;
+    ARRAY: string;
+};
+export declare const isReadOnlySchema: (schema: Schema) => boolean;
+export declare const isPromotedOneOfSchema: (schema: Schema) => boolean;
+/**
+ * @deprecated Please use isOneOfSchema type guard function from "dynamic-flow-types"
+ */
+export declare const isOneOfSchema: typeof isOneOfSchemaDF;
+/**
+ * @deprecated Please use isAllOfSchema type guard function from "dynamic-flow-types"
+ */
+export declare const isAllOfSchema: typeof isAllOfSchemaDF;
+export declare const getSchemaType: (schema: Schema) => string | null;

package/build/common/schemaTypes/schemaTypes.js

@@ -0,0 +1,53 @@
+import { isAllOfSchema as isAllOfSchemaDF, isOneOfSchema as isOneOfSchemaDF, isObjectSchema, isArraySchema, isPersistAsyncSchema, isValidationAsyncSchema, isBasicSchema, } from '../../dynamic-flow-types';
+export var schemaType = {
+    READ_ONLY: 'readOnly',
+    PERSIST_ASYNC: 'persistAsync',
+    VALIDATION_ASYNC: 'validationAsync',
+    OBJECT: 'object',
+    PROMOTED_ONE_OF: 'promotedOneOf',
+    ONE_OF: 'oneOf',
+    ALL_OF: 'allOf',
+    BASIC: 'basic',
+    ARRAY: 'array'
+};
+export var isReadOnlySchema = function (schema) { return !!schema.readOnly && isBasicSchema(schema); };
+export var isPromotedOneOfSchema = function (schema) { return !!schema.oneOf && !!schema.promotion; };
+/**
+ * @deprecated Please use isOneOfSchema type guard function from "dynamic-flow-types"
+ */
+export var isOneOfSchema = isOneOfSchemaDF;
+/**
+ * @deprecated Please use isAllOfSchema type guard function from "dynamic-flow-types"
+ */
+export var isAllOfSchema = isAllOfSchemaDF;
+export var getSchemaType = function (schema) {
+    // Order of application is important here
+    if (isReadOnlySchema(schema)) {
+        return schemaType.READ_ONLY;
+    }
+    if (isPersistAsyncSchema(schema)) {
+        return schemaType.PERSIST_ASYNC;
+    }
+    if (isValidationAsyncSchema(schema)) {
+        return schemaType.VALIDATION_ASYNC;
+    }
+    if (isObjectSchema(schema)) {
+        return schemaType.OBJECT;
+    }
+    if (isArraySchema(schema)) {
+        return schemaType.ARRAY;
+    }
+    if (isPromotedOneOfSchema(schema)) {
+        return schemaType.PROMOTED_ONE_OF;
+    }
+    if (isOneOfSchema(schema)) {
+        return schemaType.ONE_OF;
+    }
+    if (isAllOfSchema(schema)) {
+        return schemaType.ALL_OF;
+    }
+    if (isBasicSchema(schema)) {
+        return schemaType.BASIC;
+    }
+    return null;
+};

package/build/common/schemaTypes/shouldDebounceSchema.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from '../../dynamic-flow-types';
+export declare function shouldDebounceSchema(schema: Schema): boolean;

package/build/common/schemaTypes/shouldDebounceSchema.js

@@ -0,0 +1,6 @@
+import { getSchemaType, schemaType } from './schemaTypes';
+export function shouldDebounceSchema(schema) {
+    return (getSchemaType(schema) === schemaType.BASIC &&
+        schema.type !== 'boolean' &&
+        schema.format !== 'base64url');
+}

package/build/common/stepTypes/stepTypes.d.ts

@@ -0,0 +1,7 @@
+import { Schema, Step } from '../../dynamic-flow-types';
+export declare const stepType: {
+    LAYOUT: string;
+    CAMERA: string;
+};
+export declare const filterHiddenSchemas: (schemas: Schema[]) => Schema[];
+export declare const getStepType: (step: Step) => string;

package/build/common/stepTypes/stepTypes.js

@@ -0,0 +1,42 @@
+import { isFileUploadSchema, isObjectSchema } from '../../dynamic-flow-types';
+export var stepType = {
+    LAYOUT: 'layout',
+    CAMERA: 'camera'
+};
+var isCameraStep = function (step) {
+    return isFormStep(step) && hasSingleAction(step) && hasSingleFileUploadSchemaWithCameraOnly(step);
+};
+var isFormStep = function (step) { return (step === null || step === void 0 ? void 0 : step.type) === 'form'; };
+var hasSingleAction = function (step) { var _a; return ((_a = step === null || step === void 0 ? void 0 : step.actions) === null || _a === void 0 ? void 0 : _a.length) === 1; };
+var hasSingleFileUploadSchemaWithCameraOnly = function (step) {
+    if (!step.schemas) {
+        return false;
+    }
+    var schemas = filterHiddenSchemas(step.schemas);
+    if ((schemas === null || schemas === void 0 ? void 0 : schemas.length) !== 1) {
+        return false;
+    }
+    var firstSchema = schemas[0];
+    if (!isObjectSchema(firstSchema) || Object.values(firstSchema.properties).length !== 1) {
+        return false;
+    }
+    var childSchema = Object.values(firstSchema.properties)[0];
+    if (!isFileUploadSchema(childSchema)) {
+        return false;
+    }
+    return childSchema.source === 'camera';
+};
+export var filterHiddenSchemas = function (schemas) {
+    return schemas.filter(function (schema) {
+        if (isObjectSchema(schema)) {
+            return Object.values((schema === null || schema === void 0 ? void 0 : schema.properties) || {}).find(function (schema) { return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true; });
+        }
+        return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true;
+    });
+};
+export var getStepType = function (step) {
+    if (isCameraStep(step)) {
+        return stepType.CAMERA;
+    }
+    return stepType.LAYOUT;
+};

package/build/common/tracking/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export type TrackableEventName = 'Dynamic Flow - Flow Started' | 'Dynamic Flow - Flow Finished' | 'Dynamic Flow - Step Started' | 'Dynamic Flow - Step Submitted' | 'Dynamic Flow - Step Refreshed' | 'Dynamic Flow - OneOf Selected' | 'Dynamic Flow - PersistAsync' | 'Dynamic Flow - ValidationAsync' | 'Dynamic Flow - Camera Permission Denied' | 'Dynamic Flow - Camera Feed Started' | 'Dynamic Flow - Camera Not Supported' | 'Dynamic Flow - invalid submission response' | 'Dynamic Flow - onAction supressed' | 'Dynamic Flow - OneOf Searched';
+export type TrackableEventHandler = (eventName: TrackableEventName, properties: Record<string, unknown>) => void;
+type Props = {
+    metadata?: Record<string, unknown> & {
+        flowId?: string;
+        stepId?: string;
+    };
+    children: React.ReactNode;
+    onTrackableEvent: TrackableEventHandler;
+};
+export declare const TrackingContextProvider: ({ metadata, children, onTrackableEvent }: Props) => JSX.Element;
+export declare function useTracking(): TrackableEventHandler;
+export declare const getTracker: (onTrackableEvent: TrackableEventHandler, metadata?: Record<string, unknown>) => TrackableEventHandler;
+export {};

package/build/common/tracking/index.js

@@ -0,0 +1,33 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+var TrackingContext = createContext({
+    trackEvent: function () {
+        // noop
+    }
+});
+export var TrackingContextProvider = function (_a) {
+    var metadata = _a.metadata, children = _a.children, onTrackableEvent = _a.onTrackableEvent;
+    var value = useMemo(function () { return ({ trackEvent: getTracker(onTrackableEvent, metadata) }); }, [onTrackableEvent, metadata]);
+    return _jsx(TrackingContext.Provider, __assign({ value: value }, { children: children }));
+};
+export function useTracking() {
+    var trackEvent = useContext(TrackingContext).trackEvent;
+    return trackEvent;
+}
+export var getTracker = function (onTrackableEvent, metadata) {
+    return function (eventName, properties) {
+        if (properties === void 0) { properties = {}; }
+        return onTrackableEvent(eventName, __assign(__assign({}, metadata), properties));
+    };
+};

package/build/common/tracking/spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/common/tracking/spec.js

@@ -0,0 +1,49 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { useEffect } from 'react';
+import { TrackingContextProvider, useTracking } from '.';
+describe('Tracking Provider', function () {
+    var TestChild = function (_a) {
+        var eventName = _a.eventName, properties = _a.properties;
+        var trackEvent = useTracking();
+        useEffect(function () {
+            trackEvent(eventName, properties);
+        }, []);
+        return _jsx("span", { children: eventName });
+    };
+    describe('when provider is initialised with metadata', function () {
+        describe('and is called upon mounting', function () {
+            function renderComponent(onTrackableEvent) {
+                render(_jsx(TrackingContextProvider, __assign({ metadata: { flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }, onTrackableEvent: onTrackableEvent }, { children: _jsx(TestChild, { eventName: "Dynamic Flow - Flow Started", properties: { custom: 'property' } }) })));
+            }
+            describe('it calls the onTrackableEvent callback', function () {
+                it('with the specified eventName', function () {
+                    var onTrackableEvent = jest.fn();
+                    renderComponent(onTrackableEvent);
+                    expect(onTrackableEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.anything());
+                });
+                it('with the specified custom properties', function () {
+                    var onTrackableEvent = jest.fn();
+                    renderComponent(onTrackableEvent);
+                    expect(onTrackableEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ custom: 'property' }));
+                });
+                it('with the specified flow and step ids any custom properties', function () {
+                    var onTrackableEvent = jest.fn();
+                    renderComponent(onTrackableEvent);
+                    expect(onTrackableEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }));
+                });
+            });
+        });
+    });
+});

package/build/common/utils/file-utils.d.ts

@@ -0,0 +1,4 @@
+import { UploadedFile } from '@transferwise/components';
+export declare function toKilobytes(sizeInBytes: number): number;
+export declare const toBase64: (file: Blob) => Promise<string>;
+export declare function areFilesSame(newFiles: UploadedFile[], files: UploadedFile[]): boolean;

package/build/common/utils/file-utils.js

@@ -0,0 +1,45 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export function toKilobytes(sizeInBytes) {
+    var ONE_KB_IN_BYTES = 1024;
+    return Math.floor(sizeInBytes / ONE_KB_IN_BYTES);
+}
+//TODO: Refactor: This is duplicate logic as in CameraStep.tsx
+export var toBase64 = function (file) {
+    return new Promise(function (resolve, reject) {
+        // we can safely assume the type of reader.result is string
+        // because we're calling reader.readAsDataURL
+        // https://developer.mozilla.org/en-US/docs/Web/API/FileReader/result
+        var reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.addEventListener('load', function () { return resolve(reader.result); });
+        reader.addEventListener('error', function (error) { return reject(error); });
+    });
+};
+export function areFilesSame(newFiles, files) {
+    var fileIdToExistingFileMap = files.reduce(function (map, fileObject) {
+        var _a;
+        return __assign(__assign({}, map), (_a = {}, _a[fileObject.id] = fileObject, _a));
+    }, {});
+    for (var _i = 0, newFiles_1 = newFiles; _i < newFiles_1.length; _i++) {
+        var newFile = newFiles_1[_i];
+        var existingFileObject = fileIdToExistingFileMap[newFile.id];
+        var fileDoesNotExistAlready = !existingFileObject;
+        if (fileDoesNotExistAlready) {
+            return false;
+        }
+        if (existingFileObject.status !== newFile.status) {
+            return false;
+        }
+    }
+    return true;
+}

package/build/common/utils/generate-random-id.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomId: (prefix?: string) => string;

package/build/common/utils/generate-random-id.js

@@ -0,0 +1,5 @@
+export var generateRandomId = function (prefix) {
+    if (prefix === void 0) { prefix = ''; }
+    var prefixString = prefix ? "".concat(prefix, "-") : '';
+    return "".concat(prefixString).concat(Math.floor(100000000 * Math.random()));
+};

package/build/common/utils/generate-random-id.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/common/utils/generate-random-id.test.js

@@ -0,0 +1,12 @@
+import { generateRandomId } from './generate-random-id';
+jest.spyOn(Math, 'random').mockReturnValue(0.123456789);
+describe('generateRandomId', function () {
+    it('should generate a random id', function () {
+        var id = generateRandomId();
+        expect(id).toBe('12345678');
+    });
+    it('should generate a random id with a prefix', function () {
+        var id = generateRandomId('prefix');
+        expect(id).toBe('prefix-12345678');
+    });
+});

package/build/common/validation/rule-validators/index.d.ts

@@ -0,0 +1,10 @@
+declare function isValidRequired(value: unknown, isRequired?: boolean): boolean;
+declare function isValidRequiredArray(value: unknown, isRequired?: boolean): boolean;
+declare function isValidMinLength(value: unknown, minLength: number | undefined): boolean;
+declare function isValidMaxLength(value: unknown, maxLength: number | undefined): boolean;
+declare function isValidPattern(value: string | undefined | null, pattern: string | undefined): boolean;
+declare function isValidMaximum(value: unknown, maximum: string | number | undefined): boolean;
+declare function isValidMinimum(value: unknown, minimum: string | number | undefined): boolean;
+declare function isValidMinItems(value: unknown, minItems: number | undefined): boolean;
+declare function isValidMaxItems(value: unknown, maxItems: number | undefined): boolean;
+export { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, };

package/build/common/validation/rule-validators/index.js

@@ -0,0 +1,40 @@
+import { isArray, isNumber, isString, isUndefined } from '@transferwise/neptune-validation';
+function isValidRequired(value, isRequired) {
+    if (isRequired === void 0) { isRequired = false; }
+    return !isRequired || !isUndefined(value);
+}
+function isValidRequiredArray(value, isRequired) {
+    if (isRequired === void 0) { isRequired = false; }
+    return !isRequired || isArray(value);
+}
+function isValidMinLength(value, minLength) {
+    return !isNumber(minLength) || (isString(value) && value.length >= minLength);
+}
+function isValidMaxLength(value, maxLength) {
+    return !isNumber(maxLength) || (isString(value) && value.length <= maxLength);
+}
+function isValidPattern(value, pattern) {
+    if (pattern === undefined) {
+        return true; // no pattern, therefore the value is valid
+    }
+    if (value === undefined || value === null) {
+        return false; // no value, but there's a pattern, therefore the value is NOT valid
+    }
+    var regex = new RegExp(pattern);
+    return !!regex.test(value);
+}
+function isValidMaximum(value, maximum) {
+    return ((!isNumber(maximum) && !isString(maximum)) ||
+        ((isNumber(value) || isString(value)) && value <= maximum));
+}
+function isValidMinimum(value, minimum) {
+    return ((!isNumber(minimum) && !isString(minimum)) ||
+        ((isNumber(value) || isString(value)) && value >= minimum));
+}
+function isValidMinItems(value, minItems) {
+    return !isNumber(minItems) || (isArray(value) && value.length >= minItems);
+}
+function isValidMaxItems(value, maxItems) {
+    return !isNumber(maxItems) || (isArray(value) && value.length <= maxItems);
+}
+export { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, };

package/build/common/validation/rule-validators/spec.d.ts

@@ -0,0 +1 @@
+export {};