@fto-consult/expo-ui 8.59.0 → 8.61.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fto-consult/expo-ui",
-  "version": "8.59.0",
+  "version": "8.61.0",
   "description": "Bibliothèque de composants UI Expo,react-native",
   "react-native-paper-doc": "https://github.com/callstack/react-native-paper/tree/main/docs/docs/guides",
   "scripts": {
@@ -87,7 +87,7 @@
     "react-native-paper": "^5.12.3",
     "react-native-paper-dates": "^0.22.3",
     "react-native-web": "^0.19.10",
-    "react-virtuoso": "^4.7.4",
+    "react-virtuoso": "^4.7.7",
     "readable-stream": "^4.5.2",
     "sanitize-filename": "^1.6.3",
     "tippy.js": "^6.3.7",

package/src/components/Fab/FabItem/old/FabItem.js

@@ -153,7 +153,6 @@ const FAB = React.forwardRef(
             ) : null}
             {label ? (
               <Text
-                variant="labelLarge"
                 selectable={false}
                 testID={`${testID}-text`}
                 style={[

package/src/importer/getSelectFieldValue.js

@@ -0,0 +1,23 @@
+export default function getSelectedFieldValue ({field,value}){
+    let hasF = false;
+    let itemCodes = "";
+    let vStr = defaultStr(value).toLowerCase().removeSpecialChars().trim();
+    value = defaultStr(value,typeof value =="number"? String(value) : value);
+    value = value.trim();
+    Object.map(field.items,(item,j)=>{
+        if(!isObj(item)) return;
+        let itemCode = defaultStr(item.code).trim();
+        if(!itemCode) return;
+        let rLabel = defaultStr(item.label,item.text,itemCode);
+        let label = rLabel.removeSpecialChars();
+        itemCodes+=(itemCodes?", ":"")+((label?(label+(field.multiple?(" et/ou "):" ou ")):"")+itemCode);
+        label = label.toLowerCase().trim();
+        if(itemCode == value || (itemCode.toLowerCase().trim() == vStr || label == vStr)){
+            hasF = true;
+            value = itemCode;
+            return;
+        }
+    })
+    value = hasF ? value : false;
+    return {value,itemCodes};
+}

package/src/importer/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    run : require("./run"),
+    validate : require("./validate")
+}

package/src/importer/parseCSV.js

@@ -0,0 +1,81 @@
+import {isNonNullString,defaultStr} from "$cutils";
+export default function parseCSV( strData, strDelimiter ){
+    // Create an array to hold our data. Give the array
+    // a default empty first row.
+    let arrData = [[]];
+    if(!isNonNullString(strData)) return arrData;
+    // Check to see if the delimiter is defined. If not,
+    // then default to comma.
+    strDelimiter = defaultStr(strDelimiter,",");
+    
+    // Create a regular expression to parse the CSV values.
+    var objPattern = new RegExp(
+        (
+            // Delimiters.
+            "(\\" + strDelimiter + "|\\r?\\n|\\r|^)" +
+
+            // Quoted fields.
+            "(?:\"([^\"]*(?:\"\"[^\"]*)*)\"|" +
+
+            // Standard fields.
+            "([^\"\\" + strDelimiter + "\\r\\n]*))"
+        ),
+        "gi"
+        );
+
+    // Create an array to hold our individual pattern
+    // matching groups.
+    var arrMatches = null;
+
+
+    // Keep looping over the regular expression matches
+    // until we can no longer find a match.
+    while (arrMatches = objPattern.exec( strData )){
+
+        // Get the delimiter that was found.
+        var strMatchedDelimiter = arrMatches[ 1 ];
+
+        // Check to see if the given delimiter has a length
+        // (is not the start of string) and if it matches
+        // field delimiter. If id does not, then we know
+        // that this delimiter is a row delimiter.
+        if (
+            strMatchedDelimiter.length &&
+            (strMatchedDelimiter != strDelimiter)
+            ){
+
+            // Since we have reached a new row of data,
+            // add an empty row to our data array.
+            arrData.push( [] );
+
+        }
+
+
+        // Now that we have our delimiter out of the way,
+        // let's check to see which kind of value we
+        // captured (quoted or unquoted).
+        if (arrMatches[ 2 ]){
+
+            // We found a quoted value. When we capture
+            // this value, unescape any double quotes.
+            var strMatchedValue = arrMatches[ 2 ].replace(
+                new RegExp( "\"\"", "g" ),
+                "\""
+                );
+
+        } else {
+
+            // We found a non-quoted value.
+            var strMatchedValue = arrMatches[ 3 ];
+
+        }
+
+
+        // Now that we have our value string, let's add
+        // it to the data array.
+        arrData[ arrData.length - 1 ].push( strMatchedValue );
+    }
+
+    // Return the parsed data.
+    return arrData;
+}

package/src/importer/run.js

@@ -0,0 +1,400 @@
+module.exports = (args,options)=>{
+    let sellersTables = APP.DATA_FILE_MANAGER.getSellersTables ();
+    options = defaultObj(options);
+    let importer = defaultObj(options.importer);
+    let {content,name,fileName,success,error} = defaultObj(args);
+    let {getDB,constants} = require("$database");
+    let validate = require("./validate")
+    let {notify} = require("$components/Dialog")
+    let parser = require("papaparse");
+    fileName = defaultStr(fileName,name);
+    let extraData = require("$database/data/tables/extra");
+    let fFields = isFunction(importer.getFields)? importer.getFields("import") : {};
+    let handleErrors = (errors)=>{
+        if(isArray(errors) && errors.length > 0){
+            let err = "";
+            let fileName = "";
+            let cF = 0;
+            let length = 0;
+            errors.map((e,i)=>{
+                if(isObj(e)){
+                    err += "Ligne : "+e.index
+                        + ", Table : "+defaultStr(e.tableText,e.table)
+                        +", Fichier : "+defaultStr(e.dbId)
+                        +", msg : "+e.msg
+                        +"\r\n"
+                    if(cF < 3 && isNonNullString(e.tableText) && !fileName.contains(e.tableText)){
+                        fileName +=(fileName? ", ":"")+e.tableText;
+                    }
+                }
+                cF++;
+                length++;
+            });
+            if(length > 0){
+                let s = length > 1 ? "s":"";
+                let errL = (length > 9? "":"0")+length.formatNumber();
+                fileName = sanitizeFileName(("Erreur"+s+" import-"+fileName+" au &dateheure&"))+".txt";
+                APP.FILE.saveText({
+                    content : err,
+                    fileName,
+                    //mimeType : "text/csv",
+                    directory : APP.getId()+"/imports/erreurs/"
+                }).then(({path})=>{
+                    notify.warning({
+                        message : "Opération d'import terminée avec "+errL+" erreur"+s+". Retrouvez le rapport dans le fichier "+(isNonNullString(path)? path:fileName)
+                        ,timeout : 8000
+                    });
+                }).catch((e)=>{
+                    console.log(e,' saving import error');
+                })
+            }
+        }
+    }
+    return new Promise((resolve,reject)=>{
+        let json = content;
+        let TABLES = constants.TABLES; 
+        let STRUCT_DATA_TABLES = constants.STRUCT_DATA_TABLES;
+        let errors = [];
+        let breakLoop = undefined;
+        let footer = false ? [{
+            text :'Annuler',
+            icon : 'cancel',
+            onClick : ()=>{
+                breakLoop = true;
+                hidePreloader();
+                let msg = "Opération annulée";
+                notify.error(msg);
+                throw (msg);
+            }
+        }] : undefined;
+        let errorF = (e)=>{
+            hidePreloader();
+            resolve({status:false,errors});
+            handleErrors(errors);
+            if(isFunction(error)){
+                error(e,errors);
+                return;
+            }
+            if(isNonNullString(e)){
+                notify.error(e);
+            }
+        };
+        let successF = (d)=>{
+            d = {result:d,errors};
+            hidePreloader();
+            handleErrors(errors);
+            if(isFunction(success)){
+                success(d);
+                return;
+            } 
+            resolve(d);
+        }
+        if(!content) {
+            errorF(null);
+            return;
+        }
+        let dbs = {};
+        let preloader = "import fichier "+fileName;
+        showPreloader(preloader);
+        let docs = [];
+        let isCSV =  false;
+        if(!isJSON(json)) {
+            let parsedData = parser.parse(json,{delimiter:defaultStr(importer.delimiter)});
+            if(isObj(parsedData)){
+                if(isArray(parsedData.errors) && parsedData.errors.length > 0){
+                    let err = parsedData.errors[0];
+                    let _msg = "";
+                    if(isObj(err) && isNonNullString(err.message)){
+                        _msg += ", message : "+err.message;
+                    }
+                    return errorF("Impossible d'importer le fichier "+fileName+" car celui-ci contient "+parsedData.errors.length.formatNumber()+" erreur(s)"+_msg);
+                } else if(isArray(parsedData.data) && isArray(importer.fields) && isNonNullString(importer.table) && isNonNullString(importer.dbId)){
+                    let meta = parsedData.meta;
+                    if(isObj(meta) && isNonNullString(meta.delimiter)){
+                        let delimiter= meta.delimiter;
+                        let arr = [];
+                        let k = defaultNumber(importer.ignoreFirstLigne,1)? 1 : 0;
+                        let length = parsedData.data.length;
+                        while(k < length){
+                            let d = parsedData.data[k];
+                            let _d = {};
+                            let p = false;
+                            if(isArray(d) && d.length > 1){
+                                importer.fields.map((f,index)=>{
+                                    _d[f] = d[index];
+                                    if(isObj(fFields[f])){
+                                        let ff = fFields[f];
+                                        if(isNonNullString(ff.piece)){
+                                            _d.piece = ff.piece;
+                                        }
+                                    }
+                                    if(!p && _d[f] !== undefined && isNonNullString(_d[f])){
+                                        p = true;
+                                    }
+                                })
+                                _d.table = importer.table;
+                                _d.dbId = importer.dbId;
+                            }
+                            if(p){
+                                let tableText = defaultStr(importer.label,_d.table)
+                                let msg = validate({data:_d,index:k,requiredFields:defaultArray(importer.fields),fields:fFields,table:_d.table,tableText});
+                                if(isNonNullString(msg)){
+                                    errors.push({dbId:importer.dbId,index:k,msg,status:false,table:_d.table,tableText});
+                                    p = false;
+                                } else p = !msg ? false : true;
+                            }
+                            if(p) arr.push(_d);
+                            k++;
+                        }
+                        isCSV = true;
+                        
+                        if(isFunction(importer.prepareData)){
+                            json = defaultArray(importer.prepareData({docs:arr,fields:fFields,delimiter,rawDocs:parsedData.data,delimiter,table:importer.table,dbId:importer.dbId,dbName:importer.dbId}))
+                        } else json = arr;
+                    }
+                }
+            } else {
+                errorF("Le fichier "+fileName+" est un fichier de données json invalide");
+                return;
+            }
+        } else {
+            isCSV = false;
+            json = parseJSON(json);
+            if(isObj(json) && defaultStr(json.origin).toLowerCase() =="shared" && isNonNullString(json.provider) && isNonNullString(json.dataType)){
+                return require("../share/import")({success:successF,error:errorF,json});
+            }
+        }
+        if(isArray(json)){
+            json = {rows : json};
+        } else if(!isObj(json)) {
+            errorF("fichier json invalide : ")
+            return;
+        }
+        let isStructData = arrayValueExists(["struct_data",'structdata'],defaultStr(json.type).toLowerCase()); 
+        if(isStructData ){
+            if(isObj(json.rows) && Object.size(json.rows) > 0){
+                docs = json.rows;
+            } else if(isObj(json.docs) && Object.size(json.docs) > 0){
+                docs = json.docs;
+            }
+            let count = 0;
+            if(isObj(docs)){
+                let {commonDB} = require("$database");
+                let promises = [];
+                for(let i in docs){
+                    let table = i.toUpperCase();
+                    if(table in STRUCT_DATA_TABLES && isObj(docs[i])){
+                        for(let k in docs[i]){
+                            let d = docs[i][k];
+                            if(isObj(d) && isNonNullString(d.code)){
+                                promises.push(commonDB.upsertStructData(table,d).then(()=>{
+                                    count++;
+                                }));
+                            }
+                        }
+                    }
+                }
+                Promise.all(promises).then(()=>{
+                    if(count > 0){
+                        notify.success(count+" Données de structures modifiées ");
+                    }
+                })
+            }
+            ///l'import des données de structure se fait autrement
+            return successF();
+        } else {
+            if(isArray(json.rows) && json.rows.length > 0){
+                docs = json.rows;
+            } else if(isArray(json.docs) && json.docs.length > 0){
+                docs = json.docs;
+            }
+            if(docs.length <= 0) {
+                successF()
+                return;
+            }
+        }
+        let allDBS = APP.DATA_FILE_MANAGER.getAll();
+        showPreloader({content:preloader+" ...",footer});
+        
+        let doc = null;
+        for(let j in docs){
+            if(!isObj(docs[j])) continue;
+            if(breakLoop) break;
+            doc = null;
+            if(isObj(docs[j])){
+                doc = docs[j];
+                if(isObj(docs[j].doc) && (isNonNullString(docs[j].doc._id) || isNonNullString(docs[j].doc._rev))){
+                    doc = docs[j].doc;
+                }
+            }
+            if(!doc) continue;
+            let dbId = APP.DATA_FILE_MANAGER.sanitizeName(defaultStr(doc.dbId,json.dbName));
+            let dF = allDBS[dbId];
+            if(!isNonNullString(dbId) || !dF) {
+                errors.push({status:false,dbId,index:j,msg:"Impossible de faire une importation dans le "+APP.DATA_FILE_MANAGER.dataFileText+" "+dbId+" car celui-ci est innexistant",table:doc.table,tableText:doc.table})
+                continue;
+            }
+            let table = defaultStr(doc.table).toUpperCase();
+            if(!arrayValueExists(extraData.ids,doc._id) && !extraData.tables[table]){
+                if(!table) {
+                    errors.push({dbId,index:j,msg:'le champ table est invalide pour la données',status:false,table});
+                    continue;
+                }
+                let isDocStructData = dbId.trim() =='struct_data' ? true : false;
+                let tb = isDocStructData ? STRUCT_DATA_TABLES[table] : TABLES[table];
+                if(!isObj(tb)){
+                    continue;
+                }
+                let dbType = defaultStr(dF.type,"seller").toLowerCase();
+                let fields = tb.fields;
+                if(isDocStructData){
+                    dbType = "common";
+                    fields = APP.extend(true,{},{
+                        code : {
+                            required : true,
+                            label: 'Code',
+                        },label:{
+                            type : 'text',
+                            label : 'Libelé',
+                            required : true,
+                        }
+                    },fields);
+                } 
+                if(!isObj(fields)){
+                    continue;
+                }
+                if(APP.DATA_FILE_MANAGER.isCommon(tb.dbName)){
+                    dbType = "common"
+                }
+                let tableText = defaultStr(tb.label,tb.text,table);
+                let _msg = undefined;
+                if(dbType == 'common'){
+                    if(isDocStructData){
+                        if(dbId !== 'struct_data'){
+                            _msg = "Impossible d'insérer les données de structure dans le fichier "+dbId;
+                        }
+                    } else if(!APP.DATA_FILE_MANAGER.isCommon(dbId)) {
+                        _msg = "Impossible d'insérer ce type de données dans le "+APP.DATA_FILE_MANAGER.dataFileText+" communes";
+                    }
+                } else if(dbType =='project' && dbId !=='project'){
+                    _msg = "Impossible d'insérer ce type de données dans le "+APP.DATA_FILE_MANAGER.dataFileText+" des projets";
+                } else {
+                    if((dbType ==='seller' || dbType =='pos') && !arrayValueExists(sellersTables,table)){
+                        _msg = "Impossible d'enregistrer ce type de données dans un "+APP.DATA_FILE_MANAGER.dataFileText+" commercial";
+                    }
+                }
+                if(_msg){
+                    errors.push({dbId,index:j,msg:_msg,status:false,table,tableText});
+                    continue;
+                }
+                if(!doc["has-validate-content-imp"]){
+                    let vArgs = {data:doc,index:j,fields,requiredFields:defaultArray(tb.import  && tb.import.requiredFields? tb.import.requiredFields:[]),table,tableText};
+                    let msg = validate(vArgs);
+                    if(isNonNullString(msg)){
+                        errors.push({dbId,index:j,msg,status:false,table,tableText});
+                        continue;
+                    } else if(!msg) continue;
+                }
+                delete doc["has-validate-content-imp"];
+                doc.table = table;
+                doc.dbId = dbId;
+            } 
+            doc.dbId = dbId;
+            dbs[dbId] = defaultArray(dbs[dbId]);
+            dbs[dbId].push(doc);
+        }
+        if(Object.size(dbs) <= 0){
+            return successF();
+        }
+        let count = 0;
+        ///les données sont insérées par base de données;
+        for(let dbName in dbs){
+            count++;
+            if(breakLoop) break;
+            getDB(dbName).then(({db})=>{
+                let _docs = dbs[dbName];
+                let dLen = _docs.length;
+                let sLen = dLen.formatNumber()
+                let preloadP = preloader+"["+dbName+"]";
+                showPreloader({content:preloadP+"...",footer});
+                let promises = [];
+                let length = 0;
+                let c = 0;
+                for(let j in _docs){
+                    let doc = _docs[j];
+                    doc.table  = defaultStr(doc.table).toUpperCase();
+                    let table = doc.table;
+                    let isDocStructData = doc.dbId.trim() =='struct_data' ? true : false;
+                    let tb = isDocStructData ? STRUCT_DATA_TABLES[table] : TABLES[table] || {};
+                    let tableText = defaultStr(tb.label,tb.text,table);
+                    let mutator = isCSV ? (isFunction(importer.mutator)? importer.mutator:undefined) : isObj(tb.import) && isFunction(tb.import.mutator)? tb.import.mutator : undefined;
+                    let dbId = doc.dbId;
+                    if(mutator){
+                        doc = mutator({doc,db,dbId,table,tableText});
+                    }
+                    if(isNonNullString(doc)){
+                        errors.push({dbId,index:j,msg:doc,status:false,table,tableText});
+                        continue;
+                    } else if(!isObj(doc) || !isNonNullString(doc.table)){
+                        errors.push({dbId,index:j,msg:"Document non valide, car la table de données est manquante",status:false,table,tableText});
+                        continue;
+                    }
+                    doc._id = db.uniqid({data:doc}).id;
+                    /**** la fonction de muter la données au moment de la mise à jour */
+                    let upsertMutator = isCSV ? (isFunction(importer.upsertMutator)? importer.upsertMutator:undefined) : isObj(tb.import) && isFunction(tb.import.upsertMutator)? tb.import.upsertMutator : undefined;
+                    promises.push(
+                        db.upsert(
+                            doc._id,
+                            (_doc)=>{
+                                let ret  = isCSV? APP.extend({},_doc,doc):APP.extend(true,{},_doc,doc);
+                                if(upsertMutator){
+                                    return upsertMutator({doc:ret,old:_doc,new:doc,db,dbId:doc.dbId,table,tableText});
+                                }
+                                return ret;
+                            },{updatedBy:false,updatedHour:false,updatedDate:false}
+                        ).then((u)=>{
+                            c++;
+                            showPreloader({
+                                    content : preloadP+", "+(c.formatNumber()+" sur "+sLen+" traités, "+(Math.floor(c*100/dLen)+"%")),
+                                    footer
+                                }
+                            )
+                            return u;
+                        }).catch((e)=>{
+                            c++;
+                            return e;
+                        })
+                    );
+                    length++;
+                }
+                Promise.all(promises).then((a)=>{
+                    successF(a);
+                    showPreloader(preloader+", 100% traités");
+                    let dF = APP.DATA_FILE_MANAGER.get(dbName);
+                    if(dF){
+                        dbName = dF.label;
+                    }
+                    let dbPref = " le "+APP.DATA_FILE_MANAGER.dataFileText+" ["+dbName+"]";
+                    if(promises.length>0){   
+                        notify.success(promises.length+" modification(s) effectuée(s) dans "+dbPref);
+                    } else {
+                        notify.success("Auccune modification apportée au "+dbPref);
+                    }
+                    setTimeout(()=>{
+                        hidePreloader();
+                    },1000);
+                }).catch((e)=>{
+                    if(length >= _docs.length){
+                        hidePreloader();
+                        errorF(e);
+                    }
+                })
+            }).catch((e)=>{
+                if(count >= Object.size(dbs)){
+                    hidePreloader();
+                    errorF(e);
+                }
+            })
+        }
+    })
+}

package/src/importer/validate.js

@@ -0,0 +1,137 @@
+import getSelectFieldValue from "./getSelectFieldValue";
+import appConfig from "$capp/config";
+
+export default function validate(args){
+    let {data,requiredFields,index,fields,table,tableText}= defaultObj(args)
+    data = defaultObj(data);
+    requiredFields = defaultArray(requiredFields);
+    if(!isObj(fields)) return "champs de validation incorects";
+    for(let i in fields){
+        let field = fields[i];
+        if(!isObj(field)) continue;
+        let code = defaultStr(i,field.code);
+        let label = defaultStr(field.label,field.text,i);
+        let v = data[code];
+        let isFieldSelected = arrayValueExists(requiredFields,code);
+        let type = defaultStr(field.type,'text').toLowerCase().trim();
+        let validType  = defaultStr(field.validType).toLowerCase();
+        let lSuffix = isNonNullString(tableText)? ("["+tableText+"]"):"";
+        let labelStr = (isNonNullString(v) || isNumber(v) ? (" la valeur <"+v+"> du champ ") : "le champ ")+label+lSuffix+"";
+        labelStr += (index)? (", ligne "+index):""
+        let isIdField = type == 'id' || type =="piece";
+
+        /**** les donées passés en paramètre de type tableau */
+        if(type.contains("select")){
+            if(field.multiple){
+                v = isArray(v)? v : (v?(v+""):"").split(",");
+            } else v = defaultStr(v);
+            let itemCodes = "";
+            let itemsL = Object.size((isObjOrArray(field.items)? field.items : [])) > 0 ? true : false;
+            let hasF = true;
+            let isSelectTableData = type == "selecttabledata";
+            if(isArray(v)){
+                let arr = [];
+                v.map((value)=>{
+                    if(itemsL){
+                        let _v = getSelectFieldValue({field,value});
+                        itemCodes = defaultStr(itemCodes,_v.itemCodes);
+                        if(_v.value !== false){
+                            arr.push(_v.value);
+                        }
+                    } else if(isNonNullString(value)) {
+                        arr.push(isSelectTableData? value.toUpperCase():value)
+                    }
+                });
+                hasF = arr.length > 0 ? true : false;
+                v = arr;
+            } else {
+                if(itemsL){
+                    let _v = getSelectFieldValue({field,value:v});
+                    itemCodes = _v.itemCodes;
+                    hasF = _v.value !== false? true : false;
+                    if(hasF){
+                        v = _v.value;
+                    }
+                }
+                if(isSelectTableData && hasF){
+                    v = v.toUpperCase();
+                }
+                //eif(isFieldSelected) console.log(hasF, code,_v,' is value');
+            }
+            if(isFieldSelected && !hasF && itemCodes){
+                return labelStr+" doit figurer parmi la liste : ["+itemCodes+"]";
+            } 
+        }
+
+        if((isIdField || validType.contains("required") || field.required)){
+            if(isIdField && isNonNullString(data.table)){
+            } else if(v == undefined || v == null || v =='' || (isArray(v) && v.length <= 0)) {
+                return labelStr+" est requis";
+            }
+        }
+        if(isIdField  && isNonNullString(v)){
+            v = v.trim();
+            if(!isValidDataFileName(v.replaceAll("/",""))) return labelStr+" a une valeur invalide";
+        }
+        if(type =="datafile" && v && !APP.DATA_FILE_MANAGER.get(v)){
+            return labelStr+ ", le "+APP.DATA_FILE_MANAGER.dataFileText+" "+defaultStr(v) +" est innexistant"
+        }
+        if((type =="number" || type=="decimal" || validType.contains("number") || validType.contains("decimal"))){
+            if(!isNumber(v)){
+                v = parseDecimal(v);
+                if(!isNumber(v) && isFieldSelected){
+                    return labelStr+" doit être un nombre";
+                } else {
+                    v = defaultDecimal(v);
+                }
+            }
+        }
+        
+        if(type =='email' && v && !isValidEmail(v,false)){
+            return labelStr+" doit être un email valide";
+        }
+        if(type == 'date' && v){
+            let date = APP.date.toDateObj(v,true);
+            if(!date || !date.date){
+                return labelStr+" doit être une date valide au format yyyy-mm-dd";
+            }
+        }
+        if(type == 'time' && v && !APP.date.isValidSQLTime(v)){
+            return labelStr+" doit être une heure valide au format hh:mm:ss";
+        }
+        
+        let strValid = labelStr+" doit être une chaine de caractère non nulle ";
+        if(isNumber(field.length) && isNonNullString(v) && v.length != field.length){
+            return strValid+" de "+field.length + " caractères";
+        }
+        if(isNumber(field.minLength) && isNonNullString(v) && v.length < field.minLength){
+            return strValid+" de "+field.minLength+" caractères minimum";
+        }
+        if(isNumber(field.maxLength) && isNonNullString(v) && v.length > field.maxLength){
+            return strValid+" de "+field.maxLength+" caractères maximum";
+        }
+        if(type =='switch'){
+            let checkedLabel = defaultStr(field.checkedLabel,code =='archived'?'Archivé':'Désactivé').toLowerCase().trim(),
+            uncheckedLabel = defaultStr(field.uncheckedLabel,code =='archived'?'Non archivé':'Activé').toLowerCase().trim(),
+            checkedValue = defaultVal(field.checkedValue,1),uncheckedValue = defaultVal(field.uncheckedValue,0)
+            v = (defaultVal(v,field.defaultValue,"")+"").toLowerCase().trim();
+            if(v == checkedValue+""){
+                v = checkedValue;
+            } else if(v == uncheckedValue+""){
+                v = uncheckedValue;
+            } else if(v == checkedLabel){
+                v = checkedValue;
+            } else if(v == uncheckedLabel){
+                v = uncheckedValue;
+            } 
+            if(!arrayValueExists([checkedValue,uncheckedValue],v)){
+                return labelStr+" doit  l'une des valeur : "+checkedLabel+"/"+uncheckedLabel+"/"+checkedValue+"/"+uncheckedValue;
+            }
+        }
+        if(isFieldSelected && v !== undefined){
+            data[code] = v;
+        }
+    }
+    data["has-validate-content-imp"] = true;
+    return true;
+}

package/src/screens/Help/openLibraries.js

@@ -1,7 +1,7 @@
 module.exports = {
 	"@fto-consult/expo-ui": {
 		"name": "@fto-consult/expo-ui",
-		"version": "8.59.0",
+		"version": "8.60.0",
 		"repository": {
 			"type": "git",
 			"url": "git+https://github.com/borispipo/expo-ui.git"
@@ -136,7 +136,7 @@ module.exports = {
 		"license": "MIT"
 	},
 	"react-virtuoso": {
-		"version": "4.7.4",
+		"version": "4.7.7",
 		"url": "https://virtuoso.dev/",
 		"license": "MIT"
 	},