procode-lowcode-core 1.0.9 → 1.0.11

package/src/Validation/StandardValidations/minCharCountValidation.ts

@@ -0,0 +1,27 @@
+import { ValidationFcProperties } from "../Types";
+
+export const minCharCountValidation = ({
+  validation,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const minCharCount = validation.params?.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`,
+  };
+};

package/src/Validation/StandardValidations/notBetweenValidation.ts

@@ -0,0 +1,62 @@
+import { ValidationFcProperties } from "../Types";
+import {
+  resolveCompareValue,
+  parseValue,
+  formatValueForMessage,
+  isEmpty,
+} from "./comparisonValidationHelper";
+
+export const notBetweenValidation = ({
+  validation,
+  viewModel,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  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}`,
+  };
+};

package/src/Validation/Types.ts

@@ -15,6 +15,7 @@ export type Validation = {
   executeMode: ExecuteMode;
   disabled: boolean;
   screenDataField?: string;
+  params?: Record<string, any>;
 };
 
 export type ValidationInvokerProperties = {

package/src/index.ts

@@ -26,6 +26,9 @@ export type { default as IValidationFactory } from './Validation/IValidationFact
 // Schema Reader Interface
 export type { ISchemaReaderProvider } from './UIElement/ISchemaReaderProvider';
 
+// Utils
+export { resolveAppPath } from './Utils/resolveAppPath';
+
 // Core Styles Path (for SCSS imports)
 export const coreStyles = './Assets/styles/index.scss';