8121311286

Committed 02 Mar 2024 07:37AM UTC coverage: 92.529% (-0.01%) from 92.543%

Build # 8121311286

Build Type

push

github

Committed by

XhmikosR

Commit Message

More backports

Run Details

678 of 714 branches covered (94.96%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

19 existing lines in 2 files now uncovered.

3880 of 4212 relevant lines covered (92.12%)

163.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.09

/lib/svg-sprite.js

'use strict';

/**
 * svg-sprite is a Node.js module for creating SVG sprites
 *
 * @see https://github.com/svg-sprite/svg-sprite
 * @author Joschi Kuphal <joschi@kuphal.net> (https://github.com/jkphl)
 * @copyright © 2018 Joschi Kuphal
 * @license MIT https://github.com/svg-sprite/svg-sprite/blob/main/LICENSE
 */

const { Buffer } = require('buffer');
const path = require('path');
const events = require('events');
const os = require('os');
const { format } = require('util');
const merge = require('lodash.merge');
const File = require('vinyl');
const async = require('async');
const pretty = require('prettysize');
const Config = require('./svg-sprite/config.js');
const Queue = require('./svg-sprite/queue.js');
const Layouter = require('./svg-sprite/layouter.js');
const svgo = require('./svg-sprite/transform/svgo.js');
const { isFunction, isObject, isPlainObject, trimStart, zipObject } = require('./svg-sprite/utils/index.js');
const ArgumentError = require('./svg-sprite/errors/argument-error.js');

// TODO: after Node.js 12.x, `os.cpus` should never be undefined
const CPU_COUNT = os.cpus() && os.cpus().length;

/**
 * SVGSpriter class
 *
 * @param {object} config                Configuration
 */
function SVGSpriter(config) {
    this.config = new Config(config);
    this._queue = new Queue(this);
    this._shapes = [];
    this._shapeTransformers = { svgo };
    this._compileQueue = [];
    this._shapesDest = [];
    this._limit = CPU_COUNT ? CPU_COUNT * 2 : 2;

    this.info('Using %d threads', this._limit);

    events.EventEmitter.call(this);

    this._queue.on('empty', this._compile.bind(this));
    this._queue.on('empty', this._getShapes.bind(this));
    this.on('compiled', this._compile.bind(this));
    this.info('Created spriter instance');
}

/**
 * Prototype
 *
 * @type {object}
 */
SVGSpriter.prototype = Object.create(events.EventEmitter.prototype);

/**
 * SVG shapes making up the sprites
 *
 * @type {Array}
 */
SVGSpriter.prototype._shapes = [];

/**
 * Namespace powers
 *
 * @type {Array}
 */
SVGSpriter.prototype._namespacePow = [];

/**
 * Add an SVG shape to the sprites
 *
 * @param {File | string} file             Vinyl file object or absolute file path
 * @param {string} name                    Name part of the file path
 * @param {Buffer | string} svg            SVG content
 * @returns {SVGSpriter}                   Self reference
 * @throws {Error}                         In case an invalid file should be added
 */
SVGSpriter.prototype.add = function(file = '', name = '', svg = '') {
    // If no vinyl file object has been given
    if (!this._isVinylFile(file)) {
        file = file.trim();
        let error = null;

        // If the name part of the file path is absolute
        if (name && path.isAbsolute(name)) {
            error = format('SVGSpriter.add: "%s" is not a valid relative file name', name);
        } else {
            if (name) {
                name = trimStart(name.trim(), `${path.sep}.`);
            }

            name = name || path.basename(file);
            // TODO: Avoid Buffer -> String -> Buffer conversion of svg.
            if (Buffer.isBuffer(svg)) {
                svg = svg.toString();
            }

            svg = svg.trim();

            // Argument validation
            if (arguments.length < 3) {
                error = 'SVGSpriter.add: You must provide 3 arguments';
            } else if (!file.length) {
                error = format('SVGSpriter.add: "%s" is not a valid absolute file name', file);
            } else if (!name.length) {
                error = format('SVGSpriter.add: "%s" is not a valid relative file name', name);
            } else if (!svg.length) {
                error = 'SVGSpriter.add: You must provide SVG contents';
            } else if (!file.endsWith(name)) {
                error = format('SVGSpriter.add: "%s" is not the local part of "%s"', name, file);
            }
        }

        // In case of an error: Throw it!
        if (error) {
            const e = new ArgumentError(error);
            this.error(error, e);
            throw e;
        }

        // Resolve path before splitting it into base and path
        // so that Shape will properly extract a shape name later on.
        file = path.resolve(file);

        // Instantiate a vinyl file
        file = new File({
            base: file.substring(0, file.length - name.length),
            path: file,
            contents: Buffer.from(svg)
        });
    }

    file.base = path.resolve(file.base);

    // Add the shape to the internal processing queue
    this._queue.add(file);

    return this;
};

/**
 * Duck-typing check for vinyl file objects
 *
 * This check is necessary as singletons don't work cross-module and `instanceof` fails in these situations.
 *
 * @param {any} file                       Arbitrary parameter
 * @returns {boolean}                      Parameter is a vinyl file object
 */
SVGSpriter.prototype._isVinylFile = function(file) {
    return isObject(file) && (file instanceof File || (file.constructor.name === 'File' && ['path', 'contents', 'relative'].filter(function(property) {
        return property in this;
    }, file).length === 3));
};

/**
 * Transform a single shape
 *
 * @param {SVGShape} shape                Shape
 * @param {Function} cb                   Callback
 */
SVGSpriter.prototype._transformShape = function(shape, cb) {
    const tasks = [];
    const createTransformTask = transform => {
        //  If it's a custom transformer
        if (isFunction(transform[1])) {
            return () => {
                transform[1](shape, this, cb);
            };
        }

        // Else if it's a registered transformer
        if (transform[0] in this._shapeTransformers && isObject(transform[1])) {
            return () => {
                this._shapeTransformers[transform[0]](shape, transform[1], this, cb);
            };
        }

        // Else: Break
        return null;
    };

    // Run through all configured transforms
    for (let t = 0; t < this.config.shape.transform.length; t++) {
        const task = createTransformTask(this.config.shape.transform[t]);

        if (task) {
            tasks.push(task);
        }
    }

    async.waterfall(tasks, error => {
        cb(error);
    });
};

/**
 * Compile the sprite & additional resources
 *
 * @param {object} config                 Configuration
 * @param {Function} cb                   Callback
 */
SVGSpriter.prototype.compile = function(config, cb) {
    const _config = isPlainObject(config) ?
        // eslint-disable-next-line unicorn/no-array-callback-reference
        this.config.filter(config) :
        merge({}, this.config.mode);
    let _cb;

    if (isFunction(cb)) {
        _cb = cb;
    } else if (isFunction(config)) {
        _cb = config;
    } else {
        _cb = error => {
            throw error;
        };
    }

    // Schedule a compilation run
    this._compileQueue.push([_config, _cb]);
    this._compile();
};

/**
 *
 * @param {object} config                                   Configuration
 * @returns {Promise<{result:{object}, data:{object}}>}     Results
 */
SVGSpriter.prototype.compileAsync = function(config) {
    return new Promise((resolve, reject) => {
        this.compile(config, (error, result, data) => {
            if (error) {
                return reject(error);
            }

            resolve({ result, data });
        });
    });
};

/**
 * Run the next compile task
 */
SVGSpriter.prototype._compile = function() {
    // If the shape queue is not currently active
    if (!this._queue.active && this._compileQueue.length) {
        const [config, cb] = this._compileQueue.shift();

        // If this is a modeless run
        if (Object.keys(config).length === 0) {
            const files = {};

            // Add intermediate SVG files
            if (this.config.shape.dest) {
                files.shapes = this._getShapeFiles(this.config.shape.dest);
                this.verbose('Returning %d intermediate SVG files', files.shapes.length);
            }

            this._logStats(files);
            cb(null, files, {});
        } else {
            const masterShapes = this._shapes.filter(shape => !shape.master);
            this.info('Compiling %d shapes...', masterShapes.length);

            // Initialize the namespace powers
            while (!this._namespacePow.length || (26 ** this._namespacePow.length < masterShapes.length)) {
                this._namespacePow.unshift(26 ** this._namespacePow.length);
                this._shapes.forEach(shape => {
                    shape.resetNamespace();
                });
            }

            // Sort shapes by ID
            this._shapes = this._shapes.sort(this.config.shape.sort);

            // Set the shape namespaces on all master shapes
            masterShapes.forEach((shape, index) => {
                shape.setNamespace(this._indexNamespace(index));
            });

            this._layout(config, (error, files, data) => {
                // Add intermediate SVG files
                if (this.config.shape.dest) {
                    files.shapes = this._getShapeFiles(this.config.shape.dest);
                    this.verbose('Returning %d intermediate SVG files', files.shapes.length);
                }

                this.info('Finished %s sprite compilation', Object.keys(data).map(mode => `«${mode}»`).join(' + '));

                this._logStats(files);

                cb(error, files, data);
                this.emit('compiled');
            });
        }
    }
};

/**
 * Return a unique namespace prefix for a shape index
 *
 * @param {number} index             Shape index
 * @returns {string}                 Namespace prefix
 */
SVGSpriter.prototype._indexNamespace = function(index) {
    let ns = '';

    for (let n = 0; n < this._namespacePow.length; n++) {
        const c = Math.floor(index / this._namespacePow[n]);
        ns += String.fromCharCode(97 + c);
        index -= c * this._namespacePow[n];
    }

    return ns;
};

/**
 * Layout the sprites
 *
 * @param {object} config           Layout configuration
 * @param {Function} cb             Callback
 */
SVGSpriter.prototype._layout = function(config, cb) {
    const tasks = [];
    const files = {};
    const layout = new Layouter(this, config);
    const createLayoutTask = (k, m) => _cb => {
        layout.layout(files, k, m, _cb);
    };

    for (const mode in config) {
        tasks.push(createLayoutTask(mode, config[mode].mode));
    }

    async.parallelLimit(tasks, this._limit, (error, data) => {
        cb(error, files, zipObject(Object.keys(data).map(key => data[key].key), data));
    });
};

/**
 * Return all current shapes
 *
 * @param {string} dest            Destination directory
 * @param {Function} cb            Callback
 */
SVGSpriter.prototype.getShapes = function(dest, cb) {
    this._shapesDest.push([dest, cb]);
    this._getShapes();
};

/**
 * Return all current shapes
 */
SVGSpriter.prototype._getShapes = function() {
    // If the shape queue is not currently active
    if (!this._queue.active) {
        while (this._shapesDest.length) {
            const [dest, cb] = this._shapesDest.shift();
            cb(null, this._getShapeFiles(dest));
        }
    }
};

/**
 * Return the shapes as a list of vinyl files
 *
 * @param {string} dest             Destination directory
 * @returns {Array}                 Shape file list
 */
SVGSpriter.prototype._getShapeFiles = function(dest) {
    return this._shapes.map(shape => {
        return new File({
            base: this.config.dest,
            path: path.join(dest, `${shape.id}.svg`),
            contents: Buffer.from(shape.getSVG(false))
        });
    });
};

/**
 * Log file statistics
 *
 * @param {object} files        Files
 */
SVGSpriter.prototype._logStats = function(files) {
    const sizes = {};
    const exts = {};

    for (const mode in files) {
        for (const resource in files[mode]) {
            const file = files[mode][resource].relative;
            const ext = path.extname(files[mode][resource].path).toUpperCase();
            exts[ext] = (exts[ext] || 0) + 1;
            sizes[file] = pretty(files[mode][resource].contents.length);
        }
    }

    this.info('Created %s', Object.entries(exts).map(ext => `${ext[1]} x ${ext[0].substr(1)}`).join(', '));

    Object.keys(sizes).sort().forEach(file => {
        this.verbose('Created %s: %s', file, sizes[file]);
    });
};

/**
 * Pass info messages on to the logger
 *
 * @param {...any} args arguments
 */
SVGSpriter.prototype.info = function(...args) {
    this.config.log.info(...args);
};

/**
 * Pass verbose messages on to the logger
 *
 * @param {...any} args arguments
 */
SVGSpriter.prototype.verbose = function(...args) {
    this.config.log.verbose(...args);
};

/**
 * Pass debug messages on to the logger
 *
 * @param {...any} args arguments
 */
SVGSpriter.prototype.debug = function(...args) {
    this.config.log.debug(...args);
};

/**
 * Pass error messages on to the logger
 *
 * @param {...any} args arguments
 */
SVGSpriter.prototype.error = function(...args) {
    this.config.log.error(...args);
};

/**
 * Module export (constructor wrapper)
 *
 * @param {object} config           Configuration
 * @returns {SVGSpriter}            SVGSpriter instance
 */
module.exports = function(config = {}) {
    return new SVGSpriter(config);
};

1	'use strict';	1✔
2		1✔
3	/**	1✔
4	* svg-sprite is a Node.js module for creating SVG sprites	1✔
5	*	1✔
6	* @see https://github.com/svg-sprite/svg-sprite	1✔
7	* @author Joschi Kuphal <joschi@kuphal.net> (https://github.com/jkphl)	1✔
8	* @copyright © 2018 Joschi Kuphal	1✔
9	* @license MIT https://github.com/svg-sprite/svg-sprite/blob/main/LICENSE	1✔
10	*/	1✔
11		1✔
12	const { Buffer } = require('buffer');	1✔
13	const path = require('path');	1✔
14	const events = require('events');	1✔
15	const os = require('os');	1✔
16	const { format } = require('util');	1✔
17	const merge = require('lodash.merge');	1✔
18	const File = require('vinyl');	1✔
19	const async = require('async');	1✔
20	const pretty = require('prettysize');	1✔
21	const Config = require('./svg-sprite/config.js');	1✔
22	const Queue = require('./svg-sprite/queue.js');	1✔
23	const Layouter = require('./svg-sprite/layouter.js');	1✔
24	const svgo = require('./svg-sprite/transform/svgo.js');	1✔
25	const { isFunction, isObject, isPlainObject, trimStart, zipObject } = require('./svg-sprite/utils/index.js');	1✔
26	const ArgumentError = require('./svg-sprite/errors/argument-error.js');	1✔
27		1✔
28	// TODO: after Node.js 12.x, `os.cpus` should never be undefined	1✔
29	const CPU_COUNT = os.cpus() && os.cpus().length;	1✔
30		1✔
31	/**	1✔
32	* SVGSpriter class	1✔
33	*	1✔
34	* @param {object} config Configuration	1✔
35	*/	1✔
36	function SVGSpriter(config) {	69✔
37	this.config = new Config(config);	69✔
38	this._queue = new Queue(this);	69✔
39	this._shapes = [];	69✔
40	this._shapeTransformers = { svgo };	69✔
41	this._compileQueue = [];	69✔
42	this._shapesDest = [];	69✔
43	this._limit = CPU_COUNT ? CPU_COUNT * 2 : 2;	69!
44		69✔
45	this.info('Using %d threads', this._limit);	69✔
46		69✔
47	events.EventEmitter.call(this);	69✔
48		69✔
49	this._queue.on('empty', this._compile.bind(this));	69✔
50	this._queue.on('empty', this._getShapes.bind(this));	69✔
51	this.on('compiled', this._compile.bind(this));	69✔
52	this.info('Created spriter instance');	69✔
53	}	69✔
54		1✔
55	/**	1✔
56	* Prototype	1✔
57	*	1✔
58	* @type {object}	1✔
59	*/	1✔
60	SVGSpriter.prototype = Object.create(events.EventEmitter.prototype);	1✔
61		1✔
62	/**	1✔
63	* SVG shapes making up the sprites	1✔
64	*	1✔
65	* @type {Array}	1✔
66	*/	1✔
67	SVGSpriter.prototype._shapes = [];	1✔
68		1✔
69	/**	1✔
70	* Namespace powers	1✔
71	*	1✔
72	* @type {Array}	1✔
73	*/	1✔
74	SVGSpriter.prototype._namespacePow = [];	1✔
75		1✔
76	/**	1✔
77	* Add an SVG shape to the sprites	1✔
78	*	1✔
79	* @param {File \| string} file Vinyl file object or absolute file path	1✔
80	* @param {string} name Name part of the file path	1✔
81	* @param {Buffer \| string} svg SVG content	1✔
82	* @returns {SVGSpriter} Self reference	1✔
83	* @throws {Error} In case an invalid file should be added	1✔
84	*/	1✔
85	SVGSpriter.prototype.add = function(file = '', name = '', svg = '') {	1✔
86	// If no vinyl file object has been given	156✔
87	if (!this._isVinylFile(file)) {	156✔
88	file = file.trim();	155✔
89	let error = null;	155✔
90		155✔
91	// If the name part of the file path is absolute	155✔
92	if (name && path.isAbsolute(name)) {	155✔
93	error = format('SVGSpriter.add: "%s" is not a valid relative file name', name);	1✔
94	} else {	155✔
95	if (name) {	154✔
96	name = trimStart(name.trim(), `${path.sep}.`);	149✔
97	}	149✔
98		154✔
99	name = name \|\| path.basename(file);	154✔
100	// TODO: Avoid Buffer -> String -> Buffer conversion of svg.	154✔
101	if (Buffer.isBuffer(svg)) {	154✔
102	svg = svg.toString();	2✔
103	}	2✔
104		154✔
105	svg = svg.trim();	154✔
106		154✔
107	// Argument validation	154✔
108	if (arguments.length < 3) {	154✔
109	error = 'SVGSpriter.add: You must provide 3 arguments';	2✔
110	} else if (!file.length) {	154✔
111	error = format('SVGSpriter.add: "%s" is not a valid absolute file name', file);	2✔
112	} else if (!name.length) {	152!
UNCOV 113	error = format('SVGSpriter.add: "%s" is not a valid relative file name', name);	×
114	} else if (!svg.length) {	150✔
115	error = 'SVGSpriter.add: You must provide SVG contents';	2✔
116	} else if (!file.endsWith(name)) {	150✔
117	error = format('SVGSpriter.add: "%s" is not the local part of "%s"', name, file);	1✔
118	}	1✔
119	}	154✔
120		155✔
121	// In case of an error: Throw it!	155✔
122	if (error) {	155✔
123	const e = new ArgumentError(error);	8✔
124	this.error(error, e);	8✔
125	throw e;	8✔
126	}	8✔
127		147✔
128	// Resolve path before splitting it into base and path	147✔
129	// so that Shape will properly extract a shape name later on.	147✔
130	file = path.resolve(file);	147✔
131		147✔
132	// Instantiate a vinyl file	147✔
133	file = new File({	147✔
134	base: file.substring(0, file.length - name.length),	147✔
135	path: file,	147✔
136	contents: Buffer.from(svg)	147✔
137	});	147✔
138	}	147✔
139		148✔
140	file.base = path.resolve(file.base);	148✔
141		148✔
142	// Add the shape to the internal processing queue	148✔
143	this._queue.add(file);	148✔
144		148✔
145	return this;	148✔
146	};	148✔
147		1✔
148	/**	1✔
149	* Duck-typing check for vinyl file objects	1✔
150	*	1✔
151	* This check is necessary as singletons don't work cross-module and `instanceof` fails in these situations.	1✔
152	*	1✔
153	* @param {any} file Arbitrary parameter	1✔
154	* @returns {boolean} Parameter is a vinyl file object	1✔
155	*/	1✔
156	SVGSpriter.prototype._isVinylFile = function(file) {	1✔
157	return isObject(file) && (file instanceof File \|\| (file.constructor.name === 'File' && ['path', 'contents', 'relative'].filter(function(property) {	156!
UNCOV 158	return property in this;	×
159	}, file).length === 3));	156✔
160	};	156✔
161		1✔
162	/**	1✔
163	* Transform a single shape	1✔
164	*	1✔
165	* @param {SVGShape} shape Shape	1✔
166	* @param {Function} cb Callback	1✔
167	*/	1✔
168	SVGSpriter.prototype._transformShape = function(shape, cb) {	1✔
169	const tasks = [];	145✔
170	const createTransformTask = transform => {	145✔
171	// If it's a custom transformer	144✔
172	if (isFunction(transform[1])) {	144!
173	return () => {	×
UNCOV 174	transform[1](shape, this, cb);	×
UNCOV 175	};	×
UNCOV 176	}	×
177		144✔
178	// Else if it's a registered transformer	144✔
179	if (transform[0] in this._shapeTransformers && isObject(transform[1])) {	144✔
180	return () => {	144✔
181	this._shapeTransformers[transform[0]](shape, transform[1], this, cb);	144✔
182	};	144✔
183	}	144!
UNCOV 184		×
UNCOV 185	// Else: Break	×
UNCOV 186	return null;	×
187	};	145✔
188		145✔
189	// Run through all configured transforms	145✔
190	for (let t = 0; t < this.config.shape.transform.length; t++) {	145✔
191	const task = createTransformTask(this.config.shape.transform[t]);	144✔
192		144✔
193	if (task) {	144✔
194	tasks.push(task);	144✔
195	}	144✔
196	}	144✔
197		145✔
198	async.waterfall(tasks, error => {	145✔
199	cb(error);	1✔
200	});	145✔
201	};	145✔
202		1✔
203	/**	1✔
204	* Compile the sprite & additional resources	1✔
205	*	1✔
206	* @param {object} config Configuration	1✔
207	* @param {Function} cb Callback	1✔
208	*/	1✔
209	SVGSpriter.prototype.compile = function(config, cb) {	1✔
210	const _config = isPlainObject(config) ?	35✔
211	// eslint-disable-next-line unicorn/no-array-callback-reference	28✔
212	this.config.filter(config) :	35✔
213	merge({}, this.config.mode);	35✔
214	let _cb;	35✔
215		35✔
216	if (isFunction(cb)) {	35✔
217	_cb = cb;	34✔
218	} else if (isFunction(config)) {	34✔
219	_cb = config;	1✔
220	} else {	1!
221	_cb = error => {	×
UNCOV 222	throw error;	×
UNCOV 223	};	×
UNCOV 224	}	×
225		35✔
226	// Schedule a compilation run	35✔
227	this._compileQueue.push([_config, _cb]);	35✔
228	this._compile();	35✔
229	};	35✔
230		1✔
231	/**	1✔
232	*	1✔
233	* @param {object} config Configuration	1✔
234	* @returns {Promise<{result:{object}, data:{object}}>} Results	1✔
235	*/	1✔
236	SVGSpriter.prototype.compileAsync = function(config) {	1✔
237	return new Promise((resolve, reject) => {	25✔
238	this.compile(config, (error, result, data) => {	25✔
239	if (error) {	25✔
240	return reject(error);	1✔
241	}	1✔
242		24✔
243	resolve({ result, data });	24✔
244	});	25✔
245	});	25✔
246	};	25✔
247		1✔
248	/**	1✔
249	* Run the next compile task	1✔
250	*/	1✔
251	SVGSpriter.prototype._compile = function() {	1✔
252	// If the shape queue is not currently active	210✔
253	if (!this._queue.active && this._compileQueue.length) {	210✔
254	const [config, cb] = this._compileQueue.shift();	35✔
255		35✔
256	// If this is a modeless run	35✔
257	if (Object.keys(config).length === 0) {	35✔
258	const files = {};	5✔
259		5✔
260	// Add intermediate SVG files	5✔
261	if (this.config.shape.dest) {	5✔
262	files.shapes = this._getShapeFiles(this.config.shape.dest);	5✔
263	this.verbose('Returning %d intermediate SVG files', files.shapes.length);	5✔
264	}	5✔
265		5✔
266	this._logStats(files);	5✔
267	cb(null, files, {});	5✔
268	} else {	35✔
269	const masterShapes = this._shapes.filter(shape => !shape.master);	30✔
270	this.info('Compiling %d shapes...', masterShapes.length);	30✔
271		30✔
272	// Initialize the namespace powers	30✔
273	while (!this._namespacePow.length \|\| (26 ** this._namespacePow.length < masterShapes.length)) {	30✔
274	this._namespacePow.unshift(26 ** this._namespacePow.length);	11✔
275	this._shapes.forEach(shape => {	11✔
276	shape.resetNamespace();	83✔
277	});	11✔
278	}	11✔
279		30✔
280	// Sort shapes by ID	30✔
281	this._shapes = this._shapes.sort(this.config.shape.sort);	30✔
282		30✔
283	// Set the shape namespaces on all master shapes	30✔
284	masterShapes.forEach((shape, index) => {	30✔
285	shape.setNamespace(this._indexNamespace(index));	202✔
286	});	30✔
287		30✔
288	this._layout(config, (error, files, data) => {	30✔
289	// Add intermediate SVG files	30✔
290	if (this.config.shape.dest) {	30✔
291	files.shapes = this._getShapeFiles(this.config.shape.dest);	3✔
292	this.verbose('Returning %d intermediate SVG files', files.shapes.length);	3✔
293	}	3✔
294		30✔
295	this.info('Finished %s sprite compilation', Object.keys(data).map(mode => `«${mode}»`).join(' + '));	30✔
296		30✔
297	this._logStats(files);	30✔
298		30✔
299	cb(error, files, data);	30✔
300	this.emit('compiled');	30✔
301	});	30✔
302	}	30✔
303	}	35✔
304	};	210✔
305		1✔
306	/**	1✔
307	* Return a unique namespace prefix for a shape index	1✔
308	*	1✔
309	* @param {number} index Shape index	1✔
310	* @returns {string} Namespace prefix	1✔
311	*/	1✔
312	SVGSpriter.prototype._indexNamespace = function(index) {	1✔
313	let ns = '';	202✔
314		202✔
315	for (let n = 0; n < this._namespacePow.length; n++) {	202✔
316	const c = Math.floor(index / this._namespacePow[n]);	202✔
317	ns += String.fromCharCode(97 + c);	202✔
318	index -= c * this._namespacePow[n];	202✔
319	}	202✔
320		202✔
321	return ns;	202✔
322	};	202✔
323		1✔
324	/**	1✔
325	* Layout the sprites	1✔
326	*	1✔
327	* @param {object} config Layout configuration	1✔
328	* @param {Function} cb Callback	1✔
329	*/	1✔
330	SVGSpriter.prototype._layout = function(config, cb) {	1✔
331	const tasks = [];	28✔
332	const files = {};	28✔
333	const layout = new Layouter(this, config);	28✔
334	const createLayoutTask = (k, m) => _cb => {	28✔
335	layout.layout(files, k, m, _cb);	28✔
336	};	28✔
337		28✔
338	for (const mode in config) {	28✔
339	tasks.push(createLayoutTask(mode, config[mode].mode));	28✔
340	}	28✔
341		28✔
342	async.parallelLimit(tasks, this._limit, (error, data) => {	28✔
343	cb(error, files, zipObject(Object.keys(data).map(key => data[key].key), data));	28✔
344	});	28✔
345	};	28✔
346		1✔
347	/**	1✔
348	* Return all current shapes	1✔
349	*	1✔
350	* @param {string} dest Destination directory	1✔
351	* @param {Function} cb Callback	1✔
352	*/	1✔
353	SVGSpriter.prototype.getShapes = function(dest, cb) {	1✔
UNCOV 354	this._shapesDest.push([dest, cb]);	×
UNCOV 355	this._getShapes();	×
UNCOV 356	};	×
357		1✔
358	/**	1✔
359	* Return all current shapes	1✔
360	*/	1✔
361	SVGSpriter.prototype._getShapes = function() {	1✔
362	// If the shape queue is not currently active	145✔
363	if (!this._queue.active) {	145✔
364	while (this._shapesDest.length) {	145!
UNCOV 365	const [dest, cb] = this._shapesDest.shift();	×
UNCOV 366	cb(null, this._getShapeFiles(dest));	×
UNCOV 367	}	×
368	}	145✔
369	};	145✔
370		1✔
371	/**	1✔
372	* Return the shapes as a list of vinyl files	1✔
373	*	1✔
374	* @param {string} dest Destination directory	1✔
375	* @returns {Array} Shape file list	1✔
376	*/	1✔
377	SVGSpriter.prototype._getShapeFiles = function(dest) {	1✔
378	return this._shapes.map(shape => {	8✔
379	return new File({	30✔
380	base: this.config.dest,	30✔
381	path: path.join(dest, `${shape.id}.svg`),	30✔
382	contents: Buffer.from(shape.getSVG(false))	30✔
383	});	30✔
384	});	8✔
385	};	8✔
386		1✔
387	/**	1✔
388	* Log file statistics	1✔
389	*	1✔
390	* @param {object} files Files	1✔
391	*/	1✔
392	SVGSpriter.prototype._logStats = function(files) {	1✔
393	const sizes = {};	35✔
394	const exts = {};	35✔
395		35✔
396	for (const mode in files) {	35✔
397	for (const resource in files[mode]) {	36✔
398	const file = files[mode][resource].relative;	85✔
399	const ext = path.extname(files[mode][resource].path).toUpperCase();	85✔
400	exts[ext] = (exts[ext] \|\| 0) + 1;	85✔
401	sizes[file] = pretty(files[mode][resource].contents.length);	85✔
402	}	85✔
403	}	36✔
404		35✔
405	this.info('Created %s', Object.entries(exts).map(ext => `${ext[1]} x ${ext[0].substr(1)}`).join(', '));	35✔
406		35✔
407	Object.keys(sizes).sort().forEach(file => {	35✔
408	this.verbose('Created %s: %s', file, sizes[file]);	85✔
409	});	35✔
410	};	35✔
411		1✔
412	/**	1✔
413	* Pass info messages on to the logger	1✔
414	*	1✔
415	* @param {...any} args arguments	1✔
416	*/	1✔
417	SVGSpriter.prototype.info = function(...args) {	1✔
418	this.config.log.info(...args);	271✔
419	};	271✔
420		1✔
421	/**	1✔
422	* Pass verbose messages on to the logger	1✔
423	*	1✔
424	* @param {...any} args arguments	1✔
425	*/	1✔
426	SVGSpriter.prototype.verbose = function(...args) {	1✔
427	this.config.log.verbose(...args);	311✔
428	};	311✔
429		1✔
430	/**	1✔
431	* Pass debug messages on to the logger	1✔
432	*	1✔
433	* @param {...any} args arguments	1✔
434	*/	1✔
435	SVGSpriter.prototype.debug = function(...args) {	1✔
436	this.config.log.debug(...args);	300✔
437	};	300✔
438		1✔
439	/**	1✔
440	* Pass error messages on to the logger	1✔
441	*	1✔
442	* @param {...any} args arguments	1✔
443	*/	1✔
444	SVGSpriter.prototype.error = function(...args) {	1✔
445	this.config.log.error(...args);	8✔
446	};	8✔
447		1✔
448	/**	1✔
449	* Module export (constructor wrapper)	1✔
450	*	1✔
451	* @param {object} config Configuration	1✔
452	* @returns {SVGSpriter} SVGSpriter instance	1✔
453	*/	1✔
454	module.exports = function(config = {}) {	1✔
455	return new SVGSpriter(config);	69✔
456	};	69✔

svg-sprite / svg-sprite / 8121311286

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous