cssauron

What is cssauron?

cssauron is a lightweight library for creating custom CSS-like selectors for JavaScript objects. It allows you to define and use selectors to query and manipulate data structures in a way similar to how you would use CSS selectors to query and manipulate the DOM.

What are cssauron's main functionalities?

Creating a Custom Selector

This feature allows you to create a custom selector by defining how to map CSS-like properties to your JavaScript object properties. The code sample demonstrates creating a selector for a custom data structure and querying it.

const cssauron = require('cssauron');
const mySelector = cssauron({
  tag: 'type',
  class: 'className',
  id: 'id',
  children: 'children'
});

const data = {
  type: 'div',
  className: 'container',
  id: 'main',
  children: [
    { type: 'span', className: 'text', id: 'child1' },
    { type: 'span', className: 'text', id: 'child2' }
  ]
};

const matches = mySelector('div.container#main > span.text')(data);
console.log(matches);

Using the Selector

This feature demonstrates how to use the custom selector to query a data structure. The code sample shows how to find all 'span' elements with the class 'text' within the data structure.

const cssauron = require('cssauron');
const mySelector = cssauron({
  tag: 'type',
  class: 'className',
  id: 'id',
  children: 'children'
});

const data = {
  type: 'div',
  className: 'container',
  id: 'main',
  children: [
    { type: 'span', className: 'text', id: 'child1' },
    { type: 'span', className: 'text', id: 'child2' }
  ]
};

const matches = mySelector('span.text')(data);
console.log(matches);

Other packages similar to cssauron

css-select

css-select is a library for selecting elements in a DOM-like structure using CSS selectors. It is commonly used with Cheerio to query HTML documents. Unlike cssauron, which is designed for custom JavaScript objects, css-select is specifically tailored for HTML and XML documents.

sizzle

Sizzle is a pure-JavaScript CSS selector engine designed to be easily dropped in to a host library. It is the selector engine used by jQuery. Sizzle is focused on querying DOM elements, whereas cssauron is more flexible and can be used to query any JavaScript object.

json-query

json-query allows querying JSON data structures using a simple query language. It is similar to cssauron in that it can be used to query custom data structures, but it uses a different syntax and approach for defining queries.

README

cssauron

build a matching function in CSS for any nested object structure!

var language = require('cssauron')({
    tag: 'tagName'
  , contents: 'innerText'
  , id: 'id'
  , class: 'className'
  , parent: 'parentNode'
  , children: 'childNodes'
  , attr: 'getAttribute(attr)'
})

var selector = language('body > #header .logo')
  , element = document.getElementsByClassName('logo')[0]

if(selector(element)) {
  // element matches selector
} else {
  // element does not match selector
}

It's easy to use with your favorite nested tree structures! Delicious with HTML! Digestable with JSON!

HTML	JSON	GLSL AST	JS AST (Esprima)
cssauron-html	cssauron-json	cssauron-glsl	cssauron-falafel

API

require('cssauron')(options) -> selector factory

Import cssauron and configure it for the nested object structure you'll want to match against.

options

options are an object hash of lookup type to string attribute or function(node) lookups for queried nodes. You only need to provide the configuration necessary for the selectors you're planning on creating. (If you're not going to use #id lookups, there's no need to provide the id lookup in your options.)

• tag: Extract tag information from a node for div style selectors.
• contents: Extract text information from a node, for :contains(xxx) selectors.
• id: Extract id for #my_sweet_id selectors.
• class: .class_name
• parent: Used to traverse up from the current node, for composite selectors body #wrapper, body > #wrapper.
• children: Used to traverse from a parent to its children for sibling selectors div + span, a ~ p.
• attr: Used to extract attribute information, for [attr=thing] style selectors.

selector_factory('some selector') -> match function

Compiles a matching function.

match(node) -> false | node | [subjects, ...]

Returns false if the provided node matches the selector. Returns truthy if the provided node does match. Exact return value is determined by the selector, based on the CSS4 subject selector spec: if only a single node is matched, only that node is returned. If multiple subjects are matched, a deduplicated array of those subjects are returned.

For example, given the following HTML (and cssauron-html):

<div id="gary-busey">
    <p>
        <span class="jake-busey">
        </span>
    </p>
</div>

Checking the following selectors against the span.jake-busey element yields:

• #gary-busey: false, no match.
• #gary-busey *: span.jake-busey, a single match.
• !#gary-busey *: div#gary-busey, a single match using the ! subject selector.
• #gary-busey *, p span: span.jake-busey, a single match, though both selectors match.
• #gary-busey !* !*, !p > !span: [p, span.jake-busey], two matches.

Supported pseudoclasses

• :first-child
• :last-child
• :empty
• :root
• :contains(text)
• :any(selector, selector, selector)

Supported attribute lookups

• [attr=value]: Exact match
• [attr]: Attribute exists and is not false-y.
• [attr$=value]: Attribute ends with value
• [attr^=value]: Attribute starts with value
• [attr*=value]: Attribute contains value
• [attr~=value]: Attribute, split by whitespace, contains value.
• [attr|=value]: Attribute, split by -, contains value.