@wise/dynamic-flow-client 0.0.0-experimental-20240319142919

package/build/revamp/domain/mappers/schema/objectSchemaToComponent/objectSchemaToComponent.js

@@ -0,0 +1,41 @@
+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 { isObjectLocalValue, isObjectModel } from '../../../../utils/type-utils';
+import { createObjectComponent } from '../../../components/ObjectComponent';
+import { mapSchemaToComponent } from '../../mapSchemaToComponent';
+import { isObject } from '../../../../utils/type-validators';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export var objectSchemaToComponent = function (schemaMapperProps, mapperProps) {
+    var uid = schemaMapperProps.uid, localValue = schemaMapperProps.localValue, schema = schemaMapperProps.schema, model = schemaMapperProps.model, validationErrors = schemaMapperProps.validationErrors;
+    var $id = schema.$id, displayOrder = schema.displayOrder, properties = schema.properties, required = schema.required;
+    var propertyNames = Object.keys(properties);
+    if (displayOrder.length !== propertyNames.length) {
+        throw new Error("Object schema ".concat($id, " has ").concat(propertyNames.length, " properties but only ").concat(displayOrder.length, " are listed in displayOrder"));
+    }
+    var componentMap = displayOrder.reduce(function (acc, propName) {
+        var _a;
+        var _b;
+        var propSchema = properties[propName];
+        if (propSchema === undefined) {
+            throw new Error("Object schema ".concat($id, " has no property named ").concat(propName));
+        }
+        return __assign(__assign({}, acc), (_a = {}, _a[propName] = mapSchemaToComponent({
+            uid: "".concat(uid, ".obj-").concat(propName),
+            schema: propSchema,
+            model: isObjectModel(model) ? model[propName] : null,
+            localValue: isObjectLocalValue(localValue) ? localValue[propName] : null,
+            required: (_b = required === null || required === void 0 ? void 0 : required.includes(propName)) !== null && _b !== void 0 ? _b : false,
+            validationErrors: isObject(validationErrors) ? validationErrors[propName] : undefined
+        }, mapperProps), _a));
+    }, {});
+    return createObjectComponent(__assign(__assign({}, mapCommonSchemaProps(schemaMapperProps)), { componentMap: componentMap, displayOrder: displayOrder }));
+};

package/build/revamp/domain/mappers/schema/oneOfSchemaToComponent/oneOfSchemaToComponent.js

@@ -0,0 +1,67 @@
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { createSelectInputComponent } from '../../../components/SelectInputComponent';
+import { getPerformRefresh } from '../../../features/refresh/getPerformRefresh';
+import { getRequiredCheck } from '../../../features/validation/value-checks';
+import { mapSchemaToComponent } from '../../mapSchemaToComponent';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { getPersistAsyncInitialState } from '../utils/getPersistAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export var oneOfSchemaToComponent = function (schemaMapperProps, mapperProps) {
+    var _a, _b;
+    var uid = schemaMapperProps.uid, localValue = schemaMapperProps.localValue, schema = schemaMapperProps.schema, model = schemaMapperProps.model, initialError = schemaMapperProps.validationErrors, _c = schemaMapperProps.required, required = _c === void 0 ? false : _c;
+    var initialModel = (_a = model !== null && model !== void 0 ? model : schema["default"]) !== null && _a !== void 0 ? _a : null;
+    var options = schema.oneOf.map(function (childSchema, index) {
+        var _a = childSchema.title, title = _a === void 0 ? '' : _a, description = childSchema.description, image = childSchema.image, icon = childSchema.icon, _b = childSchema.keywords, keywords = _b === void 0 ? [] : _b;
+        return {
+            title: title,
+            description: description,
+            image: image,
+            icon: icon,
+            keywords: keywords,
+            disabled: 'disabled' in childSchema ? Boolean(childSchema.disabled) : false,
+            component: mapSchemaToComponent({
+                uid: "".concat(uid, ".oneOf-").concat(index),
+                schema: supressSchemaTitleAndDescription(childSchema),
+                model: initialModel,
+                localValue: localValue,
+                validationErrors: initialError,
+                required: required
+            }, mapperProps)
+        };
+    });
+    var getErrorMessageFunctions = mapperProps.getErrorMessageFunctions, updateComponent = mapperProps.updateComponent, trackEvent = mapperProps.trackEvent, onRefresh = mapperProps.onRefresh;
+    var defaultValue = schema["default"], validationMessages = schema.validationMessages;
+    var errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    var _d = getPersistAsyncInitialState(schemaMapperProps, mapperProps), performPersistAsync = _d.performPersistAsync, persistedState = _d.persistedState;
+    var initialValue = performPersistAsync ? localValue : (_b = model !== null && model !== void 0 ? model : defaultValue) !== null && _b !== void 0 ? _b : null;
+    return createSelectInputComponent(__assign(__assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(schema.autocompleteHint), checks: schema.hidden ? [] : [getRequiredCheck(required, errorMessageFunctions)], options: options, initialValue: initialValue, persistedState: persistedState, performPersistAsync: performPersistAsync, performRefresh: getPerformRefresh(schema, onRefresh), trackEvent: trackEvent }), updateComponent);
+};
+/**
+ * When using a schema in a oneOf, the title is not needed, as it is already displayed in the dropdown, radio or tab.
+ * We also suppress the description, because it is not displayed on mobile clients.
+ */
+var supressSchemaTitleAndDescription = function (schema) {
+    var title = schema.title, description = schema.description, headlessSchema = __rest(schema, ["title", "description"]);
+    return headlessSchema;
+};

