@wise/dynamic-flow-client 0.3.0-beta-ec09e7.2 → 0.3.0

package/README.md

@@ -24,15 +24,15 @@ pnpm install @wise/dynamic-flow-client
 ```
 # yarn
 yarn add react react-dom react-intl
-yarn add @transferwise/components @transferwise/formatting @transferwise/icons @transferwise/neptune-css @transferwise/neptune-validation
+yarn add @transferwise/components @transferwise/formatting @transferwise/icons @transferwise/neptune-css
 
 # npm
 npm install react react-dom react-intl
-npm install @transferwise/components @transferwise/formatting @transferwise/icons @transferwise/neptune-css @transferwise/neptune-validation
+npm install @transferwise/components @transferwise/formatting @transferwise/icons @transferwise/neptune-css
 
 # pnpm
 pnpm install react react-dom react-intl
-pnpm install @transferwise/components @transferwise/formatting @transferwise/icons @transferwise/neptune-css @transferwise/neptune-validation
+pnpm install @transferwise/components @transferwise/formatting @transferwise/icons @transferwise/neptune-css
 ```
 **Note:** Keep in mind that some of these dependencies have their own peer dependencies. Don't forget to install those, for instance: `@transferwise/components` needs `@wise/art` and `@wise/components-theming`.
 

package/build/common/constants/SchemaType.d.ts

@@ -0,0 +1,11 @@
+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;
+};

package/build/common/constants/SchemaType.js

@@ -0,0 +1,11 @@
+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'
+};

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

@@ -0,0 +1,5 @@
+export * from './DateMode';
+export * from './FormControlType';
+export * from './MonthFormat';
+export * from './SchemaType';
+export * from './Size';

package/build/common/constants/index.js

@@ -0,0 +1,5 @@
+export * from './DateMode';
+export * from './FormControlType';
+export * from './MonthFormat';
+export * from './SchemaType';
+export * from './Size';

package/build/common/contexts/{fetcherContext/fetcherContext.js → fetcherContexts/FetcherContexts.js}

