@wise/dynamic-flow-client 5.25.2-experimental-a8a898e → 5.25.2

package/build/domain/components/NumberInputComponent.js

@@ -0,0 +1,74 @@
+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 { getDebouncedSchemaOnChange } from '../features/schema-on-change/getDebouncedSchemaOnChange';
+import { getLocalValueValidator } from '../features/validation/validation-functions';
+import { getDebouncedComponentValidationAsync } from '../features/validationAsync/getComponentValidationAsync';
+import { getInputUpdateFunction } from './utils/component-utils';
+import { debounce } from './utils/debounce';
+export const createNumberInputComponent = (props, onComponentUpdate) => {
+    const { uid, id, checks, schemaOnChange, performValidationAsync, onValueChange, onPersistAsync, summariser } = props, rest = __rest(props, ["uid", "id", "checks", "schemaOnChange", "performValidationAsync", "onValueChange", "onPersistAsync", "summariser"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const onValueChangeDebounced = debounce(onValueChange, 1000);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const performOnChange = getDebouncedSchemaOnChange(schemaOnChange, getValidationErrors);
+    const validateAsync = performValidationAsync
+        ? getDebouncedComponentValidationAsync(update, performValidationAsync)
+        : undefined;
+    const component = Object.assign(Object.assign({ type: 'number', kind: 'input', uid,
+        id,
+        onBlur() {
+            const isValid = component.validate();
+            performOnChange === null || performOnChange === void 0 ? void 0 : performOnChange.flush();
+            if (isValid) {
+                void (onPersistAsync === null || onPersistAsync === void 0 ? void 0 : onPersistAsync().catch(() => { }));
+                validateAsync === null || validateAsync === void 0 ? void 0 : validateAsync.flush();
+            }
+            onValueChangeDebounced.flush();
+        },
+        onFocus() { }, // Noop
+        setValue(updatedValue) {
+            const prevValue = component.value;
+            update(component, (draft) => {
+                draft.errors = [];
+                draft.validationAsyncState.messages = {};
+                draft.value = updatedValue;
+            });
+            performOnChange === null || performOnChange === void 0 ? void 0 : performOnChange(prevValue, updatedValue);
+            const isValid = getValidationErrors(updatedValue).length === 0;
+            if (isValid) {
+                validateAsync === null || validateAsync === void 0 ? void 0 : validateAsync(component, updatedValue);
+            }
+            onValueChangeDebounced();
+        },
+        async getSubmittableValue() {
+            return component.getSubmittableValueSync();
+        },
+        getSubmittableValueSync() {
+            var _a;
+            return (_a = component.getLocalValue()) !== null && _a !== void 0 ? _a : null;
+        },
+        getSummary() {
+            return summariser(component.getLocalValue());
+        },
+        getLocalValue() {
+            return component.value;
+        },
+        validate() {
+            const errors = getValidationErrors(component.getLocalValue());
+            update(component, (draft) => {
+                draft.errors = errors;
+            });
+            return errors.length === 0;
+        } }, rest), { start() { },
+        stop() { } });
+    return component;
+};

package/build/domain/components/ObjectComponent.js

@@ -0,0 +1,54 @@
+import { mergeSummaries, summariseFromChildren } from '../features/summary/summary-utils';
+import { validateComponents } from '../features/validation/validation-functions';
+export const createObjectComponent = (props) => {
+    const { uid, schemaId, analyticsId, alert, componentMap, control, description, displayOrder, help, hidden, media, summariser, title, tags, } = props;
+    const component = {
+        type: 'object',
+        kind: 'input',
+        uid,
+        schemaId,
+        analyticsId,
+        alert,
+        componentMap,
+        control,
+        description,
+        help,
+        hidden,
+        media,
+        title,
+        tags,
+        getChildren() {
+            return displayOrder.map((propName) => component.componentMap[propName]);
+        },
+        async getSubmittableValue() {
+            return Promise.all(displayOrder.map(async (propName) => component.componentMap[propName]
+                .getSubmittableValue()
+                .then((value) => ({ value, propName })))).then((values) => values.reduce((acc, { value, propName }) => (Object.assign(Object.assign({}, acc), (value === null ? {} : { [propName]: value }))), {}));
+        },
+        getSubmittableValueSync() {
+            return mergeChildrenValues(displayOrder, (propName) => component.componentMap[propName].getSubmittableValueSync());
+        },
+        getSummary() {
+            const summary = summariser(component.getLocalValue());
+            const childSummary = summariseFromChildren(component.getChildren());
+            return mergeSummaries(summary, childSummary);
+        },
+        getLocalValue() {
+            return mergeChildrenValues(displayOrder, (propName) => component.componentMap[propName].getLocalValue());
+        },
+        validate() {
+            return hidden ? true : validateComponents(component.getChildren());
+        },
+        start() {
+            component.getChildren().forEach((child) => child.start());
+        },
+        stop() {
+            component.getChildren().forEach((child) => child.stop());
+        },
+    };
+    return component;
+};
+const mergeChildrenValues = (displayOrder, getComponentValue) => displayOrder.reduce((acc, propName) => {
+    const componentValue = getComponentValue(propName);
+    return Object.assign(Object.assign({}, acc), (componentValue === null ? {} : { [propName]: componentValue }));
+}, {});

package/build/domain/components/ParagraphComponent.js

@@ -0,0 +1,2 @@
+export const createParagraphComponent = (props) => (Object.assign(Object.assign({ type: 'paragraph', kind: 'layout' }, props), { start() { },
+    stop() { } }));

package/build/domain/components/PersistAsyncComponent.js

@@ -0,0 +1,96 @@
+import { abortAndResetController } from '../features/utils/http-utils';
+import { getInputUpdateFunction } from './utils/component-utils';
+import { isExactLocalValueMatch } from './utils/isExactLocalValueMatch';
+export const createPersistAsyncComponent = (props, performPersistAsync, schemaOnChange, onComponentUpdate) => {
+    const { uid, analyticsId, schemaId, component: childComponent, hidden, model, localValue, tags, } = props;
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const component = {
+        type: 'persist-async',
+        kind: 'input',
+        uid,
+        analyticsId,
+        schemaId,
+        component: childComponent,
+        hidden,
+        status: 'idle',
+        lastSubmitted: model != null ? (localValue !== null && localValue !== void 0 ? localValue : null) : null,
+        lastResponse: model !== null && model !== void 0 ? model : null,
+        submission: Promise.resolve(model !== null && model !== void 0 ? model : null),
+        abortController: new AbortController(),
+        errors: [],
+        tags,
+        validate() {
+            return component.component.validate();
+        },
+        getLocalValue() {
+            return component.component.getLocalValue();
+        },
+        async getSubmittableValue() {
+            return component.persist();
+        },
+        getSubmittableValueSync() {
+            return component.lastResponse;
+        },
+        getSummary() {
+            return component.component.getSummary();
+        },
+        async persist() {
+            const childLocalValue = component.component.getLocalValue();
+            if (isExactLocalValueMatch(childLocalValue, component.lastSubmitted)) {
+                return component.submission;
+            }
+            const newAbortController = abortAndResetController(component.abortController);
+            if (childLocalValue == null || childLocalValue === '') {
+                const resolvedNull = Promise.resolve(null);
+                update(component, (draft) => {
+                    draft.abortController = newAbortController;
+                    draft.lastResponse = null;
+                    draft.lastSubmitted = childLocalValue;
+                    draft.submission = resolvedNull;
+                    draft.errors = [];
+                    draft.status = 'idle';
+                });
+                void (schemaOnChange === null || schemaOnChange === void 0 ? void 0 : schemaOnChange());
+                return resolvedNull;
+            }
+            const { signal } = newAbortController;
+            const newSubmission = performPersistAsync({ value: childLocalValue, signal })
+                .then((token) => {
+                update(component, (draft) => {
+                    draft.lastResponse = token;
+                    draft.errors = [];
+                    draft.status = 'success';
+                });
+                void (schemaOnChange === null || schemaOnChange === void 0 ? void 0 : schemaOnChange());
+                return token;
+            })
+                .catch((error) => {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    return null;
+                }
+                update(component, (draft) => {
+                    draft.lastResponse = null;
+                    draft.lastSubmitted = null;
+                    draft.submission = Promise.resolve(null);
+                    draft.status = 'error';
+                    if (component.component.type !== 'upload') {
+                        draft.errors = error instanceof Error ? [error.message] : [];
+                    }
+                });
+                throw error;
+            });
+            update(component, (draft) => {
+                draft.abortController = newAbortController;
+                draft.lastSubmitted = childLocalValue;
+                draft.lastResponse = null;
+                draft.submission = newSubmission;
+                draft.errors = [];
+                draft.status = 'persisting';
+            });
+            return newSubmission;
+        },
+        start() { },
+        stop() { },
+    };
+    return component;
+};

package/build/domain/components/ProgressComponent.js

@@ -0,0 +1,2 @@
+export const createProgressComponent = (props) => (Object.assign(Object.assign({ type: 'progress', kind: 'layout' }, props), { start() { },
+    stop() { } }));

package/build/domain/components/RepeatableComponent.js

@@ -0,0 +1,106 @@
+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 { getLocalValueValidator, validateComponents, } from '../features/validation/validation-functions';
+import { getInputUpdateFunction } from './utils/component-utils';
+export const createRepeatableComponent = (props, onComponentUpdate) => {
+    const { uid, schemaId, analyticsId, checks, components, summary, onValueChange, createEditableComponent, summariser } = props, componentProps = __rest(props, ["uid", "schemaId", "analyticsId", "checks", "components", "summary", "onValueChange", "createEditableComponent", "summariser"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const component = Object.assign(Object.assign({ uid,
+        schemaId,
+        analyticsId, type: 'repeatable', kind: 'input', components, editableComponent: null, editableIndex: null, summaryDefaults: {
+            title: summary === null || summary === void 0 ? void 0 : summary.defaultTitle,
+            description: summary === null || summary === void 0 ? void 0 : summary.defaultDescription,
+            media: summary === null || summary === void 0 ? void 0 : summary.defaultMedia,
+        } }, componentProps), { editComponent(itemIndex) {
+            update(component, (draft) => {
+                draft.editableComponent = createEditableComponent(draft.components[itemIndex].getLocalValue());
+                draft.editableIndex = itemIndex;
+            });
+        },
+        addComponent() {
+            update(component, (draft) => {
+                draft.editableComponent = createEditableComponent(null);
+                draft.editableIndex = null;
+                draft.errors = [];
+            });
+        },
+        saveComponent() {
+            var _a;
+            const isValid = (_a = component.editableComponent) === null || _a === void 0 ? void 0 : _a.validate();
+            if (!isValid) {
+                return false;
+            }
+            update(component, (draft) => {
+                if (draft.editableComponent === null) {
+                    return;
+                }
+                if (draft.editableIndex === null) {
+                    // Adding a new item
+                    const newComponent = Object.assign({}, draft.editableComponent);
+                    draft.components = [...component.components, newComponent];
+                }
+                else {
+                    // Editing an item
+                    draft.components[draft.editableIndex] = Object.assign(Object.assign({}, draft.editableComponent), { uid: draft.components[draft.editableIndex].uid });
+                }
+                draft.editableComponent = null;
+                draft.editableIndex = null;
+            });
+            onValueChange();
+            return true;
+        },
+        removeComponent() {
+            update(component, (draft) => {
+                if (draft.editableIndex === null) {
+                    return;
+                }
+                draft.components.splice(draft.editableIndex, 1);
+                draft.editableComponent = null;
+                draft.editableIndex = null;
+            });
+            onValueChange();
+        },
+        getChildren() {
+            return component.editableComponent !== null
+                ? [...component.components, component.editableComponent]
+                : component.components;
+        },
+        async getSubmittableValue() {
+            return Promise.all(component.components.map(async (childComponent) => childComponent.getSubmittableValue()));
+        },
+        getSubmittableValueSync() {
+            return component.components.map((childComponent) => childComponent.getSubmittableValueSync());
+        },
+        getSummary() {
+            // It doesn't make sense to pass a value here
+            return summariser(null);
+        },
+        getLocalValue() {
+            return component.components.map((childComponent) => childComponent.getLocalValue());
+        },
+        validate() {
+            const messages = getValidationErrors(component.getLocalValue());
+            const childComponentsValid = validateComponents(component.getChildren());
+            update(component, (draft) => {
+                draft.errors = messages;
+            });
+            return messages.length === 0 && childComponentsValid;
+        },
+        start() {
+            component.getChildren().forEach((child) => child.start());
+        },
+        stop() {
+            component.getChildren().forEach((child) => child.stop());
+        } });
+    return component;
+};

package/build/domain/components/ReviewComponent.js

@@ -0,0 +1,2 @@
+export const createReviewComponent = (props) => (Object.assign(Object.assign({ type: 'review', kind: 'layout' }, props), { start() { },
+    stop() { } }));

package/build/domain/components/RootDomainComponent.js

@@ -0,0 +1,190 @@
+import { getInputUpdateFunction } from './utils/component-utils';
+export const createRootDomainComponent = (onComponentUpdate, scrollToTop, backConfig, requestCache) => {
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const component = {
+        type: 'root',
+        kind: 'step',
+        uid: 'root',
+        stepComponent: null,
+        stepStack: [],
+        backConfig,
+        requestCache,
+        dismissAllModals() {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.dismissAllModals();
+        },
+        dismissModal() {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.dismissModal();
+        },
+        showModal(modal) {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.showModal(modal);
+        },
+        getChildren() {
+            const step = component.getStep();
+            return step ? [step, ...step.getModals()] : [];
+        },
+        getLocalValue() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.getLocalValue()) !== null && _b !== void 0 ? _b : null;
+        },
+        async getSubmittableValue() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.getSubmittableValue()) !== null && _b !== void 0 ? _b : null;
+        },
+        getSubmittableValueSync() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.getSubmittableValueSync()) !== null && _b !== void 0 ? _b : null;
+        },
+        validate() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.validate()) !== null && _b !== void 0 ? _b : false;
+        },
+        setLoadingState(loadingState) {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.setLoadingState(loadingState);
+        },
+        getLoadingState() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.loadingState) !== null && _b !== void 0 ? _b : 'initial';
+        },
+        getSchemaComponents() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.schemaComponents) !== null && _b !== void 0 ? _b : [];
+        },
+        getTrackEvent() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.trackEvent) !== null && _b !== void 0 ? _b : null;
+        },
+        isBusy() {
+            const loadingState = component.getLoadingState();
+            return loadingState === 'submitting' || loadingState === 'refreshing';
+        },
+        hasStep() {
+            return Boolean(component.stepStack.length > 0);
+        },
+        getStep() {
+            var _a;
+            return (_a = component.stepStack[component.stepStack.length - 1]) !== null && _a !== void 0 ? _a : null;
+        },
+        addSubflow(subflow) {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.addSubflow(subflow);
+        },
+        closeSubflow() {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.closeSubflow();
+        },
+        getSubflow() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.subflow) !== null && _b !== void 0 ? _b : null;
+        },
+        start() {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.start();
+        },
+        stop() {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.stop();
+        },
+        updateStep(stepComponent) {
+            var _a;
+            component.closeSubflow();
+            const shouldScroll = shouldScrollOnStepUpdate(stepComponent, component.getStep());
+            update(component, (draft) => {
+                draft.stepStack = draft.stepStack.slice(0, -1);
+                draft.stepStack.push(stepComponent);
+            });
+            if (shouldScroll) {
+                scrollToTop === null || scrollToTop === void 0 ? void 0 : scrollToTop('smooth');
+            }
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.start();
+        },
+        pushStep(stepComponent) {
+            var _a;
+            component.closeSubflow();
+            const previousStep = component.getStep();
+            const previousStepHasPolling = previousStep === null || previousStep === void 0 ? void 0 : previousStep.step.polling;
+            update(component, (draft) => {
+                switch (stepComponent.stackBehavior) {
+                    case 'remove-previous':
+                    case 'replace-current':
+                        draft.stepStack.splice(draft.stepStack.length - 1, 1, stepComponent);
+                        return;
+                    case 'remove-all':
+                        draft.stepStack = [stepComponent];
+                        return;
+                    case 'default':
+                        // to prevent getting into loops, we remove a step that has polling when we
+                        // push the next step so the user does not go back only to immediately go forward again.
+                        if (previousStepHasPolling) {
+                            draft.stepStack = draft.stepStack.slice(0, -1);
+                        }
+                        draft.stepStack.push(stepComponent);
+                }
+            });
+            if (previousStep != null) {
+                (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.start();
+                scrollToTop === null || scrollToTop === void 0 ? void 0 : scrollToTop('instant');
+            }
+        },
+        clearStack() {
+            const currentStep = component.getStep();
+            if (currentStep) {
+                update(component, (draft) => {
+                    draft.stepStack = [currentStep];
+                });
+            }
+        },
+        getRefreshUrl() {
+            var _a, _b;
+            var _c, _d;
+            return ((_d = (_c = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.step.refreshUrl) !== null && _c !== void 0 ? _c : (_b = component.getStep()) === null || _b === void 0 ? void 0 : _b.step.refreshFormUrl) !== null && _d !== void 0 ? _d : null);
+        },
+        navigateBack() {
+            var _a;
+            component.closeSubflow();
+            if (component.stepStack.length === 1) {
+                return;
+            }
+            update(component, (draft) => {
+                draft.stepStack = draft.stepStack.slice(0, -1);
+            });
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.start();
+        },
+        canPerformBack() {
+            var _a;
+            var _b;
+            const navigation = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.step.navigation;
+            const stepHasBehavior = Boolean((_b = navigation === null || navigation === void 0 ? void 0 : navigation.back) !== null && _b !== void 0 ? _b : navigation === null || navigation === void 0 ? void 0 : navigation.backButton);
+            return (component.backConfig.isFlowCancellable ||
+                (component.stepStack.length > 1 && component.backConfig.isNativeBackEnabled) ||
+                stepHasBehavior);
+        },
+        startDelay(delay) {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.startDelay(delay)) !== null && _b !== void 0 ? _b : { abort: () => { } };
+        },
+        setExternalConfirmation(external) {
+            var _a;
+            (_a = component.getStep()) === null || _a === void 0 ? void 0 : _a.setExternalConfirmation(external);
+        },
+    };
+    return component;
+};
+const shouldScrollOnStepUpdate = (newStep, currentStep) => {
+    if (!currentStep) {
+        return false; // we never scroll on first step set
+    }
+    return newStep.error != null && newStep.error !== currentStep.error;
+};

