reliant-type 1.0.0

package/dist/esm/core/schema/extensions/components/AutoDocumentation/InteractiveDocumentationGenerator.js

@@ -0,0 +1,172 @@
+/**
+ * Interactive documentation generator
+ */
+class InteractiveDocumentationGenerator {
+    constructor(schema, options) {
+        this.schema = schema;
+        this.options = options;
+    }
+    generate() {
+        return {
+            html: this.generateInteractiveHTML(),
+            css: this.generateCSS(),
+            javascript: this.generateJavaScript()
+        };
+    }
+    generateInteractiveHTML() {
+        return `
+<div id="schema-playground">
+    <h1>${this.options.title || 'Schema Playground'}</h1>
+    <div class="playground-container">
+        <div class="schema-panel">
+            <h2>Schema</h2>
+            <pre id="schema-display"></pre>
+        </div>
+        <div class="input-panel">
+            <h2>Test Data</h2>
+            <textarea id="test-input" placeholder="Enter JSON data to validate..."></textarea>
+            <button id="validate-btn">Validate</button>
+        </div>
+        <div class="result-panel">
+            <h2>Result</h2>
+            <div id="validation-result"></div>
+        </div>
+    </div>
+</div>`;
+    }
+    generateCSS() {
+        return `
+.playground-container { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 1rem; }
+.schema-panel, .input-panel, .result-panel { border: 1px solid #e1e5e9; border-radius: 6px; padding: 1rem; }
+#test-input { width: 100%; height: 200px; font-family: monospace; }
+#validate-btn { background: #0366d6; color: white; border: none; padding: 0.5rem 1rem; border-radius: 4px; cursor: pointer; }
+.valid { color: #28a745; }
+.invalid { color: #dc3545; }`;
+    }
+    generateJavaScript() {
+        const schemaStr = JSON.stringify(this.schema, null, 2);
+        return `
+document.getElementById('schema-display').textContent = ${schemaStr};
+
+// Real validation function
+function validateData(schema, data) {
+    const errors = [];
+
+    for (const [fieldName, fieldType] of Object.entries(schema)) {
+        const value = data[fieldName];
+        const fieldErrors = validateField(fieldType, value, fieldName);
+        if (fieldErrors.length > 0) {
+            errors.push(...fieldErrors);
+        }
+    }
+
+    return errors;
+}
+
+function validateField(fieldType, value, fieldName) {
+    const errors = [];
+
+    if (typeof fieldType === 'string') {
+        const isOptional = fieldType.includes('?');
+        const cleanType = fieldType.replace('?', '');
+
+        // Handle null/undefined for optional fields
+        if (isOptional && (value === null || value === undefined)) {
+            return errors;
+        }
+
+        // Required field cannot be null/undefined
+        if (!isOptional && (value === null || value === undefined)) {
+            errors.push(fieldName + ': Field is required');
+            return errors;
+        }
+
+        // Type-specific validation
+        if (cleanType === 'email') {
+            if (typeof value !== 'string' || !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(value)) {
+                errors.push(fieldName + ': Invalid email format');
+            }
+        } else if (cleanType === 'url') {
+            if (typeof value !== 'string') {
+                errors.push(fieldName + ': URL must be a string');
+            } else {
+                try {
+                    new URL(value);
+                } catch {
+                    errors.push(fieldName + ': Invalid URL format');
+                }
+            }
+        } else if (cleanType === 'uuid') {
+            if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+                errors.push(fieldName + ': Invalid UUID format');
+            }
+        } else if (cleanType === 'number') {
+            if (typeof value !== 'number' || isNaN(value)) {
+                errors.push(fieldName + ': Must be a valid number');
+            }
+        } else if (cleanType === 'positive') {
+            if (typeof value !== 'number' || isNaN(value) || value <= 0) {
+                errors.push(fieldName + ': Must be a positive number');
+            }
+        } else if (cleanType === 'int') {
+            if (typeof value !== 'number' || isNaN(value) || !Number.isInteger(value)) {
+                errors.push(fieldName + ': Must be an integer');
+            }
+        } else if (cleanType === 'boolean') {
+            if (typeof value !== 'boolean') {
+                errors.push(fieldName + ': Must be a boolean');
+            }
+        } else if (cleanType === 'string') {
+            if (typeof value !== 'string') {
+                errors.push(fieldName + ': Must be a string');
+            }
+        } else if (cleanType.startsWith('string(')) {
+            if (typeof value !== 'string') {
+                errors.push(fieldName + ': Must be a string');
+            } else {
+                const match = cleanType.match(/string\\((\\d+)?,?(\\d+)?\\)/);
+                if (match) {
+                    const minLength = match[1] ? parseInt(match[1]) : 0;
+                    const maxLength = match[2] ? parseInt(match[2]) : Infinity;
+                    if (value.length < minLength) {
+                        errors.push(fieldName + ': String too short (min ' + minLength + ')');
+                    }
+                    if (value.length > maxLength) {
+                        errors.push(fieldName + ': String too long (max ' + maxLength + ')');
+                    }
+                }
+            }
+        } else if (cleanType.includes('[]')) {
+            if (!Array.isArray(value)) {
+                errors.push(fieldName + ': Must be an array');
+            }
+        }
+    }
+
+    return errors;
+}
+
+document.getElementById('validate-btn').addEventListener('click', function() {
+    const input = document.getElementById('test-input').value;
+    const result = document.getElementById('validation-result');
+
+    try {
+        const data = JSON.parse(input);
+        const schema = ${schemaStr};
+        const validationErrors = validateData(schema, data);
+
+        if (validationErrors.length === 0) {
+            result.innerHTML = '<div class="valid">✓ Valid data</div>';
+        } else {
+            result.innerHTML = '<div class="invalid">✗ Validation errors:<br>' +
+                validationErrors.map(err => '• ' + err).join('<br>') + '</div>';
+        }
+    } catch (e) {
+        result.innerHTML = '<div class="invalid">✗ Invalid JSON: ' + e.message + '</div>';
+    }
+});`;
+    }
+}
+
+export { InteractiveDocumentationGenerator };
+//# sourceMappingURL=InteractiveDocumentationGenerator.js.map

