@researchdatabox/sails-ng-common 0.2.1 → 5.0.0-RC1

package/dist/src/config/component/publish-data-location-selector.outline.d.ts

@@ -0,0 +1,110 @@
+import { FieldComponentConfigFrameKindType, FieldComponentConfigKindType, FieldComponentDefinitionFrameKindType, FieldComponentDefinitionKindType, FieldModelConfigFrameKindType, FieldModelConfigKindType, FieldModelDefinitionFrameKindType, FieldModelDefinitionKindType, FormComponentDefinitionFrameKindType, FormComponentDefinitionKindType } from "../shared.outline";
+import { FieldComponentConfigFrame, FieldComponentConfigOutline, FieldComponentDefinitionFrame, FieldComponentDefinitionOutline } from "../field-component.outline";
+import { FieldModelConfigFrame, FieldModelConfigOutline, FieldModelDefinitionFrame, FieldModelDefinitionOutline } from "../field-model.outline";
+import { FormComponentDefinitionFrame, FormComponentDefinitionOutline } from "../form-component.outline";
+import { AvailableFieldLayoutDefinitionFrames, AvailableFieldLayoutDefinitionOutlines, AvailableFormComponentDefinitionFrames, AvailableFormComponentDefinitionOutlines } from "../dictionary.outline";
+import { DataLocationAttachmentValue, DataLocationFileValue, DataLocationOption, DataLocationPhysicalValue, DataLocationUrlValue } from "./data-location.outline";
+export declare const PublishDataLocationSelectorComponentName: "PublishDataLocationSelectorComponent";
+export type PublishDataLocationSelectorComponentNameType = typeof PublishDataLocationSelectorComponentName;
+export declare const PublishDataLocationSelectorModelName: "PublishDataLocationSelectorModel";
+export type PublishDataLocationSelectorModelNameType = typeof PublishDataLocationSelectorModelName;
+export interface PublishDataLocationSelectorValueState {
+    selected?: boolean;
+}
+export type PublishDataLocationValueType = (DataLocationUrlValue & PublishDataLocationSelectorValueState) | (DataLocationPhysicalValue & PublishDataLocationSelectorValueState) | (DataLocationFileValue & PublishDataLocationSelectorValueState) | (DataLocationAttachmentValue & PublishDataLocationSelectorValueState);
+export type PublishDataLocationModelValueType = PublishDataLocationValueType[];
+export type PublishDataLocationSelectionCriterion = Record<string, string>;
+export interface PublishDataLocationSelectorFieldComponentConfigFrame extends FieldComponentConfigFrame {
+    columns?: string[] | Record<string, unknown>[];
+    editNotesButtonText?: string;
+    editNotesTitle?: string;
+    cancelEditNotesButtonText?: string;
+    applyEditNotesButtonText?: string;
+    editNotesCssClasses?: string;
+    typeHeader?: string;
+    locationHeader?: string;
+    notesHeader?: string;
+    iscHeader?: string;
+    iscEnabled?: boolean;
+    notesEnabled?: boolean;
+    metadataOnlyTitle?: string;
+    metadataOnlyBody?: string;
+    noLocationsAvailableTitle?: string;
+    noLocationsAvailableBody?: string;
+    selectionSummaryTemplate?: string;
+    headerActions?: AvailableFormComponentDefinitionFrames[];
+    publicCheck?: string;
+    selectionCriteria?: PublishDataLocationSelectionCriterion[];
+    dataTypes?: DataLocationOption[];
+    dataTypeLookup?: Record<string, string>;
+}
+export interface PublishDataLocationSelectorFieldComponentConfigOutline extends PublishDataLocationSelectorFieldComponentConfigFrame, FieldComponentConfigOutline {
+    headerActions?: AvailableFormComponentDefinitionOutlines[];
+}
+export interface PublishDataLocationSelectorFieldComponentDefinitionFrame extends FieldComponentDefinitionFrame {
+    class: PublishDataLocationSelectorComponentNameType;
+    config?: PublishDataLocationSelectorFieldComponentConfigFrame;
+}
+export interface PublishDataLocationSelectorFieldComponentDefinitionOutline extends PublishDataLocationSelectorFieldComponentDefinitionFrame, FieldComponentDefinitionOutline {
+    class: PublishDataLocationSelectorComponentNameType;
+    config?: PublishDataLocationSelectorFieldComponentConfigOutline;
+}
+export interface PublishDataLocationSelectorFieldModelConfigFrame extends FieldModelConfigFrame<PublishDataLocationModelValueType> {
+}
+export interface PublishDataLocationSelectorFieldModelConfigOutline extends PublishDataLocationSelectorFieldModelConfigFrame, FieldModelConfigOutline<PublishDataLocationModelValueType> {
+}
+export interface PublishDataLocationSelectorFieldModelDefinitionFrame extends FieldModelDefinitionFrame<PublishDataLocationModelValueType> {
+    class: PublishDataLocationSelectorModelNameType;
+    config?: PublishDataLocationSelectorFieldModelConfigFrame;
+}
+export interface PublishDataLocationSelectorFieldModelDefinitionOutline extends PublishDataLocationSelectorFieldModelDefinitionFrame, FieldModelDefinitionOutline<PublishDataLocationModelValueType> {
+    class: PublishDataLocationSelectorModelNameType;
+    config?: PublishDataLocationSelectorFieldModelConfigOutline;
+}
+export interface PublishDataLocationSelectorFormComponentDefinitionFrame extends FormComponentDefinitionFrame {
+    component: PublishDataLocationSelectorFieldComponentDefinitionFrame;
+    model?: PublishDataLocationSelectorFieldModelDefinitionFrame;
+    layout?: AvailableFieldLayoutDefinitionFrames;
+}
+/**
+ * Selects a configured data location for publication workflows.
+ *
+ * @extensionPoint Use `PublishDataLocationSelectorComponent` with its model to bind publishable location choices.
+ * @see https://github.com/redbox-mint/redbox-portal/wiki/Configuring-Record-Forms
+ */
+export interface PublishDataLocationSelectorFormComponentDefinitionOutline extends PublishDataLocationSelectorFormComponentDefinitionFrame, FormComponentDefinitionOutline {
+    component: PublishDataLocationSelectorFieldComponentDefinitionOutline;
+    model?: PublishDataLocationSelectorFieldModelDefinitionOutline;
+    layout?: AvailableFieldLayoutDefinitionOutlines;
+}
+export type PublishDataLocationSelectorTypes = {
+    kind: FieldComponentConfigFrameKindType;
+    class: PublishDataLocationSelectorFieldComponentConfigFrame;
+} | {
+    kind: FieldComponentDefinitionFrameKindType;
+    class: PublishDataLocationSelectorFieldComponentDefinitionFrame;
+} | {
+    kind: FieldModelConfigFrameKindType;
+    class: PublishDataLocationSelectorFieldModelConfigFrame;
+} | {
+    kind: FieldModelDefinitionFrameKindType;
+    class: PublishDataLocationSelectorFieldModelDefinitionFrame;
+} | {
+    kind: FormComponentDefinitionFrameKindType;
+    class: PublishDataLocationSelectorFormComponentDefinitionFrame;
+} | {
+    kind: FieldComponentConfigKindType;
+    class: PublishDataLocationSelectorFieldComponentConfigOutline;
+} | {
+    kind: FieldComponentDefinitionKindType;
+    class: PublishDataLocationSelectorFieldComponentDefinitionOutline;
+} | {
+    kind: FieldModelConfigKindType;
+    class: PublishDataLocationSelectorFieldModelConfigOutline;
+} | {
+    kind: FieldModelDefinitionKindType;
+    class: PublishDataLocationSelectorFieldModelDefinitionOutline;
+} | {
+    kind: FormComponentDefinitionKindType;
+    class: PublishDataLocationSelectorFormComponentDefinitionOutline;
+};