package/build/domain/components/SectionComponent.js

@@ -0,0 +1,12 @@
+export const createSectionComponent = (props) => {
+    const component = Object.assign(Object.assign({}, props), { type: 'section', kind: 'layout', getChildren() {
+            return props.components;
+        },
+        start() {
+            component.getChildren().forEach((child) => child.start());
+        },
+        stop() {
+            component.getChildren().forEach((child) => child.stop());
+        } });
+    return component;
+};

package/build/domain/components/SelectInputComponent.js

@@ -0,0 +1,96 @@
+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 { getLocalValueValidator } from '../features/validation/validation-functions';
+import { getInputUpdateFunction } from './utils/component-utils';
+import { isPartialModelMatch } from './utils/isPartialModelMatch';
+export const createSelectInputComponent = (props, onComponentUpdate) => {
+    const { uid, checks, initialModel, options, schemaOnChange, onValueChange, summariser } = props, rest = __rest(props, ["uid", "checks", "initialModel", "options", "schemaOnChange", "onValueChange", "summariser"]);
+    const children = options.map((option) => option.component);
+    const matchingOptions = options.map((option) => isPartialModelMatch(option.component.getSubmittableValueSync(), initialModel));
+    const selectedIndex = matchingOptions.filter((match) => match).length === 1 ? matchingOptions.indexOf(true) : null;
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const getValidationErrors = getLocalValueValidator(checks);
+    const component = Object.assign(Object.assign({ uid, type: 'select', kind: 'input', children,
+        options,
+        selectedIndex, value: null }, rest), { getChildren() {
+            return component.children;
+        },
+        getSelectedChild() {
+            return component.selectedIndex !== null ? component.children[component.selectedIndex] : null;
+        },
+        async getSubmittableValue() {
+            var _a;
+            var _b;
+            return (_b = (await ((_a = component.getSelectedChild()) === null || _a === void 0 ? void 0 : _a.getSubmittableValue()))) !== null && _b !== void 0 ? _b : null;
+        },
+        getSubmittableValueSync() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getSelectedChild()) === null || _a === void 0 ? void 0 : _a.getSubmittableValueSync()) !== null && _b !== void 0 ? _b : null;
+        },
+        getSummary() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getSelectedChild()) === null || _a === void 0 ? void 0 : _a.getSummary()) !== null && _b !== void 0 ? _b : {};
+        },
+        getLocalValue() {
+            var _a;
+            var _b;
+            return (_b = (_a = component.getSelectedChild()) === null || _a === void 0 ? void 0 : _a.getLocalValue()) !== null && _b !== void 0 ? _b : null;
+        },
+        onBlur() {
+            component.validate();
+        },
+        onFocus() { }, // noop
+        selectIndex(updatedIndex) {
+            if (updatedIndex === component.selectedIndex) {
+                return;
+            }
+            if (updatedIndex !== null) {
+                // new event, always triggered when an option is selected
+                props.trackEvent('OneOf Option Selected', {
+                    schema: component.analyticsId,
+                    selectedOption: component.children[updatedIndex].analyticsId,
+                });
+                if (component.analyticsId) {
+                    // legacy event, only triggered if the main schema has an analyticsId or $id
+                    props.trackEvent('OneOf Selected', {
+                        oneOfId: component.analyticsId,
+                        schemaId: component.children[updatedIndex].analyticsId,
+                    });
+                }
+            }
+            update(component, (draft) => {
+                draft.errors = [];
+                draft.selectedIndex = updatedIndex;
+            });
+            void (schemaOnChange === null || schemaOnChange === void 0 ? void 0 : schemaOnChange());
+            onValueChange();
+        },
+        validate() {
+            var _a;
+            var _b;
+            const validChild = (_b = (_a = component.getSelectedChild()) === null || _a === void 0 ? void 0 : _a.validate()) !== null && _b !== void 0 ? _b : true;
+            const errors = getValidationErrors(component.getLocalValue());
+            update(component, (draft) => {
+                draft.errors = errors;
+            });
+            return errors.length === 0 && validChild;
+        },
+        start() {
+            component.getChildren().forEach((child) => child.start());
+        },
+        stop() {
+            component.getChildren().forEach((child) => child.stop());
+        } });
+    return component;
+};