package/dist/esm/core/schema/extensions/components/AutoDocumentation/InteractiveDocumentationGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractiveDocumentationGenerator.js","sources":["../../../../../../../src/core/schema/extensions/components/AutoDocumentation/InteractiveDocumentationGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;AAEG;MACU,iCAAiC,CAAA;IAC1C,WACY,CAAA,MAAuB,EACvB,OAA2B,EAAA;QAD3B,IAAM,CAAA,MAAA,GAAN,MAAM,CAAiB;QACvB,IAAO,CAAA,OAAA,GAAP,OAAO,CAAoB;KACnC;IAEJ,QAAQ,GAAA;QACJ,OAAO;AACH,YAAA,IAAI,EAAE,IAAI,CAAC,uBAAuB,EAAE;AACpC,YAAA,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE;AACvB,YAAA,UAAU,EAAE,IAAI,CAAC,kBAAkB,EAAE;SACxC,CAAC;KACL;IAEO,uBAAuB,GAAA;QAC3B,OAAO,CAAA;;AAEL,QAAA,EAAA,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,mBAAmB,CAAA;;;;;;;;;;;;;;;;OAgB5C,CAAC;KACH;IAEO,WAAW,GAAA;QACf,OAAO,CAAA;;;;;;6BAMc,CAAC;KACzB;IAEO,kBAAkB,GAAA;AACtB,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACvD,OAAO,CAAA;0DAC2C,SAAS,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0G1C,SAAS,CAAA;;;;;;;;;;;;IAY9B,CAAC;KACA;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/AutoDocumentation/SchemaAnalyzer.js

