'use strict';
|
|
const stringify = require('./lib/stringify');
|
const compile = require('./lib/compile');
|
const expand = require('./lib/expand');
|
const parse = require('./lib/parse');
|
|
/**
|
* Expand the given pattern or create a regex-compatible string.
|
*
|
* ```js
|
* const braces = require('braces');
|
* console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
|
* console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
|
* ```
|
* @param {String} `str`
|
* @param {Object} `options`
|
* @return {String}
|
* @api public
|
*/
|
|
const braces = (input, options = {}) => {
|
let output = [];
|
|
if (Array.isArray(input)) {
|
for (let pattern of input) {
|
let result = braces.create(pattern, options);
|
if (Array.isArray(result)) {
|
output.push(...result);
|
} else {
|
output.push(result);
|
}
|
}
|
} else {
|
output = [].concat(braces.create(input, options));
|
}
|
|
if (options && options.expand === true && options.nodupes === true) {
|
output = [...new Set(output)];
|
}
|
return output;
|
};
|
|
/**
|
* Parse the given `str` with the given `options`.
|
*
|
* ```js
|
* // braces.parse(pattern, [, options]);
|
* const ast = braces.parse('a/{b,c}/d');
|
* console.log(ast);
|
* ```
|
* @param {String} pattern Brace pattern to parse
|
* @param {Object} options
|
* @return {Object} Returns an AST
|
* @api public
|
*/
|
|
braces.parse = (input, options = {}) => parse(input, options);
|
|
/**
|
* Creates a braces string from an AST, or an AST node.
|
*
|
* ```js
|
* const braces = require('braces');
|
* let ast = braces.parse('foo/{a,b}/bar');
|
* console.log(stringify(ast.nodes[2])); //=> '{a,b}'
|
* ```
|
* @param {String} `input` Brace pattern or AST.
|
* @param {Object} `options`
|
* @return {Array} Returns an array of expanded values.
|
* @api public
|
*/
|
|
braces.stringify = (input, options = {}) => {
|
if (typeof input === 'string') {
|
return stringify(braces.parse(input, options), options);
|
}
|
return stringify(input, options);
|
};
|
|
/**
|
* Compiles a brace pattern into a regex-compatible, optimized string.
|
* This method is called by the main [braces](#braces) function by default.
|
*
|
* ```js
|
* const braces = require('braces');
|
* console.log(braces.compile('a/{b,c}/d'));
|
* //=> ['a/(b|c)/d']
|
* ```
|
* @param {String} `input` Brace pattern or AST.
|
* @param {Object} `options`
|
* @return {Array} Returns an array of expanded values.
|
* @api public
|
*/
|
|
braces.compile = (input, options = {}) => {
|
if (typeof input === 'string') {
|
input = braces.parse(input, options);
|
}
|
return compile(input, options);
|
};
|
|
/**
|
* Expands a brace pattern into an array. This method is called by the
|
* main [braces](#braces) function when `options.expand` is true. Before
|
* using this method it's recommended that you read the [performance notes](#performance))
|
* and advantages of using [.compile](#compile) instead.
|
*
|
* ```js
|
* const braces = require('braces');
|
* console.log(braces.expand('a/{b,c}/d'));
|
* //=> ['a/b/d', 'a/c/d'];
|
* ```
|
* @param {String} `pattern` Brace pattern
|
* @param {Object} `options`
|
* @return {Array} Returns an array of expanded values.
|
* @api public
|
*/
|
|
braces.expand = (input, options = {}) => {
|
if (typeof input === 'string') {
|
input = braces.parse(input, options);
|
}
|
|
let result = expand(input, options);
|
|
// filter out empty strings if specified
|
if (options.noempty === true) {
|
result = result.filter(Boolean);
|
}
|
|
// filter out duplicates if specified
|
if (options.nodupes === true) {
|
result = [...new Set(result)];
|
}
|
|
return result;
|
};
|
|
/**
|
* Processes a brace pattern and returns either an expanded array
|
* (if `options.expand` is true), a highly optimized regex-compatible string.
|
* This method is called by the main [braces](#braces) function.
|
*
|
* ```js
|
* const braces = require('braces');
|
* console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
|
* //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
|
* ```
|
* @param {String} `pattern` Brace pattern
|
* @param {Object} `options`
|
* @return {Array} Returns an array of expanded values.
|
* @api public
|
*/
|
|
braces.create = (input, options = {}) => {
|
if (input === '' || input.length < 3) {
|
return [input];
|
}
|
|
return options.expand !== true
|
? braces.compile(input, options)
|
: braces.expand(input, options);
|
};
|
|
/**
|
* Expose "braces"
|
*/
|
|
module.exports = braces;
|
