Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
_collections.js	56.33 KB	-rw-r--r--	2016-12-25 15:17
_path.js	29.8 KB	-rw-r--r--	2017-01-29 15:46
_transforms.js	9.9 KB	-rw-r--r--	2016-08-20 17:44
addAttributesToSVGElement.js	1.34 KB	-rw-r--r--	2016-08-25 19:35
addClassesToSVGElement.js	1.58 KB	-rw-r--r--	2016-08-25 19:56
cleanupAttrs.js	1.28 KB	-rw-r--r--	2016-08-20 17:44
cleanupEnableBackground.js	2.25 KB	-rw-r--r--	2016-08-20 17:44
cleanupIDs.js	5.42 KB	-rw-r--r--	2016-11-21 19:50
cleanupListOfValues.js	3.45 KB	-rw-r--r--	2016-08-20 17:44
cleanupNumericValues.js	2.01 KB	-rw-r--r--	2016-08-20 17:44
collapseGroups.js	2.76 KB	-rw-r--r--	2016-12-25 15:17
convertColors.js	3.47 KB	-rw-r--r--	2016-12-25 15:17
convertPathData.js	29.66 KB	-rw-r--r--	2017-01-29 15:46
convertShapeToPath.js	2.82 KB	-rw-r--r--	2016-08-20 17:44
convertStyleToAttrs.js	3.93 KB	-rw-r--r--	2016-08-20 17:44
convertTransform.js	10.65 KB	-rw-r--r--	2016-08-20 17:44
mergePaths.js	2.01 KB	-rw-r--r--	2016-08-20 17:44
minifyStyles.js	1.19 KB	-rw-r--r--	2016-08-20 17:44
moveElemsAttrsToGroup.js	3.31 KB	-rw-r--r--	2016-08-20 17:44
moveGroupAttrsToElems.js	1.81 KB	-rw-r--r--	2016-08-20 17:44
removeAttrs.js	2.49 KB	-rw-r--r--	2016-08-20 17:44
removeComments.js	508 B	-rw-r--r--	2016-08-20 17:44
removeDesc.js	785 B	-rw-r--r--	2016-08-20 17:44
removeDimensions.js	662 B	-rw-r--r--	2016-08-20 17:44
removeDoctype.js	1.01 KB	-rw-r--r--	2016-08-20 17:44
removeEditorsNSData.js	1.51 KB	-rw-r--r--	2016-08-20 17:44
removeElementsByAttr.js	1.89 KB	-rw-r--r--	2016-08-20 17:44
removeEmptyAttrs.js	509 B	-rw-r--r--	2016-08-20 17:44
removeEmptyContainers.js	690 B	-rw-r--r--	2016-08-20 17:44
removeEmptyText.js	1.1 KB	-rw-r--r--	2016-08-20 17:44
removeHiddenElems.js	6.23 KB	-rw-r--r--	2016-08-20 17:44
removeMetadata.js	392 B	-rw-r--r--	2016-08-20 17:44
removeNonInheritableGroupAttrs.js	1.08 KB	-rw-r--r--	2016-11-20 10:56
removeRasterImages.js	558 B	-rw-r--r--	2016-08-20 17:44
removeStyleElement.js	426 B	-rw-r--r--	2016-08-20 17:44
removeTitle.js	497 B	-rw-r--r--	2016-08-20 17:44
removeUnknownsAndDefaults.js	4.48 KB	-rw-r--r--	2016-12-25 15:17
removeUnusedNS.js	2.33 KB	-rw-r--r--	2016-08-20 17:44
removeUselessDefs.js	1.01 KB	-rw-r--r--	2016-08-24 19:21
removeUselessStrokeAndFill.js	2.37 KB	-rw-r--r--	2016-08-20 17:44
removeViewBox.js	1.15 KB	-rw-r--r--	2016-08-20 17:44
removeXMLNS.js	591 B	-rw-r--r--	2016-08-25 19:56
removeXMLProcInst.js	487 B	-rw-r--r--	2016-08-20 17:44
sortAttrs.js	1.5 KB	-rw-r--r--	2016-08-25 19:35
transformsWithOnePath.js	10.57 KB	-rw-r--r--	2016-08-20 17:44

Rename

'use strict';

/*
 * Thanks to http://fontello.com project for sponsoring this plugin
 */

exports.type = 'full';

exports.active = false;