@@ -0,0 +1,52 @@
+/**
+ * Schema analyzer for extracting field information
+ */
+class SchemaAnalyzer {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    analyze() {
+        const fields = [];
+        Object.entries(this.schema).forEach(([name, type]) => {
+            fields.push(this.analyzeField(name, type));
+        });
+        return {
+            fields,
+            totalFields: fields.length,
+            requiredFields: fields.filter(f => f.required).length,
+            optionalFields: fields.filter(f => !f.required).length
+        };
+    }
+    analyzeField(name, type) {
+        const typeStr = typeof type === "string" ? type : JSON.stringify(type);
+        const required = !typeStr.includes("?");
+        return {
+            name,
+            type: typeStr,
+            required,
+            description: this.generateFieldDescription(name, typeStr)
+        };
+    }
+    generateFieldDescription(name, type) {
+        if (type === "email")
+            return "Email address";
+        if (type === "uuid")
+            return "Unique identifier";
+        if (type === "url")
+            return "URL address";
+        if (type.includes("string"))
+            return "Text value";
+        if (type.includes("number"))
+            return "Numeric value";
+        if (type === "boolean")
+            return "True/false value";
+        if (type === "date")
+            return "Date and time";
+        if (type.includes("[]"))
+            return "Array of values";
+        return `${name} field`;
+    }
+}
+
+export { SchemaAnalyzer };
+//# sourceMappingURL=SchemaAnalyzer.js.map

package/dist/esm/core/schema/extensions/components/AutoDocumentation/SchemaAnalyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaAnalyzer.js","sources":["../../../../../../../src/core/schema/extensions/components/AutoDocumentation/SchemaAnalyzer.ts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;AAEG;MACU,cAAc,CAAA;AACvB,IAAA,WAAA,CAAoB,MAAuB,EAAA;QAAvB,IAAM,CAAA,MAAA,GAAN,MAAM,CAAiB;KAAI;IAE/C,OAAO,GAAA;QACH,MAAM,MAAM,GAAgB,EAAE,CAAC;AAE/B,QAAA,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAI;AACjD,YAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAC/C,SAAC,CAAC,CAAC;QAEH,OAAO;YACH,MAAM;YACN,WAAW,EAAE,MAAM,CAAC,MAAM;AAC1B,YAAA,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM;AACrD,YAAA,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM;SACzD,CAAC;KACL;IAEO,YAAY,CAAC,IAAY,EAAE,IAAS,EAAA;AACxC,QAAA,MAAM,OAAO,GAAG,OAAO,IAAI,KAAK,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACvE,MAAM,QAAQ,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAExC,OAAO;YACH,IAAI;AACJ,YAAA,IAAI,EAAE,OAAO;YACb,QAAQ;YACR,WAAW,EAAE,IAAI,CAAC,wBAAwB,CAAC,IAAI,EAAE,OAAO,CAAC;SAC5D,CAAC;KACL;IAEO,wBAAwB,CAAC,IAAY,EAAE,IAAY,EAAA;QACvD,IAAI,IAAI,KAAK,OAAO;AAAE,YAAA,OAAO,eAAe,CAAC;QAC7C,IAAI,IAAI,KAAK,MAAM;AAAE,YAAA,OAAO,mBAAmB,CAAC;QAChD,IAAI,IAAI,KAAK,KAAK;AAAE,YAAA,OAAO,aAAa,CAAC;AACzC,QAAA,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;AAAE,YAAA,OAAO,YAAY,CAAC;AACjD,QAAA,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;AAAE,YAAA,OAAO,eAAe,CAAC;QACpD,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,kBAAkB,CAAC;QAClD,IAAI,IAAI,KAAK,MAAM;AAAE,YAAA,OAAO,eAAe,CAAC;AAC5C,QAAA,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;AAAE,YAAA,OAAO,iBAAiB,CAAC;QAElD,OAAO,CAAA,EAAG,IAAI,CAAA,MAAA,CAAQ,CAAC;KAC1B;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/AutoDocumentation/TypeScriptGenerator.js