package/build/revamp/domain/mappers/schema/stringSchemaToComponent/stringSchemaToComponent.js

@@ -0,0 +1,14 @@
+import { stringSchemaToDateInputComponent } from './stringSchemaToDateInputComponent';
+import { stringSchemaToUploadInputComponent } from './stringSchemaToUploadInputComponent';
+import { stringSchemaToTextInputComponent } from './stringSchemaToTextInputComponent';
+export var stringSchemaToComponent = function (schemaMapperProps, mapperProps) {
+    var schema = schemaMapperProps.schema;
+    switch (schema.format) {
+        case 'date':
+            return stringSchemaToDateInputComponent(schemaMapperProps, mapperProps);
+        case 'base64url':
+            return stringSchemaToUploadInputComponent(schemaMapperProps, mapperProps);
+        default:
+            return stringSchemaToTextInputComponent(schemaMapperProps, mapperProps);
+    }
+};

package/build/revamp/domain/mappers/schema/stringSchemaToComponent/stringSchemaToDateInputComponent.js

@@ -0,0 +1,37 @@
+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 { isString } from '../../../../utils/type-validators';
+import { createDateInputComponent } from '../../../components/DateInputComponent';
+import { getPerformRefresh } from '../../../features/refresh/getPerformRefresh';
+import { getAboveMaximumDateCheck, getBelowMinimumDateCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { getPersistAsyncInitialState } from '../utils/getPersistAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+import { getValidationAsyncInitialState } from '../utils/getValidationAsyncInitialState';
+export var stringSchemaToDateInputComponent = function (schemaMapperProps, mapperProps) {
+    var schema = schemaMapperProps.schema, localValue = schemaMapperProps.localValue, model = schemaMapperProps.model, _a = schemaMapperProps.required, required = _a === void 0 ? false : _a;
+    var autocompleteHint = schema.autocompleteHint, defaultValue = schema["default"], minimumDate = schema.minimum, maximumDate = schema.maximum;
+    var getErrorMessageFunctions = mapperProps.getErrorMessageFunctions, updateComponent = mapperProps.updateComponent, onRefresh = mapperProps.onRefresh;
+    var errorMessageFunctions = getErrorMessageFunctions(schema.validationMessages);
+    var _b = getPersistAsyncInitialState(schemaMapperProps, mapperProps), performPersistAsync = _b.performPersistAsync, persistedState = _b.persistedState;
+    var _c = getValidationAsyncInitialState(schemaMapperProps, mapperProps), performValidationAsync = _c.performValidationAsync, validationState = _c.validationState;
+    var validLocalValue = isString(localValue) ? localValue : null;
+    var validModel = isString(model) ? model : defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+    var value = performPersistAsync ? validLocalValue : validModel;
+    return createDateInputComponent(__assign(__assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(autocompleteHint), checks: schema.hidden
+            ? []
+            : [
+                getRequiredCheck(required, errorMessageFunctions),
+                getAboveMaximumDateCheck(schema, errorMessageFunctions),
+                getBelowMinimumDateCheck(schema, errorMessageFunctions),
+            ], minimumDate: minimumDate, maximumDate: maximumDate, value: value, persistedState: persistedState, validationState: validationState, performPersistAsync: performPersistAsync, performRefresh: getPerformRefresh(schema, onRefresh), performValidationAsync: performValidationAsync }), updateComponent);
+};

