@cypress/unique-selector 0.4.3 → 1.0.0

package/component.json

@@ -1,12 +0,0 @@
-{
-  "name": "unique-selector",
-  "repo": "ericclemmons/unique-selector",
-  "description": "Given a DOM element, return a unique CSS selector matching only that element",
-  "version": "0.0.1",
-  "keywords": ["element", "css", "selector"],
-  "development": {
-    "visionmedia/mocha-cloud": "*"
-  },
-  "license": "MIT",
-  "scripts": ["index.js"]
-}

package/src/getAttributes.js

@@ -1,20 +0,0 @@
-/**
- * Returns the Attribute selectors of the element
- * @param  { DOM Element } element
- * @param  { Array } array of attributes to ignore
- * @return { Array }
- */
-export function getAttributes( el, attributesToIgnore = ['id', 'class', 'length'] )
-{
-  const { attributes } = el;
-  const attrs = [ ...attributes ];
-
-  return attrs.reduce( ( sum, next ) =>
-  {
-    if ( ! ( attributesToIgnore.indexOf( next.nodeName ) > -1 ) )
-    {
-      sum.push( `[${next.nodeName}="${next.value}"]` );
-    }
-    return sum;
-  }, [] );
-}

package/src/getClasses.js

@@ -1,38 +0,0 @@
-import 'css.escape';
-
-/**
- * Get class names for an element
- *
- * @pararm { Element } el
- * @return { Array }
- */
-export function getClasses( el )
-{
-  if( !el.hasAttribute( 'class' ) )
-  {
-    return [];
-  }
-
-  try {
-    return Array.prototype.slice.call( el.classList );
-  } catch (e) {
-    let className = el.getAttribute( 'class' );
-
-    // remove duplicate and leading/trailing whitespaces
-    className = className.trim().replace( /\s+/g, ' ' );
-
-    // split into separate classnames
-    return className.split( ' ' );
-  }
-}
-
-/**
- * Returns the Class selectors of the element
- * @param  { Object } element
- * @return { Array }
- */
-export function getClassSelectors( el )
-{
-  const classList = getClasses( el ).filter( Boolean );
-  return classList.map( cl => `.${CSS.escape( cl )}` );
-}

package/src/getCombinations.js

@@ -1,44 +0,0 @@
-/**
- * Recursively combinate items.
- * @param  { Array } result
- * @param  { Array } items
- * @param  { Array } data
- * @param  { Number } start
- * @param  { Number } end
- * @param  { Number } index
- * @param  { Number } k
- */
-function kCombinations( result, items, data, start, end, index, k )
-{
-    if( index === k )
-    {
-        result.push( data.slice( 0, index ).join( '' ) );
-        return;
-    }
-
-    for( let i = start; i <= end && end - i + 1 >= k - index; ++i )
-    {
-        data[index] = items[i];
-        kCombinations( result, items, data, i + 1, end, index + 1, k );
-    }
-}
-
-/**
- * Returns all the possible selector combinations
- * @param  { Array } items
- * @param  { Number } k
- * @return { Array }
- */
-export function getCombinations( items, k )
-{
-    const result = [],
-          n = items.length,
-          data = [];
-
-    for( var l = 1; l <= k; ++l )
-    {
-        kCombinations( result, items, data, 0, n - 1, 0, l );
-    }
-
-    return result;
-}

package/src/getData.js

@@ -1,29 +0,0 @@
-/**
- * Returns the data-{dataAttr} selector of the element
- * @param  { String } selectorType - The type of selector to return.
- * @param  { String } attributes - The attributes of the element.
- * @return { String | null } - The data-{dataAttr} selector of the element.
- */
-
-export const getData = ( selectorType, attributes ) =>
-{
-  for ( let i = 0; i < attributes.length; i++ )
-  {
-    // extract node name + value
-    const { nodeName, value } = attributes[ i ];
-
-    // if this matches our selector
-    if ( nodeName === selectorType )
-    {
-      if ( value )
-      {
-        // if we have value that needs quotes
-        return `[${nodeName}="${value}"]`;
-      }
-
-      return `[${nodeName}]`;
-    }
-  }
-
-  return null;
-};