@@ -0,0 +1,48 @@
+/**
+ * TypeScript generator
+ */
+class TypeScriptGenerator {
+    constructor(schema, options) {
+        this.schema = schema;
+        this.options = options;
+    }
+    generate() {
+        const { exportName = "Schema", namespace } = this.options;
+        let output = "";
+        if (namespace) {
+            output += `export namespace ${namespace} {\n`;
+        }
+        output += `export interface ${exportName} {\n`;
+        Object.entries(this.schema).forEach(([name, type]) => {
+            const tsType = this.convertToTypeScript(type);
+            const optional = typeof type === "string" && type.includes("?") ? "?" : "";
+            output += `  ${name}${optional}: ${tsType};\n`;
+        });
+        output += "}\n";
+        if (namespace) {
+            output += "}\n";
+        }
+        return output;
+    }
+    convertToTypeScript(type) {
+        if (typeof type === "string") {
+            const cleanType = type.replace("?", "");
+            if (cleanType === "email" || cleanType === "uuid" || cleanType === "url")
+                return "string";
+            if (cleanType.startsWith("string"))
+                return "string";
+            if (cleanType.includes("number") || cleanType === "positive" || cleanType === "int")
+                return "number";
+            if (cleanType === "boolean")
+                return "boolean";
+            if (cleanType === "date")
+                return "Date";
+            if (cleanType.includes("[]"))
+                return `${this.convertToTypeScript(cleanType.replace("[]", ""))}[]`;
+        }
+        return "any";
+    }
+}
+
+export { TypeScriptGenerator };
+//# sourceMappingURL=TypeScriptGenerator.js.map

package/dist/esm/core/schema/extensions/components/AutoDocumentation/TypeScriptGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeScriptGenerator.js","sources":["../../../../../../../src/core/schema/extensions/components/AutoDocumentation/TypeScriptGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;AAEG;MACU,mBAAmB,CAAA;IAC5B,WACY,CAAA,MAAuB,EACvB,OAA0B,EAAA;QAD1B,IAAM,CAAA,MAAA,GAAN,MAAM,CAAiB;QACvB,IAAO,CAAA,OAAA,GAAP,OAAO,CAAmB;KAClC;IAEJ,QAAQ,GAAA;QACJ,MAAM,EAAE,UAAU,GAAG,QAAQ,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAE1D,IAAI,MAAM,GAAG,EAAE,CAAC;QAEhB,IAAI,SAAS,EAAE;AACX,YAAA,MAAM,IAAI,CAAA,iBAAA,EAAoB,SAAS,CAAA,IAAA,CAAM,CAAC;SACjD;AAED,QAAA,MAAM,IAAI,CAAA,iBAAA,EAAoB,UAAU,CAAA,IAAA,CAAM,CAAC;AAE/C,QAAA,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAI;YACjD,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YAC9C,MAAM,QAAQ,GAAG,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC;YAC3E,MAAM,IAAI,KAAK,IAAI,CAAA,EAAG,QAAQ,CAAK,EAAA,EAAA,MAAM,KAAK,CAAC;AACnD,SAAC,CAAC,CAAC;QAEH,MAAM,IAAI,KAAK,CAAC;QAEhB,IAAI,SAAS,EAAE;YACX,MAAM,IAAI,KAAK,CAAC;SACnB;AAED,QAAA,OAAO,MAAM,CAAC;KACjB;AAEO,IAAA,mBAAmB,CAAC,IAAS,EAAA;AACjC,QAAA,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;YAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YAExC,IAAI,SAAS,KAAK,OAAO,IAAI,SAAS,KAAK,MAAM,IAAI,SAAS,KAAK,KAAK;AAAE,gBAAA,OAAO,QAAQ,CAAC;AAC1F,YAAA,IAAI,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC;AAAE,gBAAA,OAAO,QAAQ,CAAC;AACpD,YAAA,IAAI,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,SAAS,KAAK,UAAU,IAAI,SAAS,KAAK,KAAK;AAAE,gBAAA,OAAO,QAAQ,CAAC;YACrG,IAAI,SAAS,KAAK,SAAS;AAAE,gBAAA,OAAO,SAAS,CAAC;YAC9C,IAAI,SAAS,KAAK,MAAM;AAAE,gBAAA,OAAO,MAAM,CAAC;AACxC,YAAA,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;AAAE,gBAAA,OAAO,CAAG,EAAA,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC;SACrG;AAED,QAAA,OAAO,KAAK,CAAC;KAChB;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/AutoDocumentation/index.js

@@ -0,0 +1,12 @@
+import { Docs } from './Docs.js';
+
+/**
+ * Auto Documentation - schema documentation generator
+ *
+ * This module automatically generates beautiful documentation from schemas,
+ * including API docs, type definitions, and interactive examples.
+ *
+ */
+
+export { Docs, Docs as default };
+//# sourceMappingURL=index.js.map

package/dist/esm/core/schema/extensions/components/AutoDocumentation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../src/core/schema/extensions/components/AutoDocumentation/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;AAMG;;;;"}

