procode-lowcode-core 1.0.10 → 1.0.11

package/dist/index.esm.js

@@ -18706,14 +18706,26 @@ const handleUpdateAndNavigate = (actionInvokerProps) => __awaiter(void 0, void 0
     }
 });
 
+const replaceEndPointParams = (endPoint, data) => {
+    if (!endPoint || !data || typeof data !== "object")
+        return endPoint;
+    return endPoint.replace(/:([a-zA-Z0-9_]+)/g, (match, paramName) => {
+        return data[paramName] !== undefined && data[paramName] !== null
+            ? encodeURIComponent(String(data[paramName]))
+            : match;
+    });
+};
 const handleAPICreate = (actionInvokerProps, data) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const eventService = actionInvokerProps.eventService;
     const uiSchema = eventService === null || eventService === void 0 ? void 0 : eventService.emit(eventServiceType.UISCHEMA);
-    const apiConfig = (_a = actionInvokerProps.actionProps.config.apiConfig) !== null && _a !== void 0 ? _a : _.cloneDeep(uiSchema.apiConfig);
-    const response = yield ((_b = AppDependenceyProvider.getInstance()
-        .getViewModelHandler()) === null || _b === void 0 ? void 0 : _b.createModel(data, apiConfig, eventService));
-    (_c = actionInvokerProps.callBack) === null || _c === void 0 ? void 0 : _c.call(actionInvokerProps, response);
+    const apiConfig = _.cloneDeep((_a = actionInvokerProps.actionProps.config.apiConfig) !== null && _a !== void 0 ? _a : uiSchema.apiConfig);
+    if (((_b = apiConfig === null || apiConfig === void 0 ? void 0 : apiConfig.create) === null || _b === void 0 ? void 0 : _b.endPoint) && data) {
+        apiConfig.create.endPoint = replaceEndPointParams(apiConfig.create.endPoint, Array.isArray(data) ? data[0] : data);
+    }
+    const response = yield ((_c = AppDependenceyProvider.getInstance()
+        .getViewModelHandler()) === null || _c === void 0 ? void 0 : _c.createModel(data, apiConfig, eventService));
+    (_d = actionInvokerProps.callBack) === null || _d === void 0 ? void 0 : _d.call(actionInvokerProps, response);
 });
 
 const handleAPIUpdate = (actionInvokerProps, data) => __awaiter(void 0, void 0, void 0, function* () {
@@ -18862,8 +18874,104 @@ var StandardValidationType;
     StandardValidationType["REQUIRED"] = "REQUIRED";
     StandardValidationType["EMAIL"] = "EMAIL";
     StandardValidationType["BULK_EMAIL"] = "BULK_EMAIL";
+    StandardValidationType["MIN_CHAR_COUNT"] = "MIN_CHAR_COUNT";
+    StandardValidationType["MAX_CHAR_COUNT"] = "MAX_CHAR_COUNT";
+    StandardValidationType["GREATER_THAN"] = "GREATER_THAN";
+    StandardValidationType["GREATER_THAN_EQUAL"] = "GREATER_THAN_EQUAL";
+    StandardValidationType["LESS_THAN"] = "LESS_THAN";
+    StandardValidationType["LESS_THAN_EQUAL"] = "LESS_THAN_EQUAL";
+    StandardValidationType["BETWEEN"] = "BETWEEN";
+    StandardValidationType["NOT_BETWEEN"] = "NOT_BETWEEN";
 })(StandardValidationType || (StandardValidationType = {}));
 
