@wise/dynamic-flow-client 0.3.0-beta-d45b31.38 → 0.3.0

package/build/types/specification/LayoutComponent.d.ts

@@ -0,0 +1,129 @@
+import { ExternalStepPollingConfiguration } from '../../common/hooks';
+import { Action } from './Action';
+import { Schema } from './Schema';
+import { Margin, Size, Icon, Image, Align, Orientation, Reference, Alert } from './core';
+export type LayoutComponent = AlertLayout | BoxLayout | ButtonLayout | ColumnsLayout | DecisionLayout | DividerLayout | ExternalLayout | FormLayout | HeadingLayout | ImageLayout | InfoLayout | ListLayout | LoadingIndicatorLayout | ParagraphLayout | ReviewLayout;
+export type AlertLayout = {
+    type: 'alert';
+} & Alert;
+export type BoxLayout = {
+    type: 'box';
+    components: LayoutComponent[];
+    width?: Size;
+    margin?: Margin;
+    border?: boolean;
+};
+export type ButtonLayout = {
+    type: 'button';
+    action: Action | Reference;
+    margin?: Margin;
+    /**
+     * @deprecated Only supported on web client
+     */
+    size?: Size;
+};
+export type ColumnsLayout = {
+    type: 'columns';
+    left: LayoutComponent[];
+    right: LayoutComponent[];
+    bias?: 'none' | 'left' | 'right';
+    margin?: Margin;
+};
+export type DecisionLayout = {
+    type: 'decision';
+    options: DecisionOption[];
+    margin?: Margin;
+};
+type DecisionOption = {
+    action: Action | Reference;
+    title: string;
+    description?: string;
+    icon?: Icon;
+    image?: Image;
+    disabled?: boolean;
+};
+/**
+ * @deprecated Only supported on web client
+ */
+export type DividerLayout = {
+    type: 'divider';
+    margin?: Margin;
+};
+/**
+ * @deprecated Please use the external feature set instead
+ */
+export type ExternalLayout = {
+    type: 'external';
+    requestUrl: string;
+    polling?: Omit<ExternalStepPollingConfiguration, 'responseHandlers'>;
+    responseHandlers?: ExternalStepPollingConfiguration['responseHandlers'];
+    retryTitle?: string;
+};
+export type FormLayout = {
+    type: 'form';
+    schema: Schema | Reference;
+    margin?: Margin;
+};
+export type HeadingLayout = {
+    type: 'heading';
+    size?: Size;
+    text: string;
+    margin?: Margin;
+    align?: Align;
+};
+export type ImageLayout = {
+    type: 'image';
+    url: string;
+    /**
+     * @deprecated Only supported on web client
+     */
+    text?: string;
+    size?: Size;
+    margin?: Margin;
+};
+export type InfoLayout = {
+    type: 'info';
+    markdown: string;
+    margin?: Margin;
+    align?: Align;
+};
+export type ListLayout = {
+    type: 'list';
+    items: ListItem[];
+    title?: string;
+    margin?: Margin;
+};
+type ListItem = {
+    title: string;
+    description?: string;
+    icon?: Icon;
+    status?: 'positive' | 'neutral' | 'warning';
+};
+export type LoadingIndicatorLayout = {
+    type: 'loading-indicator';
+    margin?: Margin;
+    size?: Size;
+};
+export type ParagraphLayout = {
+    type: 'paragraph';
+    text: string;
+    control?: 'copyable';
+    margin?: Margin;
+    align?: Align;
+};
+export type ReviewLayout = {
+    type: 'review';
+    title?: string;
+    fields: ReviewField[];
+    orientation?: Orientation;
+    margin?: Margin;
+    /**
+     * @deprecated Only supported on web client
+     */
+    action?: Action;
+};
+type ReviewField = {
+    label: string;
+    value: string | number | boolean | null | undefined;
+};
+export {};

package/build/types/specification/LayoutComponent.js

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

package/build/types/specification/Model.d.ts

@@ -0,0 +1,12 @@
+export type BasicModel = boolean | number | string;
+export type ObjectModel = {
+    [key: string]: Model;
+};
+export type ArrayModel = Array<BasicModel | null>;
+export type Model = BasicModel | ObjectModel | ArrayModel | null;
+export declare const isObjectModel: (model: Model) => model is ObjectModel;
+export declare const isNullableObjectModel: (model: Model) => model is ObjectModel | null;
+export declare const isNullableBasicModel: (model: Model) => model is BasicModel | null;
+export declare const isNullableStringModel: (model: Model) => model is string | null;
+export declare const isArrayModel: (model: Model) => model is ArrayModel;
+export declare const isNullableArrayModel: (model: Model) => model is ArrayModel | null;

package/build/types/specification/Model.js

@@ -0,0 +1,29 @@
+import { isArray, isBoolean, isNull, isNumber, isString } from '../../common/validators';
+// TODO HD Move these functions out of types
+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/types/specification/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/types/specification/PersistAsync.js

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

package/build/types/specification/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/types/specification/Polling.js

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

package/build/types/specification/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/types/specification/Promotion.js

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

package/build/types/specification/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/types/specification/Schema.js

@@ -0,0 +1,50 @@
+var basicTypes = new Set(['string', 'number', 'integer', 'boolean']);
+// TODO HD Move these out of types
+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/types/specification/Step.d.ts

@@ -0,0 +1,127 @@
+import { ExternalStepPollingConfiguration } from '../../common/hooks';
+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/types/specification/Step.js

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

package/build/types/specification/ValidationAsync.d.ts

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

package/build/types/specification/ValidationAsync.js

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

package/build/types/specification/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/types/specification/core.js

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