package/dist/esm/core/schema/extensions/components/ConditionalValidation/ConditionalBuilder.js

@@ -0,0 +1,68 @@
+import { ConditionalThen } from './ConditionalThen.js';
+
+/**
+ * Builder for single field conditional validation with TypeScript inference
+ */
+class ConditionalBuilder {
+    constructor(fieldName) {
+        this.fieldName = fieldName;
+        this.conditions = [];
+        this.defaultSchema = null;
+    }
+    /**
+     * Check if field equals specific value
+     */
+    is(value) {
+        return new ConditionalThen(this, (fieldValue) => fieldValue === value);
+    }
+    /**
+     * Check if field does not equal specific value
+     */
+    isNot(value) {
+        return new ConditionalThen(this, (fieldValue) => fieldValue !== value);
+    }
+    /**
+     * Check if field exists (not null/undefined)
+     */
+    exists() {
+        return new ConditionalThen(this, (fieldValue) => fieldValue != null);
+    }
+    /**
+     * Check if field matches pattern
+     */
+    matches(pattern) {
+        return new ConditionalThen(this, (fieldValue) => typeof fieldValue === "string" && pattern.test(fieldValue));
+    }
+    /**
+     * Check if field is in array of values
+     */
+    in(values) {
+        return new ConditionalThen(this, (fieldValue) => values.includes(fieldValue));
+    }
+    /**
+     * Custom condition function
+     */
+    when(condition) {
+        return new ConditionalThen(this, condition);
+    }
+    addCondition(condition, schema) {
+        this.conditions.push({ condition, schema });
+        return this;
+    }
+    default(schema) {
+        this.defaultSchema = schema;
+        return this.build();
+    }
+    build() {
+        // Return a special object that the validation engine can recognize
+        return {
+            __conditional: true,
+            fieldName: this.fieldName,
+            conditions: this.conditions,
+            default: this.defaultSchema
+        };
+    }
+}
+
+export { ConditionalBuilder };
+//# sourceMappingURL=ConditionalBuilder.js.map

package/dist/esm/core/schema/extensions/components/ConditionalValidation/ConditionalBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionalBuilder.js","sources":["../../../../../../../src/core/schema/extensions/components/ConditionalValidation/ConditionalBuilder.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAyBA;;AAEG;MACU,kBAAkB,CAAA;AAO3B,IAAA,WAAA,CAAoB,SAAiB,EAAA;QAAjB,IAAS,CAAA,SAAA,GAAT,SAAS,CAAQ;QAN7B,IAAU,CAAA,UAAA,GAGb,EAAE,CAAC;QACA,IAAa,CAAA,aAAA,GAAQ,IAAI,CAAC;KAEO;AAEzC;;AAEG;AACH,IAAA,EAAE,CAAC,KAAU,EAAA;AACT,QAAA,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,CAAC,UAAU,KAAK,UAAU,KAAK,KAAK,CAAC,CAAC;KAC1E;AAED;;AAEG;AACH,IAAA,KAAK,CAAC,KAAU,EAAA;AACZ,QAAA,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,CAAC,UAAU,KAAK,UAAU,KAAK,KAAK,CAAC,CAAC;KAC1E;AAED;;AAEG;IACH,MAAM,GAAA;AACF,QAAA,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,CAAC,UAAU,KAAK,UAAU,IAAI,IAAI,CAAC,CAAC;KACxE;AAED;;AAEG;AACH,IAAA,OAAO,CAAC,OAAe,EAAA;QACnB,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,CAAC,UAAU,KACxC,OAAO,UAAU,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAC7D,CAAC;KACL;AAED;;AAEG;AACH,IAAA,EAAE,CAAC,MAAa,EAAA;AACZ,QAAA,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,CAAC,UAAU,KAAK,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;KACjF;AAED;;AAEG;AACH,IAAA,IAAI,CAAC,SAAkC,EAAA;AACnC,QAAA,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;KAC/C;IAED,YAAY,CAAC,SAAkC,EAAE,MAAW,EAAA;QACxD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;AAC5C,QAAA,OAAO,IAAI,CAAC;KACf;AAED,IAAA,OAAO,CAAC,MAAW,EAAA;AACf,QAAA,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;AAC5B,QAAA,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;KACvB;IAED,KAAK,GAAA;;QAED,OAAO;AACH,YAAA,aAAa,EAAE,IAAI;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,OAAO,EAAE,IAAI,CAAC,aAAa;SAC9B,CAAC;KACL;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/ConditionalValidation/ConditionalElse.js