@@ -11,7 +11,7 @@ var __assign = (this && this.__assign) || function () {
 };
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo } from 'react';
-import { makeFetcher } from '.';
+import { makeFetcher } from '../../makeFetcher';
 var FetcherContext = createContext(undefined);
 export var FetcherProvider = function (_a) {
     var fetcher = _a.fetcher, children = _a.children;

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

@@ -0,0 +1,4 @@
+export * from './dynamicFlowContexts/DynamicFlowContexts';
+export * from './eventsContext/EventsContext';
+export * from './fetcherContexts/FetcherContexts';
+export * from './logContext/LogContext';

package/build/common/contexts/index.js

@@ -0,0 +1,4 @@
+export * from './dynamicFlowContexts/DynamicFlowContexts';
+export * from './eventsContext/EventsContext';
+export * from './fetcherContexts/FetcherContexts';
+export * from './logContext/LogContext';

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

@@ -0,0 +1,7 @@
+export * from './useDebouncedFunction/useDebouncedFunction';
+export * from './useExternal/useExternal';
+export * from './useExternalStepPolling/useExternalStepPolling';
+export * from './usePersistAsync/usePersistAsync';
+export * from './usePolling/usePolling';
+export * from './usePrevious/usePrevious';
+export * from './useStepPolling/useStepPolling';

package/build/common/hooks/index.js

@@ -0,0 +1,7 @@
+export * from './useDebouncedFunction/useDebouncedFunction';
+export * from './useExternal/useExternal';
+export * from './useExternalStepPolling/useExternalStepPolling';
+export * from './usePersistAsync/usePersistAsync';
+export * from './usePolling/usePolling';
+export * from './usePrevious/usePrevious';
+export * from './useStepPolling/useStepPolling';

package/build/common/hooks/useDebouncedFunction/useDebouncedFunction.d.ts

@@ -0,0 +1,2 @@
+import { DebouncedFunc } from '../../utils';
+export declare function useDebouncedFunction<T extends (...args: any[]) => any>(callback: T, waitMs: number): DebouncedFunc<T>;

package/build/common/hooks/useDebouncedFunction/useDebouncedFunction.js

@@ -0,0 +1,9 @@
+/* References:
+- https://github.com/gnbaron/use-lodash-debounce
+- https://dmitripavlutin.com/react-throttle-debounce/
+*/
+import { useCallback } from 'react';
+import { debounce } from '../../utils';
+export function useDebouncedFunction(callback, waitMs) {
+    return useCallback(debounce(callback, waitMs), [callback, waitMs]);
+}

package/build/common/hooks/useExternalStepPolling/useExternalStepPolling.d.ts

@@ -0,0 +1,12 @@
+import { Action, PollingConfiguration } from '../../../types';
+export type ExternalStepPollingConfiguration = PollingConfiguration & {
+    maxConsecutiveFails: number;
+    responseHandlers: ResponseHandler[];
+};
+type ResponseHandler = {
+    result: string;
+    action: Action;
+};
+/** @deprecated External step is no longer supported */
+export declare function useExternalStepPolling(polling: ExternalStepPollingConfiguration | undefined, onAction: (action: Action) => void): void;
+export {};

package/build/{layout/external → common/hooks/useExternalStepPolling}/useExternalStepPolling.js

@@ -10,9 +10,10 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { useCallback, useMemo } from 'react';
-import { useFetcher } from '../../common/contexts/fetcherContext';
-import { usePolling } from '../../common/hooks/usePolling';
-export function useStepPolling(polling, onAction) {
+import { usePolling } from '..';
+import { useFetcher } from '../../contexts';
+/** @deprecated External step is no longer supported */
+export function useExternalStepPolling(polling, onAction) {
     var fetcher = useFetcher();
     var asyncFn = useMemo(function () {
         if (polling) {

package/build/common/hooks/{usePersistAsync.d.ts → usePersistAsync/usePersistAsync.d.ts}

@@ -1,4 +1,4 @@
-import { PersistAsync } from '../../dynamic-flow-types';
+import { PersistAsync } from '../../../types';
 type PersistAsyncModel = string | Blob | null;
 type PerformPersistAsyncFunction = (payload: PersistAsyncModel) => Promise<{
     data: string | number;

package/build/common/hooks/{usePersistAsync.js → usePersistAsync/usePersistAsync.js}

@@ -45,14 +45,14 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import { isNull, isObject, isNumber, isString } from '@transferwise/neptune-validation';
 import { useState } from 'react';
 import { useIntl } from 'react-intl';
-import { isBlobSchema } from '../../dynamic-flow-types';
-import messages from '../../jsonSchemaForm/persistAsyncSchema/PersistAsyncSchema.messages';
-import { getErrorFromResponse } from '../../jsonSchemaForm/persistAsyncSchema/basic/PersistAsyncBasicSchema'; // FIXME: extract these functions form that schema component to either here or their own module
-import { useFetcher } from '../contexts/fetcherContext';
-import { isValidSchema } from '../validation/schema-validators';
+import { isNull, isObject, isNumber, isString } from '../../../common/validators';
+import messages from '../../../jsonSchemaForm/persistAsyncSchema/PersistAsyncSchema.messages';
+import { getErrorFromResponse } from '../../../jsonSchemaForm/persistAsyncSchema/persistAsyncBasicSchema/PersistAsyncBasicSchema'; // FIXME: extract these functions form that schema component to either here or their own module
+import { isBlobSchema } from '../../../types';
+import { useFetcher } from '../../contexts';
+import { isValidSchema } from '../../validators';
 export var usePersistAsync = function (persistAsync) {
     var _a = useState(null), abortController = _a[0], setAbortController = _a[1];
     var fetcher = useFetcher();

package/build/common/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1 @@
+export function usePrevious(value: any): undefined;

package/build/common/hooks/{usePrevious.js → usePrevious/usePrevious.js}

@@ -1,9 +1,8 @@
 import { useEffect, useRef } from 'react';
-var usePrevious = function (value) {
+export var usePrevious = function (value) {
     var reference = useRef();
     useEffect(function () {
         reference.current = value;
     }, [value]);
     return reference.current;
 };
-export default usePrevious;

package/build/{step/features/polling → common/hooks/useStepPolling}/useStepPolling.d.ts

@@ -1,2 +1,2 @@
-import { Action, PollingConfiguration } from '../../../dynamic-flow-types';
+import { Action, PollingConfiguration } from '../../../types';
 export declare function useStepPolling(polling: PollingConfiguration | undefined, onAction: (action: Action) => void): void;

package/build/{step/features/polling → common/hooks/useStepPolling}/useStepPolling.js

@@ -1,6 +1,6 @@
 import { useCallback, useMemo } from 'react';
-import { useFetcher } from '../../../common/contexts/fetcherContext';
-import { usePolling } from '../../../common/hooks/usePolling';
+import { usePolling } from '..';
+import { useFetcher } from '../../contexts';
 export function useStepPolling(polling, onAction) {
     var fetcher = useFetcher();
     var asyncFn = useMemo(function () {

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

@@ -0,0 +1 @@
+export * from './makeFetcher';

package/build/common/makeFetcher/index.js

@@ -0,0 +1 @@
+export * from './makeFetcher';

package/build/common/{contexts/fetcherContext → makeFetcher}/makeFetcher.js

@@ -9,7 +9,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { isRelativePath } from '../../api/utils';
+import { isRelativePath } from '../utils/api-utils';
 export var makeFetcher = function (baseUrl, additionalHeaders) {
     return function (input, init) {
         var resource = applyBaseUrl(input, baseUrl || '');

package/build/common/{general/index.js → utils/date-utils.js}

@@ -1,4 +1,4 @@
-import { isNumber } from '@transferwise/neptune-validation';
+import { isNumber } from '../validators';
 // function taken from: https://stackoverflow.com/questions/23593052/format-javascript-date-as-yyyy-mm-dd
 function formatDate(date) {
     var d = new Date(date);

package/build/common/utils/debounce.d.ts

@@ -0,0 +1,6 @@
+export interface DebouncedFunc<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): void;
+    cancel(): void;
+    flush(): void;
+}
+export declare const debounce: <T extends (...args: any[]) => any>(callback: T, waitMs: number) => DebouncedFunc<T>;

package/build/common/utils/debounce.js

@@ -0,0 +1,38 @@
+export var debounce = function (callback, waitMs) {
+    var timeoutId;
+    var lastArgs;
+    var clearTimer = function () {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        lastArgs = null;
+    };
+    var debouncedFn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        lastArgs = args;
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(function () {
+            callback.apply(void 0, lastArgs);
+            timeoutId = null;
+            lastArgs = null;
+        }, waitMs);
+    };
+    debouncedFn.cancel = function () {
+        if (timeoutId !== null) {
+            clearTimer();
+        }
+    };
+    debouncedFn.flush = function () {
+        if (timeoutId !== null) {
+            callback.apply(void 0, lastArgs);
+            clearTimer();
+        }
+    };
+    return debouncedFn;
+};

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

@@ -0,0 +1,8 @@
+export * from './api-utils';
+export * from './date-utils';
+export * from './debounce';
+export * from './is-equal';
+export * from './file-utils';
+export * from './id-utils';
+export * from './schema-utils';
+export * from './step-utils';

package/build/common/utils/index.js

@@ -0,0 +1,8 @@
+export * from './api-utils';
+export * from './date-utils';
+export * from './debounce';
+export * from './is-equal';
+export * from './file-utils';
+export * from './id-utils';
+export * from './schema-utils';
+export * from './step-utils';

package/build/common/utils/is-equal.d.ts

@@ -0,0 +1 @@
+export declare const isEqual: (a: unknown, b: unknown) => boolean;

package/build/common/utils/is-equal.js

@@ -0,0 +1,21 @@
+export var isEqual = function (a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every(function (item, index) { return isEqual(item, b[index]); });
+    }
+    if (isNonNullObject(a) && isNonNullObject(b) && isObjectEquals(a, b)) {
+        return true;
+    }
+    return false;
+};
+var isObjectEquals = function (a, b) {
+    var keysA = Object.keys(a);
+    var keysB = Object.keys(b);
+    return (keysA.length === keysB.length &&
+        keysA.every(function (key) { return Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]); }));
+};
+var isNonNullObject = function (a) {
+    return typeof a === 'object' && a !== null;
+};

package/build/common/{schemaTypes/schemaTypes.d.ts → utils/schema-utils.d.ts}

@@ -1,15 +1,4 @@
-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;
-};
+import { Schema, isAllOfSchema as isAllOfSchemaDF, isOneOfSchema as isOneOfSchemaDF } from '../../types';
 export declare const isReadOnlySchema: (schema: Schema) => boolean;
 export declare const isPromotedOneOfSchema: (schema: Schema) => boolean;
 /**
@@ -21,3 +10,4 @@ export declare const isOneOfSchema: typeof isOneOfSchemaDF;
  */
 export declare const isAllOfSchema: typeof isAllOfSchemaDF;
 export declare const getSchemaType: (schema: Schema) => string | null;
+export declare function shouldDebounceSchema(schema: Schema): boolean;

package/build/common/{schemaTypes/schemaTypes.js → utils/schema-utils.js}

@@ -1,15 +1,5 @@
-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'
-};
+import { isAllOfSchema as isAllOfSchemaDF, isOneOfSchema as isOneOfSchemaDF, isObjectSchema, isArraySchema, isPersistAsyncSchema, isValidationAsyncSchema, isBasicSchema, } from '../../types';
+import { SchemaType } from '../constants';
 export var isReadOnlySchema = function (schema) { return !!schema.readOnly && isBasicSchema(schema); };
 export var isPromotedOneOfSchema = function (schema) { return !!schema.oneOf && !!schema.promotion; };
 /**
@@ -23,31 +13,36 @@ export var isAllOfSchema = isAllOfSchemaDF;
 export var getSchemaType = function (schema) {
     // Order of application is important here
     if (isReadOnlySchema(schema)) {
-        return schemaType.READ_ONLY;
+        return SchemaType.READ_ONLY;
     }
     if (isPersistAsyncSchema(schema)) {
-        return schemaType.PERSIST_ASYNC;
+        return SchemaType.PERSIST_ASYNC;
     }
     if (isValidationAsyncSchema(schema)) {
-        return schemaType.VALIDATION_ASYNC;
+        return SchemaType.VALIDATION_ASYNC;
     }
     if (isObjectSchema(schema)) {
-        return schemaType.OBJECT;
+        return SchemaType.OBJECT;
     }
     if (isArraySchema(schema)) {
-        return schemaType.ARRAY;
+        return SchemaType.ARRAY;
     }
     if (isPromotedOneOfSchema(schema)) {
-        return schemaType.PROMOTED_ONE_OF;
+        return SchemaType.PROMOTED_ONE_OF;
     }
     if (isOneOfSchema(schema)) {
-        return schemaType.ONE_OF;
+        return SchemaType.ONE_OF;
     }
     if (isAllOfSchema(schema)) {
-        return schemaType.ALL_OF;
+        return SchemaType.ALL_OF;
     }
     if (isBasicSchema(schema)) {
-        return schemaType.BASIC;
+        return SchemaType.BASIC;
     }
     return null;
 };
+export function shouldDebounceSchema(schema) {
+    return (getSchemaType(schema) === SchemaType.BASIC &&
+        schema.type !== 'boolean' &&
+        schema.format !== 'base64url');
+}

package/build/common/{stepTypes/stepTypes.d.ts → utils/step-utils.d.ts}

@@ -1,4 +1,4 @@
-import { Schema, Step } from '../../dynamic-flow-types';
+import { Schema, Step } from '../../types';
 export declare const stepType: {
     LAYOUT: string;
     CAMERA: string;

package/build/common/{stepTypes/stepTypes.js → utils/step-utils.js}

@@ -1,4 +1,4 @@
-import { isFileUploadSchema, isObjectSchema } from '../../dynamic-flow-types';
+import { isFileUploadSchema, isObjectSchema } from '../../types';
 export var stepType = {
     LAYOUT: 'layout',
     CAMERA: 'camera'

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

@@ -0,0 +1,5 @@
+export { getValidModelParts, getValidObjectModelParts, getValidBasicModelOrNull, } from './models/model-validators';
+export { isValidSchema } from './schemas/schema-validators';
+export { getValidationFailures, getArrayValidationFailures, } from './validationFailures/validation-failures';
+export * from './types/type-validators';
+export * from './values/value-validators';

package/build/common/validators/index.js

@@ -0,0 +1,5 @@
+export { getValidModelParts, getValidObjectModelParts, getValidBasicModelOrNull, } from './models/model-validators';
+export { isValidSchema } from './schemas/schema-validators';
+export { getValidationFailures, getArrayValidationFailures, } from './validationFailures/validation-failures';
+export * from './types/type-validators';
+export * from './values/value-validators';

package/build/common/{validation/valid-model/index.d.ts → validators/models/model-validators.d.ts}

@@ -1,5 +1,4 @@
-import { ArrayModel, BasicModel, Model, ObjectModel, Schema } from '../../../dynamic-flow-types';
+import { BasicModel, Model, ObjectModel, Schema } from '../../../types';
 export declare const getValidModelParts: (model: Model, schema: Schema) => Model;
 export declare function getValidBasicModelOrNull(model: BasicModel | null, schema: Schema): BasicModel | null;
 export declare function getValidObjectModelParts(model: ObjectModel | null, schema: Schema): ObjectModel | null;
-export declare function getValidArrayModelParts(model: ArrayModel, schema: Schema): ArrayModel | null;

package/build/common/{validation/valid-model/index.js → validators/models/model-validators.js}

@@ -1,8 +1,7 @@
-import { isUndefined } from '@transferwise/neptune-validation';
-import { isNull } from 'lodash';
-import { isArrayModel, isArraySchema, isBasicSchema, isObjectModel, isObjectSchema, } from '../../../dynamic-flow-types';
-import { isOneOfSchema } from '../../../dynamic-flow-types/Schema';
-import { cleanArrayModelWithOneOfSchema, cleanBasicModelWithOneOfSchema, cleanModelWithArraySchema, cleanModelWithBooleanSchema, cleanModelWithNumberSchema, cleanModelWithStringSchema, cleanObjectModelWithAllOfSchema, cleanObjectModelWithObjectSchema, cleanObjectModelWithOneOfSchema, } from './utils';
+import { isArrayModel, isArraySchema, isBasicSchema, isObjectModel, isObjectSchema, } from '../../../types';
+import { isOneOfSchema } from '../../../types';
+import { isNull, isUndefined } from '../../validators';
+import { cleanArrayModelWithOneOfSchema, cleanBasicModelWithOneOfSchema, cleanModelWithArraySchema, cleanModelWithBooleanSchema, cleanModelWithNumberSchema, cleanModelWithStringSchema, cleanObjectModelWithAllOfSchema, cleanObjectModelWithObjectSchema, cleanObjectModelWithOneOfSchema, } from './models.utils';
 export var getValidModelParts = function (model, schema) {
     if (isObjectModel(model)) {
         return getValidObjectModelParts(model, schema);
@@ -53,7 +52,7 @@ export function getValidObjectModelParts(model, schema) {
     }
     return isObjectSchema(schema) ? cleanObjectModelWithObjectSchema(model, schema) : null;
 }
-export function getValidArrayModelParts(model, schema) {
+function getValidArrayModelParts(model, schema) {
     if (isOneOfSchema(schema)) {
         return cleanArrayModelWithOneOfSchema(model, schema);
     }

package/build/common/{validation/valid-model/utils.d.ts → validators/models/models.utils.d.ts}

@@ -1,4 +1,4 @@
-import { AllOfSchema, ArrayModel, ArraySchema, BasicModel, Model, ObjectModel, ObjectSchema, OneOfSchema } from '../../../dynamic-flow-types';
+import { AllOfSchema, ArrayModel, ArraySchema, BasicModel, Model, ObjectModel, ObjectSchema, OneOfSchema } from '../../../types';
 export declare function cleanBasicModelWithOneOfSchema(model: BasicModel, schema: OneOfSchema): BasicModel | null;
 export declare function cleanArrayModelWithOneOfSchema(model: ArrayModel, schema: OneOfSchema): ArrayModel | null;
 export declare function cleanModelWithStringSchema(model: Model): string | null;
@@ -8,4 +8,3 @@ export declare function cleanModelWithArraySchema(model: Model, schema: ArraySch
 export declare function cleanObjectModelWithObjectSchema(model: ObjectModel, schema: ObjectSchema): ObjectModel;
 export declare function cleanObjectModelWithAllOfSchema(model: ObjectModel, schema: AllOfSchema): ObjectModel;
 export declare function cleanObjectModelWithOneOfSchema(model: ObjectModel, schema: OneOfSchema): ObjectModel | null;
-export declare function filterOutNull<T>(array: (T | null)[]): T[];

package/build/common/{validation/valid-model/utils.js → validators/models/models.utils.js}

@@ -9,9 +9,10 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { isArray, isBoolean, isEmpty, isNull, isNumber, isString, isUndefined, } from '@transferwise/neptune-validation';
-import { isListArraySchema, isObjectModel, isArraySchema, } from '../../../dynamic-flow-types';
-import { getValidBasicModelOrNull, getValidModelParts, getValidObjectModelParts } from '.';
+import { isListArraySchema, isObjectModel, isArraySchema, } from '../../../types';
+import { isArray, isBoolean, isNull, isNumber, isString, isUndefined, } from '../types/type-validators';
+import { isEmpty } from '../values/value-validators';
+import { getValidBasicModelOrNull, getValidModelParts, getValidObjectModelParts, } from './model-validators';
 export function cleanBasicModelWithOneOfSchema(model, schema) {
     return schema.oneOf.some(function (nestedSchema) { return getValidBasicModelOrNull(model, nestedSchema) === model; })
         ? model
@@ -19,7 +20,9 @@ export function cleanBasicModelWithOneOfSchema(model, schema) {
 }
 export function cleanArrayModelWithOneOfSchema(model, schema) {
     var _a;
-    var validModels = filterOutNull(schema.oneOf.map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); }));
+    var validModels = schema.oneOf
+        .map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); })
+        .filter(function (item) { return item !== null; });
     if (validModels.length === 0) {
         return null;
     }
@@ -113,6 +116,3 @@ function deepMergeObject(object1, object2) {
         return __assign(__assign({}, acc), (_b = {}, _b[property] = object2[property], _b));
     }, __assign({}, object1));
 }
-export function filterOutNull(array) {
-    return array.filter(function (item) { return item !== null; });
-}

package/build/common/{validation/schema-validators/index.d.ts → validators/schemas/schema-validators.d.ts}

@@ -1,4 +1,4 @@
-import { Model, Schema } from '../../../dynamic-flow-types';
+import { Model, Schema } from '../../../types';
 /**
  * Validate any value against a given schema
  *

package/build/common/{validation/schema-validators/index.js → validators/schemas/schema-validators.js}

@@ -1,6 +1,6 @@
-import { isObject, isArray } from '@transferwise/neptune-validation';
-import { isListArraySchema, } from '../../../dynamic-flow-types';
-import { getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getBlobValidationFailures, } from '../validation-failures';
+import { isListArraySchema, } from '../../../types';
+import { isObject, isArray } from '../types/type-validators';
+import { getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getBlobValidationFailures, } from '../validationFailures/validation-failures';
 function isValidStringSchema(value, schema) {
     return !getStringValidationFailures(value, schema).length;
 }

package/build/common/validators/types/type-validators.d.ts

@@ -0,0 +1,8 @@
+export declare const isString: (value: unknown) => value is string;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isInteger: (value: unknown) => value is number;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
+export declare const isArray: (value: unknown) => value is unknown[];
+export declare const isNull: (value: unknown) => value is null;
+export declare const isUndefined: (value: unknown) => value is undefined;

package/build/common/validators/types/type-validators.js

@@ -0,0 +1,14 @@
+export var isString = function (value) { return typeof value === 'string'; };
+export var isNumber = function (value) {
+    return typeof value === 'number' && !Number.isNaN(value);
+};
+export var isInteger = function (value) {
+    return isNumber(value) && Math.floor(value) === value;
+};
+export var isBoolean = function (value) { return typeof value === 'boolean'; };
+export var isObject = function (value) {
+    return !isNull(value) && !isUndefined(value) && (value === null || value === void 0 ? void 0 : value.constructor) === Object;
+};
+export var isArray = function (value) { return Array.isArray(value); };
+export var isNull = function (value) { return value === null; };
+export var isUndefined = function (value) { return typeof value === 'undefined'; };

package/build/common/{validation/validation-failures/index.d.ts → validators/validationFailures/validation-failures.d.ts}

@@ -1,4 +1,4 @@
-import { BlobSchema, NumberSchema, IntegerSchema, Model, Schema, AllOfSchema, OneOfSchema, StringSchema } from '../../../dynamic-flow-types';
+import { BlobSchema, NumberSchema, IntegerSchema, Model, Schema, AllOfSchema, OneOfSchema, StringSchema } from '../../../types';
 declare function getValidationFailures(value: Model, schema: Schema, isRequired: boolean): string[];
 declare function getStringValidationFailures(value: Model, schema: StringSchema, isRequired?: boolean): string[];
 declare function getNumberValidationFailures(value: Model, schema: AllOfSchema | OneOfSchema | NumberSchema | IntegerSchema, isRequired?: boolean): string[];

package/build/common/{validation/validation-failures/index.js → validators/validationFailures/validation-failures.js}

@@ -1,7 +1,7 @@
-import { isArray, isString, isNumber, isInteger, isBoolean, isNull, } from '@transferwise/neptune-validation';
-import { isObjectModel, } from '../../../dynamic-flow-types';
-import { isStringSchema } from '../../../dynamic-flow-types/Schema';
-import { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from '../rule-validators';
+import { isObjectModel, } from '../../../types';
+import { isStringSchema } from '../../../types/specification/Schema';
+import { isArray, isString, isNumber, isInteger, isBoolean, isNull, } from '../types/type-validators';
+import { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from './validation-failures.utils';
 function getValidationFailures(value, schema, isRequired) {
     if (schema["const"]) {
         return getConstValidationFailures(value, schema, isRequired);

package/build/common/{validation/rule-validators/index.js → validators/validationFailures/validation-failures.utils.js}

@@ -1,4 +1,4 @@
-import { isArray, isNumber, isString, isUndefined } from '@transferwise/neptune-validation';
+import { isArray, isNumber, isString, isUndefined } from '../../validators';
 function isValidRequired(value, isRequired) {
     if (isRequired === void 0) { isRequired = false; }
     return !isRequired || !isUndefined(value);

package/build/common/validators/values/value-validators.d.ts

@@ -0,0 +1,2 @@
+declare const isEmpty: (value: unknown) => boolean;
+export { isEmpty };

package/build/common/validators/values/value-validators.js

@@ -0,0 +1,6 @@
+import { isString, isObject, isArray } from '../types/type-validators';
+var isEmpty = function (value) {
+    return (isString(value) && value.length === 0) ||
+        ((isObject(value) || isArray(value)) && Object.keys(value).length === 0);
+};
+export { isEmpty };

package/build/{flow → dynamicFlow}/DynamicFlow.d.ts

@@ -1,3 +1,3 @@
-import { DynamicFlowProps } from './types';
+import { DynamicFlowProps } from '../dynamicFlow/DynamicFlowTypes';
 declare const DynamicFlow: (props: DynamicFlowProps) => JSX.Element;
 export default DynamicFlow;