@medyll/idae-machine 0.123.0 → 0.125.0

package/dist/main/machineDb.js

@@ -1,7 +1,10 @@
 /*
     path: D:\boulot\python\wollama\src\lib\db\dbFields.ts
  */
-import { schemeModel } from '../db/dbSchema.js';
+import { schemeModel } from "../db/dbSchema.js";
+import { IDbCollection } from "./machine/IDbCollection.js";
+import { IDbError } from "./machine/IDbError.js";
+import { MachineForge } from "./machineForge.js";
 export var enumPrimitive;
 (function (enumPrimitive) {
     enumPrimitive["id"] = "id";
@@ -23,29 +26,7 @@ export var TplProperties;
     TplProperties["readonly"] = "readonly";
     TplProperties["required"] = "required";
 })(TplProperties || (TplProperties = {}));
-const a = 'any(private required readonly)';
-/*
-    renamed from DbCollectionError to IDbErrors
- */
-class IDbError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.name = 'DbCollectionError';
-    }
-    static throwError(message, code) {
-        throw new IDbError(message, code);
-    }
-    static handleError(error) {
-        if (error instanceof IDbError) {
-            console.error(`${error.name}: ${error.message} (Code: ${error.code})`);
-        }
-        else {
-            console.error('Unexpected error:', error);
-        }
-    }
-}
+const a = "any(private required readonly)";
 /**
  * Central class for parsing, introspecting, and extracting metadata from the database schema.
  * Provides methods to access collections, templates, fields, foreign keys, and type information.
@@ -56,6 +37,7 @@ export class MachineDb {
      * The database model (schema) used for introspection.
      */
     model = schemeModel;
