@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/dynamic-flow-types/Model.js

@@ -0,0 +1,28 @@
+import { isArray, isBoolean, isNull, isNumber, isString } from '@transferwise/neptune-validation';
+export var isObjectModel = function (model) {
+    return typeof model === 'object' && model !== null && model.constructor === Object;
+};
+export var isNullableObjectModel = function (model) {
+    return isNull(model) || isObjectModel(model);
+};
+export var isNullableBasicModel = function (model) {
+    return isBoolean(model) || isNumber(model) || isString(model) || isNull(model);
+};
+export var isNullableStringModel = function (model) {
+    return isString(model) || isNull(model);
+};
+export var isArrayModel = function (model) {
+    if (isArray(model)) {
+        if (model.length === 0) {
+            return true;
+        }
+        return model.every(function (item) { return typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean'; });
+    }
+    return false;
+};
+export var isNullableArrayModel = function (model) {
+    if (isNull(model)) {
+        return true;
+    }
+    return isArrayModel(model);
+};

package/build/dynamic-flow-types/PersistAsync.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from './Schema';
+export type PersistAsync = {
+    idProperty: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    param: string;
+    schema: Schema;
+    url: string;
+};

package/build/dynamic-flow-types/PersistAsync.js

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

package/build/dynamic-flow-types/Polling.d.ts

@@ -0,0 +1,12 @@
+import { Action } from './Action';
+export type PollingConfiguration = {
+    url: string;
+    interval: number;
+    maxAttempts: number;
+    onError: {
+        action: Action;
+    };
+};
+export type PollingResponse = {
+    action: Action;
+} | null;

package/build/dynamic-flow-types/Polling.js

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

package/build/dynamic-flow-types/Promotion.d.ts

@@ -0,0 +1,20 @@
+import { Icon, Image } from './core';
+export type Promotion = {
+    displayTwice?: boolean;
+    other: {
+        description?: string;
+        heading?: {
+            text: string;
+        };
+        icon?: Icon;
+        image?: Image;
+        title: string;
+    };
+    promoted?: {
+        title?: string;
+        description?: string;
+    };
+    control?: string;
+    checkedMeans?: 'promoted' | 'other';
+    default?: 'promoted' | 'other';
+};

package/build/dynamic-flow-types/Promotion.js

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

package/build/dynamic-flow-types/Schema.d.ts

@@ -0,0 +1,184 @@
+import { FileUploadSchema } from './FileUploadSchema';
+import { Model, ObjectModel } from './Model';
+import { PersistAsync } from './PersistAsync';
+import { Promotion } from './Promotion';
+import { ValidationAsync } from './ValidationAsync';
+import { Icon, Image, Alert, Help } from './core';
+export type Schema = AllOfSchema | ArraySchema | BlobSchema | BooleanSchema | IntegerSchema | NumberSchema | ObjectSchema | OneOfSchema | StringSchema | ListArraySchema | TupleArraySchema | FileUploadSchema | MultipleFileUploadSchema | ConstSchema;
+type SchemaBase = {
+    $id?: string;
+    type?: 'boolean' | 'blob' | 'array' | 'integer' | 'number' | 'string' | 'object';
+    alert?: Alert;
+    autofillProvider?: string;
+    autofillKey?: string;
+    allOf?: never;
+    analyticsId?: string;
+    const?: Model;
+    default?: Model;
+    description?: string;
+    disabled?: boolean;
+    format?: string;
+    help?: Help;
+    hidden?: boolean;
+    icon?: Icon;
+    image?: Image;
+    oneOf?: never;
+    persistAsync?: never;
+    promoted?: boolean;
+    promotion?: never;
+    /**
+     * @deprecated Please use disabled
+     */
+    readOnly?: boolean;
+    refreshFormOnChange?: boolean;
+    refreshFormUrl?: string;
+    summary?: SchemaSummary;
+    title?: string;
+    validationAsync?: ValidationAsync;
+    validationMessages?: Record<string, string>;
+    /**
+     * @deprecated Please use oneOf instead
+     */
+    values?: {
+        label: string;
+        value: string | number;
+    }[];
+    /**
+     * @deprecated Please use layouts instead
+     */
+    width?: string;
+    keywords?: string[];
+};
+export type AllOfSchema = Omit<SchemaBase, 'allOf'> & {
+    allOf: Schema[];
+    maximum?: number;
+    minimum?: number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    required?: string[];
+};
+export type ArraySchema = Omit<SchemaBase, 'persistAsync'> & {
+    type: 'array';
+    addItemTitle?: string;
+    editItemTitle?: string;
+    removeItemTitle?: string;
+    items: Schema | Schema[];
+    maxItems?: number;
+    minItems?: number;
+    persistAsync?: PersistAsync;
+    summary?: ArraySchemaSummary;
+};
+export type ListArraySchema = ArraySchema & {
+    items: Schema;
+};
+export type TupleArraySchema = ArraySchema & {
+    items: Schema[];
+};
+export type MultipleFileUploadSchema = ListArraySchema & {
+    items: PersistAsyncSchema;
+};
+export type BlobSchema = SchemaBase & {
+    type: 'blob';
+    accepts?: string[];
+    maxSize?: number;
+};
+export type BooleanSchema = SchemaBase & {
+    type: 'boolean';
+    default?: boolean;
+    const?: boolean;
+    oneOf?: BooleanSchema[];
+};
+export type ConstSchema = SchemaBase & {
+    type?: never;
+    const: Model;
+};
+export type IntegerSchema = Omit<SchemaBase, 'persistAsync'> & {
+    type: 'integer';
+    default?: number;
+    maximum?: number;
+    minimum?: number;
+    persistAsync?: PersistAsync;
+    placeholder?: number;
+    const?: number;
+    oneOf?: IntegerSchema[];
+};
+export type NumberSchema = SchemaBase & Omit<IntegerSchema, 'type'> & {
+    type: 'number';
+    oneOf?: NumberSchema[];
+};
+export type ObjectSchema = SchemaBase & {
+    type: 'object';
+    displayOrder: string[];
+    properties: Record<string, Schema>;
+    required?: string[];
+    oneOf?: ObjectSchema[];
+};
+export type OneOfSchema = Omit<SchemaBase, 'oneOf' | 'promotion'> & {
+    oneOf: Schema[];
+    promotion?: Promotion;
+    maximum?: number;
+    minimum?: number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    required?: string[];
+    default?: Model;
+    placeholder?: Model;
+    control?: string;
+};
+export type OneOfObjectSchema = Omit<OneOfSchema, 'oneOf' | 'default'> & {
+    oneOf: ObjectSchema[];
+    default?: ObjectModel;
+};
+export type PersistAsyncSchema = Schema & {
+    persistAsync: PersistAsync;
+};
+export type StringSchema = Omit<SchemaBase, 'persistAsync'> & {
+    type: 'string';
+    control?: string;
+    default?: string;
+    displayFormat?: string;
+    minimum?: string;
+    maximum?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    persistAsync?: PersistAsync;
+    placeholder?: string;
+    const?: string;
+    oneOf?: StringSchema[];
+};
+export type BasicSchema = BooleanSchema | IntegerSchema | NumberSchema | StringSchema;
+export type ValidationAsyncSchema = BasicSchema & {
+    validationAsync: ValidationAsync;
+};
+type SchemaSummary = {
+    providesDescription?: boolean;
+    providesIcon?: boolean;
+    providesImage?: boolean;
+    providesTitle?: boolean;
+};
+type ArraySchemaSummary = SchemaSummary & {
+    defaultDescription?: string;
+    defaultIcon?: Icon;
+    defaultImage?: Image;
+    defaultTitle?: string;
+};
+export declare function isBasicSchema(schema: Schema): schema is BasicSchema;
+export declare function isObjectSchema(schema: Schema): schema is ObjectSchema;
+export declare function isOneOfObjectSchema(schema: Schema): schema is OneOfObjectSchema;
+export declare function isOneOfSchema(schema: Schema): schema is OneOfSchema;
+export declare function isAllOfSchema(schema: Schema): schema is AllOfSchema;
+export declare function isBlobSchema(schema: Schema): schema is BlobSchema;
+export declare function isArraySchema(schema: Schema): schema is ArraySchema;
+export declare function isTupleArraySchema(schema: ArraySchema): schema is TupleArraySchema;
+export declare function isListArraySchema(schema: ArraySchema): schema is ListArraySchema;
+export declare function isStringSchema(schema: Schema): schema is StringSchema;
+export declare function isPersistAsyncSchema(schema: Schema): schema is PersistAsyncSchema;
+export declare function isPersistAsyncFileSchema(schema: Schema): schema is PersistAsyncSchema;
+export declare const isValidationAsyncSchema: (schema: Schema) => schema is ValidationAsyncSchema;
+export declare const isMultipleFileUploadSchema: (schema: Schema) => schema is MultipleFileUploadSchema;
+export {};

package/build/dynamic-flow-types/Schema.js

@@ -0,0 +1,49 @@
+var basicTypes = new Set(['string', 'number', 'integer', 'boolean']);
+export function isBasicSchema(schema) {
+    return basicTypes.has(schema.type || '') || ('const' in schema && schema["const"] !== undefined);
+}
+export function isObjectSchema(schema) {
+    return schema.type === 'object';
+}
+export function isOneOfObjectSchema(schema) {
+    return isOneOfSchema(schema) && schema.oneOf.every(function (subSchema) { return subSchema.type === 'object'; });
+}
+export function isOneOfSchema(schema) {
+    return !!schema.oneOf;
+}
+export function isAllOfSchema(schema) {
+    return !!schema.allOf;
+}
+export function isBlobSchema(schema) {
+    return schema.type === 'blob';
+}
+export function isArraySchema(schema) {
+    return schema.type === 'array';
+}
+export function isTupleArraySchema(schema) {
+    var schemaItems = schema.items;
+    return Array.isArray(schemaItems);
+}
+export function isListArraySchema(schema) {
+    var schemaItems = schema.items;
+    return !Array.isArray(schemaItems);
+}
+export function isStringSchema(schema) {
+    return schema.type === 'string';
+}
+export function isPersistAsyncSchema(schema) {
+    return !!schema.persistAsync;
+}
+export function isPersistAsyncFileSchema(schema) {
+    return (isPersistAsyncSchema(schema) &&
+        (isBlobSchema(schema.persistAsync.schema) || isBase64FileSchema(schema.persistAsync.schema)));
+}
+export var isValidationAsyncSchema = function (schema) {
+    return isBasicSchema(schema) && !!schema.validationAsync;
+};
+function isBase64FileSchema(schema) {
+    return schema.type === 'string' && schema.format === 'base64url';
+}
+export var isMultipleFileUploadSchema = function (schema) {
+    return (isArraySchema(schema) && isListArraySchema(schema) && isPersistAsyncFileSchema(schema.items));
+};

package/build/dynamic-flow-types/Step.d.ts

@@ -0,0 +1,127 @@
+import { ExternalStepPollingConfiguration } from '../layout/external/useExternalStepPolling';
+import { Action } from './Action';
+import { LayoutComponent } from './LayoutComponent';
+import { ObjectModel } from './Model';
+import { PollingConfiguration } from './Polling';
+import { Schema } from './Schema';
+import { Image, HttpMethod } from './core';
+export type Step = FormStep | DecisionStep | ExternalStep | WebStep | FinalStep;
+type BaseStep = {
+    key?: string;
+    type: string;
+    title?: string;
+    description?: string;
+    analytics?: Record<string, unknown>;
+    layout?: LayoutComponent[];
+    schemas?: Schema[];
+    actions?: Action[];
+    model?: ObjectModel;
+    refreshFormUrl?: string;
+    polling?: PollingConfiguration;
+    external?: {
+        url: string;
+    };
+    errors?: {
+        error?: GlobalError;
+        validation?: FormErrors;
+    };
+};
+export type FormStep = BaseStep & {
+    type: 'form';
+    title: string;
+    layout: LayoutComponent[];
+    actions: Action[];
+    schemas: Schema[];
+    errors?: unknown;
+};
+/**
+ * @deprecated Please use a form step with a layout instead
+ */
+export type FinalStep = BaseStep & {
+    type: 'final';
+    actions: Action[];
+    details: {
+        description: string;
+        image?: Image;
+        title: string;
+    };
+    success: boolean;
+};
+/**
+ * @deprecated Please use the external feature set instead
+ */
+export type ExternalStep = BaseStep & {
+    type: 'external';
+    description?: string;
+    polling?: Omit<ExternalStepPollingConfiguration, 'responseHandlers'>;
+    requestUrl: string;
+    responseHandlers?: ExternalStepPollingConfiguration['responseHandlers'];
+    retryTitle?: string;
+    title: string;
+};
+/**
+ * @deprecated Please use the external feature set instead
+ */
+type WebStep = BaseStep & {
+    type: 'web';
+    hideBackButton?: boolean;
+    initialRequest: {
+        body?: string;
+        headers?: Record<string, string>;
+        method: HttpMethod;
+        url: string;
+    };
+    interceptablePatterns: {
+        action?: Action;
+        regexPattern: string;
+        threshold?: number;
+        type: 'submit' | 'cancel' | 'redirect' | 'abort-load' | 'log';
+    }[];
+    javaScriptMessageHandler?: unknown;
+};
+/**
+ * @deprecated Please use DecisionLayout instead
+ */
+export type DecisionStep = BaseStep & {
+    type: 'decision';
+    options?: DecisionStepOption[];
+};
+/**
+ * @deprecated Please use DecisionLayout instead
+ */
+export type DecisionStepOption = {
+    title: string;
+    description?: string;
+    url: string;
+    disabled?: boolean;
+};
+export type FormErrors = Record<string, unknown> | string | undefined | null;
+export type GlobalError = string | undefined | null;
+export type ErrorResponseBody = {
+    error?: GlobalError;
+    validation?: FormErrors;
+    refreshFormUrl?: string;
+};
+/**
+ * @deprecated Please use the review layout component
+ */
+export type LegacyReviewStep = Omit<FormStep, 'actions' | 'schemas' | 'layout'> & {
+    reviewFields?: LegacyReviewFields;
+    actions?: Action[];
+    schemas?: Schema[];
+};
+export type LegacyReviewFields = {
+    title?: string;
+    fields: Array<{
+        title: string;
+        value: string;
+    }>;
+};
+export type LegacyFormStep = Step & {
+    type: 'form';
+    reviewFields?: LegacyReviewFields;
+    schemas?: Schema[];
+    actions?: Action[];
+};
+export declare const isBasicError: (error: FormErrors) => error is string | null;
+export {};

package/build/dynamic-flow-types/Step.js

@@ -0,0 +1,4 @@
+import { isNull, isString } from '@transferwise/neptune-validation';
+export var isBasicError = function (error) {
+    return isString(error) || isNull(error);
+};

package/build/dynamic-flow-types/ValidationAsync.d.ts

@@ -0,0 +1,6 @@
+import { HttpMethod } from './core';
+export type ValidationAsync = {
+    param: string;
+    url: string;
+    method?: HttpMethod;
+};

package/build/dynamic-flow-types/ValidationAsync.js

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

package/build/dynamic-flow-types/core.d.ts

@@ -0,0 +1,29 @@
+export type Image = {
+    url: string;
+    text?: string;
+    name?: string;
+};
+export type Icon = {
+    name?: string;
+    text?: never;
+} | {
+    name?: never;
+    text?: string;
+};
+export type Size = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type Margin = Size;
+export type Context = 'neutral' | 'warning' | 'positive' | 'negative';
+export type Orientation = 'horizontal' | 'vertical';
+export type Align = 'left' | 'right' | 'center';
+export type HttpMethod = 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+export type Reference = {
+    $ref: string;
+};
+export type Alert = {
+    markdown: string;
+    context?: Context;
+    margin?: Margin;
+};
+export type Help = {
+    markdown: string;
+};

package/build/dynamic-flow-types/core.js

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

package/build/dynamic-flow-types/index.d.ts

@@ -0,0 +1,14 @@
+export * from './core';
+export * from './Action';
+export * from './LayoutComponent';
+export * from './Model';
+export * from './Polling';
+export * from './Step';
+export * from './PersistAsync';
+export * from './ValidationAsync';
+export * from './Promotion';
+export type { Schema, AllOfSchema, ArraySchema, BasicSchema, BlobSchema, BooleanSchema, IntegerSchema, NumberSchema, ObjectSchema, OneOfObjectSchema, OneOfSchema, PersistAsyncSchema, StringSchema, ListArraySchema, TupleArraySchema, ValidationAsyncSchema, } from './Schema';
+export { isObjectSchema, isOneOfSchema, isAllOfSchema, isBlobSchema, isArraySchema, isTupleArraySchema, isListArraySchema, isValidationAsyncSchema, isPersistAsyncSchema, isBasicSchema, } from './Schema';
+export type { FileUploadSchema, CameraDirection } from './FileUploadSchema';
+export { isFileUploadSchema } from './FileUploadSchema';
+export { isBasicError } from './Step';

package/build/dynamic-flow-types/index.js

@@ -0,0 +1,12 @@
+export * from './core';
+export * from './Action';
+export * from './LayoutComponent';
+export * from './Model';
+export * from './Polling';
+export * from './Step';
+export * from './PersistAsync';
+export * from './ValidationAsync';
+export * from './Promotion';
+export { isObjectSchema, isOneOfSchema, isAllOfSchema, isBlobSchema, isArraySchema, isTupleArraySchema, isListArraySchema, isValidationAsyncSchema, isPersistAsyncSchema, isBasicSchema, } from './Schema';
+export { isFileUploadSchema } from './FileUploadSchema';
+export { isBasicError } from './Step';

package/build/field/Field.d.ts

@@ -0,0 +1,69 @@
+export namespace FieldTypes {
+    const STRING: string;
+    const NUMBER: string;
+    const INTEGER: string;
+    const BOOLEAN: string;
+    const BLOB: string;
+}
+export namespace FieldFormats {
+    const DATE: string;
+    const PHONE: string;
+    const BASE_64_URL: string;
+    const PASSWORD: string;
+    const EMAIL: string;
+    const URI: string;
+}
+declare class Field extends Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        focused: boolean;
+        changed: boolean;
+        error: any;
+    };
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    onFocus(value: any): void;
+    onBlur(value: any): void;
+    onChange(value: any): void;
+    validateValue(newValue: any): {};
+    objectSizeOf: (object: any) => number;
+    updateAlert(control: any): {
+        type: string;
+        content: any;
+    } | {
+        type: null;
+        content: null;
+    };
+    render(): JSX.Element;
+}
+declare namespace Field {
+    namespace propTypes {
+        const name: any;
+        const value: any;
+        const field: any;
+        const countryCode: any;
+        const onChange: any;
+        const onFocus: any;
+        const onBlur: any;
+        const errorMessage: any;
+        const warningMessage: any;
+        const label: any;
+    }
+    namespace defaultProps {
+        const countryCode_1: null;
+        export { countryCode_1 as countryCode };
+        const value_1: null;
+        export { value_1 as value };
+        const errorMessage_1: null;
+        export { errorMessage_1 as errorMessage };
+        const warningMessage_1: null;
+        export { warningMessage_1 as warningMessage };
+        const onFocus_1: null;
+        export { onFocus_1 as onFocus };
+        const onBlur_1: null;
+        export { onBlur_1 as onBlur };
+        const label_1: null;
+        export { label_1 as label };
+    }
+}
+export default Field;
+import { Component } from "react";