npm - ondc-code-generator - Versions diffs - 0.0.6 → 0.0.7 - Mend

ondc-code-generator 0.0.6 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/example.js CHANGED Viewed

@@ -2,9 +2,9 @@
 // import { readFileSync } from "fs";
 // import path from "path";
 // import { fileURLToPath } from "url";
-// import { SupportedLanguages } from "./types/compiler-types.js";
 // const __filename = fileURLToPath(import.meta.url);
 // const __dirname = path.dirname(__filename);
+// import { SupportedLanguages } from "./types/compiler-types.js";
 // const main = async () => {
 // 	const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
 // 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");

package/dist/generator/generators/documentation/templates/index.mustache ADDED Viewed

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>API SERVICE VALIDATIONS</title>
+    <!-- Link to the CSS file -->
+    <link rel="stylesheet" href="./style.css">
+</head>
+<body>
+    <div id="content">
+        <h2>List of validations of api</h2>
+        {{{content}}}
+    </div>
+</body>
+<script>
+    document.addEventListener('DOMContentLoaded', function() {
+        // Select all list items that have a nested <ul> (collapsible items)
+        const collapsibleItems = document.querySelectorAll('li > ul');
+        collapsibleItems.forEach(function(nestedList) {
+            const parentLi = nestedList.parentElement;
+            parentLi.classList.add('collapsible', 'collapsed');
+            // Add click event listener to the <p> inside the list item
+            const clickableArea = parentLi.querySelector('p');
+            clickableArea.addEventListener('click', function(e) {
+                // Prevent click events on links inside the <p>
+                if (e.target.tagName !== 'A') {
+                    parentLi.classList.toggle('collapsed');
+                }
+            });
+        });
+    });
+</script>
+</html>

package/dist/generator/generators/documentation/templates/style.css ADDED Viewed

