@oneuptime/common 14.0.12 → 14.0.13

package/build/dist/Types/Form/FormField.js

@@ -0,0 +1,713 @@
+import { parseCustomFieldDropdownOptions, serializeCustomFieldDropdownOptions, } from "../CustomField/CustomFieldDropdownOption";
+import CustomFieldType from "../CustomField/CustomFieldType";
+import ColumnLength from "../Database/ColumnLength";
+import ObjectID from "../ObjectID";
+import { getFormTargetField, getFormTargetFields, getFormTargetFieldsThatMustBeAsked, isChoiceTargetField, } from "./FormTargetCatalog";
+import { FORM_TARGET_TYPE_TEXT } from "./FormTargetType";
+/*
+ * The questions a form asks, in the order it asks them: Form.fields, the
+ * form builder's output.
+ *
+ * Every question has a source that says where its answer goes:
+ *
+ *   - Question: one of the form's own questions - a short answer, a
+ *     paragraph, a dropdown, a date and so on. Its answer is kept with the
+ *     submission and written on the private note the created record gets.
+ *   - TargetField: one of the built-in fields of what the form creates (the
+ *     incident's title, its severity, a maintenance event's start). Its
+ *     answer becomes that field's value. See FormTargetCatalog.
+ *   - TargetCustomField: one of the project's custom fields of what the form
+ *     creates (an incident custom field, a scheduled maintenance custom
+ *     field), by its id. Its answer becomes the record's value for it.
+ *   - Submitter: the submitter's name or email. Kept with the submission and
+ *     named on the private note; never on the record itself.
+ *
+ * A question's answers are keyed by its id, which never changes once the
+ * question exists, so relabelling a question keeps its submissions readable.
+ *
+ * Read the stored value with readFormFields (it never throws, and drops what
+ * it cannot use), and check a value before storing it with
+ * validateFormFields, which the server runs on every write - from the
+ * dashboard, the API, Terraform or a workflow.
+ *
+ * Pure, with no database or React imports, so the server, the builder and
+ * the public page read questions the same way.
+ */
+export var FormFieldSource;
+(function (FormFieldSource) {
+    FormFieldSource["Question"] = "Question";
+    FormFieldSource["TargetField"] = "TargetField";
+    FormFieldSource["TargetCustomField"] = "TargetCustomField";
+    FormFieldSource["Submitter"] = "Submitter";
+})(FormFieldSource || (FormFieldSource = {}));
+export var FormSubmitterField;
+(function (FormSubmitterField) {
+    FormSubmitterField["Name"] = "Name";
+    FormSubmitterField["Email"] = "Email";
+})(FormSubmitterField || (FormSubmitterField = {}));
+// The most questions one form asks.
+export const FORM_MAX_FIELDS = 50;
+export const FORM_FIELD_LABEL_MAX_LENGTH = 200;
+export const FORM_FIELD_HELP_TEXT_MAX_LENGTH = 1000;
+// The most options a dropdown question offers.
+export const FORM_QUESTION_MAX_OPTIONS = 100;
+export const FORM_QUESTION_OPTION_MAX_LENGTH = ColumnLength.ShortText;
+// The most records a choice field may offer on the public page.
+export const FORM_FIELD_MAX_ALLOWED_OPTIONS = 100;
+/*
+ * The longest answer to a text question or a text custom field. Answers are
+ * kept with the submission (and custom field answers on the record), and
+ * the request body may be up to 50 MB.
+ */
+export const FORM_TEXT_ANSWER_MAX_LENGTH = 10000;
+// FormSubmission.submitterName and submitterEmail are varchar(100).
+export const FORM_SUBMITTER_NAME_MAX_LENGTH = ColumnLength.ShortText;
+export const FORM_SUBMITTER_EMAIL_MAX_LENGTH = ColumnLength.Email;
+/*
+ * A question's id: letters, digits, "-" and "_", starting with a letter or
+ * digit, at most 64 characters. Ids are keys of the answers object, so a
+ * name such as "__proto__" or "constructor"-like trickery must not be one,
+ * and a dot or a bracket would be read as a path by the form library.
+ */
+export const FORM_FIELD_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+// The types a question of the form's own can have, in the palette's order.
+export const FORM_QUESTION_TYPES = [
+    CustomFieldType.Text,
+    CustomFieldType.LongText,
+    CustomFieldType.Markdown,
+    CustomFieldType.Number,
+    CustomFieldType.Dropdown,
+    CustomFieldType.MultiSelectDropdown,
+    CustomFieldType.Boolean,
+    CustomFieldType.Date,
+    CustomFieldType.DateTime,
+];
+export const FORM_CHOICE_QUESTION_TYPES = [
+    CustomFieldType.Dropdown,
+    CustomFieldType.MultiSelectDropdown,
+];
+export const FORM_SUBMITTER_FIELDS = [
+    FormSubmitterField.Name,
+    FormSubmitterField.Email,
+];
+export const FORM_SUBMITTER_FIELD_DEFINITIONS = {
+    [FormSubmitterField.Name]: {
+        field: FormSubmitterField.Name,
+        title: "Name",
+        description: "Who is submitting. Kept with the submission.",
+        defaultLabel: "Your Name",
+    },
+    [FormSubmitterField.Email]: {
+        field: FormSubmitterField.Email,
+        title: "Email",
+        description: "How to reach the submitter. Kept with the submission.",
+        defaultLabel: "Your Email",
+    },
+};
+const FORM_FIELD_SOURCES = Object.values(FormFieldSource);
+const isPlainObject = (value) => {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+// A fresh id for a new question.
+export const generateFormFieldId = () => {
+    return ObjectID.generate().toString();
+};
+export const isFormFieldId = (value) => {
+    return typeof value === "string" && FORM_FIELD_ID_PATTERN.test(value);
+};
+const readOptionalText = (value) => {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const text = value.trim();
+    return text.length > 0 ? text : undefined;
+};
+// A list of record ids, lowercased, each once, in order; junk dropped.
+const readIdList = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const ids = [];
+    for (const entry of value) {
+        const id = typeof entry === "string" ? entry.trim().toLowerCase() : "";
+        if (ObjectID.isValidUUID(id) && !ids.includes(id)) {
+            ids.push(id);
+        }
+    }
+    return ids;
+};
+/*
+ * One stored question as the builder and the public page read it, or null
+ * for an entry that cannot be one: no usable id, an unknown source, or a
+ * source without what it needs (a question with an unknown type, a linked
+ * field with no key or custom field id, a submitter field of no kind).
+ * Properties that do not belong to its source are left behind.
+ */
+const readField = (value) => {
+    if (!isPlainObject(value)) {
+        return null;
+    }
+    const id = value["id"];
+    const source = value["source"];
+    if (!isFormFieldId(id) ||
+        typeof source !== "string" ||
+        !FORM_FIELD_SOURCES.includes(source)) {
+        return null;
+    }
+    const field = {
+        id: id,
+        source: source,
+        label: typeof value["label"] === "string" ? value["label"].trim() : "",
+        isRequired: value["isRequired"] === true,
+    };
+    const helpText = readOptionalText(value["helpText"]);
+    if (helpText) {
+        field.helpText = helpText;
+    }
+    switch (field.source) {
+        case FormFieldSource.Question: {
+            const type = value["type"];
+            if (typeof type !== "string" ||
+                !FORM_QUESTION_TYPES.includes(type)) {
+                return null;
+            }
+            field.type = type;
+            if (FORM_CHOICE_QUESTION_TYPES.includes(field.type) &&
+                typeof value["dropdownOptions"] === "string" &&
+                value["dropdownOptions"].trim()) {
+                field.dropdownOptions = value["dropdownOptions"];
+            }
+            return field;
+        }
+        case FormFieldSource.TargetField: {
+            const targetField = readOptionalText(value["targetField"]);
+            if (!targetField) {
+                return null;
+            }
+            field.targetField = targetField;
+            const allowedOptionIds = readIdList(value["allowedOptionIds"]);
+            if (allowedOptionIds.length > 0) {
+                field.allowedOptionIds = allowedOptionIds;
+            }
+            return field;
+        }
+        case FormFieldSource.TargetCustomField: {
+            const customFieldId = typeof value["customFieldId"] === "string"
+                ? value["customFieldId"].trim().toLowerCase()
+                : "";
+            if (!ObjectID.isValidUUID(customFieldId)) {
+                return null;
+            }
+            field.customFieldId = customFieldId;
+            return field;
+        }
+        case FormFieldSource.Submitter: {
+            const submitterField = value["submitterField"];
+            if (typeof submitterField !== "string" ||
+                !FORM_SUBMITTER_FIELDS.includes(submitterField)) {
+                return null;
+            }
+            field.submitterField = submitterField;
+            return field;
+        }
+        default:
+            return null;
+    }
+};
+/**
+ * A form's stored questions, in order, as the builder and the public page
+ * read them: entries that cannot be a question are dropped, and so is a
+ * second question with an id already listed. Never throws.
+ */
+export const readFormFields = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const fields = [];
+    const ids = new Set();
+    for (const entry of value.slice(0, FORM_MAX_FIELDS)) {
+        const field = readField(entry);
+        if (!field || ids.has(field.id)) {
+            continue;
+        }
+        ids.add(field.id);
+        fields.push(field);
+    }
+    return fields;
+};
+/*
+ * How a problem names the question it is about: its position, and its
+ * label when it has one - "Question 3 ("What broke?")".
+ */
+export const describeFormField = (data) => {
+    const label = typeof data.label === "string" ? data.label.trim().slice(0, 60) : "";
+    return label
+        ? `Question ${data.index + 1} ("${label}")`
+        : `Question ${data.index + 1}`;
+};
+// The checks every question shares: its label, help text and Required.
+const checkCommonProperties = (data) => {
+    const label = data.entry["label"];
+    if (typeof label !== "string" || label.trim().length === 0) {
+        data.problems.push(`${data.name} needs a label.`);
+    }
+    else if (label.trim().length > FORM_FIELD_LABEL_MAX_LENGTH) {
+        data.problems.push(`${data.name}: the label cannot be more than ${FORM_FIELD_LABEL_MAX_LENGTH} characters.`);
+    }
+    const helpText = data.entry["helpText"];
+    if (helpText !== undefined && helpText !== null) {
+        if (typeof helpText !== "string") {
+            data.problems.push(`${data.name}: the help text must be text.`);
+        }
+        else if (helpText.trim().length > FORM_FIELD_HELP_TEXT_MAX_LENGTH) {
+            data.problems.push(`${data.name}: the help text cannot be more than ${FORM_FIELD_HELP_TEXT_MAX_LENGTH} characters.`);
+        }
+    }
+    const isRequired = data.entry["isRequired"];
+    if (isRequired !== undefined && typeof isRequired !== "boolean") {
+        data.problems.push(`${data.name}: Required must be true or false.`);
+    }
+};
+// A question of the form's own: its type, and a choice question's options.
+const checkQuestion = (data) => {
+    const type = data.entry["type"];
+    if (typeof type !== "string" ||
+        !FORM_QUESTION_TYPES.includes(type)) {
+        data.problems.push(`${data.name} must have one of these types: ${FORM_QUESTION_TYPES.join(", ")}.`);
+        return;
+    }
+    if (!FORM_CHOICE_QUESTION_TYPES.includes(type)) {
+        return;
+    }
+    const serialized = data.entry["dropdownOptions"];
+    if (serialized !== undefined && typeof serialized !== "string") {
+        data.problems.push(`${data.name}: its options must be text.`);
+        return;
+    }
+    const options = parseCustomFieldDropdownOptions(serialized).map((option) => {
+        return option.value;
+    });
+    if (options.length === 0) {
+        data.problems.push(`${data.name} needs at least one option to choose from.`);
+        return;
+    }
+    if (options.length > FORM_QUESTION_MAX_OPTIONS) {
+        data.problems.push(`${data.name} cannot have more than ${FORM_QUESTION_MAX_OPTIONS} options.`);
+    }
+    const tooLong = options.find((option) => {
+        return option.length > FORM_QUESTION_OPTION_MAX_LENGTH;
+    });
+    if (tooLong) {
+        data.problems.push(`${data.name}: an option cannot be more than ${FORM_QUESTION_OPTION_MAX_LENGTH} characters.`);
+    }
+    if (new Set(options).size !== options.length) {
+        data.problems.push(`${data.name} lists the same option twice.`);
+    }
+};
+// A built-in field of the target: one it has, and the records it offers.
+const checkTargetField = (data) => {
+    const definition = getFormTargetField(data.targetType, data.entry["targetField"]);
+    if (!definition) {
+        data.problems.push(`${data.name} is linked to a field ${FORM_TARGET_TYPE_TEXT[data.targetType].nounWithArticle} does not have. Fields it can be linked to: ${getFormTargetFields(data.targetType)
+            .map((field) => {
+            return field.key;
+        })
+            .join(", ")}.`);
+        return;
+    }
+    const allowed = data.entry["allowedOptionIds"];
+    if (!isChoiceTargetField(definition)) {
+        if (allowed !== undefined &&
+            allowed !== null &&
+            !(Array.isArray(allowed) && allowed.length === 0)) {
+            data.problems.push(`${data.name}: ${definition.title} is not answered by choosing, so it takes no allowed options.`);
+        }
+        return;
+    }
+    if (allowed !== undefined && allowed !== null && !Array.isArray(allowed)) {
+        data.problems.push(`${data.name}: the allowed options must be a list.`);
+        return;
+    }
+    const entries = Array.isArray(allowed) ? allowed : [];
+    if (entries.length > FORM_FIELD_MAX_ALLOWED_OPTIONS) {
+        data.problems.push(`${data.name} cannot offer more than ${FORM_FIELD_MAX_ALLOWED_OPTIONS} options.`);
+        return;
+    }
+    const invalid = entries.some((entry) => {
+        return (typeof entry !== "string" ||
+            !ObjectID.isValidUUID(entry.trim().toLowerCase()));
+    });
+    if (invalid) {
+        data.problems.push(`${data.name}: every allowed option must be an id.`);
+        return;
+    }
+    if (definition.mustChooseOptions && entries.length === 0) {
+        data.problems.push(`${data.name}: choose which ${definition.title.toLowerCase()} the form offers. A public form only lists the ones you choose.`);
+    }
+};
+const checkTargetCustomField = (data) => {
+    const customFieldId = data.entry["customFieldId"];
+    if (typeof customFieldId !== "string" ||
+        !ObjectID.isValidUUID(customFieldId.trim().toLowerCase())) {
+        data.problems.push(`${data.name} must name a custom field by its id.`);
+    }
+};
+const checkSubmitterField = (data) => {
+    const submitterField = data.entry["submitterField"];
+    if (typeof submitterField !== "string" ||
+        !FORM_SUBMITTER_FIELDS.includes(submitterField)) {
+        data.problems.push(`${data.name} must ask for the submitter's ${FORM_SUBMITTER_FIELDS.join(" or ").toLowerCase()}.`);
+    }
+};
+const CHECKS_BY_SOURCE = {
+    [FormFieldSource.Question]: checkQuestion,
+    [FormFieldSource.TargetField]: checkTargetField,
+    [FormFieldSource.TargetCustomField]: checkTargetCustomField,
+    [FormFieldSource.Submitter]: checkSubmitterField,
+};
+// The most problems one refusal lists.
+const MAX_LISTED_PROBLEMS = 8;
+/**
+ * Null when the questions can be stored for a form of this target;
+ * otherwise one message naming every problem (the first eight). Checked:
+ *
+ *   - a list of at most FORM_MAX_FIELDS questions, each an object with a
+ *     unique id, a known source, a label and Required as true or false;
+ *   - a question of the form's own has a known type, and a dropdown has
+ *     between one and FORM_QUESTION_MAX_OPTIONS distinct options;
+ *   - a linked field is one the target has, asked once, and a field
+ *     answered by choosing offers record ids (and must offer some when the
+ *     public page only lists chosen ones);
+ *   - a custom field is named by its id, and asked once;
+ *   - the submitter's name and email are asked once each;
+ *   - every field the target cannot do without, and that nothing else
+ *     supplies (a maintenance event's start and end), is asked and required.
+ *
+ * Whether a linked custom field, or an allowed record, still exists in the
+ * project is the server's to check: this module has no database.
+ */
+export const validateFormFields = (data) => {
+    if (data.value === null || data.value === undefined) {
+        return null;
+    }
+    if (!Array.isArray(data.value)) {
+        return "Fields must be a list of questions.";
+    }
+    if (data.value.length > FORM_MAX_FIELDS) {
+        return `A form cannot have more than ${FORM_MAX_FIELDS} questions.`;
+    }
+    const problems = [];
+    const ids = new Set();
+    const targetFields = new Set();
+    const customFields = new Set();
+    const submitterFields = new Set();
+    data.value.forEach((entry, index) => {
+        if (!isPlainObject(entry)) {
+            problems.push(`${describeFormField({ index })} must be an object.`);
+            return;
+        }
+        const name = describeFormField({ index, label: entry["label"] });
+        const id = entry["id"];
+        if (!isFormFieldId(id)) {
+            problems.push(`${name} needs an id of letters, digits, "-" and "_", starting with a letter or digit, at most 64 characters.`);
+        }
+        else if (ids.has(id)) {
+            problems.push(`${name} has the same id as another question.`);
+        }
+        else {
+            ids.add(id);
+        }
+        const source = entry["source"];
+        if (typeof source !== "string" || !FORM_FIELD_SOURCES.includes(source)) {
+            problems.push(`${name} must have one of these sources: ${FORM_FIELD_SOURCES.join(", ")}.`);
+            return;
+        }
+        checkCommonProperties({
+            entry,
+            name,
+            targetType: data.targetType,
+            problems,
+        });
+        CHECKS_BY_SOURCE[source]({
+            entry,
+            name,
+            targetType: data.targetType,
+            problems,
+        });
+        // Each linked field, custom field and submitter detail is asked once.
+        if (source === FormFieldSource.TargetField) {
+            const key = String(entry["targetField"] || "");
+            if (key && targetFields.has(key)) {
+                problems.push(`${name} asks for a field another question already asks.`);
+            }
+            targetFields.add(key);
+        }
+        if (source === FormFieldSource.TargetCustomField) {
+            const key = String(entry["customFieldId"] || "").toLowerCase();
+            if (key && customFields.has(key)) {
+                problems.push(`${name} asks for a custom field another question already asks.`);
+            }
+            customFields.add(key);
+        }
+        if (source === FormFieldSource.Submitter) {
+            const key = String(entry["submitterField"] || "");
+            if (key && submitterFields.has(key)) {
+                problems.push(`${name} asks for a submitter detail another question already asks.`);
+            }
+            submitterFields.add(key);
+        }
+    });
+    // What the target cannot be created without, nothing else supplies.
+    for (const required of getFormTargetFieldsThatMustBeAsked(data.targetType)) {
+        const asking = data.value.find((entry) => {
+            return (isPlainObject(entry) &&
+                entry["source"] === FormFieldSource.TargetField &&
+                entry["targetField"] === required.key);
+        });
+        if (!asking) {
+            problems.push(`A form that creates ${FORM_TARGET_TYPE_TEXT[data.targetType].nounWithArticle} must ask for ${required.title}.`);
+        }
+        else if (asking["isRequired"] !== true) {
+            problems.push(`${required.title} must be required: ${FORM_TARGET_TYPE_TEXT[data.targetType].nounWithArticle} cannot be created without it.`);
+        }
+    }
+    if (problems.length === 0) {
+        return null;
+    }
+    const more = problems.length - MAX_LISTED_PROBLEMS;
+    return `${problems.slice(0, MAX_LISTED_PROBLEMS).join(" ")}${more > 0 ? ` And ${more} more ${more === 1 ? "problem" : "problems"}.` : ""}`;
+};
+// The options a new dropdown question starts with, as they are stored.
+export const getDefaultQuestionOptions = () => {
+    return serializeCustomFieldDropdownOptions([
+        { value: "Option 1" },
+        { value: "Option 2" },
+    ]);
+};
+/** A new question of the form's own. */
+export const createQuestionField = (data) => {
+    const field = {
+        id: data.id || generateFormFieldId(),
+        source: FormFieldSource.Question,
+        label: data.label,
+        isRequired: false,
+        type: data.type,
+    };
+    if (FORM_CHOICE_QUESTION_TYPES.includes(data.type)) {
+        field.dropdownOptions = data.dropdownOptions || getDefaultQuestionOptions();
+    }
+    return field;
+};
+/**
+ * A new question for a built-in field of the target, with the label and
+ * help text the catalog suggests. A field the target cannot do without and
+ * that nothing else supplies starts required.
+ */
+export const createTargetField = (data) => {
+    const field = {
+        id: data.id || generateFormFieldId(),
+        source: FormFieldSource.TargetField,
+        label: data.definition.defaultLabel,
+        isRequired: data.definition.isRequiredByTarget && !data.definition.hasDefault,
+        targetField: data.definition.key,
+    };
+    if (data.definition.defaultHelpText) {
+        field.helpText = data.definition.defaultHelpText;
+    }
+    return field;
+};
+/** A new question for one of the target's custom fields. */
+export const createCustomFieldField = (data) => {
+    const field = {
+        id: data.id || generateFormFieldId(),
+        source: FormFieldSource.TargetCustomField,
+        label: data.name.slice(0, FORM_FIELD_LABEL_MAX_LENGTH),
+        isRequired: false,
+        customFieldId: data.customFieldId.toLowerCase(),
+    };
+    const helpText = readOptionalText(data.description);
+    if (helpText) {
+        field.helpText = helpText.slice(0, FORM_FIELD_HELP_TEXT_MAX_LENGTH);
+    }
+    return field;
+};
+/** A new question for the submitter's name or email. */
+export const createSubmitterField = (data) => {
+    return {
+        id: data.id || generateFormFieldId(),
+        source: FormFieldSource.Submitter,
+        label: FORM_SUBMITTER_FIELD_DEFINITIONS[data.submitterField].defaultLabel,
+        isRequired: data.isRequired === true,
+        submitterField: data.submitterField,
+    };
+};
+/**
+ * The questions a new form starts with, so it works the moment it is
+ * created: the target's title, its description, every field it cannot do
+ * without (a maintenance event's start and end), and who is submitting -
+ * required, so the people who act on a submission can follow it up.
+ */
+export const getDefaultFormFields = (targetType) => {
+    const fields = [];
+    for (const definition of getFormTargetFields(targetType)) {
+        if (definition.key === "title" ||
+            definition.key === "description" ||
+            (definition.isRequiredByTarget && !definition.hasDefault)) {
+            const field = createTargetField({ definition });
+            // The title is what the people acting on it read first.
+            if (definition.key === "title") {
+                field.isRequired = true;
+            }
+            fields.push(field);
+        }
+    }
+    fields.push(createSubmitterField({
+        submitterField: FormSubmitterField.Name,
+        isRequired: true,
+    }), createSubmitterField({
+        submitterField: FormSubmitterField.Email,
+        isRequired: true,
+    }));
+    return fields;
+};
+/**
+ * The questions with the default labels and help texts of fields of what
+ * the form creates, and of the submitter's fields, put in the reader's
+ * language - so a form built in a German dashboard starts with German
+ * questions. Only a label or help text that is still exactly the English
+ * default is translated: one someone wrote is theirs, and stays as it is.
+ * A translation that comes back empty keeps the English.
+ */
+export const translateFormFieldDefaults = (data) => {
+    const translate = (text) => {
+        const translated = data.translate(text);
+        return typeof translated === "string" && translated.trim()
+            ? translated
+            : text;
+    };
+    return data.fields.map((field) => {
+        let defaultLabel = undefined;
+        let defaultHelpText = undefined;
+        if (field.source === FormFieldSource.TargetField && field.targetField) {
+            const definition = getFormTargetField(data.targetType, field.targetField);
+            defaultLabel = definition === null || definition === void 0 ? void 0 : definition.defaultLabel;
+            defaultHelpText = definition === null || definition === void 0 ? void 0 : definition.defaultHelpText;
+        }
+        else if (field.source === FormFieldSource.Submitter &&
+            field.submitterField &&
+            FORM_SUBMITTER_FIELD_DEFINITIONS[field.submitterField]) {
+            defaultLabel =
+                FORM_SUBMITTER_FIELD_DEFINITIONS[field.submitterField].defaultLabel;
+        }
+        const translated = Object.assign({}, field);
+        if (defaultLabel && field.label === defaultLabel) {
+            translated.label = translate(defaultLabel);
+        }
+        if (defaultHelpText && field.helpText === defaultHelpText) {
+            translated.helpText = translate(defaultHelpText);
+        }
+        return translated;
+    });
+};
+/**
+ * The questions of a form whose target changes, as they are kept for the
+ * new one. Nothing the submitter is asked disappears:
+ *
+ *   - a question of the form's own and a submitter detail stay as they are;
+ *   - a built-in field the new target also has stays linked to it (an
+ *     incident's title becomes the maintenance event's title), keeping only
+ *     the allowed records that still make sense, and is required when the
+ *     new target needs it;
+ *   - any other linked field - a built-in field the new target lacks, or
+ *     one of the old target's custom fields - becomes a question of the
+ *     form's own with the same label, help text and Required, answered the
+ *     same way (a choice of records becomes a short answer, since the
+ *     records belonged to the old target);
+ *
+ * and then every field the new target cannot do without is added at the
+ * end, required.
+ */
+export const convertFormFieldsForTarget = (data) => {
+    if (data.from === data.to) {
+        return data.fields.map((field) => {
+            return Object.assign({}, field);
+        });
+    }
+    const converted = data.fields.map((field) => {
+        if (field.source === FormFieldSource.Question ||
+            field.source === FormFieldSource.Submitter) {
+            return Object.assign({}, field);
+        }
+        if (field.source === FormFieldSource.TargetField) {
+            const before = getFormTargetField(data.from, field.targetField);
+            const after = getFormTargetField(data.to, field.targetField);
+            if (after &&
+                before &&
+                after.inputType === before.inputType &&
+                after.optionsSource === before.optionsSource) {
+                const kept = Object.assign({}, field);
+                if (after.isRequiredByTarget && !after.hasDefault) {
+                    kept.isRequired = true;
+                }
+                return kept;
+            }
+            const question = {
+                id: field.id,
+                source: FormFieldSource.Question,
+                label: field.label,
+                isRequired: field.isRequired,
+                type: before && !isChoiceTargetField(before)
+                    ? before.inputType
+                    : CustomFieldType.Text,
+            };
+            if (field.helpText) {
+                question.helpText = field.helpText;
+            }
+            return question;
+        }
+        // A custom field of the old target.
+        const question = {
+            id: field.id,
+            source: FormFieldSource.Question,
+            label: field.label,
+            isRequired: field.isRequired,
+            type: CustomFieldType.Text,
+        };
+        if (field.helpText) {
+            question.helpText = field.helpText;
+        }
+        return question;
+    });
+    for (const definition of getFormTargetFieldsThatMustBeAsked(data.to)) {
+        const exists = converted.some((field) => {
+            return (field.source === FormFieldSource.TargetField &&
+                field.targetField === definition.key);
+        });
+        if (!exists) {
+            converted.push(createTargetField({ definition }));
+        }
+    }
+    return converted;
+};
+// The question that asks for a built-in field of the target, if any.
+export const findTargetField = (fields, key) => {
+    return fields.find((field) => {
+        return (field.source === FormFieldSource.TargetField && field.targetField === key);
+    });
+};
+// The question that asks for one of the target's custom fields, if any.
+export const findCustomFieldField = (fields, customFieldId) => {
+    const id = customFieldId.toLowerCase();
+    return fields.find((field) => {
+        return (field.source === FormFieldSource.TargetCustomField &&
+            field.customFieldId === id);
+    });
+};
+// The question that asks for the submitter's name or email, if any.
+export const findSubmitterField = (fields, submitterField) => {
+    return fields.find((field) => {
+        return (field.source === FormFieldSource.Submitter &&
+            field.submitterField === submitterField);
+    });
+};
+//# sourceMappingURL=FormField.js.map