svg-path-simplify 0.0.1 → 0.0.2

package/src/svgii/...parse.js

@@ -0,0 +1,402 @@
+//import { arcToBezier, quadratic2Cubic } from './convert.js';
+//import { getAngle, bezierhasExtreme, getDistance  } from "./geometry";
+
+
+
+export function parse(path, debug = true) {
+
+
+    debug = 'log'
+
+    const paramCounts = {
+        // Move (absolute & relative)
+        0x4D: 2,  // 'M'
+        0x6D: 2,  // 'm'
+
+        // Arc
+        0x41: 7,  // 'A'
+        0x61: 7,  // 'a'
+
+        // Cubic Bézier
+        0x43: 6,  // 'C'
+        0x63: 6,  // 'c'
+
+        // Horizontal Line
+        0x48: 1,  // 'H'
+        0x68: 1,  // 'h'
+
+        // Line To
+        0x4C: 2,  // 'L'
+        0x6C: 2,  // 'l'
+
+        // Quadratic Bézier
+        0x51: 4,  // 'Q'
+        0x71: 4,  // 'q'
+
+        // Smooth Cubic Bézier
+        0x53: 4,  // 'S'
+        0x73: 4,  // 's'
+
+        // Smooth Quadratic Bézier
+        0x54: 2,  // 'T'
+        0x74: 2,  // 't'
+
+        // Vertical Line
+        0x56: 1,  // 'V'
+        0x76: 1,  // 'v'
+
+        // Close Path
+        0x5A: 0,  // 'Z'
+        0x7A: 0   // 'z'
+    };
+
+
+
+    const commandSet = new Set([
+
+        //M
+        0x4D,
+        0x6D,
+
+        // Arc
+        0x41,
+        0x61,
+
+        // Cubic Bézier
+        0x43,
+        0x63,
+
+        // Horizontal Line
+        0x48,
+        0x68,
+
+        // Line To
+        0x4C,
+        0x6C,
+
+        // Quadratic Bézier
+        0x51,
+        0x71,
+
+        // Smooth Cubic Bézier
+        0x53,
+        0x73,
+
+        // Smooth Quadratic Bézier
+        0x54,
+        0x74,
+
+        // Vertical Line
+        0x56,
+        0x76,
+
+        // Close Path
+        0x5A,
+        0x7A,
+    ]);
+
+
+    const SPECIAL_SPACES = new Set([
+        0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006,
+        0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF
+    ]);
+
+
+    function isSpace(ch) {
+        return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029) || // Line terminators
+            // White spaces or comma
+            (ch === 0x002C) || (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
+            (ch >= 0x1680 && SPECIAL_SPACES.has(ch) >= 0);
+    }
+
+
+    function isCommandType(code) {
+        //return paramCounts.hasOwnProperty(code);
+        return commandSet.has(code);
+    }
+
+
+    let i = 0, len = path.length;
+    let lastCommand = "";
+    let pathData = [];
+    let itemCount = -1;
+    let val = '';
+    let wasE = false;
+    let wasSpace = false;
+    let floatCount = 0;
+    let valueIndex = 0;
+    let maxParams = 0;
+    let needsNewSegment = false;
+
+    //absolute/relative or shorthands
+    let hasRelatives = false;
+    let hasArcs = false;
+    let hasShorthands = false;
+    let hasQuadratics = false;
+
+    let relatives = new Set(['m', 'c', 'q', 'l', 'a', 't', 's', 'v', 'h']);
+    let shorthands = new Set(['t', 's', 'v', 'h', 'T', 'S', 'V', 'H']);
+    let quadratics = new Set(['t', 'q', 'T', 'Q']);
+
+    //collect errors 
+    let log = [];
+    let feedback;
+
+    function addSeg() {
+        // Create new segment if needed before adding the minus sign
+        if (needsNewSegment) {
+
+            // sanitize implicit linetos
+            if (lastCommand === 'M') lastCommand = 'L';
+            else if (lastCommand === 'm') lastCommand = 'l';
+
+            pathData.push({ type: lastCommand, values: [] });
+            itemCount++;
+            valueIndex = 0;
+            needsNewSegment = false;
+
+
+        }
+    }
+
+    function pushVal(checkFloats = false) {
+
+        // regular value or float
+        if (!checkFloats ? val !== '' : floatCount > 0) {
+
+            // error: no first command
+            if (debug && itemCount === -1) {
+
+                feedback = 'Pathdata must start with M command'
+                log.push(feedback)
+
+                // add M command to collect subsequent errors
+                lastCommand = 'M'
+                pathData.push({ type: lastCommand, values: [] });
+                maxParams = 2;
+                valueIndex = 0
+                itemCount++
+
+            }
+
+            if (lastCommand === 'A' || lastCommand === 'a') {
+                val = sanitizeArc()
+                pathData[itemCount].values.push(...val);
+
+            } else {
+                // error: leading zeroes
+                if (debug && val[1] && val[1] !== '.' && val[0] === '0') {
+                    feedback = 'Leading zeros not valid: ' + val
+                    log.push(feedback)
+                }
+
+                pathData[itemCount].values.push(+val);
+            }
+
+            valueIndex++;
+            val = '';
+            floatCount = 0;
+
+            // Mark that a new segment is needed if maxParams is reached
+            needsNewSegment = valueIndex >= maxParams;
+
+        }
+
+    }
+
+
+    function sanitizeArc() {
+
+        let valLen = val.length;
+        let arcSucks = false;
+
+        // large arc and sweep
+        if (valueIndex === 3 && valLen === 2) {
+            //console.log('large arc sweep combined', val, +val[0], +val[1]);
+            val = [+val[0], +val[1]];
+            arcSucks = true
+            valueIndex++
+        }
+
+        // sweep and final
+        else if (valueIndex === 4 && valLen > 1) {
+            //console.log('sweep and final', val, val[0], val[1]);
+            val = [+val[0], +val[1]];
+            arcSucks = true
+            valueIndex++
+        }
+
+        // large arc, sweep and final pt combined
+        else if (valueIndex === 3 && valLen >= 3) {
+            //console.log('large arc, sweep and final pt combined', val);
+            val = [+val[0], +val[1], +val.substring(2)];
+            arcSucks = true
+            valueIndex += 2
+        }
+
+        //console.log('val arc', val);
+        return !arcSucks ? [+val] : val;
+
+    }
+
+    function validateCommand() {
+        if (debug) {
+            let lastCom = itemCount > 0 ? pathData[itemCount] : 0
+            let valLen = lastCom ? lastCom.values.length : 0;
+
+            //console.log(lastCom, valLen, maxParams,  (valLen && valLen < maxParams ) );
+
+            if ((valLen && valLen < maxParams) || (valLen && valLen > maxParams) || ((lastCommand === 'z' || lastCommand === 'Z') && valLen > 0)) {
+                let diff = maxParams - valLen
+                feedback = `Pathdata commands in "${lastCommand}" (segment index: ${itemCount}) don't match allowed number of values: ${diff}/${maxParams}`;
+                log.push(feedback)
+            }
+        }
+    }
+
+
+
+    while (i < len) {
+        let char = path[i];
+        let charCode = path.charCodeAt(i);
+
+        // New command
+        if (isCommandType(charCode)) {
+
+
+            // command is concatenated without whitespace
+            if (val !== '') {
+                pathData[itemCount].values.push(+val);
+                valueIndex++;
+                val = '';
+            }
+
+            // check if previous command was correctly closed
+            validateCommand()
+
+
+            // new command type
+            lastCommand = char;
+            maxParams = paramCounts[charCode];
+            let isM = lastCommand === 'M' || lastCommand === 'm'
+            let wasClosePath = itemCount>0 && (pathData[itemCount].type === 'z' || pathData[itemCount].type === 'Z')
+
+            // add omitted M command after Z
+            if ( wasClosePath && !isM  ) {
+                pathData.push({ type: 'm', values: [0, 0]});
+                itemCount++;
+            }
+
+
+
+            pathData.push({ type: lastCommand, values: [] });
+            itemCount++;
+
+            //check types relative arcs or quadratics
+            if (!hasRelatives) hasRelatives = relatives.has(lastCommand);
+            if (!hasShorthands) hasShorthands = shorthands.has(lastCommand);
+            if (!hasQuadratics) hasQuadratics = quadratics.has(lastCommand);
+            if (!hasArcs) hasArcs = lastCommand === 'a' || lastCommand === 'A';
+
+            // reset counters
+            wasSpace = false;
+            floatCount = 0;
+            valueIndex = 0;
+            needsNewSegment = false;
+
+            i++;
+            continue;
+        }
+
+        // Separated by White space 
+        if (isSpace(charCode)) {
+
+            // push value
+            pushVal()
+
+            wasSpace = true;
+            wasE = false;
+            i++;
+            continue;
+        }
+
+
+        // if last
+        else if (i === len - 1) {
+
+            val += char;
+            //console.log('last', val, char);
+
+            // push value
+            pushVal()
+            wasSpace = false;
+            wasE = false;
+
+            validateCommand()
+            break;
+        }
+
+
+        // minus or float separated
+        if ((!wasE && !wasSpace && charCode === 0x2D) ||
+            (!wasE && charCode === 0x2E)
+        ) {
+
+            // checkFloats changes condition for value adding
+            let checkFloats = charCode === 0x2E;
+
+            // new val
+            pushVal(checkFloats);
+
+            // new segment
+            addSeg()
+
+
+            // concatenated floats
+            if (checkFloats) {
+                floatCount++;
+            }
+        }
+
+
+        // regular splitting
+        else {
+            addSeg()
+        }
+
+        val += char;
+
+        // e/scientific notation in value
+        wasE = (charCode === 0x45 || charCode === 0x65);
+        wasSpace = false;
+        i++;
+    }
+
+    //validate final
+    validateCommand()
+
+    // return error log
+    if (debug && log.length) {
+        feedback = 'Invalid path data:\n' + log.join('\n')
+        if (debug === 'log') {
+            console.log(feedback);
+        } else {
+            throw new Error(feedback)
+        }
+    }
+
+    pathData[0].type = 'M'
+
+
+
+
+    return {
+        pathData: pathData,
+        hasRelatives: hasRelatives,
+        hasShorthands: hasShorthands,
+        hasQuadratics: hasQuadratics,
+        hasArcs: hasArcs
+    }
+
+}
+