kwikid-forms 0.0.0-watch

package/esm2015/lib/renderer/form-view/form-view.decorators.js

@@ -0,0 +1,93 @@
+/**
+ * A function that logs the execution of a method.
+ * @param {any} target - The object the method belongs to.
+ * @param {string} propertyKey - The name of the method.
+ * @param {PropertyDescriptor} descriptor - The property descriptor for the method.
+ */
+export function log(target, propertyKey, descriptor) {
+    // save a reference to the original method
+    const originalMethod = descriptor.value;
+    // update the descriptor value with a new function that will log and execute the original method
+    descriptor.value = function (...args) {
+        console.group("Logging Method"); // start a new logging group
+        console.time("Execution Time:"); // start a timer
+        let result; // declare result variable
+        try {
+            // execute the original method and save the result
+            result = originalMethod.apply(this, args);
+        }
+        catch (error) {
+            // if an error is thrown, log the error and throw it again
+            logSyncMethodError(target.constructor.name, propertyKey, args, error);
+            console.timeEnd(`Execution Time:`); // stop the timer
+            console.groupEnd(); // end the logging group
+            throw error;
+        }
+        // if the result is a Promise, handle it as an async method
+        if (result instanceof Promise) {
+            result = result
+                .then((resolvedValue) => {
+                // on success, log the resolved value and return it
+                logAsyncMethod(target.constructor.name, propertyKey, args, resolvedValue);
+                console.timeEnd(`Execution Time:`); // stop the timer
+                console.groupEnd(); // end the logging group
+                return resolvedValue;
+            })
+                .catch((error) => {
+                // on error, log the error and throw it again
+                logAsyncMethodError(target.constructor.name, propertyKey, args, error);
+                console.timeEnd(`Execution Time:`); // stop the timer
+                console.groupEnd(); // end the logging group
+                throw error;
+            });
+        }
+        else {
+            // if the result is not a Promise, handle it as a sync method
+            logSyncMethod(target.constructor.name, propertyKey, args, result);
+            console.timeEnd("Execution Time:");
+            console.groupEnd();
+        }
+        return result;
+    };
+}
+/**
+ * This function logs a sync method's information to the console.
+ * @param {string} className - The name of the class where the method belongs.
+ * @param {string} methodName - The name of the method being called.
+ * @param {any[]} args - An array of arguments passed to the method.
+ * @param {any} result - The result of the method.
+ */
+function logSyncMethod(className, methodName, args, result) {
+    console.log("%cType: Sync Method -", "color: #0d47a1; font-weight: bold;", "\nClass:", className, "\nMethod:", methodName, "\nArgs:", args, "\nReturn:", result);
+}
+/**
+ * Logs an error that occurred during the execution of a synchronous method.
+ * @param {string} className - The name of the class the method belongs to.
+ * @param {string} methodName - The name of the method.
+ * @param {any[]} args - The arguments passed to the method.
+ * @param {Error} error - The error that occurred.
+ */
+function logSyncMethodError(className, methodName, args, error) {
+    console.log("%cType: Sync Method -", "color: #0d47a1; font-weight: bold;", "\nClass:", className, "\nMethod:", methodName, "\nArgs:", args, "\nError:", error);
+}
+/**
+ * Logs the result of the execution of an asynchronous method.
+ * @param {string} className - The name of the class the method belongs to.
+ * @param {string} methodName - The name of the method.
+ * @param {any[]} args - The arguments passed to the method.
+ * @param {any} result - The result of the method execution.
+ */
+function logAsyncMethod(className, methodName, args, result) {
+    console.log("%cType: Async Method -", "color: #1565c0; font-weight: bold;", "\nClass:", className, "\nMethod:", methodName, "\nArgs:", args, "\nReturn:", result);
+}
+/**
+ * Logs an error that occurred during the execution of an asynchronous method.
+ * @param {string} className - The name of the class the method belongs to.
+ * @param {string} methodName - The name of the method.
+ * @param {any[]} args - The arguments passed to the method.
+ * @param {Error} error - The error that occurred.
+ */
+function logAsyncMethodError(className, methodName, args, error) {
+    console.log("%cType: Async Method -", "color: #1565c0; font-weight: bold;", "\nClass:", className, "\nMethod:", methodName, "\nArgs:", args, "\nError:", error);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.decorators.js","sourceRoot":"","sources":["../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/form-view.decorators.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * A function that logs the execution of a method.\r\n * @param {any} target - The object the method belongs to.\r\n * @param {string} propertyKey - The name of the method.\r\n * @param {PropertyDescriptor} descriptor - The property descriptor for the method.\r\n */\r\nexport function log(\r\n  target: any,\r\n  propertyKey: string,\r\n  descriptor: PropertyDescriptor\r\n) {\r\n  // save a reference to the original method\r\n  const originalMethod = descriptor.value;\r\n  // update the descriptor value with a new function that will log and execute the original method\r\n  descriptor.value = function (...args: any[]) {\r\n    console.group(\"Logging Method\"); // start a new logging group\r\n    console.time(\"Execution Time:\"); // start a timer\r\n\r\n    let result; // declare result variable\r\n    try {\r\n      // execute the original method and save the result\r\n      result = originalMethod.apply(this, args);\r\n    } catch (error) {\r\n      // if an error is thrown, log the error and throw it again\r\n      logSyncMethodError(target.constructor.name, propertyKey, args, error);\r\n      console.timeEnd(`Execution Time:`); // stop the timer\r\n      console.groupEnd(); // end the logging group\r\n      throw error;\r\n    }\r\n\r\n    // if the result is a Promise, handle it as an async method\r\n    if (result instanceof Promise) {\r\n      result = result\r\n        .then((resolvedValue) => {\r\n          // on success, log the resolved value and return it\r\n          logAsyncMethod(\r\n            target.constructor.name,\r\n            propertyKey,\r\n            args,\r\n            resolvedValue\r\n          );\r\n          console.timeEnd(`Execution Time:`); // stop the timer\r\n          console.groupEnd(); // end the logging group\r\n          return resolvedValue;\r\n        })\r\n        .catch((error) => {\r\n          // on error, log the error and throw it again\r\n          logAsyncMethodError(\r\n            target.constructor.name,\r\n            propertyKey,\r\n            args,\r\n            error\r\n          );\r\n          console.timeEnd(`Execution Time:`); // stop the timer\r\n          console.groupEnd(); // end the logging group\r\n          throw error;\r\n        });\r\n    } else {\r\n      // if the result is not a Promise, handle it as a sync method\r\n      logSyncMethod(target.constructor.name, propertyKey, args, result);\r\n      console.timeEnd(\"Execution Time:\");\r\n      console.groupEnd();\r\n    }\r\n    return result;\r\n  };\r\n}\r\n\r\n/**\r\n * This function logs a sync method's information to the console.\r\n * @param {string} className - The name of the class where the method belongs.\r\n * @param {string} methodName - The name of the method being called.\r\n * @param {any[]} args - An array of arguments passed to the method.\r\n * @param {any} result - The result of the method.\r\n */\r\nfunction logSyncMethod(className, methodName, args, result) {\r\n  console.log(\r\n    \"%cType: Sync Method -\",\r\n    \"color: #0d47a1; font-weight: bold;\",\r\n    \"\\nClass:\",\r\n    className,\r\n    \"\\nMethod:\",\r\n    methodName,\r\n    \"\\nArgs:\",\r\n    args,\r\n    \"\\nReturn:\",\r\n    result\r\n  );\r\n}\r\n\r\n/**\r\n * Logs an error that occurred during the execution of a synchronous method.\r\n * @param {string} className - The name of the class the method belongs to.\r\n * @param {string} methodName - The name of the method.\r\n * @param {any[]} args - The arguments passed to the method.\r\n * @param {Error} error - The error that occurred.\r\n */\r\nfunction logSyncMethodError(className, methodName, args, error) {\r\n  console.log(\r\n    \"%cType: Sync Method -\",\r\n    \"color: #0d47a1; font-weight: bold;\",\r\n    \"\\nClass:\",\r\n    className,\r\n    \"\\nMethod:\",\r\n    methodName,\r\n    \"\\nArgs:\",\r\n    args,\r\n    \"\\nError:\",\r\n    error\r\n  );\r\n}\r\n\r\n/**\r\n * Logs the result of the execution of an asynchronous method.\r\n * @param {string} className - The name of the class the method belongs to.\r\n * @param {string} methodName - The name of the method.\r\n * @param {any[]} args - The arguments passed to the method.\r\n * @param {any} result - The result of the method execution.\r\n */\r\nfunction logAsyncMethod(className, methodName, args, result) {\r\n  console.log(\r\n    \"%cType: Async Method -\",\r\n    \"color: #1565c0; font-weight: bold;\",\r\n    \"\\nClass:\",\r\n    className,\r\n    \"\\nMethod:\",\r\n    methodName,\r\n    \"\\nArgs:\",\r\n    args,\r\n    \"\\nReturn:\",\r\n    result\r\n  );\r\n}\r\n\r\n/**\r\n * Logs an error that occurred during the execution of an asynchronous method.\r\n * @param {string} className - The name of the class the method belongs to.\r\n * @param {string} methodName - The name of the method.\r\n * @param {any[]} args - The arguments passed to the method.\r\n * @param {Error} error - The error that occurred.\r\n */\r\nfunction logAsyncMethodError(className, methodName, args, error) {\r\n  console.log(\r\n    \"%cType: Async Method -\",\r\n    \"color: #1565c0; font-weight: bold;\",\r\n    \"\\nClass:\",\r\n    className,\r\n    \"\\nMethod:\",\r\n    methodName,\r\n    \"\\nArgs:\",\r\n    args,\r\n    \"\\nError:\",\r\n    error\r\n  );\r\n}\r\n"]}

package/esm2015/lib/renderer/form-view/form-view.module.js

@@ -0,0 +1,37 @@
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { TuiLabelModule } from "@taiga-ui/core";
+import { KwikUIModule } from "kwikui";
+import { KwikIDFormViewComponent } from "./form-view.component";
+import * as i0 from "@angular/core";
+export class KwikIDFormViewModule {
+}
+/** @nocollapse */ KwikIDFormViewModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: KwikIDFormViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ KwikIDFormViewModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: KwikIDFormViewModule, declarations: [KwikIDFormViewComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        TuiLabelModule,
+        KwikUIModule], exports: [KwikIDFormViewComponent] });
+/** @nocollapse */ KwikIDFormViewModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: KwikIDFormViewModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TuiLabelModule,
+            KwikUIModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: KwikIDFormViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [KwikIDFormViewComponent],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        TuiLabelModule,
+                        KwikUIModule
+                    ],
+                    exports: [KwikIDFormViewComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS12aWV3Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2t3aWtpZC1mb3Jtcy9zcmMvbGliL3JlbmRlcmVyL2Zvcm0tdmlldy9mb3JtLXZpZXcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUN0QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFhaEUsTUFBTSxPQUFPLG9CQUFvQjs7cUlBQXBCLG9CQUFvQjtzSUFBcEIsb0JBQW9CLGlCQVZoQix1QkFBdUIsYUFFcEMsWUFBWTtRQUNaLFdBQVc7UUFDWCxtQkFBbUI7UUFDbkIsY0FBYztRQUNkLFlBQVksYUFFSix1QkFBdUI7c0lBRXRCLG9CQUFvQixZQVR0QjtZQUNQLFlBQVk7WUFDWixXQUFXO1lBQ1gsbUJBQW1CO1lBQ25CLGNBQWM7WUFDZCxZQUFZO1NBQ2I7NEZBR1Usb0JBQW9CO2tCQVhoQyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHVCQUF1QixDQUFDO29CQUN2QyxPQUFPLEVBQUU7d0JBQ1AsWUFBWTt3QkFDWixXQUFXO3dCQUNYLG1CQUFtQjt3QkFDbkIsY0FBYzt3QkFDZCxZQUFZO3FCQUNiO29CQUNELE9BQU8sRUFBRSxDQUFDLHVCQUF1QixDQUFDO2lCQUNuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQgeyBGb3Jtc01vZHVsZSwgUmVhY3RpdmVGb3Jtc01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9mb3Jtc1wiO1xyXG5pbXBvcnQgeyBUdWlMYWJlbE1vZHVsZSB9IGZyb20gXCJAdGFpZ2EtdWkvY29yZVwiO1xyXG5pbXBvcnQgeyBLd2lrVUlNb2R1bGUgfSBmcm9tIFwia3dpa3VpXCI7XHJcbmltcG9ydCB7IEt3aWtJREZvcm1WaWV3Q29tcG9uZW50IH0gZnJvbSBcIi4vZm9ybS12aWV3LmNvbXBvbmVudFwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBkZWNsYXJhdGlvbnM6IFtLd2lrSURGb3JtVmlld0NvbXBvbmVudF0sXHJcbiAgaW1wb3J0czogW1xyXG4gICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgRm9ybXNNb2R1bGUsXHJcbiAgICBSZWFjdGl2ZUZvcm1zTW9kdWxlLFxyXG4gICAgVHVpTGFiZWxNb2R1bGUsXHJcbiAgICBLd2lrVUlNb2R1bGVcclxuICBdLFxyXG4gIGV4cG9ydHM6IFtLd2lrSURGb3JtVmlld0NvbXBvbmVudF1cclxufSlcclxuZXhwb3J0IGNsYXNzIEt3aWtJREZvcm1WaWV3TW9kdWxlIHt9XHJcbiJdfQ==

package/esm2015/lib/renderer/form-view/form-view.service.js

@@ -0,0 +1,27 @@
+import { __awaiter, __decorate } from "tslib";
+import { FormControl, FormGroup } from "@angular/forms";
+import { log } from "./form-view.decorators";
+import { Defaults } from "./helpers/form-view.defaults.helper";
+import { Validations } from "./helpers/form-view.validations.helper";
+export class KwikIDFormViewService {
+    constructor() { }
+    // 'init' stage of the form
+    createFormGroup(fields, formData, previousFormData, allFormsData, takeAction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let formGroup = new FormGroup({});
+            for (let field of fields) {
+                if (field.type !== "title") {
+                    const defaults = new Defaults(field, allFormsData, formData, previousFormData, takeAction);
+                    const value = yield defaults.getDefaultValue();
+                    const validators = new Validations(field, formData, previousFormData, allFormsData, takeAction).getFieldValidators(field);
+                    formGroup.addControl(field.key, new FormControl({ value: value, disabled: field.disabled }, { validators: validators }));
+                }
+            }
+            return formGroup;
+        });
+    }
+}
+__decorate([
+    log
+], KwikIDFormViewService.prototype, "createFormGroup", null);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/renderer/form-view/helpers/form-view.actions.helper.js