package/build/domain/components/StatusListComponent.js

@@ -0,0 +1,2 @@
+export const createStatusListComponent = (props) => (Object.assign(Object.assign({ type: 'status-list', kind: 'layout' }, props), { start() { },
+    stop() { } }));

package/build/domain/components/SubflowComponent.js

@@ -0,0 +1,19 @@
+import { getInputUpdateFunction } from './utils/component-utils';
+import { getRandomId } from './utils/getRandomId';
+export const createSubflowComponent = (props, onComponentUpdate) => {
+    switch (props.subflowType) {
+        case 'dynamic':
+            return createDynamicSubflowComponent(props, onComponentUpdate);
+        case 'native':
+            return createNativeSubflowComponent(props);
+    }
+};
+const createDynamicSubflowComponent = (props, onComponentUpdate) => {
+    const update = getInputUpdateFunction(onComponentUpdate);
+    return Object.assign(Object.assign({ uid: `subflow-dynamic-${getRandomId()}`, type: 'subflow', subflowType: 'dynamic', kind: 'layout' }, props), { start() { },
+        stop() { } });
+};
+const createNativeSubflowComponent = (props) => {
+    return Object.assign(Object.assign({ uid: `subflow-native-${getRandomId()}`, type: 'subflow', subflowType: 'native', kind: 'layout' }, props), { start() { },
+        stop() { } });
+};

package/build/domain/components/TabsComponent.js

@@ -0,0 +1,2 @@
+export const createTabsComponent = (props) => (Object.assign(Object.assign({}, props), { type: 'tabs', kind: 'layout', start() { },
+    stop() { } }));