@@ -0,0 +1,38 @@
+/**
+ * Builder for the "else" part of conditional validation with TypeScript inference
+ * This class is returned after calling .then() and provides the .else() method
+ */
+class ConditionalElse {
+    constructor(builder, condition, thenSchema) {
+        this.builder = builder;
+        this.condition = condition;
+        this.thenSchema = thenSchema;
+    }
+    /**
+     * Specify the schema to use when the condition is false
+     */
+    else(elseSchema) {
+        // Add the condition with the "then" schema
+        this.builder.addCondition(this.condition, this.thenSchema);
+        // Set the default schema (used when condition is false)
+        const result = this.builder.default(elseSchema);
+        // Return with type information for TypeScript inference
+        return result;
+    }
+    /**
+     * Alias for else() - for backward compatibility
+     */
+    default(defaultSchema) {
+        return this.else(defaultSchema);
+    }
+    /**
+     * Build without else clause (same as calling .else(undefined))
+     */
+    build() {
+        this.builder.addCondition(this.condition, this.thenSchema);
+        return this.builder.build();
+    }
+}
+
+export { ConditionalElse };
+//# sourceMappingURL=ConditionalElse.js.map

package/dist/esm/core/schema/extensions/components/ConditionalValidation/ConditionalElse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionalElse.js","sources":["../../../../../../../src/core/schema/extensions/components/ConditionalValidation/ConditionalElse.ts"],"sourcesContent":[null],"names":[],"mappings":"AAyBA;;;AAGG;MACU,eAAe,CAAA;AACxB,IAAA,WAAA,CACY,OAA2B,EAC3B,SAAkC,EAClC,UAAiB,EAAA;QAFjB,IAAO,CAAA,OAAA,GAAP,OAAO,CAAoB;QAC3B,IAAS,CAAA,SAAA,GAAT,SAAS,CAAyB;QAClC,IAAU,CAAA,UAAA,GAAV,UAAU,CAAO;KACzB;AAEJ;;AAEG;AACH,IAAA,IAAI,CAAuB,UAAiB,EAAA;;AAExC,QAAA,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;;QAG3D,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;;AAGhD,QAAA,OAAO,MAAyC,CAAC;KACpD;AAED;;AAEG;AACH,IAAA,OAAO,CAAuB,aAAoB,EAAA;AAC9C,QAAA,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;KACnC;AAED;;AAEG;IACH,KAAK,GAAA;AACD,QAAA,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;AAC3D,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;KAC/B;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/ConditionalValidation/ConditionalThen.js

@@ -0,0 +1,17 @@
+import { ConditionalElse } from './ConditionalElse.js';
+
+/**
+ * Builder for the "then" part of conditional validation with TypeScript inference
+ */
+class ConditionalThen {
+    constructor(builder, condition) {
+        this.builder = builder;
+        this.condition = condition;
+    }
+    then(schema) {
+        return new ConditionalElse(this.builder, this.condition, schema);
+    }
+}
+
+export { ConditionalThen };
+//# sourceMappingURL=ConditionalThen.js.map

package/dist/esm/core/schema/extensions/components/ConditionalValidation/ConditionalThen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionalThen.js","sources":["../../../../../../../src/core/schema/extensions/components/ConditionalValidation/ConditionalThen.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAoBA;;AAEG;MACU,eAAe,CAAA;IACxB,WACY,CAAA,OAA2B,EAC3B,SAAkC,EAAA;QADlC,IAAO,CAAA,OAAA,GAAP,OAAO,CAAoB;QAC3B,IAAS,CAAA,SAAA,GAAT,SAAS,CAAyB;KAC1C;AAEJ,IAAA,IAAI,CAAmB,MAAS,EAAA;AAC5B,QAAA,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;KACpE;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/ConditionalValidation/MultiConditionalBuilder.js