@@ -0,0 +1,27 @@
+import { __awaiter, __decorate } from "tslib";
+import { log } from "../form-view.decorators";
+import { Condition } from "./form-view.condition.helper";
+export class Actions {
+    constructor(action, field, ruleMapping, allFormsData, formData, previousFormData, takeAction) {
+        this._action = action;
+        this._field = field;
+        this._ruleMapping = ruleMapping;
+        this._allFormsData = allFormsData;
+        this._formData = formData;
+        this._previousFormData = previousFormData;
+        this._takeAction = takeAction;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const condition = new Condition(this._action.condition, this._ruleMapping);
+            const actionSuccess = condition.evaluate();
+            if (actionSuccess) {
+                return this._takeAction(this._action, this._field, this._allFormsData, this._formData, this._previousFormData);
+            }
+        });
+    }
+}
+__decorate([
+    log
+], Actions.prototype, "execute", null);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/renderer/form-view/helpers/form-view.apis.helper.js

@@ -0,0 +1,105 @@
+import { __awaiter, __decorate } from "tslib";
+import { log } from "../form-view.decorators";
+import { Actions } from "./form-view.actions.helper";
+import { setValueToObject } from "./form-view.common.helper";
+import { Condition } from "./form-view.condition.helper";
+import { Rules } from "./form-view.rules.helper";
+import { Sources } from "./form-view.sources.helper";
+export class Apis {
+    constructor(field, formData, previousFormData, allFormsData, takeAction) {
+        this._field = field;
+        this._formData = formData;
+        this._previousFormData = previousFormData;
+        this._allFormsData = allFormsData;
+        this._takeAction = takeAction;
+        this._api = field.api;
+        this._request = field.api.request;
+        this._response = field.api.response;
+        this._status = field.api.status;
+    }
+    setRequestBodyParams() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = this._request.body.params;
+            let paramIndex = 0;
+            for (let param of params) {
+                let sources = param.sources;
+                let sourceIndex = 0;
+                for (let source of sources) {
+                    const sources = new Sources(this._field, this._formData, this._previousFormData, this._allFormsData);
+                    const value = sources.getValueFromSource(source);
+                    // Set the Value of current source.
+                    this._field = setValueToObject(this._field, `api.request.body.params[${paramIndex}].sources[${sourceIndex}].value`, value);
+                    const validation = source.validation;
+                    const triggers = (_a = validation === null || validation === void 0 ? void 0 : validation.triggers) !== null && _a !== void 0 ? _a : [];
+                    const rules = (_b = validation === null || validation === void 0 ? void 0 : validation.rules) !== null && _b !== void 0 ? _b : [];
+                    const actions = (_c = validation === null || validation === void 0 ? void 0 : validation.actions) !== null && _c !== void 0 ? _c : [];
+                    const rulesMapping = new Rules(rules, this._field, this._formData, this._previousFormData, this._allFormsData).mapping();
+                    for (let action of actions) {
+                        const conditionEvaluation = new Condition(action.condition, rulesMapping).evaluate();
+                        if (conditionEvaluation) {
+                            const actions = new Actions(action, this._field, rulesMapping, this._allFormsData, this._formData, this._previousFormData, this._takeAction);
+                            yield actions.execute();
+                        }
+                    }
+                    sourceIndex++;
+                }
+                paramIndex++;
+            }
+            return this._field;
+        });
+    }
+    validateRequestBody() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = this._request.body;
+            const validation = body.validation;
+            const triggers = validation.triggers;
+            const rules = validation.rules;
+            const actions = validation.actions;
+            const rulesMapping = new Rules(rules, this._field, this._formData, this._previousFormData, this._allFormsData).mapping();
+            for (let action of actions) {
+                const conditionSuccess = new Condition(action.condition, rulesMapping).evaluate();
+                if (conditionSuccess) {
+                    const actions = new Actions(action, this._field, rulesMapping, this._allFormsData, this._formData, this._previousFormData, this._takeAction);
+                    yield actions.execute();
+                }
+            }
+            return this._field;
+        });
+    }
+    validateApiCallResponse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validation = this._response.validation;
+            const triggers = validation.triggers;
+            const rules = validation.rules;
+            const actions = validation.actions;
+            const rulesMapping = new Rules(rules, this._field, this._formData, this._previousFormData, this._allFormsData).mapping();
+            for (let action of actions) {
+                const conditionSuccess = new Condition(action.condition, rulesMapping).evaluate();
+                if (conditionSuccess) {
+                    const actions = new Actions(action, this._field, rulesMapping, this._allFormsData, this._formData, this._previousFormData, this._takeAction);
+                    yield actions.execute();
+                }
+            }
+            return this._field;
+        });
+    }
+    getPropsValues() {
+        return {
+            field: this._field,
+            formData: this._formData,
+            previousFormData: this._previousFormData,
+            allFormsData: this._allFormsData
+        };
+    }
+}
+__decorate([
+    log
+], Apis.prototype, "setRequestBodyParams", null);
+__decorate([
+    log
+], Apis.prototype, "validateRequestBody", null);
+__decorate([
+    log
+], Apis.prototype, "validateApiCallResponse", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.apis.helper.js","sourceRoot":"","sources":["../../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/helpers/form-view.apis.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { TAction } from \"../definitions/actions/form-view.actions.type.definitions\";\r\nimport {\r\n  TApi,\r\n  TApiRequest,\r\n  TApiRequestBody,\r\n  TApiRequestBodyParam,\r\n  TApiResponse,\r\n  TApiStatus\r\n} from \"../definitions/apis/form-view.apis.type.definitions\";\r\nimport { TFieldApiCall } from \"../definitions/fields/form-view.fields.type.definitions\";\r\nimport { TRule } from \"../definitions/rules/form-view.rules.type.definitions\";\r\nimport { TSource } from \"../definitions/sources/form-view.sources.type.definitions\";\r\nimport { TTrigger } from \"../definitions/triggers/form-view.triggers.type.definitions\";\r\nimport { TValidation } from \"../definitions/validations/form-view.validations.type.definitions\";\r\nimport { log } from \"../form-view.decorators\";\r\nimport { Actions } from \"./form-view.actions.helper\";\r\nimport { setValueToObject } from \"./form-view.common.helper\";\r\nimport { Condition } from \"./form-view.condition.helper\";\r\nimport { Rules } from \"./form-view.rules.helper\";\r\nimport { Sources } from \"./form-view.sources.helper\";\r\n\r\nexport class Apis {\r\n  private _formData: any;\r\n  private _previousFormData: any;\r\n  private _allFormsData: any;\r\n  private _field: TFieldApiCall;\r\n  private _takeAction: Function;\r\n\r\n  private _api: TApi;\r\n  private _request: TApiRequest;\r\n  private _response: TApiResponse;\r\n  private _status: TApiStatus;\r\n\r\n  constructor(\r\n    field: TFieldApiCall,\r\n    formData: any,\r\n    previousFormData: any,\r\n    allFormsData: any,\r\n    takeAction: Function\r\n  ) {\r\n    this._field = field;\r\n    this._formData = formData;\r\n    this._previousFormData = previousFormData;\r\n    this._allFormsData = allFormsData;\r\n    this._takeAction = takeAction;\r\n\r\n    this._api = field.api;\r\n    this._request = field.api.request;\r\n    this._response = field.api.response;\r\n    this._status = field.api.status;\r\n  }\r\n\r\n  @log\r\n  public async setRequestBodyParams(): Promise<TFieldApiCall> {\r\n    let params: Array<TApiRequestBodyParam> = this._request.body.params;\r\n\r\n    let paramIndex = 0;\r\n    for (let param of params) {\r\n      let sources: Array<TSource> = param.sources;\r\n\r\n      let sourceIndex = 0;\r\n      for (let source of sources) {\r\n        const sources = new Sources(\r\n          this._field,\r\n          this._formData,\r\n          this._previousFormData,\r\n          this._allFormsData\r\n        );\r\n        const value = sources.getValueFromSource(source);\r\n        // Set the Value of current source.\r\n        this._field = setValueToObject(\r\n          this._field,\r\n          `api.request.body.params[${paramIndex}].sources[${sourceIndex}].value`,\r\n          value\r\n        );\r\n\r\n        const validation: TValidation = source.validation;\r\n\r\n        const triggers: Array<TTrigger> = validation?.triggers ?? [];\r\n        const rules: Array<TRule> = validation?.rules ?? [];\r\n        const actions: Array<TAction> = validation?.actions ?? [];\r\n\r\n        const rulesMapping = new Rules(\r\n          rules,\r\n          this._field,\r\n          this._formData,\r\n          this._previousFormData,\r\n          this._allFormsData\r\n        ).mapping();\r\n\r\n        for (let action of actions) {\r\n          const conditionEvaluation = new Condition(\r\n            action.condition,\r\n            rulesMapping\r\n          ).evaluate();\r\n\r\n          if (conditionEvaluation) {\r\n            const actions = new Actions(\r\n              action,\r\n              this._field,\r\n              rulesMapping,\r\n              this._allFormsData,\r\n              this._formData,\r\n              this._previousFormData,\r\n              this._takeAction\r\n            );\r\n\r\n            await actions.execute();\r\n          }\r\n        }\r\n\r\n        sourceIndex++;\r\n      }\r\n\r\n      paramIndex++;\r\n    }\r\n\r\n    return this._field;\r\n  }\r\n\r\n  @log\r\n  public async validateRequestBody(): Promise<TFieldApiCall> {\r\n    const body: TApiRequestBody = this._request.body;\r\n\r\n    const validation: TValidation = body.validation;\r\n\r\n    const triggers: Array<TTrigger> = validation.triggers;\r\n    const rules: Array<TRule> = validation.rules;\r\n    const actions: Array<TAction> = validation.actions;\r\n\r\n    const rulesMapping = new Rules(\r\n      rules,\r\n      this._field,\r\n      this._formData,\r\n      this._previousFormData,\r\n      this._allFormsData\r\n    ).mapping();\r\n\r\n    for (let action of actions) {\r\n      const conditionSuccess = new Condition(\r\n        action.condition,\r\n        rulesMapping\r\n      ).evaluate();\r\n\r\n      if (conditionSuccess) {\r\n        const actions = new Actions(\r\n          action,\r\n          this._field,\r\n          rulesMapping,\r\n          this._allFormsData,\r\n          this._formData,\r\n          this._previousFormData,\r\n          this._takeAction\r\n        );\r\n\r\n        await actions.execute();\r\n      }\r\n    }\r\n\r\n    return this._field;\r\n  }\r\n\r\n  @log\r\n  public async validateApiCallResponse(): Promise<TFieldApiCall> {\r\n    const validation: TValidation = this._response.validation;\r\n\r\n    const triggers: Array<TTrigger> = validation.triggers;\r\n    const rules: Array<TRule> = validation.rules;\r\n    const actions: Array<TAction> = validation.actions;\r\n\r\n    const rulesMapping = new Rules(\r\n      rules,\r\n      this._field,\r\n      this._formData,\r\n      this._previousFormData,\r\n      this._allFormsData\r\n    ).mapping();\r\n\r\n    for (let action of actions) {\r\n      const conditionSuccess = new Condition(\r\n        action.condition,\r\n        rulesMapping\r\n      ).evaluate();\r\n\r\n      if (conditionSuccess) {\r\n        const actions = new Actions(\r\n          action,\r\n          this._field,\r\n          rulesMapping,\r\n          this._allFormsData,\r\n          this._formData,\r\n          this._previousFormData,\r\n          this._takeAction\r\n        );\r\n\r\n        await actions.execute();\r\n      }\r\n    }\r\n\r\n    return this._field;\r\n  }\r\n\r\n  getPropsValues(): any {\r\n    return {\r\n      field: this._field,\r\n      formData: this._formData,\r\n      previousFormData: this._previousFormData,\r\n      allFormsData: this._allFormsData\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2015/lib/renderer/form-view/helpers/form-view.common.helper.js

@@ -0,0 +1,136 @@
+import { TuiDay } from "@taiga-ui/cdk";
+import jp from "jsonpath";
+import _ from "lodash";
+import { EFieldType } from "../definitions/fields/form-view.fields.enum.definitions";
+export const hasKey = (object, key) => {
+    return object.hasOwnProperty(key);
+};
+export const hasPath = (object, path) => {
+    return _.has(object, path);
+};
+export const isEmptyString = (value) => {
+    return value === "";
+};
+export const isUndefined = (value) => {
+    return value === undefined;
+};
+export const isNull = (value) => {
+    return value === null;
+};
+export const isEmptyObject = (object) => {
+    return (object &&
+        Object.keys(object).length === 0 &&
+        Object.getPrototypeOf(object) === Object.prototype);
+};
+export const isEmptyArray = (arr) => {
+    return arr.length === 0;
+};
+export const isEmpty = (value) => {
+    if (isEmptyString(value) || isUndefined(value) || isNull(value)) {
+        return true;
+    }
+    else if (isEmptyObject(value)) {
+        return true;
+    }
+    else if (Array.isArray(value)) {
+        if (isEmptyArray(value)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+};
+export const isNotEmpty = (value) => {
+    return !isEmpty(value);
+};
+export const isEmptyBrowserStorageValue = (value) => {
+    return isNull(value) && isUndefined(value);
+};
+export const isNotEmptyBrowserStorageValue = (value) => {
+    return !isEmptyBrowserStorageValue(value);
+};
+export const handleJPQueryResponse = (value) => {
+    /**
+     * jp.query doesn't always return an array with one element
+     * so directly can't access with [0], need to check conditionally
+     */
+    if (Array.isArray(value)) {
+        if (value.length > 0) {
+            value = value[0];
+        }
+        else if (value.length === 0) {
+            value = "";
+        }
+    }
+    else {
+        value = "";
+    }
+    return value;
+};
+export const jpQueryWrapper = (obj, key) => {
+    return handleJPQueryResponse(jp.query(obj, key));
+};
+export const replaceString = (str, find, replace) => {
+    return str.replace(new RegExp(find, "g"), replace);
+};
+export const setFieldKeyValue = (field, path, value) => {
+    return _.set(field, path, value);
+};
+export const setValueToObject = (object, path, value) => {
+    return _.set(object, path, value);
+};
+export const formatValue = (field, fieldValue) => {
+    const fieldType = field.type;
+    let value;
+    if (isNotEmpty(fieldValue)) {
+        switch (fieldType) {
+            case EFieldType.DATE:
+                const splitDate = fieldValue.split("-");
+                value = new TuiDay(Number(splitDate[2]), // Year
+                Number(splitDate[1]) - 1, // Month, Why '-1' => Because Taiga-UI Required It, So...
+                Number(splitDate[0]) // Day
+                );
+                break;
+            case EFieldType.RADIO:
+                const fieldRadio = field;
+                value = fieldRadio.options.find((item) => {
+                    return item.label === fieldValue;
+                });
+                break;
+            case EFieldType.CHECKBOX:
+                value = Boolean(fieldValue);
+                break;
+            default:
+                value = fieldValue;
+                break;
+        }
+    }
+    else {
+        value = fieldValue;
+    }
+    return value;
+};
+export const setEmptyValue = (field) => {
+    const fieldType = field.type;
+    let value;
+    switch (fieldType) {
+        case EFieldType.CHECKBOX:
+            value = false;
+            break;
+        case EFieldType.NUMBER:
+            value = null;
+            break;
+        case EFieldType.DATE:
+            value = null;
+            break;
+        default:
+            value = "";
+            break;
+    }
+    return value;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.common.helper.js","sourceRoot":"","sources":["../../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/helpers/form-view.common.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { TuiDay } from \"@taiga-ui/cdk\";\r\nimport jp from \"jsonpath\";\r\nimport _ from \"lodash\";\r\nimport { EFieldType } from \"../definitions/fields/form-view.fields.enum.definitions\";\r\nimport {\r\n  TField,\r\n  TFieldRadio,\r\n  TFieldType\r\n} from \"../definitions/fields/form-view.fields.type.definitions\";\r\n\r\nexport const hasKey = (object: any, key: string): boolean => {\r\n  return object.hasOwnProperty(key);\r\n};\r\n\r\nexport const hasPath = (object: any, path: string): boolean => {\r\n  return _.has(object, path);\r\n};\r\n\r\nexport const isEmptyString = (value: string): boolean => {\r\n  return value === \"\";\r\n};\r\nexport const isUndefined = (value: any): boolean => {\r\n  return value === undefined;\r\n};\r\nexport const isNull = (value: any): boolean => {\r\n  return value === null;\r\n};\r\nexport const isEmptyObject = (object: any): boolean => {\r\n  return (\r\n    object &&\r\n    Object.keys(object).length === 0 &&\r\n    Object.getPrototypeOf(object) === Object.prototype\r\n  );\r\n};\r\nexport const isEmptyArray = (arr: any[]): boolean => {\r\n  return arr.length === 0;\r\n};\r\n\r\nexport const isEmpty = (value: any): boolean => {\r\n  if (isEmptyString(value) || isUndefined(value) || isNull(value)) {\r\n    return true;\r\n  } else if (isEmptyObject(value)) {\r\n    return true;\r\n  } else if (Array.isArray(value)) {\r\n    if (isEmptyArray(value)) {\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  } else {\r\n    return false;\r\n  }\r\n};\r\n\r\nexport const isNotEmpty = (value: any) => {\r\n  return !isEmpty(value);\r\n};\r\n\r\nexport const isEmptyBrowserStorageValue = (value: any) => {\r\n  return isNull(value) && isUndefined(value);\r\n};\r\n\r\nexport const isNotEmptyBrowserStorageValue = (value: any) => {\r\n  return !isEmptyBrowserStorageValue(value);\r\n};\r\n\r\nexport const handleJPQueryResponse = (value: any): any => {\r\n  /**\r\n   * jp.query doesn't always return an array with one element\r\n   * so directly can't access with [0], need to check conditionally\r\n   */\r\n  if (Array.isArray(value)) {\r\n    if (value.length > 0) {\r\n      value = value[0];\r\n    } else if (value.length === 0) {\r\n      value = \"\";\r\n    }\r\n  } else {\r\n    value = \"\";\r\n  }\r\n\r\n  return value;\r\n};\r\n\r\nexport const jpQueryWrapper = (obj: any, key: string) => {\r\n  return handleJPQueryResponse(jp.query(obj, key));\r\n};\r\n\r\nexport const replaceString = (\r\n  str: string,\r\n  find: string,\r\n  replace: string\r\n): string => {\r\n  return str.replace(new RegExp(find, \"g\"), replace);\r\n};\r\n\r\nexport const setFieldKeyValue = (field: any, path: string, value: any): any => {\r\n  return _.set(field, path, value);\r\n};\r\n\r\nexport const setValueToObject = (\r\n  object: any,\r\n  path: string,\r\n  value: any\r\n): any => {\r\n  return _.set(object, path, value);\r\n};\r\n\r\nexport const formatValue = (field: TField, fieldValue: any): any => {\r\n  const fieldType: TFieldType = field.type;\r\n  let value: any;\r\n\r\n  if (isNotEmpty(fieldValue)) {\r\n    switch (fieldType) {\r\n      case EFieldType.DATE:\r\n        const splitDate = fieldValue.split(\"-\");\r\n        value = new TuiDay(\r\n          Number(splitDate[2]), // Year\r\n          Number(splitDate[1]) - 1, // Month, Why '-1' => Because Taiga-UI Required It, So...\r\n          Number(splitDate[0]) // Day\r\n        );\r\n        break;\r\n      case EFieldType.RADIO:\r\n        const fieldRadio = field as TFieldRadio;\r\n        value = fieldRadio.options.find((item: any) => {\r\n          return item.label === fieldValue;\r\n        });\r\n        break;\r\n      case EFieldType.CHECKBOX:\r\n        value = Boolean(fieldValue);\r\n        break;\r\n      default:\r\n        value = fieldValue;\r\n        break;\r\n    }\r\n  } else {\r\n    value = fieldValue;\r\n  }\r\n\r\n  return value;\r\n};\r\n\r\nexport const setEmptyValue = (field: TField): any => {\r\n  const fieldType: TFieldType = field.type;\r\n  let value: any;\r\n\r\n  switch (fieldType) {\r\n    case EFieldType.CHECKBOX:\r\n      value = false;\r\n      break;\r\n    case EFieldType.NUMBER:\r\n      value = null;\r\n      break;\r\n    case EFieldType.DATE:\r\n      value = null;\r\n      break;\r\n    default:\r\n      value = \"\";\r\n      break;\r\n  }\r\n\r\n  return value;\r\n};\r\n"]}

package/esm2015/lib/renderer/form-view/helpers/form-view.condition.helper.js

@@ -0,0 +1,46 @@
+import { __decorate } from "tslib";
+import { log } from "../form-view.decorators";
+import { replaceString } from "./form-view.common.helper";
+export class Condition {
+    constructor(condition, rulesMapping) {
+        this._condition = condition;
+        this._rulesMapping = rulesMapping;
+    }
+    parseKeys(condition, rulesEvaluationMapping) {
+        Object.keys(rulesEvaluationMapping).forEach((key) => {
+            condition = replaceString(condition, key, rulesEvaluationMapping[key]);
+        });
+        return condition;
+    }
+    parseOperators(condition) {
+        return condition.replace(/AND|OR|NOT|XOR|NAND|NOR|XNOR/g, (match) => {
+            switch (match) {
+                case "AND":
+                    return "&&";
+                case "OR":
+                    return "||";
+                case "NOT":
+                    return "!";
+                case "XOR":
+                    return "^";
+                case "NAND":
+                    return "!&";
+                case "NOR":
+                    return "!|";
+                case "XNOR":
+                    return "!^";
+                default:
+                    return match;
+            }
+        });
+    }
+    evaluate() {
+        this._condition = this.parseKeys(this._condition, this._rulesMapping);
+        this._condition = this.parseOperators(this._condition);
+        return eval(this._condition);
+    }
+}
+__decorate([
+    log
+], Condition.prototype, "evaluate", null);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/renderer/form-view/helpers/form-view.defaults.helper.js

@@ -0,0 +1,52 @@
+import { __awaiter, __decorate } from "tslib";
+import { isEmpty } from "../../renderer.helper";
+import { log } from "../form-view.decorators";
+import { Actions } from "./form-view.actions.helper";
+import { setEmptyValue, setValueToObject } from "./form-view.common.helper";
+import { Condition } from "./form-view.condition.helper";
+import { Rules } from "./form-view.rules.helper";
+import { Sources } from "./form-view.sources.helper";
+export class Defaults {
+    constructor(field, allFormsData, formData, previousFormData, takeAction) {
+        this._field = field;
+        this._allFormsData = allFormsData;
+        this._formData = formData;
+        this._previousFormData = previousFormData;
+        this._takeAction = takeAction;
+    }
+    getDefaultValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let defaultValue;
+            const sources = this._field.default.value.sources;
+            let sourceIndex = 0;
+            for (let source of sources) {
+                const sources = new Sources(this._field, this._formData, this._previousFormData, this._allFormsData);
+                const value = sources.getValueFromSource(source);
+                // Set the Value of current source.
+                this._field = setValueToObject(this._field, `default.value.sources.[${sourceIndex}].value`, value);
+                const validation = source.validation;
+                const triggers = validation.triggers;
+                const rules = validation.rules;
+                const actions = validation.actions;
+                const rulesMapping = new Rules(rules, this._field, this._formData, this._previousFormData, this._allFormsData).mapping();
+                for (let action of actions) {
+                    const conditionEvaluation = new Condition(action.condition, rulesMapping).evaluate();
+                    if (conditionEvaluation) {
+                        const actions = new Actions(action, this._field, rulesMapping, this._allFormsData, this._formData, this._previousFormData, this._takeAction);
+                        yield actions.execute();
+                    }
+                }
+                sourceIndex++;
+            }
+            defaultValue = this._field.default.value.value;
+            if (isEmpty(defaultValue)) {
+                defaultValue = setEmptyValue(this._field);
+            }
+            return defaultValue;
+        });
+    }
+}
+__decorate([
+    log
+], Defaults.prototype, "getDefaultValue", null);
+//# sourceMappingURL=data:application/json;base64,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