@emmetio/abbreviation

What is @emmetio/abbreviation?

@emmetio/abbreviation is an npm package that provides a way to parse and transform Emmet abbreviations into structured data. Emmet abbreviations are shorthand syntaxes used to generate HTML and CSS code quickly. This package is useful for developers who want to integrate Emmet-like functionality into their own tools or editors.

What are @emmetio/abbreviation's main functionalities?

Parsing Abbreviations

This feature allows you to parse Emmet abbreviations into a structured tree format. In this example, the abbreviation 'ul>li*3' is parsed into a tree structure representing an unordered list with three list items.

const parse = require('@emmetio/abbreviation');
const tree = parse('ul>li*3');
console.log(tree);

Transforming Abbreviations

This feature allows you to transform the parsed abbreviation tree. In this example, the tree is transformed to include placeholders for fields, which can be useful for creating templates.

const parse = require('@emmetio/abbreviation');
const transform = require('@emmetio/abbreviation/lib/transform');
const tree = parse('ul>li*3');
const transformedTree = transform(tree, { field: (index, placeholder) => `
	${placeholder}` });
console.log(transformedTree);

Stringify Abbreviations

This feature allows you to convert the parsed abbreviation tree back into a string format, such as HTML. In this example, the tree is converted into an HTML string representing an unordered list with three list items.

const parse = require('@emmetio/abbreviation');
const stringify = require('@emmetio/abbreviation/lib/stringify');
const tree = parse('ul>li*3');
const html = stringify(tree);
console.log(html);

Other packages similar to @emmetio/abbreviation

emmet

The 'emmet' package provides a comprehensive set of tools for expanding Emmet abbreviations into HTML and CSS. It offers more features and integrations compared to @emmetio/abbreviation, making it suitable for use in various editors and IDEs.

README

Emmet markup abbreviation parser

Parses given Emmet markup abbreviation into AST. Parsing is performed in two steps: first it tokenizes given abbreviation (useful for syntax highlighting in editors) and then tokens are analyzed and converted into AST nodes as plain, JSON-serializable objects.

Note that AST tree in most cases cannot be used directly for output: for example, AST node produced from .foo.bar element misses element name and contains two class attributes with foo and bar values (not a single class with foo bar value).

Usage

You can install it via npm:

npm install @emmetio/abbreviation

Then add it into your project:

import parse from '@emmetio/abbreviation';

const tree = parse('div#foo>span.bar*3');
/* {
    type: 'Abbreviation',
    children: [{
        type: 'AbbreviationNode',
        name: 'div',
        attributes: [...],
        children: [...]
    }]
} */

The returned tree contains AbbreviationNode items: a node with name, attributes and/or text content. E.g. an element that can be represented somehow. Repeated and grouped nodes like a>(b+c)*3 are automatically converted and duplicated as distinct AbbreviationNode with distinct .repeat property which identifies node in repeating sequence.

Abbreviation syntax

Emmet abbreviation element has the following basic parts:

name.class#id[attributes?, ...]{text value}*repeater/

• name — element name, like div, span etc. Stored as node.name property.
• [attributes] — list of attributes. Each attribute is stored as AbbreviationAttribute instance and can be accessed by node.getAttribute(name). Each attribute can be written in different formats:
  • attr — attribute with empty value.
  • attr=value — attribute with value. The value may contain any character except space or ].
  • attr="value" or attr='value' — attribute with value in quotes. Quotes are automatically removed. Expression values like attr={value} are supported and can be identified by valueType: "expression" property.
  • attr. — boolean attribute, e.g. attribute without value, like required in <input>.
  • !attr – implicit attribute, will be outputted if its value is not empty. Used as a placeholder to preserve attribute order in output.
  • ./non/attr/value — value for default attribute. In other words, anything that doesn’t match a attribute name characters. Can be a single- or double-quotted as well. Default attribute is stored with null as name and should be used later, for example, to resolve predefined attributes.
• .class — shorthand for class attribute. Note that an element can have multiple classes, like .class1.class2.class3.
• #id — shorthand for id attribute.
• {text} — node’s text content
• *N — element repeater, tells parser to create N copies of given node.
• / — optional self-closing operator. Marks element with node.selfClosing = true.

Operators

Each element of abbreviation must be separated with any of these operators:

elem1+elem2>elem3

• + — sibling operator, adds next element as a next sibling of current element in tree.
• > — child operator, adds next element as a child of current element.
• ^ — climb-up operator, adds next element as a child of current element’s parent node. Multiple climb-up operators are allowed, each operator moves one level up by tree.

Groups

A set of elements could be grouped using (), mostly for repeating and for easier elements nesting:

a>(b>c+d)*4+(e+f)

Groups can be optionally concatenated with + operator.