[added] Node object abstraction used by the compiler

Adds a light abstraction over element and instances for a common
traversal API

src/compiler.js

@@ -2,20 +2,23 @@ import React from 'react';
 import transform from 'lodash/object/transform';
 import has from 'lodash/object/has';
 import uid from 'lodash/utility/uniqueId';
+import { createNode, NODE_TYPES } from './node';
 import { isTextElement, legacySelector } from './utils';
 import { CssSelectorParser } from 'css-selector-parser';
 import fnName from 'fn-name';
 
 let parser = new CssSelectorParser();
-let name = type => type.displayName || fnName(type) || ''
+
+let name = type => typeof type === 'string'
+  ? type : type.displayName || fnName(type) || ''
 
 let prim = value => {
   let typ = typeof value;
   return value === null || ['string', 'number'].indexOf(typ) !== -1
 }
 
 function failText(fn){
-  return (...args) => isTextElement(args[0]) ? false : fn(...args)
+  return (...args) => args[0].nodeType === NODE_TYPES.TEXT ? false : fn(...args)
 }
 
 export function parse(selector){
@@ -88,9 +91,7 @@ export function create(options = {}) {
     let rule = rules.shift();
 
     if (rule.tagName)
-      fns.push(
-        failText(getTagComparer(rule, values))
-      )
+      fns.push(getTagComparer(rule, values))
 
     if (rule.attrs)
       fns.push(
@@ -99,7 +100,7 @@ export function create(options = {}) {
 
     if (rule.classNames)
       fns.push(
-        failText(({ props }) => {
+        failText(({ element: { props } }) => {
           let className = props && props.className
           return rule.classNames.every(clsName =>
             className && className.indexOf(clsName) !== -1)
@@ -131,9 +132,11 @@ export function create(options = {}) {
       fns.push(NESTING[operator](nestedCompiled))
     }
 
-    return fns.reduce((current, next = ()=> true)=> {
+    let compiledRule = fns.reduce((current, next = ()=> true)=> {
       return (...args)=> current(...args) && next(...args)
     })
+
+    return (element, ...args)=> compiledRule(createNode(element), ...args)
   }
 
   function selector(strings, ...values){
@@ -161,24 +164,27 @@ export function create(options = {}) {
 }
 
 function getTagComparer(rule, values) {
-  let isStr = t => typeof t === 'string'
-  let tagName = values[rule.tagName] || rule.tagName;
+  let tagName = values[rule.tagName] || rule.tagName
+    , test;
 
   if (rule.tagName === '*')
-    return ()=> true
+    test = ()=> true
+
+  else {
+    if (typeof tagName !== 'string')
+      test = root => root.element.type === tagName
+    else {
+      test = root => name(root.element.type).toUpperCase() === tagName.toUpperCase();
+    }
 
-  if (isStr(tagName)){
-    tagName = tagName.toUpperCase();
-    return root => isStr(root.type)
-      ? root.type.toUpperCase() === tagName
-      : name(root.type).toUpperCase() === tagName;
+    test = failText(test)
   }
 
-  return root => root.type === tagName
+  return test
 }
 
 function getPropComparer(rule, values) {
-  return ({ props }) => rule.attrs.every(attr => {
+  return ({ element: { props } }) => rule.attrs.every(attr => {
     if (!has(attr, 'value'))
       return !!props[attr.name]
 

src/index.js

@@ -1,15 +1,25 @@
 import { isValidElement } from 'react';
-import * as elements from './element-selector';
-import * as instance from './instance-selector';
+import { NODE_TYPE } from './node';
+import { findAll, createNode } from './node';
+import { create as createCompiler, parse } from './compiler';
+import selectors from './selectors';
 
-function match(selector, element){
-  if (isValidElement(element))
-    return elements.match(selector, element)
+let compiler = createCompiler()
 
-  return instance.match(selector, element)
+selectors(compiler);
+
+function match(selector, tree, includeSelf = true) {
+  return createNode(tree).findAll(compiler.compile(selector), includeSelf)
+}
+
+function matchKind(selector, element, includeSelf) {
+  return match(selector, element, includeSelf)
+    .map(node => node.instance || node.element)
 }
 
 module.exports = {
   match,
-  selector: elements.compiler.selector 
+  matchKind,
+  findAll,
+  isNode: el => el && el.$$typeof === NODE_TYPE,
 }