package/dist/src/config/component/publish-data-location-selector.outline.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishDataLocationSelectorModelName = exports.PublishDataLocationSelectorComponentName = void 0;
+exports.PublishDataLocationSelectorComponentName = "PublishDataLocationSelectorComponent";
+exports.PublishDataLocationSelectorModelName = "PublishDataLocationSelectorModel";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaC1kYXRhLWxvY2F0aW9uLXNlbGVjdG9yLm91dGxpbmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29uZmlnL2NvbXBvbmVudC9wdWJsaXNoLWRhdGEtbG9jYXRpb24tc2VsZWN0b3Iub3V0bGluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUF1Q2EsUUFBQSx3Q0FBd0MsR0FBRyxzQ0FBK0MsQ0FBQztBQUczRixRQUFBLG9DQUFvQyxHQUFHLGtDQUEyQyxDQUFDIn0=

package/dist/src/config/component/question-tree.helper.d.ts

@@ -0,0 +1,58 @@
+import { QuestionTreeFieldComponentDefinitionOutline, QuestionTreeMeta, QuestionTreeQuestion, QuestionTreeQuestionRules } from "./question-tree.outline";
+import { ReusableFormComponentDefinitionFrame } from "./reusable.outline";
+import { LineagePaths } from "../names/naming-helpers";
+import { ILogger } from "../../logger.interface";
+export declare class QuestionTreeHelper {
+    private readonly logName;
+    private readonly defaultQuestionTreeLabelPrefix;
+    private readonly logger;
+    constructor(logger: ILogger);
+    validateQuestions(questions: QuestionTreeQuestion[]): {
+        errors: string[];
+        questionAnswerValuesMap: {
+            [k: string]: string[];
+        };
+    };
+    /**
+     * Validate a question tree's questions to ensure they are internally consistent.
+     * @param question A question tree question definition.
+     * @param questionIndex The question index.
+     * @param availableOutcomeValues The available outcome ids.
+     * @param availableMeta The available meta data.
+     * @param questionAnswerValuesMap A map of question answer values.
+     * @return An array of errors, an empty array indicates no errors.
+     */
+    validateQuestion(question: QuestionTreeQuestion, questionIndex: number, availableOutcomeValues: string[], availableMeta: QuestionTreeMeta, questionAnswerValuesMap: {
+        [k: string]: string[];
+    }): string[];
+    /**
+     * Transform a question tree question to a reusable form definition to be used in the form config.
+     * @param name The question tree name.
+     * @param lineagePath The question tree lineage path.
+     * @param item The question tree component config.
+     * @param modelData The full question tree model data.
+     * @param questionId The question config to transform.
+     * @param questions The questions config.
+     * @return A reusable form definition representing the question and available answers.
+     */
+    transformQuestionConfig(name: string, lineagePath: LineagePaths, item: QuestionTreeFieldComponentDefinitionOutline, modelData: unknown, questionId: string, questions: QuestionTreeQuestion[]): ReusableFormComponentDefinitionFrame;
+    private questionLabelPrefix;
+    private questionLabelKey;
+    private questionHelpKey;
+    private questionAnswerLabelKey;
+}
+/**
+ * Determine whether a question should be 'activated' based on the provided question tree form model data.
+ * - An activated question is visible and can have a non-null data model. A question is active if its rules evaluate to true.
+ * - A deactivated question is not visible and its form model data must be null.
+ * @param questionId The question id.
+ * @param questions The questions config.
+ * @param data The current question tree form data.
+ */
+export declare function isQuestionTreeQuestionActivated(questionId: string, questions: QuestionTreeQuestion[], data: Record<string, unknown>): boolean;
+/**
+ * Determine whether a rule is true given the data.
+ * @param rule The question tree question rule to check.
+ * @param data The question tree data.
+ */
+export declare function isQuestionTreeQuestionRuleTrue(rule: QuestionTreeQuestionRules, data: Record<string, unknown>): boolean;

