@clxmedia/clxforms-client 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 John Biundo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+<h1 align="center"></h1>
+
+<h3 align="center">CLXperience Forms Client</h3>
+
+## Usage
+
+Static processing of form data and rule conditions
+
+## Change Log
+
+See [Changelog](CHANGELOG.md) for more information.
+
+## Author
+
+**Brandon Thompson**
+
+## License
+
+Licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+import { CLXFormMode } from '@clxmedia/types/core/clxforms';
+export type CLXFormRights = 'none' | 'view' | 'edit' | 'admin';
+export type CLXFormSettings = {
+    rights: CLXFormRights;
+    mode: CLXFormMode;
+    locked: boolean;
+};
+export declare const CLXFormConstants: {
+    yesNoOptions: {
+        value: string;
+        label: string;
+    }[];
+};

package/dist/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLXFormConstants = void 0;
+exports.CLXFormConstants = {
+    yesNoOptions: [
+        { value: 'Y', label: 'Yes' },
+        { value: 'N', label: 'No' }
+    ]
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { CLXFormLayoutProcessor, ProcessedCLXFormSection, ProcessedCLXFormStep, ProcessedCLXFormLayout } from './layout-processor';
+export { CLXRulesetProcessor } from './rules-processor';
+export { CLXRulesEngine } from './rules-engine';
+export { CLXFormConstants, CLXFormRights, CLXFormSettings } from './constants';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLXFormConstants = exports.CLXRulesEngine = exports.CLXRulesetProcessor = exports.CLXFormLayoutProcessor = void 0;
+var layout_processor_1 = require("./layout-processor");
+Object.defineProperty(exports, "CLXFormLayoutProcessor", { enumerable: true, get: function () { return layout_processor_1.CLXFormLayoutProcessor; } });
+var rules_processor_1 = require("./rules-processor");
+Object.defineProperty(exports, "CLXRulesetProcessor", { enumerable: true, get: function () { return rules_processor_1.CLXRulesetProcessor; } });
+var rules_engine_1 = require("./rules-engine");
+Object.defineProperty(exports, "CLXRulesEngine", { enumerable: true, get: function () { return rules_engine_1.CLXRulesEngine; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "CLXFormConstants", { enumerable: true, get: function () { return constants_1.CLXFormConstants; } });

package/dist/layout-processor.d.ts

@@ -0,0 +1,35 @@
+import { CLXFormLayout, CLXFormMode, CLXFormQuestionLayout, CLXFormResponses, CLXFormRuleSet, FormStats } from '@clxmedia/types/core/clxforms';
+import { CLXFormRights } from './constants';
+export type ProcessedCLXFormSection = {
+    id: number;
+    name: string;
+    question_layouts: CLXFormQuestionLayout[];
+    conditions?: CLXFormRuleSet;
+    is_complete: boolean;
+};
+export type ProcessedCLXFormStep = {
+    id: number;
+    name: string;
+    description: string;
+    is_gate: boolean;
+    sections: ProcessedCLXFormSection[];
+    conditions?: CLXFormRuleSet;
+    is_complete: boolean;
+};
+export type ProcessedCLXFormLayout = {
+    form: {
+        slug: string;
+        name: string;
+        description?: string;
+    };
+    steps: ProcessedCLXFormStep[];
+    stats?: FormStats;
+};
+export declare const CLXFormLayoutProcessor: ({ mode, responseData, formRights }: {
+    mode: CLXFormMode;
+    responseData: CLXFormResponses;
+    formRights: CLXFormRights;
+}) => {
+    process: (layout: CLXFormLayout) => ProcessedCLXFormLayout;
+    processRuleSet: (ruleSet?: CLXFormRuleSet) => boolean;
+};

package/dist/layout-processor.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLXFormLayoutProcessor = void 0;
+const rules_processor_1 = require("./rules-processor");
+const CLXFormLayoutProcessor = ({ mode, responseData, formRights }) => {
+    const isQuestionLayoutEnabled = (questionLayout) => {
+        if (mode === 'edit') {
+            return true;
+        }
+        if (questionLayout.is_enabled === false) {
+            return false;
+        }
+        if (!questionLayout.conditions ||
+            !questionLayout.conditions.rules ||
+            questionLayout.conditions.rules.length === 0) {
+            return true;
+        }
+        return (0, rules_processor_1.CLXRulesetProcessor)({ responseData }).processRuleSet(questionLayout.conditions);
+    };
+    const containsErrors = (errs) => {
+        return errs !== undefined && Array.isArray(errs) && errs.some(err => err !== null);
+    };
+    const isResponseSaved = (response) => {
+        if (!response) {
+            return false;
+        }
+        return !!response && response.value !== undefined && !containsErrors(response.errorMsg);
+    };
+    const isSectionComplete = (section) => {
+        if (!section || !section.question_layouts || section.question_layouts.length === 0) {
+            return true;
+        }
+        const requiredQuestionLayouts = section.question_layouts.filter(ql => {
+            return ql.is_required && isQuestionLayoutEnabled(ql);
+        });
+        return requiredQuestionLayouts.every(ql => {
+            return isResponseSaved(responseData[ql.form_question_slug]);
+        });
+    };
+    const questionLayoutProcessor = (questionLayout, response) => {
+        const is_enabled = isQuestionLayoutEnabled(questionLayout);
+        return Object.assign(Object.assign({}, questionLayout), { is_enabled, is_complete: is_enabled ? isResponseSaved(response) : false });
+    };
+    const sectionProcessor = (section) => {
+        if (section.conditions && !(0, rules_processor_1.CLXRulesetProcessor)({ responseData }).processRuleSet(section.conditions)) {
+            return Object.assign(Object.assign({}, section), { is_complete: true, question_layouts: [] });
+        }
+        const is_section_complete = isSectionComplete(section);
+        return Object.assign(Object.assign({}, section), { is_complete: is_section_complete, question_layouts: section.question_layouts.map(questionLayout => questionLayoutProcessor(questionLayout, responseData[questionLayout.form_question_slug])) });
+    };
+    const stepProcessor = (step) => {
+        if (step.conditions && !(0, rules_processor_1.CLXRulesetProcessor)({ responseData }).processRuleSet(step.conditions)) {
+            return Object.assign(Object.assign({}, step), { is_complete: true, sections: [] });
+        }
+        const sections = step.sections
+            .map(section => sectionProcessor(section))
+            .filter(section => section.question_layouts.some(ql => ql.is_enabled));
+        return Object.assign(Object.assign({}, step), { is_complete: sections.every(section => section.is_complete), sections });
+    };
+    const gatherFormStats = (steps) => {
+        const allEnabledQuestions = steps
+            .flatMap(step => step.sections)
+            .flatMap(section => section.question_layouts)
+            .filter(ql => ql.is_enabled);
+        const requiredQuestions = allEnabledQuestions.filter(ql => ql.is_required);
+        const optionalQuestions = allEnabledQuestions.filter(ql => !ql.is_required);
+        return {
+            required: { complete: requiredQuestions.filter(rq => rq.is_complete).length, total: requiredQuestions.length },
+            optional: { complete: optionalQuestions.filter(rq => rq.is_complete).length, total: optionalQuestions.length }
+        };
+    };
+    const isResponseBooleanTrue = (key) => {
+        const value = responseData[key];
+        return !!value && value.type === 'BOOLEAN' && value.value;
+    };
+    const MockProcessor = (layout) => {
+        return {
+            form: layout.form,
+            steps: layout.steps.map(step => {
+                return Object.assign(Object.assign({}, step), { is_complete: false, sections: step.sections.map(section => {
+                        return Object.assign(Object.assign({}, section), { is_complete: false });
+                    }) });
+            })
+        };
+    };
+    const process = (layout) => {
+        if (mode === 'edit') {
+            return MockProcessor(layout);
+        }
+        let isGated = false;
+        const isCLXInternalUser = isResponseBooleanTrue('is_clxinternal_user');
+        const steps = formRights === 'none'
+            ? []
+            : layout.steps
+                .map(step => stepProcessor(step))
+                .filter(step => step.sections.length > 0)
+                .reduce((acc, step) => {
+                if (isGated && !isCLXInternalUser) {
+                    return acc;
+                }
+                if (step.is_gate && !isCLXInternalUser) {
+                    isGated = !step.is_complete;
+                }
+                acc.push(step);
+                return acc;
+            }, [])
+                .filter(step => !step.is_gate || isCLXInternalUser);
+        return { form: layout.form, steps, stats: gatherFormStats(steps) };
+    };
+    return {
+        process,
+        processRuleSet: (0, rules_processor_1.CLXRulesetProcessor)({ responseData }).processRuleSet
+    };
+};
+exports.CLXFormLayoutProcessor = CLXFormLayoutProcessor;

package/dist/rules-engine.d.ts

@@ -0,0 +1,6 @@
+import { CLXFormResponseDateValue, CLXFormRuleInstance } from '@clxmedia/types/core/clxforms';
+export declare const CLXRulesEngine: {
+    compareNumbers: (comparison: 'numberEquals' | 'numberGreaterThan' | 'numberLessThan', a?: any, b?: any) => boolean;
+    compareDates: (comparison: 'dateEquals' | 'dateBefore' | 'dateAfter', subject?: CLXFormResponseDateValue, target?: CLXFormResponseDateValue) => boolean;
+    evaluateRuleInstance: (ruleInstance?: CLXFormRuleInstance) => boolean;
+};

package/dist/rules-engine.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLXRulesEngine = void 0;
+const luxon_1 = require("luxon");
+exports.CLXRulesEngine = {
+    compareNumbers: (comparison, a, b) => {
+        if (a === undefined || b === undefined) {
+            return false;
+        }
+        if (isNaN(Number(a)) || isNaN(Number(b))) {
+            return false;
+        }
+        switch (comparison) {
+            case 'numberEquals':
+                return Number(a) === Number(b);
+            case 'numberGreaterThan':
+                return Number(a) > Number(b);
+            case 'numberLessThan':
+                return Number(a) < Number(b);
+            default:
+                return false;
+        }
+    },
+    compareDates: (comparison, subject, target) => {
+        if (subject === undefined || target === undefined || subject.type !== 'DATE' || target.type !== 'DATE') {
+            return false;
+        }
+        try {
+            const subjectDate = luxon_1.DateTime.fromISO(subject.value.iso_date_time, { zone: subject.value.zone }).toSeconds();
+            const targetDate = luxon_1.DateTime.fromISO(target.value.iso_date_time, { zone: target.value.zone }).toSeconds();
+            switch (comparison) {
+                case 'dateEquals':
+                    return subjectDate === targetDate;
+                case 'dateBefore':
+                    return subjectDate < targetDate;
+                case 'dateAfter':
+                    return subjectDate > targetDate;
+                default:
+                    return false;
+            }
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    evaluateRuleInstance: (ruleInstance) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (!ruleInstance ||
+            ruleInstance.subject === undefined ||
+            ruleInstance.target === undefined ||
+            ruleInstance.comparisonType === undefined) {
+            return false;
+        }
+        switch (ruleInstance.comparisonType) {
+            case 'stringEquals':
+                return ruleInstance.subject.value === ruleInstance.target.value;
+            case 'stringContains':
+                return (_a = ruleInstance.subject.value) === null || _a === void 0 ? void 0 : _a.includes(ruleInstance.target.value);
+            case 'stringStartsWith':
+                return (_b = ruleInstance.subject.value) === null || _b === void 0 ? void 0 : _b.startsWith(ruleInstance.target.value);
+            case 'stringEndsWith':
+                return (_c = ruleInstance.subject.value) === null || _c === void 0 ? void 0 : _c.endsWith(ruleInstance.target.value);
+            case 'stringListContainsAny':
+                return (Array.isArray(ruleInstance.subject.value) &&
+                    Array.isArray(ruleInstance.target.value) &&
+                    ruleInstance.target.value.some((item) => ruleInstance.subject.value.includes(item)));
+            case 'stringListContainsAll':
+                return (Array.isArray(ruleInstance.subject.value) &&
+                    Array.isArray(ruleInstance.target.value) &&
+                    ruleInstance.target.value.every((item) => ruleInstance.subject.value.includes(item)));
+            case 'dateEquals':
+            case 'dateBefore':
+            case 'dateAfter':
+                return exports.CLXRulesEngine.compareDates(ruleInstance.comparisonType, ruleInstance.subject, ruleInstance.target);
+            case 'stringInList':
+                return (Array.isArray(ruleInstance.target.value) && ((_d = ruleInstance.target.value) === null || _d === void 0 ? void 0 : _d.includes(ruleInstance.subject.value)));
+            case 'stringListEntryContains':
+                return (Array.isArray(ruleInstance.subject.value) &&
+                    ((_e = ruleInstance.subject.value) === null || _e === void 0 ? void 0 : _e.some((item) => item.includes(ruleInstance.target.value))));
+            case 'stringListEntryStartsWith':
+                return (Array.isArray(ruleInstance.subject.value) &&
+                    ((_f = ruleInstance.subject.value) === null || _f === void 0 ? void 0 : _f.some((item) => item.startsWith(ruleInstance.target.value))));
+            case 'stringListEntryEndsWith':
+                return (Array.isArray(ruleInstance.subject.value) &&
+                    ruleInstance.subject.value.some((item) => item.endsWith(ruleInstance.target.value)));
+            case 'stringListEntryEquals':
+                return (Array.isArray(ruleInstance.subject.value) && ruleInstance.subject.value.includes(ruleInstance.target.value));
+            case 'fileExists':
+                if (ruleInstance.target.value === true) {
+                    return ruleInstance.subject.value !== undefined && Object.keys(ruleInstance.subject.value).length > 0;
+                }
+                else {
+                    return ruleInstance.subject.value === undefined || Object.keys(ruleInstance.subject.value).length === 0;
+                }
+            case 'booleanEquals':
+                return ruleInstance.subject.value === ruleInstance.target.value;
+            case 'numberEquals':
+            case 'numberGreaterThan':
+            case 'numberLessThan':
+                return exports.CLXRulesEngine.compareNumbers(ruleInstance.comparisonType, ruleInstance.subject.value, ruleInstance.target.value);
+            default:
+                return false;
+        }
+    }
+};

package/dist/rules-processor.d.ts

@@ -0,0 +1,6 @@
+import { CLXFormResponses, CLXFormRuleSet } from '@clxmedia/types/core/clxforms';
+export declare const CLXRulesetProcessor: ({ responseData }: {
+    responseData: CLXFormResponses;
+}) => {
+    processRuleSet: (ruleSet?: CLXFormRuleSet) => boolean;
+};

package/dist/rules-processor.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLXRulesetProcessor = void 0;
+const rules_engine_1 = require("./rules-engine");
+const CLXRulesetProcessor = ({ responseData }) => {
+    const processRuleSet = (ruleSet) => {
+        const evaluateRuleBase = (ruleBase) => {
+            if (ruleBase.comparison) {
+                const ruleDefinition = ruleBase;
+                const ruleInstance = {
+                    subject: responseData[ruleDefinition.subject] || { value: undefined },
+                    target: ruleDefinition.target,
+                    comparisonType: ruleDefinition.comparison
+                };
+                return rules_engine_1.CLXRulesEngine.evaluateRuleInstance(ruleInstance);
+            }
+            else {
+                const ruleSet = ruleBase;
+                return processRuleSet(ruleSet);
+            }
+        };
+        if (!ruleSet || !ruleSet.rules || ruleSet.rules.length === 0) {
+            return true;
+        }
+        if (ruleSet.combinator === 'or') {
+            return ruleSet.rules.some((ruleBase) => {
+                return evaluateRuleBase(ruleBase);
+            });
+        }
+        else {
+            return ruleSet.rules.every((ruleBase) => {
+                return evaluateRuleBase(ruleBase);
+            });
+        }
+    };
+    return {
+        processRuleSet
+    };
+};
+exports.CLXRulesetProcessor = CLXRulesetProcessor;

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@clxmedia/clxforms-client",
+  "version": "1.0.0",
+  "description": "CLXperience Forms Client",
+  "author": "Brandon Thompson <brandont@clxmedia.com>",
+  "license": "MIT",
+  "readmeFilename": "README.md",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "*.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./layout-processor": "./dist/layout-processor.js",
+    "./constants": "./dist/constants.js",
+    "./rules-engine": "./dist/rules-engine.js",
+    "./rules-processor": "./dist/rules-processor.js"
+
+  },
+  "scripts": {
+    "start:dev": "tsc -w",
+    "build": "rm -Rf dist && tsc",
+    "prepare": "npm run build",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "tslint -p tsconfig.json -c tslint.json",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:e2e": "jest --config ./test/jest-e2e.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adsupnow/xperience-library/clxforms-client"
+  },
+  "bugs": "https://github.com/adsupnow/xperience-library/clxforms-client",
+  "peerDependencies": {},
+  "dependencies": {
+    "@clxmedia/types": "1.0.47",
+    "luxon": "3.4.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.2.2",
+    "@types/node": "^20",
+    "@types/jsonwebtoken": "9.0.6",
+    "jest": "29.7.0",
+    "ts-jest": "29.1.2",
+    "nock": "13.5.4",
+    "tslint": "6.1.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}