NxTIC/public_html/js/lib/reset.js

/* SELECTOR ALIASES */
function $(selector){  return document.querySelector(selector);    }
function $$(selector){ return document.querySelectorAll(selector); }


/* Retourne un data-* attribute d'un element (surcharge de l'ELEMENT natif)
*
* @attribute<String>			L'attribut qui nous interesse
*
* @return value<String>			Retourne la valeur si l'attribut existe
* @return false 				Retourne FALSE si rien n'a ete trouve
*
*
*/
Element.prototype.getData = function(attribute){
	// On verifie qu'un data-* attribute existe
	if( typeof this.dataset == 'undefined' )
		return false;

	return ( this.dataset.hasOwnProperty(attribute) ) ? this.dataset[attribute] : false;
};


/* Ajout de classe pour un element (surcharge de l'ELEMENT natif)
*
* @className<String>				Classe a ajouter a l'element
*
*/
Element.prototype.addClass = function(className){
	/* [1] On transforme la classe actuelle en tableau
	====================================================*/
	var classArray = this.className.split(' ');

	/* [2] On ajoute la classe si elle n'y est pas deja
	====================================================*/
	if( classArray.indexOf(className) > -1 ) return; // La classe y est deja

	classArray.push(className);

	/* [3] On reformatte tout
	====================================================*/
	this.className = classArray.join(' ').trim();
};


/* Suppression de classe pour un element (surcharge de l'ELEMENT natif)
*
* @className<String>				Classe a supprimer a l'element
*
*/
Element.prototype.remClass = function(className){
	/* [1] On transforme la classe actuelle en tableau
	====================================================*/
	var classArray = this.className.split(' ');

	/* [2] On retire la classe si elle y est
	====================================================*/
	var index = classArray.indexOf(className);

	if( index == -1 ) return; // La classe n'y est pas

	classArray = classArray.slice(0,index).concat( classArray.slice(index+1) );

	/* [3] On reformatte tout
	====================================================*/
	this.className = classArray.join(' ').trim();
};


// on définit le "indexOf" pour <HTMLCollection> et <NodeList>
NodeList.prototype.indexOf = HTMLCollection.prototype.indexOf = function(searchedElement){
	for( var i = 0 ; i < this.length ; i++ ) // on parcours la collection
		// si on trouve l'élement, on retourne son rang
		if( this[i] == searchedElement ) return i;

	// si on a rien trouvé, on retourne -1
	return -1;
};


// GESTION DES ANIMATIONS (CLASSE PENDANT TEMPS IMPARTI)
Element.prototype.anim = function(className, timeout){

	var pointer = this; // on cree un pointeur

	pointer.addClass(className); // on met la classe

	// on la retire apres le @timeout imparti
	setTimeout(function(){ pointer.remClass(className); }, timeout);

};


// INCLUSION D'UN SCRIPT JAVASCRIPT
var _includes = [];
var _includeTags = [];
var _includeLoad = [];

function include(jsResource, callback, action){ // action=true -> EXCLUSION, SINON -> INCLUSION
	/* (0) On formatte les arguments */
	jsResource = typeof jsResource === 'string'   ? jsResource : null;
	callback   = typeof callback   === 'function' ? callback   : function(){ console.log('[x] '+jsResource+' loaded'); };
	action     = typeof action     === 'boolean'  ? action     : false;

	// Si la ressource n'est pas donnée
	if( !jsResource ) return false;


	/* (1) Gestion de l'inclusion */
	if( !action ){

		var index = _includes.indexOf(jsResource);

		// Si le fichier est déja inclus, on lance le callback
		if( index > -1 ){

			// Si le fichier est déja chargé uniquement, on relance
			callback();
			return true;
		}

		// On crée l'élément dans le tag <head>
		var tag  = document.createElement('script');

		// On ajoute la ressource et le tag à la liste
		index               = _includes.length;
		_includes[index]    = jsResource;
		_includeLoad[index] = false;
		_includeTags[index] = tag;


		// On définit le callback
		tag.onload = (function(v){

			var i = v;

			return function(){

				_includeLoad[i] = true;
				callback();
			};

		})(index);

		// Attributs de l'élément
		tag.setAttribute('src', jsResource);
		tag.setAttribute('type', 'text/javascript');
		document.head.appendChild( tag );


		return true;
	/* (2) Gestion de l'exclusion */
	}else{
		var index = _includes.indexOf(jsResource);

		// On vérifie que le fichier est déja inclus
		if( index == -1 ) return false;

		// On supprime l'élément
		document.head.removeChild( _includeTags[index] );

		// On dé-indexe l'élément
		_includes.splice(index, 1);
		_includeTags.splice(index, 1);

		return true;
	}
}


/* RETOURNE LES CLÉS N'AYANT PAS UNE VALEUR EGALE POUR 2 OBJETS
*
* @A<Object> 									Premier Objet
* @B<Object> 									Second Objet
* @ignore<Array> 								Tableau des clés à ignorer
*
* @return diff<Array> 							Tableau contenant les clés des valeurs différentes (uniquement les clés communes et non NULLes)
*
*/
function diff(A, B, ignore){
	var dKeys = [];

	for( var key in A ){
		// Si A[key] ou B[key] est NULL, on ne compare pas
		if( B[key] == null || A[key] == null || ignore instanceof Array && ignore.indexOf(key) > -1 )
			continue;


		/* (1) On vérifie le type */
		if( typeof A[key] !== typeof B[key] )
			dKeys.push(key);

		/* (2) Vérification récursive si 2 objets */
		else if( A[key] instanceof Object && B[key] instanceof Object ){
			// Si au moins 1 différence profonde (récursive), on ajoute la clé
			if( diff(A[key], B[key]).length > 0 )
				dKeys.push(key);

		/* (3) Vérification superficielle (types non composés) */
		}else if( A[key] != B[key] )
			dKeys.push(key);

	}

	return dKeys;
}


/* CLONE UN OBJET DE PROFONDEUR 1
*
* @input<Object> 										Objet à cloner
*
* @return clone<Object> 								Objet identique (cloné)
*
* Note: prise en compte des primitifs && tableaux uniquement
*
*/
cloneObject = function(input){
	return JSON.parse( JSON.stringify(input) );
};


/* DEFINITION DES FORMATS UTILES POUR INPUT-CHECKER
*
*/
// Numéro de téléphone
var format_number = new formatChecker(null, '0i ii ii ii ii' );