package/dist/src/config/component/question-tree.helper.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTreeHelper = void 0;
+exports.isQuestionTreeQuestionActivated = isQuestionTreeQuestionActivated;
+exports.isQuestionTreeQuestionRuleTrue = isQuestionTreeQuestionRuleTrue;
+const helpers_1 = require("../helpers");
+class QuestionTreeHelper {
+    logName = "QuestionTreeHelper";
+    defaultQuestionTreeLabelPrefix = "questiontree";
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    validateQuestions(questions) {
+        // Prepare question and answer info to assist checking for valid structure
+        const questionAnswerValuesMap = Object.fromEntries(questions?.map(question => [question.id, question.answers.map(answer => answer.value)]));
+        const errors = [];
+        const duplicateQuestionIds = new Set(Object.keys(questionAnswerValuesMap).filter((e, i, a) => a.indexOf(e) !== i));
+        if (duplicateQuestionIds.size > 0) {
+            errors.push(`Question ids must be unique, these were not ${Array.from(duplicateQuestionIds).sort().join(', ')}.`);
+        }
+        return { errors, questionAnswerValuesMap };
+    }
+    /**
+     * Validate a question tree's questions to ensure they are internally consistent.
+     * @param question A question tree question definition.
+     * @param questionIndex The question index.
+     * @param availableOutcomeValues The available outcome ids.
+     * @param availableMeta The available meta data.
+     * @param questionAnswerValuesMap A map of question answer values.
+     * @return An array of errors, an empty array indicates no errors.
+     */
+    validateQuestion(question, questionIndex, availableOutcomeValues, availableMeta, questionAnswerValuesMap) {
+        const id = question.id;
+        const answersMin = question.answersMin;
+        const answersMax = question.answersMax;
+        const answers = question.answers;
+        const rules = question.rules;
+        const errors = [];
+        // validate question structure
+        if (!id) {
+            errors.push(`Question ${questionIndex + 1} has no id.`);
+        }
+        const msgQ = `Question ${questionIndex + 1} '${id}'`;
+        if (answersMin < 1 || answersMin > answersMax) {
+            errors.push(`${msgQ} answer min (${answersMin}) must be 1 or greater and equal or less than max (${answersMax}).`);
+        }
+        if (answersMax < 1 || answersMin > answersMax || answersMax > answers.length) {
+            errors.push(`${msgQ} answer max (${answersMax}) must be 1 or greater, equal or greater than min (${answersMin}), and equal or less than the number of answers (${answers.length}).`);
+        }
+        if (answers.length < 1) {
+            errors.push(`${msgQ} must have at least one answer.`);
+        }
+        if (Object.keys(rules).length === 0) {
+            // Must have at least one rule - add a rule that always matches, so the question always shows.
+            rules.op = "true";
+        }
+        // All answer outcome property keys and values must match a defined outcome.
+        answers.forEach((answer, answerIndex) => {
+            const outcome = answer.outcome;
+            if (outcome && !availableOutcomeValues.includes(outcome)) {
+                errors.push(`${msgQ} answer ${answerIndex + 1} '${answer.value}' outcome is unknown '${outcome}', available are '${availableOutcomeValues.join(', ')}'.`);
+            }
+            const meta = answer.meta ?? {};
+            for (const [metaKey, metaValue] of Object.entries(meta)) {
+                if (!(metaKey in availableMeta)) {
+                    errors.push(`${msgQ} answer ${answerIndex + 1} '${answer.value}' meta key is unknown '${metaKey}', available are '${Object.keys(availableMeta).join(', ')}'.`);
+                }
+                if (availableMeta[metaKey] && !(metaValue in availableMeta[metaKey])) {
+                    errors.push(`${msgQ} answer ${answerIndex + 1} '${answer.value}' meta key '${metaKey}' has unknown value '${metaValue}', available are '${Object.values(availableMeta).join(', ')}'.`);
+                }
+            }
+        });
+        // All rules that reference questions or answer values must use valid values.
+        const rulesToCheck = [rules];
+        while (rulesToCheck.length > 0) {
+            const currentRule = rulesToCheck.shift();
+            if (!currentRule) {
+                continue;
+            }
+            switch (currentRule.op) {
+                case "true":
+                    continue;
+                case "and":
+                case "or":
+                    rulesToCheck.push(...currentRule.args);
+                    break;
+                case "in":
+                case "notin":
+                case "only":
+                    if (!(currentRule.q in questionAnswerValuesMap)) {
+                        errors.push(`${msgQ} rule op '${currentRule.op}' references an invalid question id '${currentRule.q}'.`);
+                    }
+                    const questionAnswers = questionAnswerValuesMap[currentRule.q];
+                    for (const ruleAnswerValue of currentRule.a) {
+                        if (!questionAnswers.includes(ruleAnswerValue)) {
+                            errors.push(`${msgQ} rule op '${currentRule.op}' question '${currentRule.q}' references an invalid answer value '${ruleAnswerValue}'.`);
+                        }
+                    }
+                    break;
+                default:
+                    // Setting currentRule to a variable typed with never ensures that all possible switch cases
+                    // are present. TypeScript compile will fail if there are any possible cases missing.
+                    const _unexpected = currentRule;
+                    errors.push(`${msgQ} unknown rule ${JSON.stringify(_unexpected)}.`);
+                    break;
+            }
+        }
+        return errors;
+    }
+    /**
+     * Transform a question tree question to a reusable form definition to be used in the form config.
+     * @param name The question tree name.
+     * @param lineagePath The question tree lineage path.
+     * @param item The question tree component config.
+     * @param modelData The full question tree model data.
+     * @param questionId The question config to transform.
+     * @param questions The questions config.
+     * @return A reusable form definition representing the question and available answers.
+     */
+    transformQuestionConfig(name, lineagePath, item, modelData, questionId, questions) {
+        if (!lineagePath.angularComponentsJsonPointer) {
+            throw new Error(`${this.logName}: Did not provide lineage path JSON pointer ${JSON.stringify({
+                name, lineagePath, item
+            })}`);
+        }
+        if (modelData !== undefined && ((0, helpers_1.guessType)(modelData) !== 'object' || typeof modelData !== 'object')) {
+            throw new Error(`${this.logName}: Expected model data to be an object, but got ${modelData}`);
+        }
+        const question = questions.find(q => q.id === questionId);
+        if (question === undefined) {
+            throw new Error(`${this.logName}: Could not find question id ${questionId}`);
+        }
+        const id = questionId;
+        const answersMax = question.answersMax;
+        const answers = question.answers;
+        const isVisible = isQuestionTreeQuestionActivated(id, questions, modelData);
+        // build reusable component
+        const hasOneAnswer = answersMax === 1;
+        const componentOptions = answers.map(a => {
+            return { value: a.value, label: this.questionAnswerLabelKey(name, id, a.value, a.label) };
+        });
+        const questionLabel = this.questionLabelKey(name, id, question.label);
+        const questionHelpText = this.questionHelpKey(name, id);
+        const componentAnswerOne = {
+            overrides: { reusableFormName: "questiontree-answer-one" },
+            name: "",
+            component: {
+                class: "ReusableComponent", config: {
+                    componentDefinitions: [
+                        {
+                            name: "questiontree_answer_one",
+                            overrides: { replaceName: id },
+                            layout: {
+                                class: "DefaultLayout",
+                                config: { label: questionLabel, helpText: questionHelpText, visible: isVisible }
+                            },
+                            component: { class: "RadioInputComponent", config: { options: componentOptions, visible: isVisible } },
+                        },
+                    ],
+                },
+            },
+        };
+        const componentAnswerMore = {
+            overrides: { reusableFormName: "questiontree-answer-one-more" },
+            name: "",
+            component: {
+                class: 'ReusableComponent',
+                config: {
+                    componentDefinitions: [
+                        {
+                            name: 'questiontree_answer_one_more',
+                            overrides: { replaceName: id },
+                            layout: {
+                                class: 'DefaultLayout',
+                                config: { label: questionLabel, helpText: questionHelpText, visible: isVisible }
+                            },
+                            component: { class: 'CheckboxInputComponent', config: { options: componentOptions, visible: isVisible } },
+                        },
+                    ],
+                },
+            },
+        };
+        return hasOneAnswer ? componentAnswerOne : componentAnswerMore;
+    }
+    questionLabelPrefix(componentName) {
+        return (componentName ?? "").trim().replace(/^@+/, "") || this.defaultQuestionTreeLabelPrefix;
+    }
+    questionLabelKey(componentName, questionId, questionLabel) {
+        if (!!questionLabel?.trim()) {
+            return questionLabel;
+        }
+        const keyPrefix = this.questionLabelPrefix(componentName);
+        return `@${keyPrefix}-item-${questionId}-label`;
+    }
+    questionHelpKey(componentName, questionId) {
+        const keyPrefix = this.questionLabelPrefix(componentName);
+        return `@${keyPrefix}-item-${questionId}-help`;
+    }
+    questionAnswerLabelKey(componentName, questionId, answerValue, answerLabel) {
+        if (!!answerLabel?.trim()) {
+            return answerLabel;
+        }
+        const keyPrefix = this.questionLabelPrefix(componentName);
+        return `@${keyPrefix}-item-${questionId}-${answerValue}-label`;
+    }
+}
+exports.QuestionTreeHelper = QuestionTreeHelper;
+/**
+ * Determine whether a question should be 'activated' based on the provided question tree form model data.
+ * - An activated question is visible and can have a non-null data model. A question is active if its rules evaluate to true.
+ * - A deactivated question is not visible and its form model data must be null.
+ * @param questionId The question id.
+ * @param questions The questions config.
+ * @param data The current question tree form data.
+ */
+function isQuestionTreeQuestionActivated(questionId, questions, data) {
+    const questionIdsToCheck = [questionId];
+    while (questionIdsToCheck.length > 0) {
+        const currentQuestionId = questionIdsToCheck.shift();
+        const currentQuestion = questions.find(q => q.id === currentQuestionId);
+        if (currentQuestion === undefined) {
+            return false;
+        }
+        const rulesToCheck = [currentQuestion?.rules];
+        while (rulesToCheck.length > 0) {
+            const currentRule = rulesToCheck.shift();
+            if (currentRule === undefined) {
+                return false;
+            }
+            if (!isQuestionTreeQuestionRuleTrue(currentRule, data)) {
+                return false;
+            }
+            switch (currentRule?.op) {
+                case "true":
+                    continue;
+                case "and":
+                    rulesToCheck.push(...currentRule.args);
+                    continue;
+                case "or":
+                    rulesToCheck.push(...currentRule.args.filter(rule => isQuestionTreeQuestionRuleTrue(rule, data)));
+                    continue;
+                case "in":
+                case "notin":
+                case "only":
+                    if (currentRule.q) {
+                        questionIdsToCheck.push(currentRule.q);
+                    }
+                    continue;
+                default:
+                    throw new Error(`Unknown question tree question rule ${JSON.stringify(currentRule)}.`);
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Determine whether a rule is true given the data.
+ * @param rule The question tree question rule to check.
+ * @param data The question tree data.
+ */
+function isQuestionTreeQuestionRuleTrue(rule, data) {
+    switch (rule.op) {
+        case "true":
+            return true;
+        case "and":
+            return rule.args.every(rule => isQuestionTreeQuestionRuleTrue(rule, data));
+        case "or":
+            return rule.args.some(rule => isQuestionTreeQuestionRuleTrue(rule, data));
+        case "in":
+            const valueIn = data?.[rule.q] ?? "";
+            const actualIn = Array.isArray(valueIn) ? valueIn : [valueIn];
+            const expectedIn = Array.isArray(rule.a) ? rule.a : [rule.a];
+            return expectedIn.every(e => actualIn.filter(a => !!a).includes(e));
+        case "notin":
+            const valueNotIn = data?.[rule.q] ?? "";
+            const actualNotIn = Array.isArray(valueNotIn) ? valueNotIn : [valueNotIn];
+            const expectedNotIn = Array.isArray(rule.a) ? rule.a : [rule.a];
+            return expectedNotIn.every(e => !actualNotIn.filter(a => !!a).includes(e));
+        case "only":
+            const valueOnly = data?.[rule.q] ?? "";
+            const actualOnly = Array.isArray(valueOnly) ? valueOnly : [valueOnly];
+            const expectedOnly = Array.isArray(rule.a) ? rule.a : [rule.a];
+            return actualOnly.length === expectedOnly.length &&
+                expectedOnly.every(e => actualOnly.filter(a => !!a).includes(e)) &&
+                actualOnly.every(a => expectedOnly.filter(e => !!e).includes(a));
+        default:
+            throw new Error(`Unknown question tree question rule ${JSON.stringify(rule)}.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"question-tree.helper.js","sourceRoot":"","sources":["../../../../src/config/component/question-tree.helper.ts"],"names":[],"mappings":"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"}

package/dist/src/config/component/question-tree.model.d.ts

@@ -0,0 +1,64 @@
+import { FieldComponentConfig, FieldComponentDefinition } from "../field-component.model";
+import { FieldModelConfig, FieldModelDefinition } from "../field-model.model";
+import { FormComponentDefinition } from "../form-component.model";
+import { FormConfigVisitorOutline } from "../visitor/base.outline";
+import { QuestionTreeFieldComponentConfigOutline, QuestionTreeFieldComponentDefinitionOutline, QuestionTreeFieldModelConfigOutline, QuestionTreeFieldModelDefinitionOutline, QuestionTreeFormComponentDefinitionOutline, QuestionTreeModelValueType, QuestionTreeOutcome, QuestionTreeMeta, QuestionTreeQuestion } from "./question-tree.outline";
+import { AvailableFieldLayoutDefinitionOutlines, AvailableFormComponentDefinitionOutlines } from "../dictionary.outline";
+export declare class QuestionTreeFieldComponentConfig extends FieldComponentConfig implements QuestionTreeFieldComponentConfigOutline {
+    availableOutcomes: QuestionTreeOutcome[];
+    availableMeta?: QuestionTreeMeta;
+    questions: QuestionTreeQuestion[];
+    componentDefinitions: AvailableFormComponentDefinitionOutlines[];
+    constructor();
+}
+export declare class QuestionTreeFieldComponentDefinition extends FieldComponentDefinition implements QuestionTreeFieldComponentDefinitionOutline {
+    class: "QuestionTreeComponent";
+    config?: QuestionTreeFieldComponentConfigOutline;
+    constructor();
+    accept(visitor: FormConfigVisitorOutline): Promise<void>;
+}
+export declare class QuestionTreeFieldModelConfig extends FieldModelConfig<QuestionTreeModelValueType> implements QuestionTreeFieldModelConfigOutline {
+    constructor();
+}
+export declare class QuestionTreeFieldModelDefinition extends FieldModelDefinition<QuestionTreeModelValueType> implements QuestionTreeFieldModelDefinitionOutline {
+    class: "QuestionTreeModel";
+    config?: QuestionTreeFieldModelConfigOutline;
+    constructor();
+    accept(visitor: FormConfigVisitorOutline): Promise<void>;
+}
+export declare class QuestionTreeFormComponentDefinition extends FormComponentDefinition implements QuestionTreeFormComponentDefinitionOutline {
+    component: QuestionTreeFieldComponentDefinitionOutline;
+    model?: QuestionTreeFieldModelDefinitionOutline;
+    layout?: AvailableFieldLayoutDefinitionOutlines;
+    constructor();
+    accept(visitor: FormConfigVisitorOutline): Promise<void>;
+}
+export declare const QuestionTreeMap: ({
+    kind: "FieldComponentConfigKind";
+    def: typeof QuestionTreeFieldComponentConfig;
+    class?: undefined;
+} | {
+    kind: "FieldComponentDefinitionKind";
+    def: typeof QuestionTreeFieldComponentDefinition;
+    class: "QuestionTreeComponent";
+} | {
+    kind: "FieldModelConfigKind";
+    def: typeof QuestionTreeFieldModelConfig;
+    class?: undefined;
+} | {
+    kind: "FieldModelDefinitionKind";
+    def: typeof QuestionTreeFieldModelDefinition;
+    class: "QuestionTreeModel";
+} | {
+    kind: "FormComponentDefinitionKind";
+    def: typeof QuestionTreeFormComponentDefinition;
+    class: "QuestionTreeComponent";
+})[];
+export declare const QuestionTreeDefaults: {
+    FormComponentDefinitionKind: {
+        QuestionTreeComponent: {
+            FieldComponentDefinitionKind: "QuestionTreeComponent";
+            FieldModelDefinitionKind: "QuestionTreeModel";
+        };
+    };
+};

package/dist/src/config/component/question-tree.model.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionTreeDefaults = exports.QuestionTreeMap = exports.QuestionTreeFormComponentDefinition = exports.QuestionTreeFieldModelDefinition = exports.QuestionTreeFieldModelConfig = exports.QuestionTreeFieldComponentDefinition = exports.QuestionTreeFieldComponentConfig = void 0;
+const field_component_model_1 = require("../field-component.model");
+const field_model_model_1 = require("../field-model.model");
+const form_component_model_1 = require("../form-component.model");
+const shared_outline_1 = require("../shared.outline");
+const question_tree_outline_1 = require("./question-tree.outline");
+/* QuestionTree Component */
+class QuestionTreeFieldComponentConfig extends field_component_model_1.FieldComponentConfig {
+    availableOutcomes;
+    availableMeta;
+    questions;
+    componentDefinitions;
+    constructor() {
+        super();
+        this.availableOutcomes = [];
+        this.questions = [];
+        this.componentDefinitions = [];
+    }
+}
+exports.QuestionTreeFieldComponentConfig = QuestionTreeFieldComponentConfig;
+class QuestionTreeFieldComponentDefinition extends field_component_model_1.FieldComponentDefinition {
+    class = question_tree_outline_1.QuestionTreeComponentName;
+    config;
+    constructor() {
+        super();
+    }
+    async accept(visitor) {
+        await visitor.visitQuestionTreeFieldComponentDefinition(this);
+    }
+}
+exports.QuestionTreeFieldComponentDefinition = QuestionTreeFieldComponentDefinition;
+/* QuestionTree Model */
+class QuestionTreeFieldModelConfig extends field_model_model_1.FieldModelConfig {
+    constructor() {
+        super();
+    }
+}
+exports.QuestionTreeFieldModelConfig = QuestionTreeFieldModelConfig;
+class QuestionTreeFieldModelDefinition extends field_model_model_1.FieldModelDefinition {
+    class = question_tree_outline_1.QuestionTreeModelName;
+    config;
+    constructor() {
+        super();
+    }
+    async accept(visitor) {
+        await visitor.visitQuestionTreeFieldModelDefinition(this);
+    }
+}
+exports.QuestionTreeFieldModelDefinition = QuestionTreeFieldModelDefinition;
+/* QuestionTree Form Component */
+class QuestionTreeFormComponentDefinition extends form_component_model_1.FormComponentDefinition {
+    component;
+    model;
+    layout;
+    constructor() {
+        super();
+    }
+    async accept(visitor) {
+        await visitor.visitQuestionTreeFormComponentDefinition(this);
+    }
+}
+exports.QuestionTreeFormComponentDefinition = QuestionTreeFormComponentDefinition;
+exports.QuestionTreeMap = [
+    { kind: shared_outline_1.FieldComponentConfigKind, def: QuestionTreeFieldComponentConfig },
+    { kind: shared_outline_1.FieldComponentDefinitionKind, def: QuestionTreeFieldComponentDefinition, class: question_tree_outline_1.QuestionTreeComponentName },
+    { kind: shared_outline_1.FieldModelConfigKind, def: QuestionTreeFieldModelConfig },
+    { kind: shared_outline_1.FieldModelDefinitionKind, def: QuestionTreeFieldModelDefinition, class: question_tree_outline_1.QuestionTreeModelName },
+    { kind: shared_outline_1.FormComponentDefinitionKind, def: QuestionTreeFormComponentDefinition, class: question_tree_outline_1.QuestionTreeComponentName },
+];
+exports.QuestionTreeDefaults = {
+    [shared_outline_1.FormComponentDefinitionKind]: {
+        [question_tree_outline_1.QuestionTreeComponentName]: {
+            [shared_outline_1.FieldComponentDefinitionKind]: question_tree_outline_1.QuestionTreeComponentName,
+            [shared_outline_1.FieldModelDefinitionKind]: question_tree_outline_1.QuestionTreeModelName,
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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