@@ -0,0 +1,18 @@
+import { MultiConditionalThen } from './MultiConditionalThen.js';
+
+/**
+ * Builder for multi-field conditional validation
+ */
+class MultiConditionalBuilder {
+    constructor(fieldNames) {
+        this.fieldNames = fieldNames;
+        this.matchConditions = {};
+    }
+    match(conditions) {
+        this.matchConditions = conditions;
+        return new MultiConditionalThen(this, conditions);
+    }
+}
+
+export { MultiConditionalBuilder };
+//# sourceMappingURL=MultiConditionalBuilder.js.map

package/dist/esm/core/schema/extensions/components/ConditionalValidation/MultiConditionalBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiConditionalBuilder.js","sources":["../../../../../../../src/core/schema/extensions/components/ConditionalValidation/MultiConditionalBuilder.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;AAEG;MACU,uBAAuB,CAAA;AAGhC,IAAA,WAAA,CAAoB,UAAoB,EAAA;QAApB,IAAU,CAAA,UAAA,GAAV,UAAU,CAAU;QAFhC,IAAe,CAAA,eAAA,GAAQ,EAAE,CAAC;KAEU;AAE5C,IAAA,KAAK,CAAC,UAA+B,EAAA;AACjC,QAAA,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC;AAClC,QAAA,OAAO,IAAI,oBAAoB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;KACrD;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/ConditionalValidation/MultiConditionalThen.js

@@ -0,0 +1,45 @@
+/**
+ * Builder for multi-field "then" part
+ */
+class MultiConditionalThen {
+    constructor(builder, conditions) {
+        this.builder = builder;
+        this.conditions = conditions;
+    }
+    then(schema) {
+        return new MultiConditionalElse(schema, null);
+    }
+}
+/**
+ * Builder for multi-field "else" part
+ */
+class MultiConditionalElse {
+    constructor(thenSchema, elseSchema) {
+        this.thenSchema = thenSchema;
+        this.elseSchema = elseSchema;
+    }
+    else(schema) {
+        return {
+            __multiConditional: true,
+            then: this.thenSchema,
+            else: schema
+        };
+    }
+}
+/**
+ * Custom validator builder
+ */
+class CustomValidator {
+    constructor(validator) {
+        this.validator = validator;
+    }
+    build() {
+        return {
+            __customValidator: true,
+            validator: this.validator
+        };
+    }
+}
+
+export { CustomValidator, MultiConditionalElse, MultiConditionalThen };
+//# sourceMappingURL=MultiConditionalThen.js.map

package/dist/esm/core/schema/extensions/components/ConditionalValidation/MultiConditionalThen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiConditionalThen.js","sources":["../../../../../../../src/core/schema/extensions/components/ConditionalValidation/MultiConditionalThen.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;AAEG;MACU,oBAAoB,CAAA;IAC7B,WACY,CAAA,OAAgC,EAChC,UAA+B,EAAA;QAD/B,IAAO,CAAA,OAAA,GAAP,OAAO,CAAyB;QAChC,IAAU,CAAA,UAAA,GAAV,UAAU,CAAqB;KACvC;AAEJ,IAAA,IAAI,CAAC,MAAW,EAAA;AACZ,QAAA,OAAO,IAAI,oBAAoB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;KACjD;AACJ,CAAA;AAKD;;AAEG;MACU,oBAAoB,CAAA;IAC7B,WACY,CAAA,UAAe,EACf,UAAe,EAAA;QADf,IAAU,CAAA,UAAA,GAAV,UAAU,CAAK;QACf,IAAU,CAAA,UAAA,GAAV,UAAU,CAAK;KACvB;AAEJ,IAAA,IAAI,CAAC,MAAW,EAAA;QACZ,OAAO;AACH,YAAA,kBAAkB,EAAE,IAAI;YACxB,IAAI,EAAE,IAAI,CAAC,UAAU;AACrB,YAAA,IAAI,EAAE,MAAM;SACf,CAAC;KACL;AACJ,CAAA;AAED;;AAEG;MACU,eAAe,CAAA;AACxB,IAAA,WAAA,CAAoB,SAA6D,EAAA;QAA7D,IAAS,CAAA,SAAA,GAAT,SAAS,CAAoD;KAAI;IAErF,KAAK,GAAA;QACD,OAAO;AACH,YAAA,iBAAiB,EAAE,IAAI;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC5B,CAAC;KACL;AACJ;;;;"}