package/build/revamp/domain/mappers/schema/stringSchemaToComponent/stringSchemaToTextInputComponent.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 { createTextInputComponent } from '../../../components/TextInputComponent';
+import { isString } from '../../../../utils/type-validators';
+import { getDebouncedPerformRefresh } from '../../../features/refresh/getPerformRefresh';
+import { getAboveMaxLengthCheck, getBelowMinLengthCheck, getNotAdheringToPatternCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { getPersistAsyncInitialState } from '../utils/getPersistAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+import { getValidationAsyncInitialState } from '../utils/getValidationAsyncInitialState';
+export var stringSchemaToTextInputComponent = function (schemaMapperProps, mapperProps) {
+    var schema = schemaMapperProps.schema, localValue = schemaMapperProps.localValue, model = schemaMapperProps.model, _a = schemaMapperProps.required, required = _a === void 0 ? false : _a;
+    var autocompleteHint = schema.autocompleteHint, control = schema.control, defaultValue = schema["default"], displayFormat = schema.displayFormat, format = schema.format, validationMessages = schema.validationMessages;
+    var getErrorMessageFunctions = mapperProps.getErrorMessageFunctions, updateComponent = mapperProps.updateComponent, onRefresh = mapperProps.onRefresh;
+    var controlForLegacyFormat = getControlForLegacyFormat(format);
+    var errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    var _b = getPersistAsyncInitialState(schemaMapperProps, mapperProps), performPersistAsync = _b.performPersistAsync, persistedState = _b.persistedState;
+    var _c = getValidationAsyncInitialState(schemaMapperProps, mapperProps), performValidationAsync = _c.performValidationAsync, validationState = _c.validationState;
+    var validLocalValue = isString(localValue) ? localValue : null;
+    var validModel = isString(model) ? model : defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+    var value = performPersistAsync ? validLocalValue : validModel;
+    return createTextInputComponent(__assign(__assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(autocompleteHint), checks: schema.hidden
+            ? []
+            : [
+                getRequiredCheck(required, errorMessageFunctions),
+                getAboveMaxLengthCheck(schema, errorMessageFunctions),
+                getBelowMinLengthCheck(schema, errorMessageFunctions),
+                getNotAdheringToPatternCheck(schema, errorMessageFunctions),
+            ], control: control !== null && control !== void 0 ? control : controlForLegacyFormat, displayFormat: displayFormat, value: value, persistedState: persistedState, validationState: validationState, performPersistAsync: performPersistAsync, performRefresh: getDebouncedPerformRefresh(schema, onRefresh), performValidationAsync: performValidationAsync }), updateComponent);
+};
+var getControlForLegacyFormat = function (format) {
+    if (format && ['numeric', 'phone-number', 'email', 'password'].includes(format)) {
+        return format;
+    }
+    return undefined;
+};

package/build/revamp/domain/mappers/schema/stringSchemaToComponent/stringSchemaToUploadInputComponent.js

@@ -0,0 +1,32 @@
+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 { isFile } from '../../../../utils/type-validators';
+import { createUploadInputComponent } from '../../../components/UploadInputComponent';
+import { getInitialPersistedState } from '../../../features/persistAsync/getInitialPersistedState';
+import { getPerformRefresh } from '../../../features/refresh/getPerformRefresh';
+import { getRequiredCheck } from '../../../features/validation/value-checks';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { getPersistAsyncInitialState } from '../utils/getPersistAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export var stringSchemaToUploadInputComponent = function (schemaMapperProps, mapperProps) {
+    var schema = schemaMapperProps.schema, localValue = schemaMapperProps.localValue, model = schemaMapperProps.model, _a = schemaMapperProps.required, required = _a === void 0 ? false : _a;
+    var accepts = schema.accepts, autocompleteHint = schema.autocompleteHint, maxSize = schema.maxSize, validationMessages = schema.validationMessages;
+    var getErrorMessageFunctions = mapperProps.getErrorMessageFunctions, updateComponent = mapperProps.updateComponent, onRefresh = mapperProps.onRefresh;
+    var errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    var performPersistAsync = getPersistAsyncInitialState(schemaMapperProps, mapperProps).performPersistAsync;
+    var persistedState = performPersistAsync
+        ? getInitialPersistedState(null, model)
+        : getInitialPersistedState();
+    var validLocalValue = isFile(localValue) ? localValue : null;
+    var value = performPersistAsync ? validLocalValue : null;
+    return createUploadInputComponent(__assign(__assign({}, mapCommonSchemaProps(schemaMapperProps)), { accepts: accepts, autoComplete: getAutocompleteString(autocompleteHint), checks: schema.hidden ? [] : [getRequiredCheck(required, errorMessageFunctions)], format: 'base64', maxSize: maxSize, value: value, persistedState: persistedState, performPersistAsync: performPersistAsync, performRefresh: getPerformRefresh(schema, onRefresh) }), updateComponent);
+};