+/**
+ * Resolves a comparison value from either a static param or a field path in the viewModel.
+ * fieldPath takes priority over static value when both are provided.
+ */
+const resolveCompareValue = (staticValue, fieldPath, viewModel) => {
+    if (fieldPath) {
+        return getValueFromNestedObject(fieldPath, viewModel);
+    }
+    return staticValue;
+};
+/**
+ * Parses a raw value into a comparable numeric representation based on dataType.
+ * Returns null if the value cannot be parsed.
+ */
+const parseValue = (raw, dataType) => {
+    if (raw === null || raw === undefined || raw === "")
+        return null;
+    if (dataType === "number") {
+        const num = Number(raw);
+        return isNaN(num) ? null : num;
+    }
+    if (dataType === "date") {
+        const timestamp = new Date(raw).getTime();
+        return isNaN(timestamp) ? null : timestamp;
+    }
+    if (dataType === "list") {
+        if (Array.isArray(raw))
+            return raw.length;
+        const num = Number(raw);
+        return isNaN(num) ? null : num;
+    }
+    return null;
+};
+/**
+ * Formats a raw value for display in validation messages.
+ */
+const formatValueForMessage = (raw, dataType) => {
+    if (dataType === "date") {
+        const date = new Date(raw);
+        return isNaN(date.getTime()) ? String(raw) : date.toLocaleDateString();
+    }
+    if (dataType === "list") {
+        return `${raw} item${Number(raw) === 1 ? "" : "s"}`;
+    }
+    return String(raw);
+};
+/**
+ * Checks if a raw value is empty (null, undefined, or empty string).
+ */
+const isEmpty = (value) => value === null ||
+    value === undefined ||
+    value === "" ||
+    (Array.isArray(value) && value.length === 0);
+
+const betweenValidation = ({ validation, viewModel, value, }) => {
+    const { minValue, minFieldPath, maxValue, maxFieldPath, dataType = "number", } = validation.params || {};
+    if (minValue === undefined && !minFieldPath) {
+        console.error("BETWEEN validation requires 'minValue' or 'minFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: min boundary is missing" };
+    }
+    if (maxValue === undefined && !maxFieldPath) {
+        console.error("BETWEEN validation requires 'maxValue' or 'maxFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: max boundary is missing" };
+    }
+    if (isEmpty(value))
+        return { isValid: true, message: "" };
+    const rawMin = resolveCompareValue(minValue, minFieldPath, viewModel);
+    const rawMax = resolveCompareValue(maxValue, maxFieldPath, viewModel);
+    if (isEmpty(rawMin) || isEmpty(rawMax))
+        return { isValid: true, message: "" };
+    const parsedValue = parseValue(value, dataType);
+    const parsedMin = parseValue(rawMin, dataType);
+    const parsedMax = parseValue(rawMax, dataType);
+    if (parsedValue === null || parsedMin === null || parsedMax === null) {
+        return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+    }
+    const isValid = parsedValue >= parsedMin && parsedValue <= parsedMax;
+    const minLabel = formatValueForMessage(rawMin, dataType);
+    const maxLabel = formatValueForMessage(rawMax, dataType);
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message ||
+                `Value must be between ${minLabel} and ${maxLabel}`,
+    };
+};
+
 const emailBulkValidation = ({ validation, viewModel, eventService, value, }) => {
     const regex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
     const emails = String(value).toLowerCase().split(";");
@@ -18885,6 +18993,194 @@ const emailValidation = ({ validation, viewModel, eventService, value, }) => {
     };
 };
 