+    machineForge = new MachineForge();
     #idbCollectionsList = {};
     /**
      * Create a new IDbBase instance.
@@ -63,6 +45,7 @@ export class MachineDb {
      */
     constructor(model) {
         this.model = model ?? schemeModel;
+        this.machineForge = new MachineForge();
     }
     /**
      * Get an IDbCollection instance for a collection name.
@@ -73,30 +56,32 @@ export class MachineDb {
         }
         return this.#idbCollectionsList[collection];
     }
-    /**
-     * Public: Get the value of the index field for a given data object.
-     */
-    indexValue(collection, data) {
-        const indexName = this.collection(collection).getIndexName();
-        return data && typeof data === 'object' && indexName && data[indexName];
-    }
-    /**
-     * Get an IDbCollectionValues instance for a collection name.
-     */
-    collectionValues(collection) {
-        return new IDbCollectionValues(collection, this);
-    }
-    /**
-     * Get an IDbCollectionFieldValues instance for a collection and data.
-     */
-    collectionFieldValues(collection, data) {
-        return new IDbCollectionFieldValues(collection, data, this.collectionValues(collection));
+    fks(collection) {
+        const fks = this.collection(collection).getModelTemplateFks();
+        const out = {};
+        if (fks) {
+            Object.keys(fks).forEach((collection) => {
+                out[collection] = this.parseRawCollection(collection);
+            });
+        }
+        return out;
     }
-    /**
-     * Get an IDbFormValidate instance for a collection name.
-     */
-    formValidate(collection) {
-        return new IDbFormValidate(collection, this);
+    reverseFks(targetCollection) {
+        const result = {};
+        Object.entries(this.model).forEach(([collectionName, collectionModel]) => {
+            const template = collectionModel.template;
+            if (template && template.fks) {
+                Object.entries(template.fks).forEach(([fkName, fkConfig]) => {
+                    if (fkConfig?.code === targetCollection) {
+                        if (!result[collectionName]) {
+                            result[collectionName] = {};
+                        }
+                        result[collectionName][fkName] = fkConfig;
+                    }
+                });
+            }
+        });
+        return result;
     }
     /**
      * Parse all fields of a given collection.
@@ -118,37 +103,30 @@ export class MachineDb {
      * Parse a single field of a collection and return its IDbForge metadata.
      */
     parseCollectionFieldName(collection, fieldName) {
-        const field = this.#getTemplateFieldRule(collection, fieldName);
+        const field = this.collection(collection).getFieldRule(fieldName);
         if (!field) {
-            IDbError.throwError(`Field ${fieldName} not found in collection ${collection}`, 'FIELD_NOT_FOUND');
+            IDbError.throwError(`Field ${fieldName} not found in collection ${collection}`, "FIELD_NOT_FOUND");
             return undefined;
         }
-        const array = this.testIs('array', field);
-        const object = this.testIs('object', field);
-        const fk = this.testIs('fk', field);
-        const primitive = this.testIs('primitive', field);
+        const array = this.machineForge.testIs("array", field);
+        const object = this.machineForge.testIs("object", field);
+        const fk = this.machineForge.testIs("fk", field);
+        const primitive = this.machineForge.testIs("primitive", field);
         const fieldType = array ?? object ?? fk ?? primitive;
-        return this.forge({ collection, fieldName, ...fieldType });
-    }
-    // Toutes ces méthodes sont maintenant dans IDbCollection
-    #getTemplateFieldRule(collection, fieldName) {
-        // Utilise la nouvelle API orientée collection
-        return new IDbCollection(collection, this, this.model).getFieldRule(fieldName);
-    }
-    getFkFieldType(string) {
-        const [collection, field] = string.split('.');
-        let template = this.#getTemplateFieldRule(collection, field);
-        return template;
-    }
-    getFkTemplateFields(string) {
-        const [collection, field] = string.split('.');
-        return this.collection(collection).getTemplate()?.fields;
+        return this.machineForge.forge({ collection, fieldName, ...fieldType });
     }
     testIs(what, fieldRule) {
-        const typeMappings = { fk: 'fk-', array: 'array-of-', object: 'object-', primitive: '' };
+        const typeMappings = {
+            fk: "fk-",
+            array: "array-of-",
+            object: "object-",
+            primitive: "",
+        };
         const prefix = typeMappings[what];
-        if (what === 'primitive') {
-            if (!fieldRule.startsWith('array-of-') && !fieldRule.startsWith('object-') && !fieldRule.startsWith('fk-')) {
+        if (what === "primitive") {
+            if (!fieldRule.startsWith("array-of-") &&
+                !fieldRule.startsWith("object-") &&
+                !fieldRule.startsWith("fk-")) {
                 return this.is(what, fieldRule);
             }
             return undefined;
@@ -163,15 +141,15 @@ export class MachineDb {
     }
     extract(type, fieldRule) {
         function extractAfter(pattern, source) {
-            const reg = source?.split('(')?.[0];
+            const reg = source?.split("(")?.[0];
             return reg.split(pattern)[1];
         }
         function extractArgs(source) {
-            const [piece, remaining] = source.split('(');
+            const [piece, remaining] = source.split("(");
             if (!remaining)
                 return { piece: piece.trim(), args: undefined };
-            const [central] = remaining?.split(')');
-            const args = central?.split(' ');
+            const [central] = remaining?.split(")");
+            const args = central?.split(" ");
             return { piece: piece.trim(), args };
         }
         let extractedArgs = extractArgs(fieldRule);
@@ -179,594 +157,23 @@ export class MachineDb {
         let is = extractedArgs?.piece;
         let fieldArgs = extractedArgs?.args;
         switch (type) {
-            case 'array':
-                fieldType = extractAfter('array-of-', fieldRule);
+            case "array":
+                fieldType = extractAfter("array-of-", fieldRule);
                 is = is ?? fieldType;
                 break;
-            case 'object':
-                fieldType = extractAfter('object-', fieldRule);
+            case "object":
+                fieldType = extractAfter("object-", fieldRule);
                 is = is ?? fieldType;
                 break;
-            case 'fk':
-                fieldType = 'fk-' + extractAfter('fk-', fieldRule);
+            case "fk":
+                fieldType = "fk-" + extractAfter("fk-", fieldRule);
                 is = extractedArgs?.piece;
                 break;
-            case 'primitive':
+            case "primitive":
                 fieldType = extractedArgs?.piece;
                 is = is ?? fieldType;
                 break;
         }
         return { fieldType, fieldRule, fieldArgs, is: type };
     }
-    fks(collection) {
-        let fks = this.collection(collection).getModelTemplateFks();
-        let out = {};
-        if (fks) {
-            Object.keys(fks).forEach((collection) => {
-                out[collection] = this.parseRawCollection(collection);
-            });
-        }
-        return out;
-    }
-    reverseFks(targetCollection) {
-        const result = {};
-        Object.entries(this.model).forEach(([collectionName, collectionModel]) => {
-            const template = collectionModel.template;
-            if (template && template.fks) {
-                Object.entries(template.fks).forEach(([fkName, fkConfig]) => {
-                    if (fkConfig?.code === targetCollection) {
-                        if (!result[collectionName]) {
-                            result[collectionName] = {};
-                        }
-                        result[collectionName][fkName] = fkConfig;
-                    }
-                });
-            }
-        });
-        return result;
-    }
-    iterateArrayField(collection, fieldName, data) {
-        const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
-        if (fieldInfo?.is !== 'array' || !Array.isArray(data)) {
-            return [];
-        }
-        return data.map((_, idx) => ({ ...fieldInfo, fieldName: `${String(fieldName)}[${idx}]` }));
-    }
-    iterateObjectField(collection, fieldName, data) {
-        const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
-        if (fieldInfo?.is !== 'object' || typeof data !== 'object' || data === null) {
-            return [];
-        }
-        return Object.keys(data).map((key) => ({ ...fieldInfo, fieldName: `${String(fieldName)}.${key}` }));
-    }
-    /**
-     * Internal helper to construct an IDbForge object from its components.
-     */
-    forge({ collection, fieldName, fieldType, fieldRule, fieldArgs, is }) {
-        return { collection, fieldName, fieldType, fieldRule, fieldArgs, is };
-    }
-}
-/* Single collection template relies on IDbBase */
-export class IDbCollection {
-    collection;
-    #template;
-    #machineDb;
-    #model;
-    constructor(collection, idbBase, model) {
-        this.collection = collection;
-        this.#machineDb = idbBase;
-        this.#model = model[String(collection)];
-        this.#template = this.#model['template'];
-    }
-    get model() {
-        return this.#model;
-    }
-    get fields() {
-        return this.#template?.fields;
-    }
-    getPresentation() {
-        return this.#template?.presentation;
-    }
-    getFieldRule(fieldName) {
-        return this.fields[String(fieldName)];
-    }
-    getTemplate() {
-        return this.#template;
-    }
-    getModelTemplateFks() {
-        return this.#template?.fks;
-    }
-    getIndexName() {
-        return this.#template?.index;
-    }
-    collectionValues() {
-        return new IDbCollectionValues(this.collection, this.#machineDb);
-    }
-    collectionFieldValues(data) {
-        return new IDbCollectionFieldValues(this.collection, data, this.collectionValues());
-    }
-    fieldForge(fieldName, data) {
-        return new IDbCollectionFieldForge(this.collection, fieldName, data, this.collectionValues());
-    }
-    getFormValidate() {
-        return new IDbFormValidate(this.collection, this.#machineDb);
-    }
-    fks() {
-        return this.#machineDb.fks(this.collection);
-    }
-    reverseFks() {
-        return this.#machineDb.reverseFks(this.collection);
-    }
-}
-/**
- * IDbCollectionValues
- *
- * This class provides utilities to display, format, and introspect field values for a given collection, using the schema and provided data.
- * It is designed for dynamic UI rendering, presentation logic, and metadata extraction for form generation in schema-driven applications.
- *
- * Main responsibilities:
- * - Holds a reference to the collection name and the schema (IDbBase).
- * - Provides methods to format field values according to their type (number, text, array, object, etc.).
- * - Supplies presentation logic for displaying records (e.g., presentation string, index value).
- * - Offers input attribute generation for forms (inputDataSet).
- * - Supports iteration over array/object fields for advanced UI layouts.
- * - Enables access to field metadata for validation and rendering.
- *
- * Usage:
- *   const values = new IDbCollectionValues('agents');
- *   const display = values.presentation(agentData); // formatted display string
- *   const index = values.indexValue(agentData); // index field value
- *   const formatted = values.format('name', agentData); // formatted field value
- *   const attrs = values.getInputDataSet('name', agentData); // input attributes for forms
- *
- * This class is typically used via IDbBase.getCollectionValues for shared instance management.
- * @template T - The type of the data object for the collection.
- */
-export class IDbCollectionValues {
-    /**
-     * The IDbBase instance used for schema introspection.
-     */
-    idbBase;
-    /**
-     * The collection name this instance operates on.
-     */
-    collectionName;
-    /**
-     * Create a new IDbCollectionValues instance for a given collection.
-     * @param collectionName The collection name.
-     */
-    constructor(collectionName, idbBase) {
-        this.collectionName = collectionName;
-        this.idbBase = idbBase ?? new MachineDb();
-    }
-    presentation(data) {
-        try {
-            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            const presentation = this.idbBase.collection(this.collectionName).getPresentation();
-            this.#checkError(!presentation, 'Presentation template not found', 'TEMPLATE_NOT_FOUND');
-            const fields = presentation.split(' ');
-            return fields
-                .map((field) => {
-                const value = data[field];
-                return value !== null && value !== undefined ? String(value) : '';
-            })
-                .join(' ');
-        }
-        catch (error) {
-            IDbError.handleError(error);
-            return '';
-        }
-    }
-    /**
-     * Get the value of the index field for a data object.
-     * @param data The data object.
-     * @returns The value of the index field, or null if not found.
-     */
-    indexValue(data) {
-        try {
-            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            const indexName = this.idbBase.collection(this.collectionName).getIndexName();
-            this.#checkError(!indexName, 'Index not found for collection', 'INDEX_NOT_FOUND');
-            this.#checkError(!(indexName in data), `Index field ${indexName} not found in data`, 'FIELD_NOT_FOUND');
-            return data[indexName];
-        }
-        catch (error) {
-            IDbError.handleError(error);
-            return null;
-        }
-    }
-    /**
-     * Format a field value for display, using the field type and schema.
-     * @param fieldName The field name.
-     * @param data The data object.
-     * @returns The formatted value as a string.
-     */
-    format(fieldName, data) {
-        try {
-            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            this.#checkError(!(fieldName in data), `Field ${String(fieldName)} not found in data`, 'FIELD_NOT_FOUND');
-            const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
-            this.#checkError(!fieldInfo, `Field ${String(fieldName)} not found in collection`, 'FIELD_NOT_FOUND');
-            switch (fieldInfo?.fieldType) {
-                case 'number':
-                    return this.#formatNumberField(data[fieldName]);
-                case 'text':
-                case 'text-tiny':
-                case 'text-short':
-                case 'text-medium':
-                case 'text-long':
-                case 'text-giant':
-                    return this.#formatTextField(data[fieldName], fieldInfo.fieldType);
-                default:
-                    return String(data[fieldName]);
-            }
-        }
-        catch (error) {
-            IDbError.handleError(error);
-            return '';
-        }
-    }
-    /**
-     * Get a set of data-* attributes for a field, for use in form generation or UI.
-     * @param fieldName The field name.
-     * @param data The data object.
-     * @returns An object with data-* attributes for the field.
-     */
-    getInputDataSet(fieldName, data) {
-        const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
-        const fieldType = fieldInfo?.fieldType ?? '';
-        const fieldArgs = fieldInfo?.fieldArgs?.join(' ') ?? '';
-        const indexName = this.idbBase.collection(this.collectionName).getIndexName();
-        return {
-            'data-collection': this.collectionName,
-            'data-collectionId': indexName && data?.[indexName] !== undefined ? String(data?.[indexName]) : '',
-            'data-fieldName': String(fieldName),
-            'data-fieldType': fieldType,
-            'data-fieldArgs': fieldArgs
-        };
-    }
-    /**
-     * Iterate over an array field and return an array of IDbForge objects for each element.
-     * @param fieldName The field name.
-     * @param data The array data.
-     * @returns An array of IDbForge objects.
-     */
-    iterateArrayField(fieldName, data) {
-        return this.idbBase.iterateArrayField(this.collectionName, fieldName, data);
-    }
-    /**
-     * Iterate over an object field and return an array of IDbForge objects for each property.
-     * @param fieldName The field name.
-     * @param data The object data.
-     * @returns An array of IDbForge objects.
-     */
-    iterateObjectField(fieldName, data) {
-        return this.idbBase.iterateObjectField(this.collectionName, fieldName, data);
-    }
-    /**
-     * Internal: Format a number field for display.
-     * @param value The number value.
-     * @returns The formatted string.
-     */
-    #formatNumberField(value) {
-        // Implement number formatting logic here
-        return value.toString();
-    }
-    /**
-     * Internal: Format a text field for display, with length limits by type.
-     * @param value The string value.
-     * @param type The text type (e.g. 'text-short').
-     * @returns The formatted string.
-     */
-    #formatTextField(value, type) {
-        const lengths = {
-            'text-tiny': 10,
-            'text-short': 20,
-            'text-medium': 30,
-            'text-long': 40,
-            'text-giant': 50
-        };
-        const str = typeof value === 'string' ? value : String(value ?? '');
-        const maxLength = lengths[type] || str.length;
-        return str.substring(0, maxLength);
-    }
-    /**
-     * Internal: Check if access is allowed (override for custom logic).
-     * @returns True if access is allowed.
-     */
-    #checkAccess() {
-        // Implement access check logic here
-        return true;
-    }
-    /**
-     * Internal: Throw an error if a condition is met.
-     * @param condition The condition to check.
-     * @param message The error message.
-     * @param code The error code.
-     */
-    #checkError(condition, message, code) {
-        if (condition) {
-            IDbError.throwError(message, code);
-        }
-    }
-}
-export class IDbCollectionFieldValues {
-    #collection;
-    #collectionValues;
-    #data;
-    /**
- * Returns the IDbForge metadata for a given field name.
- * @param fieldName The field name to introspect.
- */
-    getForge(fieldName) {
-        return this.#collectionValues.idbBase.parseCollectionFieldName(this.#collection, String(fieldName));
-    }
-    constructor(collection, data, collectionValues) {
-        this.#collection = collection;
-        this.#collectionValues = collectionValues ?? new IDbCollectionValues(collection);
-        this.#data = data;
-    }
-    format(fieldName) {
-        const fieldInfo = this.#collectionValues.idbBase.parseCollectionFieldName(this.#collection, fieldName);
-        if (fieldInfo?.is === 'array') {
-            return this.iterateArray(String(fieldName), this.#data);
-        }
-        if (fieldInfo?.is === 'object') {
-            return this.iterateObject(String(fieldName), this.#data);
-        }
-        return this.#collectionValues.format(fieldName, this.#data);
-    }
-    getInputDataSet(fieldName) {
-        return this.#collectionValues.getInputDataSet(String(fieldName), this.#data);
-    }
-    // renamed from parseCollectionFieldName
-    // get forge(): IDbForge | undefined {
-    //     return undefined; // Pas de #fieldName dans cette classe, getter non pertinent
-    // }
-    iterateArray(fieldName, data) {
-        return this.#collectionValues.iterateArrayField(fieldName, data);
-    }
-    iterateObject(fieldName, data) {
-        return this.#collectionValues.iterateObjectField(fieldName, data);
-    }
-}
-/**
- * IDbCollectionFieldForge
- *
- * This class provides advanced metadata and formatting for a single field of a collection, given a data object.
- * It is designed for dynamic UI generation, form rendering, and introspection in schema-driven applications.
- *
- * Main responsibilities:
- * - Holds references to the collection name, field name, and the data object for context.
- * - Provides access to the parsed field metadata (IDbForge) for the field, including type, rules, and arguments.
- * - Offers formatting utilities for the field value, adapting to type (number, text, array, object, etc.).
- * - Supplies input attributes and type hints for form generation (e.g., htmlInputType, inputDataSet).
- * - Supports iteration over array/object fields for complex form layouts.
- * - Enables extraction of raw data and field arguments for validation and UI logic.
- *
- * Usage:
- *   const forge = new IDbCollectionFieldForge('agents', 'name', agentData);
- *   const formatted = forge.format; // formatted value for display
- *   const inputType = forge.htmlInputType; // e.g. 'text', 'area', 'email', etc.
- *   const meta = forge.forge; // IDbForge metadata for the field
- *
- * This class is typically used via IDbBase.getCollectionFieldForge for shared instance management.
- */
-export class IDbCollectionFieldForge {
-    #collection;
-    #collectionValues;
-    #fieldName;
-    #data;
-    constructor(collection, fieldName, data, collectionValues) {
-        this.#collection = collection;
-        this.#collectionValues = collectionValues ?? new IDbCollectionValues(collection);
-        this.#fieldName = String(fieldName);
-        this.#data = data;
-    }
-    get format() {
-        return this.#collectionValues.format(String(this.#fieldName), this.#data);
-    }
-    get inputDataSet() {
-        return this.#collectionValues.getInputDataSet(String(this.#fieldName), this.#data);
-    }
-    // renamed from parseCollectionFieldName
-    get forge() {
-        return this.#collectionValues.idbBase.parseCollectionFieldName(this.#collection, String(this.#fieldName));
-    }
-    get fieldArgs() {
-        return this.forge?.fieldArgs;
-    }
-    get fieldType() {
-        return this.forge?.fieldType;
-    }
-    /**
-     * will return  text.inputBase  for ['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password']
-     */
-    get htmlInputType() {
-        let variant = this?.fieldType?.split('text-')?.[1] ?? this.fieldType;
-        if (variant === 'area')
-            return variant;
-        if (this.forge?.fieldType?.startsWith('text-'))
-            return 'text';
-        if (['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password'].includes(this.forge?.fieldType ?? '')) {
-            return this.forge?.fieldType?.trim?.() ?? 'text';
-        }
-        return 'text';
-    }
-    get rawData() {
-        return this.#data;
-    }
-    iterateArray(fieldName, data) {
-        return this.#collectionValues.iterateArrayField(fieldName, data);
-    }
-    iterateObject(fieldName, data) {
-        return this.#collectionValues.iterateObjectField(fieldName, data);
-    }
-}
-class IDbValidationError extends Error {
-    field;
-    code;
-    constructor(field, code, message) {
-        super(message);
-        this.field = field;
-        this.code = code;
-        this.name = 'IDbValidationError';
-    }
-}
-export class IDbFormValidate {
-    collection;
-    idbCollections;
-    constructor(collection, idbCollections) {
-        this.collection = collection;
-        this.idbCollections = idbCollections ?? new MachineDb();
-    }
-    validateField(fieldName, value) {
-        try {
-            const fieldInfo = this.idbCollections.parseCollectionFieldName(this.collection, fieldName);
-            if (!fieldInfo) {
-                return { isValid: false, error: `Field ${String(fieldName)} not found in collection` };
-            }
-            // Vérification du type
-            if (!this.#validateType(value, fieldInfo.fieldType)) {
-                return this.#returnError(fieldName, fieldInfo.fieldType);
-            }
-            // Vérification des arguments du champ (required, etc.)
-            if (fieldInfo.fieldArgs) {
-                for (const arg of fieldInfo.fieldArgs) {
-                    if (arg === 'required' && (value === undefined || value === null || value === '')) {
-                        return this.#returnError(fieldName, 'required');
-                    }
-                }
-            }
-            // Validations spécifiques selon le type de champ
-            switch (fieldInfo.fieldType) {
-                case enumPrimitive.email:
-                    if (!this.validateEmail(value)) {
-                        return this.#returnError(fieldName, fieldInfo.fieldType);
-                    }
-                    break;
-                case enumPrimitive.url:
-                    if (!this.validateUrl(value)) {
-                        return this.#returnError(fieldName, fieldInfo.fieldType);
-                    }
-                    break;
-                case enumPrimitive.phone:
-                    if (!this.validatePhone(value)) {
-                        return this.#returnError(fieldName, fieldInfo.fieldType);
-                    }
-                    break;
-                case enumPrimitive.date:
-                case enumPrimitive.datetime:
-                case enumPrimitive.time:
-                    if (!this.validateDateTime(value, fieldInfo.fieldType)) {
-                        return this.#returnError(fieldName, fieldInfo.fieldType);
-                    }
-                    break;
-                // Ajoutez d'autres cas spécifiques ici
-            }
-            return { isValid: true };
-        }
-        catch (error) {
-            if (error instanceof IDbValidationError) {
-                return { isValid: false, error: error.message };
-            }
-            throw error;
-        }
-    }
-    /**
-     * Validate a single field value for a collection.
-     * @param fieldName The field name.
-     * @param value The value to validate.
-     * @returns True if valid, false otherwise.
-     */
-    validateFieldValue(fieldName, value) {
-        const result = this.validateField(fieldName, value);
-        return !!result.isValid;
-    }
-    validateForm(formData, options = {}) {
-        const errors = {};
-        const invalidFields = [];
-        let isValid = true;
-        const fields = this.idbCollections.collection(this.collection).getTemplate().fields;
-        if (!fields) {
-            return {
-                isValid: false,
-                errors: { general: 'Collection template not found' },
-                invalidFields: ['general']
-            };
-        }
-        for (const [fieldName, fieldRule] of Object.entries(fields)) {
-            // Ignorer les champs spécifiés dans options.ignoreFields
-            if (options.ignoreFields && options.ignoreFields.includes(fieldName)) {
-                continue;
-            }
-            const result = this.validateField(fieldName, formData[fieldName]);
-            if (!result.isValid) {
-                errors[fieldName] = result.error || 'Invalid field';
-                invalidFields.push(fieldName);
-                isValid = false;
-            }
-        }
-        return { isValid, errors, invalidFields };
-    }
-    #validateType(value, type) {
-        switch (type) {
-            case enumPrimitive.number:
-                return typeof value === 'number' && !isNaN(value);
-            case enumPrimitive.boolean:
-                return typeof value === 'boolean';
-            case enumPrimitive.text:
-            case enumPrimitive.email:
-            case enumPrimitive.url:
-            case enumPrimitive.phone:
-            case enumPrimitive.password:
-                return typeof value === 'string';
-            case enumPrimitive.date:
-            case enumPrimitive.datetime:
-            case enumPrimitive.time:
-                return value instanceof Date || typeof value === 'string';
-            case enumPrimitive.any:
-                return true;
-            default:
-                return true; // Pour les types non gérés, on considère que c'est valide
-        }
-    }
-    #returnError(fieldName, enumCode) {
-        throw new IDbValidationError(String(fieldName), enumCode ?? 'unknown', `Invalid format for field ${String(fieldName)}. Cause "${enumCode}" `);
-    }
-    validateEmail(email) {
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        return emailRegex.test(email);
-    }
-    validateUrl(url) {
-        try {
-            new URL(url);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    validatePhone(phone) {
-        // Ceci est un exemple simple. Vous pouvez ajuster selon vos besoins spécifiques
-        const phoneRegex = /^\+?[\d\s-]{10,}$/;
-        return phoneRegex.test(phone);
-    }
-    validateDateTime(value, type) {
-        const date = value instanceof Date ? value : new Date(value);
-        if (isNaN(date.getTime()))
-            return false;
-        switch (type) {
-            case enumPrimitive.date:
-                return true; // La conversion en Date a déjà validé le format
-            case enumPrimitive.time:
-                // Vérifiez si la chaîne contient uniquement l'heure
-                return /^([01]\d|2[0-3]):([0-5]\d)(:([0-5]\d))?$/.test(value);
-            case enumPrimitive.datetime:
-                return true; // La conversion en Date a déjà validé le format
-            default:
-                return false;
-        }
-    }
 }
-// (fin de fichier)