package/build/revamp/domain/mappers/schema/types.js

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

package/build/revamp/domain/mappers/schema/utils/getPersistAsyncInitialState.js

@@ -0,0 +1,35 @@
+import { getPerformPersistAsync } from '../../../features/persistAsync/getPerformPersistAsync';
+import { getInitialPersistedState } from '../../../features/persistAsync/getInitialPersistedState';
+export var getPersistAsyncInitialState = function (schemaMapperProps, mapperProps) {
+    var localValue = schemaMapperProps.localValue, model = schemaMapperProps.model;
+    var performPersistAsync = getPerformPersisAsyncFn(schemaMapperProps, mapperProps);
+    var persistedState = performPersistAsync
+        ? getInitialPersistedState(localValue, model)
+        : getInitialPersistedState();
+    return { performPersistAsync: performPersistAsync, persistedState: persistedState };
+};
+var getPerformPersisAsyncFn = function (schemaMapperProps, mapperProps) {
+    var schema = schemaMapperProps.schema, persistAsyncConfig = schemaMapperProps.persistAsyncConfig;
+    var trackEvent = mapperProps.trackEvent, logEvent = mapperProps.logEvent;
+    if (!persistAsyncConfig) {
+        return undefined;
+    }
+    var $id = schema.$id, analyticsId = schema.analyticsId;
+    var getErrorMessageFunctions = mapperProps.getErrorMessageFunctions, httpClient = mapperProps.httpClient;
+    var validationMessages = schemaHasValidationMessages(schema)
+        ? schema.validationMessages
+        : undefined;
+    var errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    var persistAsyncError = errorMessageFunctions.genericError();
+    return getPerformPersistAsync({
+        genericErrorMessage: persistAsyncError,
+        httpClient: httpClient,
+        logEvent: logEvent,
+        persistAsyncConfig: persistAsyncConfig,
+        schemaId: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id,
+        trackEvent: trackEvent
+    });
+};
+var schemaHasValidationMessages = function (schema) {
+    return Boolean('validationMessages' in schema && schema.validationMessages);
+};

package/build/revamp/domain/mappers/schema/utils/getValidationAsyncInitialState.js

@@ -0,0 +1,25 @@
+import { getPerformValidationAsync } from '../../../features/validationAsync/getPerformValidationAsync';
+import { getInitialValidationState } from '../../../features/validationAsync/getInitialValidationState';
+export var getValidationAsyncInitialState = function (schemaMapperProps, mapperProps) {
+    var performValidationAsync = getValidationAsyncFn(schemaMapperProps, mapperProps);
+    var validationState = getInitialValidationState();
+    return { performValidationAsync: performValidationAsync, validationState: validationState };
+};
+var getValidationAsyncFn = function (schemaMapperProps, mapperProps) {
+    var schema = schemaMapperProps.schema;
+    var trackEvent = mapperProps.trackEvent;
+    if (!schemaHasValidationAsync(schema)) {
+        return undefined;
+    }
+    var $id = schema.$id, analyticsId = schema.analyticsId, validationAsync = schema.validationAsync;
+    var httpClient = mapperProps.httpClient;
+    return getPerformValidationAsync({
+        httpClient: httpClient,
+        validationAsyncConfig: validationAsync,
+        schemaId: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id,
+        trackEvent: trackEvent
+    });
+};
+var schemaHasValidationAsync = function (schema) {
+    return Boolean('validationAsync' in schema && schema.validationAsync);
+};

package/build/revamp/domain/mappers/schema/utils/mapCommonSchemaProps.js