package/src/getID.js

@@ -1,17 +0,0 @@
-import 'css.escape';
-
-/**
- * Returns the Tag of the element
- * @param  { Object } element
- * @return { String }
- */
-export function getID( el )
-{
-  const id = el.getAttribute( 'id' );
-
-  if( id !== null && id !== '')
-  {
-    return `#${CSS.escape( id )}`;
-  }
-  return null;
-}

package/src/getNthChild.js

@@ -1,33 +0,0 @@
-import { isElement } from './isElement';
-
-/**
- * Returns the selectors based on the position of the element relative to its siblings
- * @param  { Object } element
- * @return { Array }
- */
-export function getNthChild( element )
-{
-  let counter = 0;
-  let k;
-  let sibling;
-  const { parentNode } = element;
-
-  if( Boolean( parentNode ) )
-  {
-    const { childNodes } = parentNode;
-    const len = childNodes.length;
-    for ( k = 0; k < len; k++ )
-    {
-      sibling = childNodes[ k ];
-      if( isElement( sibling ) )
-      {
-        counter++;
-        if( sibling === element )
-        {
-          return `:nth-child(${counter})`;
-        }
-      }
-    }
-  }
-  return null;
-}

package/src/getParents.js

@@ -1,19 +0,0 @@
-import { isElement } from './isElement';
-
-/**
- * Returns all the element and all of its parents
- * @param { DOM Element }
- * @return { Array of DOM elements }
- */
-export function getParents( el )
-{
-  const parents = [];
-  let currentElement = el;
-  while( isElement( currentElement ) )
-  {
-    parents.push( currentElement );
-    currentElement = currentElement.parentNode;
-  }
-
-  return parents;
-}

package/src/getTag.js

@@ -1,9 +0,0 @@
-/**
- * Returns the Tag of the element
- * @param  { Object } element
- * @return { String }
- */
-export function getTag( el )
-{
-  return el.tagName.toLowerCase().replace(/:/g, '\\:');
-}

package/src/index.js