exports.description = 'performs a set of operations on SVG with one path inside (disabled by default)';

exports.params = {
    // width and height to resize SVG and rescale inner Path
    width: false,
    height: false,

// scale inner Path without resizing SVG
    scale: false,

// shiftX/Y inner Path
    shiftX: false,
    shiftY: false,

// crop SVG width along the real width of inner Path
    hcrop: false,

// vertical center inner Path inside SVG height
    vcenter: false,

// stringify params
    floatPrecision: 3,
    leadingZero: true,
    negativeExtraSpace: true
};

var _path = require('./_path.js'),
    relative2absolute = _path.relative2absolute,
    computeCubicBoundingBox = _path.computeCubicBoundingBox,
    computeQuadraticBoundingBox = _path.computeQuadraticBoundingBox,
    applyTransforms = _path.applyTransforms,
    js2path = _path.js2path,
    path2js = _path.path2js,
    EXTEND = require('whet.extend');

exports.fn = function(data, params) {

data.content.forEach(function(item) {

// only for SVG with one Path inside
        if (item.isElem('svg') &&
            item.content.length === 1 &&
            item.content[0].isElem('path')
        ) {

var svgElem = item,
                pathElem = svgElem.content[0],
                // get absoluted Path data
                path = relative2absolute(EXTEND(true, [], path2js(pathElem))),
                xs = [],
                ys = [],
                cubicСontrolPoint = [0, 0],
                quadraticСontrolPoint = [0, 0],
                lastPoint = [0, 0],
                cubicBoundingBox,
                quadraticBoundingBox,
                i,
                segment;

path.forEach(function(pathItem) {

// ML
                if ('ML'.indexOf(pathItem.instruction) > -1) {

for (i = 0; i < pathItem.data.length; i++) {
                        if (i % 2 === 0) {
                            xs.push(pathItem.data[i]);
                        } else {
                            ys.push(pathItem.data[i]);
                        }
                    }

lastPoint = cubicСontrolPoint = quadraticСontrolPoint = pathItem.data.slice(-2);

// H
                } else if (pathItem.instruction === 'H') {

pathItem.data.forEach(function(d) {
                        xs.push(d);
                    });

lastPoint[0] = cubicСontrolPoint[0] = quadraticСontrolPoint[0] = pathItem.data[pathItem.data.length - 2];

// V
                } else if (pathItem.instruction === 'V') {

pathItem.data.forEach(function(d) {
                        ys.push(d);
                    });

lastPoint[1] = cubicСontrolPoint[1] = quadraticСontrolPoint[1] = pathItem.data[pathItem.data.length - 1];

// C
                } else if (pathItem.instruction === 'C') {

for (i = 0; i < pathItem.data.length; i += 6) {

segment = pathItem.data.slice(i, i + 6);

cubicBoundingBox = computeCubicBoundingBox.apply(this, lastPoint.concat(segment));

xs.push(cubicBoundingBox.minx);
                        xs.push(cubicBoundingBox.maxx);

ys.push(cubicBoundingBox.miny);
                        ys.push(cubicBoundingBox.maxy);

// reflected control point for the next possible S
                        cubicСontrolPoint = [
                            2 * segment[4] - segment[2],
                            2 * segment[5] - segment[3]
                        ];

lastPoint = segment.slice(-2);

}

// S
                } else if (pathItem.instruction === 'S') {

for (i = 0; i < pathItem.data.length; i += 4) {

segment = pathItem.data.slice(i, i + 4);

cubicBoundingBox = computeCubicBoundingBox.apply(this, lastPoint.concat(cubicСontrolPoint).concat(segment));

xs.push(cubicBoundingBox.minx);
                        xs.push(cubicBoundingBox.maxx);

ys.push(cubicBoundingBox.miny);
                        ys.push(cubicBoundingBox.maxy);

// reflected control point for the next possible S
                        cubicСontrolPoint = [
                            2 * segment[2] - cubicСontrolPoint[0],
                            2 * segment[3] - cubicСontrolPoint[1],
                        ];

lastPoint = segment.slice(-2);

}

// Q
                } else if (pathItem.instruction === 'Q') {

for (i = 0; i < pathItem.data.length; i += 4) {

segment = pathItem.data.slice(i, i + 4);

quadraticBoundingBox = computeQuadraticBoundingBox.apply(this, lastPoint.concat(segment));

xs.push(quadraticBoundingBox.minx);
                        xs.push(quadraticBoundingBox.maxx);

ys.push(quadraticBoundingBox.miny);
                        ys.push(quadraticBoundingBox.maxy);

// reflected control point for the next possible T
                        quadraticСontrolPoint = [
                            2 * segment[2] - segment[0],
                            2 * segment[3] - segment[1]
                        ];

lastPoint = segment.slice(-2);

}

// S
                } else if (pathItem.instruction === 'T') {

for (i = 0; i < pathItem.data.length; i += 2) {

segment = pathItem.data.slice(i, i + 2);

quadraticBoundingBox = computeQuadraticBoundingBox.apply(this, lastPoint.concat(quadraticСontrolPoint).concat(segment));

xs.push(quadraticBoundingBox.minx);
                        xs.push(quadraticBoundingBox.maxx);

ys.push(quadraticBoundingBox.miny);
                        ys.push(quadraticBoundingBox.maxy);

// reflected control point for the next possible T
                        quadraticСontrolPoint = [
                            2 * segment[0] - quadraticСontrolPoint[0],
                            2 * segment[1] - quadraticСontrolPoint[1]
                        ];

lastPoint = segment.slice(-2);

}

});

var xmin = Math.min.apply(this, xs).toFixed(params.floatPrecision),
                xmax = Math.max.apply(this, xs).toFixed(params.floatPrecision),
                ymin = Math.min.apply(this, ys).toFixed(params.floatPrecision),
                ymax = Math.max.apply(this, ys).toFixed(params.floatPrecision),
                svgWidth = +svgElem.attr('width').value,
                svgHeight = +svgElem.attr('height').value,
                realWidth = Math.round(xmax - xmin),
                realHeight = Math.round(ymax - ymin),
                transform = '',
                scale;

// width & height
            if (params.width && params.height) {

scale = Math.min(params.width / svgWidth, params.height / svgHeight);

realWidth = realWidth * scale;
                realHeight = realHeight * scale;

svgWidth = svgElem.attr('width').value = params.width;
                svgHeight = svgElem.attr('height').value = params.height;

transform += ' scale(' + scale + ')';

// width
            } else if (params.width && !params.height) {

scale = params.width / svgWidth;

realWidth = realWidth * scale;
                realHeight = realHeight * scale;

svgWidth = svgElem.attr('width').value = params.width;
                svgHeight = svgElem.attr('height').value = svgHeight * scale;

transform += ' scale(' + scale + ')';

// height
            } else if (params.height && !params.width) {

scale = params.height / svgHeight;

realWidth = realWidth * scale;
                realHeight = realHeight * scale;

svgWidth = svgElem.attr('width').value = svgWidth * scale;
                svgHeight = svgElem.attr('height').value = params.height;

transform += ' scale(' + scale + ')';

}

// shiftX
            if (params.shiftX) {
                transform += ' translate(' + realWidth * params.shiftX + ', 0)';
            }

// shiftY
            if (params.shiftY) {
                transform += ' translate(0, ' + realHeight * params.shiftY + ')';
            }

// scale
            if (params.scale) {
                scale = params.scale;

var shiftX = svgWidth / 2,
                    shiftY = svgHeight / 2;

realWidth = realWidth * scale;
                realHeight = realHeight * scale;

if (params.shiftX || params.shiftY) {
                    transform += ' scale(' + scale + ')';
                } else {
                    transform += ' translate(' + shiftX + ' ' + shiftY + ') scale(' + scale + ') translate(-' + shiftX + ' -' + shiftY + ')';
                }
            }

// hcrop
            if (params.hcrop) {
                transform += ' translate(' + (-xmin) + ' 0)';

svgElem.attr('width').value = realWidth;
            }

// vcenter
            if (params.vcenter) {
                transform += ' translate(0 ' + (((svgHeight - realHeight) / 2) - ymin) + ')';
            }

if (transform) {
                pathElem.addAttr({
                    name: 'transform',
                    prefix: '',
                    local: 'transform',
                    value: transform
                });

path = applyTransforms(pathElem, pathElem.pathJS, true, params.floatPrecision);

// transformed data rounding
                path.forEach(function(pathItem) {
                    if (pathItem.data) {
                        pathItem.data = pathItem.data.map(function(num) {
                            return +num.toFixed(params.floatPrecision);
                        });
                    }
                });

// save new
                js2path(pathElem, path, params);
            }

}

});

return data;

};