package/dist/esm/core/schema/extensions/components/ConditionalValidation/index.js

@@ -0,0 +1,92 @@
+import { ConditionalBuilder } from './ConditionalBuilder.js';
+import { MultiConditionalBuilder } from './MultiConditionalBuilder.js';
+import { CustomValidator } from './MultiConditionalThen.js';
+
+/**
+ * Conditional Validation - dependent field validation
+ *
+ * This module provides powerful conditional validation where fields can depend
+ * on other fields' values, making complex business logic validation simple.
+ */
+/**
+ * Conditional validation utilities
+ */
+const When = {
+    /**
+     * Create conditional validation based on another field's value
+     *
+     * @example
+     * ```typescript
+     * const UserSchema = Interface({
+     *   accountType: Make.union("free", "premium", "enterprise"),
+     *   maxProjects: When.field("accountType").is("free").then("int(1,3)")
+     *                   .is("premium").then("int(1,50)")
+     *                   .is("enterprise").then("int(1,)")
+     *                   .default("int(1,1)"),
+     *
+     *   paymentMethod: When.field("accountType").isNot("free").then("string").else("string?"),
+     *   billingAddress: When.field("paymentMethod").exists().then({
+     *     street: "string",
+     *     city: "string",
+     *     country: "string(2,2)"
+     *   }).else("any?")
+     * });
+     * ```
+     */
+    field(fieldName) {
+        return new ConditionalBuilder(fieldName);
+    },
+    /**
+     * Create validation that depends on multiple fields
+     *
+     * @example
+     * ```typescript
+     * const OrderSchema = Interface({
+     *   orderType: Make.union("pickup", "delivery"),
+     *   address: "string?",
+     *   deliveryFee: "number?",
+     *
+     *   // Complex conditional validation
+     *   ...When.fields(["orderType", "address"]).match({
+     *     orderType: "delivery",
+     *     address: (val) => val && val.length > 0
+     *   }).then({
+     *     deliveryFee: "number(0,)"  // Required for delivery with address
+     *   }).else({
+     *     deliveryFee: "number?"     // Optional otherwise
+     *   })
+     * });
+     * ```
+     */
+    fields(fieldNames) {
+        return new MultiConditionalBuilder(fieldNames);
+    },
+    /**
+     * Create custom validation logic
+     *
+     * @example
+     * ```typescript
+     * const EventSchema = Interface({
+     *   startDate: "date",
+     *   endDate: "date",
+     *
+     *   // Custom validation: endDate must be after startDate
+     *   ...When.custom((data) => {
+     *     if (data.endDate <= data.startDate) {
+     *       return { error: "End date must be after start date" };
+     *     }
+     *     return { valid: true };
+     *   })
+     * });
+     * ```
+     */
+    custom(validator) {
+        return new CustomValidator(validator);
+    },
+    // Note: Clean syntax like "when:role=admin:string:string?" is automatically
+    // supported in Interface schemas without needing to import When utilities.
+    // The syntax is parsed internally by the schema validation engine.
+};
+
+export { ConditionalBuilder, CustomValidator, MultiConditionalBuilder, When, When as default };
+//# sourceMappingURL=index.js.map

package/dist/esm/core/schema/extensions/components/ConditionalValidation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../src/core/schema/extensions/components/ConditionalValidation/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAAA;;;;;AAKG;AAOH;;AAEG;AACU,MAAA,IAAI,GAAG;AAClB;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,KAAK,CAAC,SAAiB,EAAA;AACrB,QAAA,OAAO,IAAI,kBAAkB,CAAC,SAAS,CAAC,CAAC;KAC1C;AAED;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH,IAAA,MAAM,CAAC,UAAoB,EAAA;AACzB,QAAA,OAAO,IAAI,uBAAuB,CAAC,UAAU,CAAC,CAAC;KAChD;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACH,IAAA,MAAM,CACJ,SAA6D,EAAA;AAE7D,QAAA,OAAO,IAAI,eAAe,CAAC,SAAS,CAAC,CAAC;KACvC;;;;;;;;"}