@@ -1,197 +0,0 @@
-/**
- * Expose `unique`
- */
-
-import { getID } from './getID';
-import { getClassSelectors } from './getClasses';
-import { getCombinations } from './getCombinations';
-import { getAttributes } from './getAttributes';
-import { getNthChild } from './getNthChild';
-import { getTag } from './getTag';
-import { isUnique } from './isUnique';
-import { getParents } from './getParents';
-import { getData } from './getData';
-
-const dataRegex = /^data-(.+)/;
-
-/**
- * Returns all the selectors of the element
- * @param  { Object } element
- * @return { Object }
- */
-function getAllSelectors( el, selectors, attributesToIgnore )
-{
-  const funcs =
-    {
-      'tag'        : getTag,
-      'nth-child'  : getNthChild,
-      'attributes' : elem => getAttributes( elem, attributesToIgnore ),
-      'class'      : getClassSelectors,
-      'id'         : getID,
-    };
-
-  return selectors
-  .filter( ( selector ) => !dataRegex.test( selector ) )
-  .reduce( ( res, next ) =>
-  {
-    res[ next ] = funcs[ next ]( el );
-    return res;
-  }, {} );
-}
-
-/**
- * Tests uniqueNess of the element inside its parent
- * @param  { Object } element
- * @param { String } Selectors
- * @return { Boolean }
- */
-function testUniqueness( element, selector )
-{
-  const { parentNode } = element;
-  const elements = parentNode.querySelectorAll( selector );
-  return elements.length === 1 && elements[ 0 ] === element;
-}
-
-/**
- * Tests all selectors for uniqueness and returns the first unique selector.
- * @param  { Object } element
- * @param  { Array } selectors
- * @return { String }
- */
-function getFirstUnique( element, selectors )
-{
-  return selectors.find( testUniqueness.bind( null, element ) );
-}
-
-/**
- * Checks all the possible selectors of an element to find one unique and return it
- * @param  { Object } element
- * @param  { Array } items
- * @param  { String } tag
- * @return { String }
- */
-function getUniqueCombination( element, items, tag )
-{
-  let combinations = getCombinations( items, 3 ),
-    firstUnique = getFirstUnique( element, combinations );
-
-  if( Boolean( firstUnique ) )
-  {
-    return firstUnique;
-  }
-
-  if( Boolean( tag ) )
-  {
-    combinations = combinations.map( combination => tag + combination );
-    firstUnique = getFirstUnique( element, combinations );
-
-    if( Boolean( firstUnique ) )
-      {
-      return firstUnique;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Returns a uniqueSelector based on the passed options
- * @param  { DOM } element
- * @param  { Array } options
- * @return { String }
- */
-function getUniqueSelector( element, selectorTypes, attributesToIgnore )
-{
-  let foundSelector;
-
-  const attributes = [...element.attributes];
-
-  const elementSelectors = getAllSelectors( element, selectorTypes, attributesToIgnore );
-
-  for( let selectorType of selectorTypes )
-  {
-    let selector = elementSelectors[ selectorType ];
-
-    // if we are a data attribute
-    if ( dataRegex.test( selectorType ) )
-    {
-      const dataSelector = getData( selectorType, attributes );
-
-      // if we found a selector via data attributes
-      if ( dataSelector )
-      {
-        selector = dataSelector;
-        selectorType = 'data';
-      }
-    }
-
-    if ( !Boolean( selector ) ) continue;
-
-    switch ( selectorType )
-    {
-      case 'data' :
-      case 'id' :
-      case 'tag':
-        if ( testUniqueness( element, selector ) )
-        {
-          return selector;
-        }
-        break;
-      case 'class':
-      case 'attributes':
-        if ( selector.length )
-        {
-          foundSelector = getUniqueCombination( element, selector, elementSelectors.tag );
-          if ( foundSelector )
-          {
-            return foundSelector;
-          }
-        }
-        break;
-
-      case 'nth-child':
-        return selector;
-
-      default:
-        break;
-    }
-  }
-  return '*';
-}
-
-/**
- * Generate unique CSS selector for given DOM element
- *
- * @param {Element} el
- * @return {String}
- * @api private
- */
-
-export default function unique( el, options={} )
-{
-  const { selectorTypes=['id', 'class', 'tag', 'nth-child'], attributesToIgnore= ['id', 'class', 'length'] } = options;
-  const allSelectors = [];
-  const parents = getParents( el );
-
-  for( let elem of parents )
-  {
-    const selector = getUniqueSelector( elem, selectorTypes, attributesToIgnore );
-    if( Boolean( selector ) )
-    {
-      allSelectors.push( selector );
-    }
-  }
-
-  const selectors = [];
-  for( let it of allSelectors )
-  {
-    selectors.unshift( it );
-    const selector = selectors.join( ' > ' );
-    if( isUnique( el, selector ) )
-    {
-      return selector;
-    }
-  }
-
-  return null;
-}

package/src/isElement.js

@@ -1,17 +0,0 @@
-/**
- * Determines if the passed el is a DOM element
- */
-export function isElement( el )
-{
-  let isElem;
-
-  if ( typeof HTMLElement === 'object' )
-  {
-    isElem = el instanceof HTMLElement;
-  }
-  else
-  {
-    isElem = !!el && ( typeof el === 'object' ) && el.nodeType === 1 && typeof el.nodeName === 'string';
-  }
-  return isElem;
-}

package/src/isUnique.js

@@ -1,12 +0,0 @@
-/**
- * Checks if the selector is unique
- * @param  { Object } element
- * @param  { String } selector
- * @return { Array }
- */
-export function isUnique( el, selector )
-{
-  if( !Boolean( selector ) ) return false;
-  const elems = el.ownerDocument.querySelectorAll( selector );
-  return elems.length === 1 && elems[ 0 ] === el;
-}