@progress/sitefinity-nextjs-sdk/widgets/form/rules/form-rules-settings.js

Provides OOB widgets developed using the Next.js framework, which includes an abstraction layer for Sitefinity communication. Additionally, it offers an expanded API, typings, and tools for further development and integration.

import { ConditionEvaluator } from './condition-evaluator';
import { FieldSelector } from './field-selector';
import { addActionExecutors } from './rule-objects/add-action-executors';
import { addConditionEvaluators } from './rule-objects/add-contitional-evaluators';
import { addFieldSelectors } from './rule-objects/add-field-selectors';
import { addValueParsers } from './rule-objects/add-value-parsers';
import { ValueParser } from './value-parser';
export class FormRulesSettings {
    ConditionEvaluators = [];
    InputTypeParsers = [];
    RuleValueParsers = [];
    FieldSelectors = [];
    ActionExecutors = [];
    constructor() {
        addActionExecutors(this);
        addConditionEvaluators(this);
        addFieldSelectors(this);
        addValueParsers(this);
    }
    addConditionEvaluator(name, conditionEvaluator) {
        this.ConditionEvaluators.push(new ConditionEvaluator(name, conditionEvaluator, this));
    }
    removeConditionEvaluator(name) {
        for (let i = 0; i < this.ConditionEvaluators.length; i++) {
            if (this.ConditionEvaluators[i].name === name) {
                this.ConditionEvaluators.splice(i, 1);
                break;
            }
        }
    }
    processConditionEvaluator(name, inputType, currentValue, ruleValue) {
        for (let i = 0; i < this.ConditionEvaluators.length; i++) {
            if (this.ConditionEvaluators[i].canProcess(name)) {
                return this.ConditionEvaluators[i].process(currentValue, ruleValue, inputType);
            }
        }
        return false;
    }
    getConditionEvaluator(name) {
        for (let i = 0; i < this.ConditionEvaluators.length; i++) {
            if (this.ConditionEvaluators[i].canProcess(name)) {
                return this.ConditionEvaluators[i];
            }
        }
        return null;
    }
    addActionExecutor(actionName, actionExecutor) {
        this.ActionExecutors.push({ actionName: actionName, actionExecutor: actionExecutor });
    }
    removeActionExecutor(actionName) {
        this.ActionExecutors = this.ActionExecutors.filter(function (a) {
            return a.actionName !== actionName;
        });
    }
    getActionExecutor(actionName) {
        const entry = this.ActionExecutors.filter(function (a) {
            return a.actionName === actionName;
        })[0];
        if (entry) {
            return entry.actionExecutor;
        }
        return null;
    }
    addInputTypeParser(inputType, parser, escape, escapeRegEx) {
        this.InputTypeParsers.push(new ValueParser(inputType, parser, escape, escapeRegEx));
    }
    removeInputTypeParser(inputType) {
        for (let i = 0; i < this.InputTypeParsers.length; i++) {
            if (this.InputTypeParsers[i].inputType === inputType) {
                this.InputTypeParsers.splice(i, 1);
                break;
            }
        }
    }
    addRuleValueParser(inputType, parser, escape, escapeRegEx) {
        this.RuleValueParsers.push(new ValueParser(inputType, parser, escape, escapeRegEx));
    }
    removeRuleValueParser(inputType) {
        for (let i = 0; i < this.RuleValueParsers.length; i++) {
            if (this.RuleValueParsers[i].inputType === inputType) {
                this.RuleValueParsers.splice(i, 1);
                break;
            }
        }
    }
    addFieldSelector(fieldContainerDataSfRole, elementSelector, additionalFilter) {
        let element = this.FieldSelectors.map(function (e) {
            return e.fieldContainerDataSfRole;
        }).indexOf(fieldContainerDataSfRole);
        if (element > -1) {
            throw 'Container with attribute [data-sf-role=\'' + fieldContainerDataSfRole + '\'] have been registered already.';
        }
        else {
            this.FieldSelectors.push(new FieldSelector(fieldContainerDataSfRole, elementSelector, additionalFilter));
        }
    }
    removeFieldSelector(fieldContainerDataSfRole) {
        for (let i = 0; i < this.FieldSelectors.length; i++) {
            if (this.FieldSelectors[i].fieldContainerDataSfRole === fieldContainerDataSfRole) {
                this.FieldSelectors.splice(i, 1);
                break;
            }
        }
    }
    getFieldValues(fieldContainer) {
        for (let i = 0; i < this.FieldSelectors.length; i++) {
            if (this.FieldSelectors[i].canGetValues(fieldContainer)) {
                return this.FieldSelectors[i].getFieldValues(fieldContainer);
            }
        }
        return [];
    }
    getFieldValueElements(fieldContainer) {
        for (let i = 0; i < this.FieldSelectors.length; i++) {
            if (this.FieldSelectors[i].canGetValues(fieldContainer)) {
                return this.FieldSelectors[i].getFieldValueElements(fieldContainer);
            }
        }
        return null;
    }
    getFieldValueElement(fieldContainer) {
        for (let i = 0; i < this.FieldSelectors.length; i++) {
            if (this.FieldSelectors[i].canGetValues(fieldContainer)) {
                return this.FieldSelectors[i].getFieldValueElement(fieldContainer);
            }
        }
        return null;
    }
    getFieldsContainerNames() {
        let containers = [];
        for (let i = 0; i < this.FieldSelectors.length; i++) {
            containers.push(this.FieldSelectors[i].getFieldContainerDataSfRole());
        }
        return containers;
    }
}