@@ -0,0 +1,28 @@
+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 { isString } from '../../../../utils/type-validators';
+import { getSummariser } from '../../../features/summary/summary-utils';
+export var mapCommonSchemaProps = function (schemaMapperProps) {
+    var _a;
+    var uid = schemaMapperProps.uid, schema = schemaMapperProps.schema, required = schemaMapperProps.required, validationErrors = schemaMapperProps.validationErrors;
+    var $id = schema.$id, analyticsId = schema.analyticsId, control = schema.control, description = schema.description, keywords = schema.keywords, title = schema.title, hidden = schema.hidden;
+    return __assign(__assign({ uid: uid, id: $id !== null && $id !== void 0 ? $id : uid, analyticsId: (_a = analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id) !== null && _a !== void 0 ? _a : '', control: control, description: description, disabled: schemaHasDisabled(schema) ? schema.disabled : false, errors: isString(validationErrors) ? [validationErrors] : [], hidden: Boolean(hidden), keywords: keywords, required: Boolean(required), title: title, summariser: getSummariser(schema) }, (schemaHasHelp(schema) ? { help: schema.help.markdown } : {})), (schemaHasPlaceholder(schema) ? { placeholder: schema.placeholder } : {}));
+};
+var schemaHasDisabled = function (schema) {
+    return Boolean('disabled' in schema && schema.disabled !== undefined);
+};
+var schemaHasHelp = function (schema) {
+    return Boolean('help' in schema && schema.help);
+};
+var schemaHasPlaceholder = function (schema) {
+    return Boolean('placeholder' in schema && schema.placeholder);
+};

package/build/revamp/domain/mappers/types.js

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

package/build/revamp/domain/mappers/utils/getAutocompleteString.js

@@ -0,0 +1,76 @@
+export var getAutocompleteString = function (hints) {
+    if (!hints || hints.length === 0) {
+        return 'off';
+    }
+    var validHints = hints.filter(function (hint) { return autocompleteTokenMap[hint]; });
+    if (validHints.length === 0) {
+        return 'off';
+    }
+    return validHints.map(function (hint) { return autocompleteTokenMap[hint]; }).join(' ');
+};
+var autocompleteTokenMap = {
+    on: 'on',
+    name: 'name',
+    'name-prefix': 'honorific-prefix',
+    'given-name': 'given-name',
+    'additional-name': 'additional-name',
+    'family-name': 'family-name',
+    'name-suffix': 'honorific-suffix',
+    nickname: 'nickname',
+    email: 'email',
+    // Web doesn't have a specific mapping for new username, but this is semantically close enough
+    'new-username': 'username',
+    username: 'username',
+    'new-password': 'new-password',
+    password: 'current-password',
+    'one-time-code': 'one-time-code',
+    'job-title': 'organization-title',
+    'organization-name': 'organization',
+    'full-street-address': 'street-address',
+    'street-address-line-1': 'address-line1',
+    'street-address-line-2': 'address-line2',
+    'street-address-line-3': 'address-line3',
+    'address-level-1': 'address-level1',
+    'address-level-2': 'address-level2',
+    'address-level-3': 'address-level3',
+    'address-level-4': 'address-level4',
+    'country-code': 'country',
+    'country-name': 'country-name',
+    'postal-code': 'postal-code',
+    'credit-card-name': 'cc-name',
+    'credit-card-given-name': 'cc-given-name',
+    'credit-card-middle-name': 'cc-additional-name',
+    'credit-card-family-name': 'cc-family-name',
+    'credit-card-number': 'cc-number',
+    'credit-card-expiration': 'cc-exp',
+    'credit-card-expiration-month': 'cc-exp-month',
+    'credit-card-expiration-year': 'cc-exp-year',
+    'credit-card-security-code': 'cc-csc',
+    'credit-card-type': 'cc-type',
+    'transaction-currency': 'transaction-currency',
+    'transaction-amount': 'transaction-amount',
+    language: 'language',
+    birthdate: 'bday',
+    'birthdate-day': 'bday-day',
+    'birthdate-month': 'bday-month',
+    'birthdate-year': 'bday-year',
+    gender: 'sex',
+    'phone-number': 'tel',
+    'phone-country-code': 'tel-country-code',
+    'phone-national': 'tel-national',
+    'phone-area-code': 'tel-area-code',
+    'phone-local': 'tel-local',
+    'phone-local-prefix': 'tel-local-prefix',
+    'phone-local-suffix': 'tel-local-suffix',
+    'phone-extension': 'tel-extension',
+    url: 'url',
+    photo: 'photo',
+    impp: 'impp',
+    shipping: 'shipping',
+    billing: 'billing',
+    home: 'home',
+    work: 'work',
+    mobile: 'mobile',
+    fax: 'fax',
+    pager: 'pager'
+};