@@ -0,0 +1,204 @@
+/* RESET DEFAULT STYLES */
+body, ul, li, p, blockquote {
+	margin: 0;
+	padding: 0;
+}
+ul, li {
+	list-style: none;
+}
+/* BODY STYLES */
+body {
+	font-family: "Helvetica Neue", Arial, sans-serif;
+	background-color: #ffffff; /* Light background */
+	color: #333333; /* Dark text */
+	line-height: 1.8;
+	padding: 20px;
+}
+/* LIST STYLES */
+ul {
+	padding-left: 20px;
+}
+li {
+	margin-bottom: 16px;
+	position: relative;
+}
+li > p {
+	margin-bottom: 8px;
+	background-color: #f7f7f7; /* Light background */
+	color: #555555; /* Dark text */
+	padding: 10px 15px;
+	border: 1px solid #ddd;
+	border-radius: 5px;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+li > p:hover {
+	background-color: #e8e8e8;
+	border-color: #1296d9; /* Updated to blue accent color */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+/* NESTED LIST ITEMS */
+ul ul li > p {
+	background-color: #f0f0f0; /* Slightly darker than parent */
+}
+ul ul li > p:hover {
+	background-color: #e0e0e0;
+}
+/* HEADINGS AND EMPHASIS TEXT */
+h2,
+li > p > strong {
+	color: #1296d9; /* Changed header color to match blue theme */
+	font-weight: 600;
+}
+li > p > strong {
+	font-size: 1.1em;
+}
+/* BLOCKQUOTE STYLES */
+blockquote {
+	margin: 15px 0;
+	padding: 15px 20px;
+	background-color: #f7f7f7;
+	border-left: 5px solid #1296d9; /* Updated border to blue */
+	color: #555555;
+	font-style: italic;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border-left-color 0.3s, box-shadow 0.3s;
+}
+blockquote:hover {
+	background-color: #e8e8e8;
+	border-left-color: #1296d9; /* Updated hover border to blue */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+/* BLOCKQUOTE INTERNAL ELEMENTS */
+blockquote > p {
+	margin-bottom: 12px;
+	padding: 10px 15px;
+	background-color: #f7f7f7;
+	border-radius: 5px;
+	font-size: 1em;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+blockquote > p:hover {
+	background-color: #e8e8e8;
+	border: 1px solid #1296d9; /* Updated border to blue on hover */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+blockquote > ul {
+	padding-left: 20px;
+	margin-top: 10px;
+}
+blockquote > ul > li {
+	margin-bottom: 16px;
+	position: relative;
+	background-color: #f7f7f7;
+	padding: 10px 15px;
+	border: 1px solid #ddd;
+	border-radius: 5px;
+	box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+blockquote > ul > li:hover {
+	background-color: #e8e8e8;
+	border-color: #1296d9; /* Updated border to blue on hover */
+	box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+blockquote > ul > li > strong {
+	color: #1296d9; /* Changed to blue for emphasis */
+	font-weight: 600;
+	font-size: 1.1em;
+}
+blockquote > ul > li > ul {
+	padding-left: 20px;
+	margin-top: 8px;
+}
+blockquote > ul > li > ul > li {
+	background-color: #f0f0f0;
+	padding: 8px 12px;
+	border: 1px solid #ccc;
+	border-radius: 4px;
+	box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+	transition: background-color 0.3s, border 0.3s, box-shadow 0.3s;
+}
+blockquote > ul > li > ul > li:hover {
+	background-color: #e0e0e0;
+	border-color: #1296d9; /* Updated border to blue on hover */
+	box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+}
+/* COLLAPSIBLE INDICATORS */
+li.collapsible > p {
+	cursor: pointer;
+}
+li.collapsible > p::before {
+	content: "▼";
+	display: inline-block;
+	margin-right: 8px;
+	transition: transform 0.3s, color 0.3s;
+	color: #1296d9; /* Updated color to blue */
+}
+li.collapsible.collapsed > p::before {
+	transform: rotate(-90deg);
+}
+li.collapsible > p:hover::before {
+	color: #1296d9; /* Lighter blue on hover */
+}
+/* Hide nested lists by default */
+li.collapsible.collapsed > ul {
+	display: none;
+}
+/* RESPONSIVE DESIGN */
+@media only screen and (max-width: 768px) {
+	body {
+		padding: 15px;
+	}
+	ul {
+		padding-left: 15px;
+	}
+	li > p,
+	blockquote > p,
+	blockquote > ul > li {
+		font-size: 0.95em;
+		padding: 8px 12px;
+	}
+}
+/* CUSTOM SCROLLBAR */
+::-webkit-scrollbar {
+	width: 8px;
+	background-color: #ffffff;
+}
+::-webkit-scrollbar-thumb {
+	background-color: #ccc;
+	border-radius: 10px;
+}
+::-webkit-scrollbar-thumb:hover {
+	background-color: #bbb;
+}

package/dist/generator/generators/typescript/templates/api-test.mustache ADDED Viewed

@@ -0,0 +1,7 @@
+import payloadUtils from "../utils/json-path-utils";
+import validations from "../utils/validation-utils";
+import { testFunctionArray, validationInput, validationOutput } from "../types/test-config";
+export default {{{functionCode}}}

package/dist/generator/generators/typescript/templates/json-path-utils.mustache ADDED Viewed

@@ -0,0 +1,17 @@
+import jsonpath from "jsonpath";
+function getJsonPath(payload: any, path: string) {
+	let output = jsonpath.query(payload, path);
+	if (isListOfStringsOrNull(output)) {
+		output = output.map((o) => (o === null ? "null" : o));
+	}
+	return output.length === 0 ? [] : output;
+}
+function isListOfStringsOrNull(variable: any): boolean {
+	return (
+		Array.isArray(variable) &&
+		variable.every((item) => item === null || typeof item === "string")
+	);
+}
+export default {
+	getJsonPath,
+};

package/dist/generator/generators/typescript/templates/schema-template.mustache ADDED Viewed

@@ -0,0 +1,18 @@
+{{#actions}}
+import { {{{action}}} } from './{{{action}}}'
+{{/actions}}
+export default function getSchema(action : string){
+    switch(action){
+        {{#actions}}
+        case '{{{action}}}':
+            return {{{action}}};
+        {{/actions}}
+        default:
+            throw new Error('Action not found');
+    }
+}

package/dist/generator/generators/typescript/templates/test-config.mustache ADDED Viewed

@@ -0,0 +1,28 @@
+export interface ValidationConfig {
+    runAllValidations: boolean;
+}
+export type validationOutput = {
+	valid: boolean;
+	code: number;
+	description?: string;
+}[];
+/*
+{% comment %} export type ExternalData = {
+    {{#externalData}}
+    {{name}}?: string[];
+    {{/externalData}}
+}; {% endcomment %}
+*/
+export type ExternalData = {}
+export type validationInput = {
+	payload: any;
+	externalData: ExternalData;
+	config: ValidationConfig
+};
+export type testFunctionArray = Array<(input: validationInput) => validationOutput>;

package/dist/generator/generators/typescript/templates/test-object.mustache ADDED Viewed

@@ -0,0 +1,20 @@
+function {{name}}(input: validationInput): validationOutput {
+    const scope = payloadUtils.getJsonPath(input.payload,"{{{scopePath}}}");
+    let subResults: validationOutput = [];
+    let valid = true;
+    for(const testObj of scope){
+        testObj._EXTERNAL = input.externalData;
+        {{#variables}}
+        const {{name}} = {{{value}}}
+        {{/variables}}
+        {{#hasContinue}}
+            const skipCheck = {{{skipCheckStatement}}};
+            if(skipCheck) continue;
+        {{/hasContinue}}
+        {{{validationCode}}}
+        delete testObj._EXTERNAL;
+    }
+    return [{valid: valid,code: {{successCode}} },...subResults];
+}

package/dist/generator/generators/typescript/templates/validation-code.mustache ADDED Viewed

@@ -0,0 +1,39 @@
+{{#isNested}}
+{{{nestedFunctions}}}
+const testFunctions: testFunctionArray = [
+    {{#names}}
+    {{name}},
+    {{/names}}
+];
+let invalidResults: validationOutput = [];
+for (const fn of testFunctions) {
+    const subResult = fn(input);
+    // .filter(r => !r.valid);
+    invalidResults = [...invalidResults, ...subResult];
+    if(!input.config.runAllValidations && invalidResults.length > 0) {
+        return invalidResults;
+    }
+}
+if(invalidResults.length > 0) {
+    // return invalidResults;
+    subResults = invalidResults;
+    valid = subResults.every(r => r.valid);
+}
+{{/isNested}}
+{{^isNested}}
+const validate = {{{returnStatement}}}
+if(!validate){
+    return [{
+        valid: false,
+        code: {{errorCode}},
+        description: `{{{errorDescription}}}`
+    }]
+}
+{{/isNested}}

package/dist/generator/generators/typescript/templates/validation-utils.mustache ADDED Viewed

@@ -0,0 +1,117 @@
+function areUnique(operand: string[]) {
+	const valuesSet = new Set(operand);
+	return valuesSet.size === operand.length;
+}
+function arePresent(operand: string[]) {
+	return noneIn(operand, ["", "null", "undefined"]) && operand.length > 0;
+}
+function allIn(left: string[], right: string[]) {
+	return left.every((v) => right.includes(v));
+}
+function anyIn(left: string[], right: string[]) {
+	return left.some((v) => right.includes(v));
+}
+function noneIn(left: string[], right: string[]) {
+	return left.every((v) => !right.includes(v));
+}
+function equalTo(left: string[], right: string[]) {
+	if (left.length !== right.length) return false;
+	return left.every((v, i) => v === right[i]);
+}
+function greaterThan(left: string[], right: string[]): boolean {
+	// Check if all elements in an array are ISO 8601 dates
+	const areAllISO = (arr: string[]) => arr.every((v) => isISO8601(v));
+	// Check if all elements in an array are numbers
+	const areAllNumbers = (arr: string[]) =>
+		arr.every((v) => !isNaN(Number(v)));
+	if (areAllISO(left) && areAllISO(right)) {
+		// Compare ISO 8601 dates
+		const leftDates = left.map((date) => new Date(date).getTime());
+		const rightDates = right.map((date) => new Date(date).getTime());
+		return leftDates.every(
+			(ld, index) => ld > rightDates[index] || index >= rightDates.length,
+		);
+	} else if (areAllNumbers(left) && areAllNumbers(right)) {
+		// Compare numbers
+		const leftNumbers = left.map(Number);
+		const rightNumbers = right.map(Number);
+		return leftNumbers.every(
+			(ln, index) =>
+				ln > rightNumbers[index] || index >= rightNumbers.length,
+		);
+	}
+	// If neither condition is met, return false
+	return false;
+}
+function lessThan(left: string[], right: string[]): boolean {
+	// Check if all elements in an array are ISO 8601 dates
+	const areAllISO = (arr: string[]) => arr.every((v) => isISO8601(v));
+	// Check if all elements in an array are numbers
+	const areAllNumbers = (arr: string[]) =>
+		arr.every((v) => !isNaN(Number(v)));
+	if (areAllISO(left) && areAllISO(right)) {
+		// Compare ISO 8601 dates
+		const leftDates = left.map((date) => new Date(date).getTime());
+		const rightDates = right.map((date) => new Date(date).getTime());
+		return leftDates.every(
+			(ld, index) => ld < rightDates[index] || index >= rightDates.length,
+		);
+	} else if (areAllNumbers(left) && areAllNumbers(right)) {
+		// Compare numbers
+		const leftNumbers = left.map(Number);
+		const rightNumbers = right.map(Number);
+		return leftNumbers.every(
+			(ln, index) =>
+				ln < rightNumbers[index] || index >= rightNumbers.length,
+		);
+	}
+	// If neither condition is met, return false
+	return false;
+}
+function followRegex(left: string[], regexArray: string[]) {
+	for (const regex of regexArray) {
+		const re = new RegExp(regex);
+		if (left.some((v) => !re.test(v))) return false;
+	}
+	return true;
+}
+function isISO8601(str: string): boolean {
+	// Regular expression to match ISO 8601 format
+	const iso8601Regex =
+		/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+	// Check if the string matches the ISO 8601 format
+	if (!iso8601Regex.test(str)) {
+		return false;
+	}
+	// Check if the string is a valid date
+	const date = new Date(str);
+	return !isNaN(date.getTime());
+}
+export default {
+	areUnique,
+	arePresent,
+	allIn,
+	anyIn,
+	noneIn,
+	equalTo,
+	followRegex,
+	greaterThan,
+	lessThan,
+};

package/dist/generator/generators/typescript/ts-generator.js CHANGED Viewed

@@ -35,8 +35,8 @@ export class TypescriptGenerator extends CodeGenerator {
             }
         };
         this.generateCode = async () => {
-            const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.ts"), "utf-8");
-            const validtionUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.ts"), "utf-8");
+            const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.mustache"), "utf-8");
+            const validtionUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.mustache"), "utf-8");
             const typesTemplate = readFileSync(path.resolve(__dirname, "./templates/test-config.mustache"), "utf-8");
             const typesCode = Mustache.render(typesTemplate, {
                 externalData: this.getExternalKeys(),

package/dist/index.d.ts CHANGED Viewed

@@ -1,2 +1 @@
-import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+export {};

package/dist/index.js CHANGED Viewed

@@ -1,2 +1,42 @@
+// import { ConfigCompiler } from "./generator/config-compiler.js";
+// export { ConfigCompiler };
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { SupportedLanguages } from "./types/compiler-types.js";
 import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+// Get __dirname equivalent
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const main = async () => {
+    const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+    const buildPath = path.resolve(__dirname, "../samples/build.yaml");
+    const valConfigPath = path.resolve(__dirname, "../samples/validation-config.json");
+    const buildYaml = readFileSync(buildPath, "utf-8");
+    const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
+    await compiler.initialize(buildYaml);
+    await compiler.generateCode(valConfig);
+    // await compiler.generateL0Schema();
+    // await compiler.performValidations(valConfig);
+    // const inputs = [
+    // 	"a are unique && b are unique",
+    // 	"a are unique",
+    // 	"(a are unique && b are unique) || c are unique",
+    // 	"a are unique && b are unique || c are unique",
+    // 	"a are unique && (b are unique || c are unique)",
+    // 	"a are unique && b are unique && c are unique && d are unique",
+    // 	"a are unique && !(b are unique || !(c are unique))",
+    // 	"a are unique && (b are unique || !(!(c are unique))) && !(d are unique)",
+    // ];
+    // let output = "";
+    // for (const input of inputs) {
+    // 	const cst = parseReturnInput(input);
+    // 	const ast = buildAst(cst);
+    // 	const out = CompileToMarkdown(ast, "A", 0, false);
+    // 	output += `\n## ${input}\n\n${out}\n`;
+    // }
+    // writeFileSync(path.resolve(__dirname, "../samples/output.md"), output);
+};
+(async () => {
+    await main();
+})();

package/package.json CHANGED Viewed

@@ -1,11 +1,11 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.0.6",
+	"version": "0.0.7",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
 	"type": "module",
 	"scripts": {
-		"build": "tsc",
+		"build": "tsc && copyfiles -u 1 \"src/**/*.{yaml,html,css,mustache}\" dist/",
 		"start": "node ./dist/index.js",
 		"dev": "nodemon",
 		"clean": "rm -rf dist",
@@ -20,6 +20,7 @@
 		"@types/jsonpath": "^0.2.4",
 		"@types/mustache": "^4.2.5",
 		"@types/node": "^22.10.1",
+		"copyfiles": "^2.4.1",
 		"esm-loader-typescript": "^1.0.6",
 		"nodemon": "^3.1.7",
 		"ts-node": "^10.9.2",

package/dist/generator/generators/typescript/templates/json-path-utils.d.ts DELETED Viewed

@@ -1,5 +0,0 @@
-declare function getJsonPath(payload: any, path: string): any[];
-declare const _default: {
-    getJsonPath: typeof getJsonPath;
-};
-export default _default;

package/dist/generator/generators/typescript/templates/json-path-utils.js DELETED Viewed

@@ -1,15 +0,0 @@
-import jsonpath from "jsonpath";
-function getJsonPath(payload, path) {
-    let output = jsonpath.query(payload, path);
-    if (isListOfStringsOrNull(output)) {
-        output = output.map((o) => (o === null ? "null" : o));
-    }
-    return output.length === 0 ? [] : output;
-}
-function isListOfStringsOrNull(variable) {
-    return (Array.isArray(variable) &&
-        variable.every((item) => item === null || typeof item === "string"));
-}
-export default {
-    getJsonPath,
-};

package/dist/generator/generators/typescript/templates/validation-utils.d.ts DELETED Viewed

@@ -1,21 +0,0 @@
-declare function areUnique(operand: string[]): boolean;
-declare function arePresent(operand: string[]): boolean;
-declare function allIn(left: string[], right: string[]): boolean;
-declare function anyIn(left: string[], right: string[]): boolean;
-declare function noneIn(left: string[], right: string[]): boolean;
-declare function equalTo(left: string[], right: string[]): boolean;
-declare function greaterThan(left: string[], right: string[]): boolean;
-declare function lessThan(left: string[], right: string[]): boolean;
-declare function followRegex(left: string[], regexArray: string[]): boolean;
-declare const _default: {
-    areUnique: typeof areUnique;
-    arePresent: typeof arePresent;
-    allIn: typeof allIn;
-    anyIn: typeof anyIn;
-    noneIn: typeof noneIn;
-    equalTo: typeof equalTo;
-    followRegex: typeof followRegex;
-    greaterThan: typeof greaterThan;
-    lessThan: typeof lessThan;
-};
-export default _default;

package/dist/generator/generators/typescript/templates/validation-utils.js DELETED Viewed

@@ -1,91 +0,0 @@
-function areUnique(operand) {
-    const valuesSet = new Set(operand);
-    return valuesSet.size === operand.length;
-}
-function arePresent(operand) {
-    return noneIn(operand, ["", "null", "undefined"]) && operand.length > 0;
-}
-function allIn(left, right) {
-    return left.every((v) => right.includes(v));
-}
-function anyIn(left, right) {
-    return left.some((v) => right.includes(v));
-}
-function noneIn(left, right) {
-    return left.every((v) => !right.includes(v));
-}
-function equalTo(left, right) {
-    if (left.length !== right.length)
-        return false;
-    return left.every((v, i) => v === right[i]);
-}
-function greaterThan(left, right) {
-    // Check if all elements in an array are ISO 8601 dates
-    const areAllISO = (arr) => arr.every((v) => isISO8601(v));
-    // Check if all elements in an array are numbers
-    const areAllNumbers = (arr) => arr.every((v) => !isNaN(Number(v)));
-    if (areAllISO(left) && areAllISO(right)) {
-        // Compare ISO 8601 dates
-        const leftDates = left.map((date) => new Date(date).getTime());
-        const rightDates = right.map((date) => new Date(date).getTime());
-        return leftDates.every((ld, index) => ld > rightDates[index] || index >= rightDates.length);
-    }
-    else if (areAllNumbers(left) && areAllNumbers(right)) {
-        // Compare numbers
-        const leftNumbers = left.map(Number);
-        const rightNumbers = right.map(Number);
-        return leftNumbers.every((ln, index) => ln > rightNumbers[index] || index >= rightNumbers.length);
-    }
-    // If neither condition is met, return false
-    return false;
-}
-function lessThan(left, right) {
-    // Check if all elements in an array are ISO 8601 dates
-    const areAllISO = (arr) => arr.every((v) => isISO8601(v));
-    // Check if all elements in an array are numbers
-    const areAllNumbers = (arr) => arr.every((v) => !isNaN(Number(v)));
-    if (areAllISO(left) && areAllISO(right)) {
-        // Compare ISO 8601 dates
-        const leftDates = left.map((date) => new Date(date).getTime());
-        const rightDates = right.map((date) => new Date(date).getTime());
-        return leftDates.every((ld, index) => ld < rightDates[index] || index >= rightDates.length);
-    }
-    else if (areAllNumbers(left) && areAllNumbers(right)) {
-        // Compare numbers
-        const leftNumbers = left.map(Number);
-        const rightNumbers = right.map(Number);
-        return leftNumbers.every((ln, index) => ln < rightNumbers[index] || index >= rightNumbers.length);
-    }
-    // If neither condition is met, return false
-    return false;
-}
-function followRegex(left, regexArray) {
-    for (const regex of regexArray) {
-        const re = new RegExp(regex);
-        if (left.some((v) => !re.test(v)))
-            return false;
-    }
-    return true;
-}
-function isISO8601(str) {
-    // Regular expression to match ISO 8601 format
-    const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
-    // Check if the string matches the ISO 8601 format
-    if (!iso8601Regex.test(str)) {
-        return false;
-    }
-    // Check if the string is a valid date
-    const date = new Date(str);
-    return !isNaN(date.getTime());
-}
-export default {
-    areUnique,
-    arePresent,
-    allIn,
-    anyIn,
-    noneIn,
-    equalTo,
-    followRegex,
-    greaterThan,
-    lessThan,
-};