+const greaterThanEqualValidation = ({ validation, viewModel, value, }) => {
+    const { compareValue, compareFieldPath, dataType = "number" } = validation.params || {};
+    if (compareValue === undefined && !compareFieldPath) {
+        console.error("GREATER_THAN_EQUAL validation requires 'compareValue' or 'compareFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+    }
+    if (isEmpty(value))
+        return { isValid: true, message: "" };
+    const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+    if (isEmpty(rawCompare))
+        return { isValid: true, message: "" };
+    const parsedValue = parseValue(value, dataType);
+    const parsedCompare = parseValue(rawCompare, dataType);
+    if (parsedValue === null || parsedCompare === null) {
+        return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+    }
+    const isValid = parsedValue >= parsedCompare;
+    const compareLabel = compareFieldPath
+        ? formatValueForMessage(rawCompare, dataType)
+        : formatValueForMessage(compareValue, dataType);
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message ||
+                `Value must be greater than or equal to ${compareLabel}`,
+    };
+};
+
+const greaterThanValidation = ({ validation, viewModel, value, }) => {
+    const { compareValue, compareFieldPath, dataType = "number" } = validation.params || {};
+    if (compareValue === undefined && !compareFieldPath) {
+        console.error("GREATER_THAN validation requires 'compareValue' or 'compareFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+    }
+    if (isEmpty(value))
+        return { isValid: true, message: "" };
+    const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+    if (isEmpty(rawCompare))
+        return { isValid: true, message: "" };
+    const parsedValue = parseValue(value, dataType);
+    const parsedCompare = parseValue(rawCompare, dataType);
+    if (parsedValue === null || parsedCompare === null) {
+        return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+    }
+    const isValid = parsedValue > parsedCompare;
+    const compareLabel = compareFieldPath
+        ? formatValueForMessage(rawCompare, dataType)
+        : formatValueForMessage(compareValue, dataType);
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message || `Value must be greater than ${compareLabel}`,
+    };
+};
+
+const lessThanEqualValidation = ({ validation, viewModel, value, }) => {
+    const { compareValue, compareFieldPath, dataType = "number" } = validation.params || {};
+    if (compareValue === undefined && !compareFieldPath) {
+        console.error("LESS_THAN_EQUAL validation requires 'compareValue' or 'compareFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+    }
+    if (isEmpty(value))
+        return { isValid: true, message: "" };
+    const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+    if (isEmpty(rawCompare))
+        return { isValid: true, message: "" };
+    const parsedValue = parseValue(value, dataType);
+    const parsedCompare = parseValue(rawCompare, dataType);
+    if (parsedValue === null || parsedCompare === null) {
+        return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+    }
+    const isValid = parsedValue <= parsedCompare;
+    const compareLabel = compareFieldPath
+        ? formatValueForMessage(rawCompare, dataType)
+        : formatValueForMessage(compareValue, dataType);
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message ||
+                `Value must be less than or equal to ${compareLabel}`,
+    };
+};
+
+const lessThanValidation = ({ validation, viewModel, value, }) => {
+    const { compareValue, compareFieldPath, dataType = "number" } = validation.params || {};
+    if (compareValue === undefined && !compareFieldPath) {
+        console.error("LESS_THAN validation requires 'compareValue' or 'compareFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+    }
+    if (isEmpty(value))
+        return { isValid: true, message: "" };
+    const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+    if (isEmpty(rawCompare))
+        return { isValid: true, message: "" };
+    const parsedValue = parseValue(value, dataType);
+    const parsedCompare = parseValue(rawCompare, dataType);
+    if (parsedValue === null || parsedCompare === null) {
+        return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+    }
+    const isValid = parsedValue < parsedCompare;
+    const compareLabel = compareFieldPath
+        ? formatValueForMessage(rawCompare, dataType)
+        : formatValueForMessage(compareValue, dataType);
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message || `Value must be less than ${compareLabel}`,
+    };
+};
+
+const maxCharCountValidation = ({ validation, value, }) => {
+    var _a;
+    const maxCharCount = (_a = validation.params) === null || _a === void 0 ? void 0 : _a.maxCharCount;
+    if (maxCharCount === undefined || maxCharCount === null) {
+        console.error("MAX_CHAR_COUNT validation requires 'maxCharCount' in params");
+        return { isValid: false, message: "Validation misconfigured: maxCharCount param is missing" };
+    }
+    if (value === null || value === undefined || value === "") {
+        return { isValid: true, message: "" };
+    }
+    const strValue = String(value);
+    const isValid = strValue.length <= maxCharCount;
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message || `Maximum ${maxCharCount} characters allowed`,
+    };
+};
+
+const minCharCountValidation = ({ validation, value, }) => {
+    var _a;
+    const minCharCount = (_a = validation.params) === null || _a === void 0 ? void 0 : _a.minCharCount;
+    if (minCharCount === undefined || minCharCount === null) {
+        console.error("MIN_CHAR_COUNT validation requires 'minCharCount' in params");
+        return { isValid: false, message: "Validation misconfigured: minCharCount param is missing" };
+    }
+    if (value === null || value === undefined || value === "") {
+        return { isValid: true, message: "" };
+    }
+    const strValue = String(value);
+    const isValid = strValue.length >= minCharCount;
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message || `Minimum ${minCharCount} characters required`,
+    };
+};
+
+const notBetweenValidation = ({ validation, viewModel, value, }) => {
+    const { minValue, minFieldPath, maxValue, maxFieldPath, dataType = "number", } = validation.params || {};
+    if (minValue === undefined && !minFieldPath) {
+        console.error("NOT_BETWEEN validation requires 'minValue' or 'minFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: min boundary is missing" };
+    }
+    if (maxValue === undefined && !maxFieldPath) {
+        console.error("NOT_BETWEEN validation requires 'maxValue' or 'maxFieldPath' in params");
+        return { isValid: false, message: "Validation misconfigured: max boundary is missing" };
+    }
+    if (isEmpty(value))
+        return { isValid: true, message: "" };
+    const rawMin = resolveCompareValue(minValue, minFieldPath, viewModel);
+    const rawMax = resolveCompareValue(maxValue, maxFieldPath, viewModel);
+    if (isEmpty(rawMin) || isEmpty(rawMax))
+        return { isValid: true, message: "" };
+    const parsedValue = parseValue(value, dataType);
+    const parsedMin = parseValue(rawMin, dataType);
+    const parsedMax = parseValue(rawMax, dataType);
+    if (parsedValue === null || parsedMin === null || parsedMax === null) {
+        return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+    }
+    const isValid = parsedValue < parsedMin || parsedValue > parsedMax;
+    const minLabel = formatValueForMessage(rawMin, dataType);
+    const maxLabel = formatValueForMessage(rawMax, dataType);
+    return {
+        isValid,
+        message: isValid
+            ? ""
+            : validation.message ||
+                `Value must not be between ${minLabel} and ${maxLabel}`,
+    };
+};
+
 const requiredValidation = ({ validation, viewModel, eventService, value, }) => {
     const isValid = !((Array.isArray(value) && value.length === 0) ||
         value === null ||
@@ -18906,6 +19202,14 @@ class StandardValidationFactory {
                 [StandardValidationType.REQUIRED]: requiredValidation,
                 [StandardValidationType.EMAIL]: emailValidation,
                 [StandardValidationType.BULK_EMAIL]: emailBulkValidation,
+                [StandardValidationType.MIN_CHAR_COUNT]: minCharCountValidation,
+                [StandardValidationType.MAX_CHAR_COUNT]: maxCharCountValidation,
+                [StandardValidationType.GREATER_THAN]: greaterThanValidation,
+                [StandardValidationType.GREATER_THAN_EQUAL]: greaterThanEqualValidation,
+                [StandardValidationType.LESS_THAN]: lessThanValidation,
+                [StandardValidationType.LESS_THAN_EQUAL]: lessThanEqualValidation,
+                [StandardValidationType.BETWEEN]: betweenValidation,
+                [StandardValidationType.NOT_BETWEEN]: notBetweenValidation,
             }
         });
     }