package/build/revamp/domain/mappers/utils/legacy-utils.js

@@ -0,0 +1,53 @@
+export var mapLegacyContext = function (context) {
+    switch (context) {
+        case 'success':
+            return 'positive';
+        case 'failure':
+            return 'negative';
+        case 'info':
+        case 'primary':
+            return 'neutral';
+        default:
+            return context;
+    }
+};
+export var mapLegacyBias = function (bias) {
+    switch (bias) {
+        case 'left':
+            return 'start';
+        case 'right':
+            return 'end';
+        default:
+            return bias;
+    }
+};
+export var mapLegacyAlign = function (align) {
+    switch (align) {
+        case 'left':
+            return 'start';
+        case 'right':
+            return 'end';
+        default:
+            return align;
+    }
+};
+var legacyActionTypeToContext = {
+    positive: 'positive',
+    negative: 'negative',
+    primary: 'neutral',
+    secondary: 'neutral',
+    link: 'neutral'
+};
+export var mapLegacyActionTypeToContext = function (type) {
+    return type && type in legacyActionTypeToContext ? legacyActionTypeToContext[type] : 'neutral';
+};
+var legacyActionTypeToControl = {
+    primary: 'primary',
+    secondary: 'secondary',
+    link: 'tertiary',
+    positive: 'primary',
+    negative: 'primary'
+};
+export var mapLegacyActionTypeToControl = function (type) {
+    return type && type in legacyActionTypeToControl ? legacyActionTypeToControl[type] : 'secondary';
+};

package/build/revamp/domain/types.js

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

package/build/revamp/flow/executeRefresh.js

@@ -0,0 +1,97 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { assertStepResponseBody, isErrorResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
+export var executeRefresh = function (props) { return __awaiter(void 0, void 0, void 0, function () {
+    var abortSignal, url, model, schemaId, etag, httpClient, trackEvent, response, responseBody, body_1, newEtag, body, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                abortSignal = props.abortSignal, url = props.url, model = props.model, schemaId = props.schemaId, etag = props.etag, httpClient = props.httpClient, trackEvent = props.trackEvent;
+                trackEvent('Refresh Triggered', { schema: schemaId });
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 6, , 7]);
+                return [4 /*yield*/, httpClient(url !== null && url !== void 0 ? url : '', {
+                        method: 'POST',
+                        body: JSON.stringify(model),
+                        headers: __assign({ 'Content-Type': 'application/json' }, (etag ? { 'If-None-Match': etag } : {})),
+                        signal: abortSignal
+                    })];
+            case 2:
+                response = _a.sent();
+                if (response.status === 304) {
+                    trackEvent('Refresh Succeeded', { schema: schemaId });
+                    return [2 /*return*/, { type: 'noop' }];
+                }
+                if (!!response.ok) return [3 /*break*/, 4];
+                return [4 /*yield*/, parseResponseBodyAsJsonElement(response)["catch"](function () { return ({}); })];
+            case 3:
+                responseBody = _a.sent();
+                body_1 = isErrorResponseBody(responseBody) ? responseBody : {};
+                trackEvent('Refresh Failed', __assign({ schema: schemaId }, body_1.analytics));
+                return [2 /*return*/, { type: 'error', body: body_1 }];
+            case 4:
+                newEtag = response.headers.get('etag') || null;
+                return [4 /*yield*/, parseResponseBodyAsJsonElement(response)];
+            case 5:
+                body = _a.sent();
+                assertStepResponseBody(body);
+                trackEvent('Refresh Succeeded', { schema: schemaId });
+                return [2 /*return*/, { type: 'refresh-step', step: body, etag: newEtag }];
+            case 6:
+                error_1 = _a.sent();
+                if (error_1 instanceof DOMException && error_1.name === 'AbortError') {
+                    trackEvent('Refresh Aborted', { schema: schemaId });
+                    return [2 /*return*/, { type: 'noop' }];
+                }
+                trackEvent('Refresh Failed', { schema: schemaId });
+                return [2 /*return*/, { type: 'error', body: {} }];
+            case 7: return [2 /*return*/];
+        }
+    });
+}); };