react-native-nano-icons 0.0.0 → 0.1.0

package/lib/commonjs/src/core/svg/svg_pathops.js

@@ -0,0 +1,611 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPathopsBackend = buildPathopsBackend;
+//** */
+// ----- numeric helpers -----
+const EPS = 1e-2;
+// ✅ round-half-to-even (banker's rounding) at ndigits
+function roundN(x, ndigits = 3) {
+    const m = 10 ** ndigits;
+    const s = x * m;
+    // Handle very large values safely
+    if (!Number.isFinite(s))
+        return x;
+    const floor = Math.floor(s);
+    const frac = s - floor;
+    // floating tolerance for "exactly .5"
+    const TIE_EPS = 1e-12;
+    let roundedInt;
+    if (Math.abs(frac - 0.5) < TIE_EPS) {
+        // tie -> choose even
+        roundedInt = floor % 2 === 0 ? floor : floor + 1;
+    }
+    else if (Math.abs(frac + 0.5) < TIE_EPS) {
+        // negative tie case (rare due to floor behavior, but keep for completeness)
+        const ceil = Math.ceil(s);
+        roundedInt = ceil % 2 === 0 ? ceil : ceil - 1;
+    }
+    else {
+        roundedInt = Math.round(s);
+    }
+    return roundedInt / m;
+}
+function normPt(p) {
+    return [Math.round(p[0] * 10000) / 10000, Math.round(p[1] * 10000) / 10000];
+}
+function eqPt(a, b) {
+    const aa = normPt(a);
+    const bb = normPt(b);
+    return Math.abs(aa[0] - bb[0]) < EPS && Math.abs(aa[1] - bb[1]) < EPS;
+}
+function signedAreaPolyline(points) {
+    if (points.length < 3)
+        return 0;
+    let a = 0;
+    for (let i = 0; i < points.length; i++) {
+        const [x1, y1] = points[i];
+        const [x2, y2] = points[(i + 1) % points.length];
+        a += x1 * y2 - x2 * y1;
+    }
+    return a / 2;
+}
+function approxSignedAreaFromContourCmds(contourCmds, VERB, steps = 24) {
+    let cx = 0, cy = 0;
+    let sx = 0, sy = 0;
+    const pts = [];
+    const add = (x, y) => pts.push([x, y]);
+    for (const cmd of contourCmds) {
+        const v = cmd[0];
+        if (v === VERB.MOVE) {
+            cx = cmd[1];
+            cy = cmd[2];
+            sx = cx;
+            sy = cy;
+            add(cx, cy);
+        }
+        else if (v === VERB.LINE) {
+            cx = cmd[1];
+            cy = cmd[2];
+            add(cx, cy);
+        }
+        else if (v === VERB.QUAD) {
+            const x0 = cx, y0 = cy;
+            const x1 = cmd[1], y1 = cmd[2];
+            const x2 = cmd[3], y2 = cmd[4];
+            for (let i = 1; i <= steps; i++) {
+                const t = i / steps;
+                const mt = 1 - t;
+                const x = mt * mt * x0 + 2 * mt * t * x1 + t * t * x2;
+                const y = mt * mt * y0 + 2 * mt * t * y1 + t * t * y2;
+                add(x, y);
+            }
+            cx = x2;
+            cy = y2;
+        }
+        else if (v === VERB.CUBIC) {
+            const x0 = cx, y0 = cy;
+            const x1 = cmd[1], y1 = cmd[2];
+            const x2 = cmd[3], y2 = cmd[4];
+            const x3 = cmd[5], y3 = cmd[6];
+            for (let i = 1; i <= steps; i++) {
+                const t = i / steps;
+                const mt = 1 - t;
+                const x = mt * mt * mt * x0 +
+                    3 * mt * mt * t * x1 +
+                    3 * mt * t * t * x2 +
+                    t * t * t * x3;
+                const y = mt * mt * mt * y0 +
+                    3 * mt * mt * t * y1 +
+                    3 * mt * t * t * y2 +
+                    t * t * t * y3;
+                add(x, y);
+            }
+            cx = x3;
+            cy = y3;
+        }
+        else if (v === VERB.CLOSE) {
+            add(sx, sy);
+        }
+    }
+    if (pts.length &&
+        (pts[0][0] !== pts[pts.length - 1][0] ||
+            pts[0][1] !== pts[pts.length - 1][1])) {
+        pts.push([pts[0][0], pts[0][1]]);
+    }
+    return signedAreaPolyline(pts);
+}
+function splitContours(cmds, VERB) {
+    const contours = [];
+    let cur = null;
+    for (const cmd of cmds) {
+        const v = cmd[0];
+        if (v === VERB.MOVE) {
+            if (cur && cur.length)
+                contours.push(cur);
+            cur = [cmd];
+        }
+        else if (cur) {
+            cur.push(cmd);
+        }
+    }
+    if (cur && cur.length)
+        contours.push(cur);
+    return contours;
+}
+function ensureClosed(contourCmds, VERB) {
+    return contourCmds.some((c) => c[0] === VERB.CLOSE)
+        ? [...contourCmds]
+        : [...contourCmds, [VERB.CLOSE]];
+}
+function explicitCloseWantedFromCmds(contourCmds, VERB) {
+    if (!contourCmds?.length)
+        return false;
+    const m = contourCmds[0];
+    if (m[0] !== VERB.MOVE)
+        return false;
+    const start = [m[1], m[2]];
+    for (let i = contourCmds.length - 1; i >= 1; i--) {
+        const cmd = contourCmds[i];
+        const v = cmd[0];
+        if (v === VERB.CLOSE)
+            continue;
+        let end = null;
+        if (v === VERB.LINE)
+            end = [cmd[1], cmd[2]];
+        else if (v === VERB.QUAD)
+            end = [cmd[3], cmd[4]];
+        else if (v === VERB.CUBIC)
+            end = [cmd[5], cmd[6]];
+        else
+            continue;
+        return eqPt(end, start);
+    }
+    return false;
+}
+function contourToSegments(contourCmds, VERB) {
+    const c = ensureClosed(contourCmds, VERB);
+    const move = c[0];
+    const sx = move[1], sy = move[2];
+    let last = [sx, sy];
+    const segs = [];
+    for (let i = 1; i < c.length; i++) {
+        const cmd = c[i];
+        const v = cmd[0];
+        if (v === VERB.LINE) {
+            const end = [cmd[1], cmd[2]];
+            segs.push({ type: 'L', start: last, end, synthetic: false });
+            last = end;
+        }
+        else if (v === VERB.QUAD) {
+            const ctrl = [cmd[1], cmd[2]];
+            const end = [cmd[3], cmd[4]];
+            segs.push({ type: 'Q', start: last, ctrl, end, synthetic: false });
+            last = end;
+        }
+        else if (v === VERB.CUBIC) {
+            const c1 = [cmd[1], cmd[2]];
+            const c2 = [cmd[3], cmd[4]];
+            const end = [cmd[5], cmd[6]];
+            segs.push({ type: 'C', start: last, c1, c2, end, synthetic: false });
+            last = end;
+        }
+        else if (v === VERB.CLOSE) {
+            const end = [sx, sy];
+            if (!eqPt(last, end)) {
+                segs.push({ type: 'L', start: last, end, synthetic: true });
+            }
+            last = end;
+        }
+    }
+    return { start: [sx, sy], segs };
+}
+function applyClosePolicy(segs, startPt, explicitCloseWanted) {
+    if (!segs.length)
+        return segs;
+    for (const s of segs)
+        s.synthetic = false;
+    const last = segs[segs.length - 1];
+    const lastEnd = last.end;
+    if (!eqPt(lastEnd, startPt)) {
+        segs.push({ type: 'L', start: lastEnd, end: startPt, synthetic: false });
+    }
+    if (!explicitCloseWanted) {
+        segs[segs.length - 1].synthetic = true;
+    }
+    return segs;
+}
+function segmentsToContourCmds(startPt, segs, VERB) {
+    const out = [[VERB.MOVE, roundN(startPt[0]), roundN(startPt[1])]];
+    for (const s of segs) {
+        if (s.synthetic)
+            continue;
+        if (s.type === 'L') {
+            out.push([VERB.LINE, roundN(s.end[0]), roundN(s.end[1])]);
+        }
+        else if (s.type === 'Q') {
+            out.push([
+                VERB.QUAD,
+                roundN(s.ctrl[0]),
+                roundN(s.ctrl[1]),
+                roundN(s.end[0]),
+                roundN(s.end[1]),
+            ]);
+        }
+        else {
+            out.push([
+                VERB.CUBIC,
+                roundN(s.c1[0]),
+                roundN(s.c1[1]),
+                roundN(s.c2[0]),
+                roundN(s.c2[1]),
+                roundN(s.end[0]),
+                roundN(s.end[1]),
+            ]);
+        }
+    }
+    out.push([VERB.CLOSE]);
+    return out;
+}
+function reverseClosedContourKeepStart(contourCmds, explicitCloseWanted, VERB) {
+    const { start, segs } = contourToSegments(contourCmds, VERB);
+    const reversed = segs
+        .slice()
+        .reverse()
+        .map((s) => {
+        if (s.type === 'L') {
+            return { type: 'L', start: s.end, end: s.start, synthetic: false };
+        }
+        if (s.type === 'Q') {
+            return {
+                type: 'Q',
+                start: s.end,
+                ctrl: s.ctrl,
+                end: s.start,
+                synthetic: false,
+            };
+        }
+        return {
+            type: 'C',
+            start: s.end,
+            c1: s.c2,
+            c2: s.c1,
+            end: s.start,
+            synthetic: false,
+        };
+    });
+    applyClosePolicy(reversed, start, explicitCloseWanted);
+    return segmentsToContourCmds(start, reversed, VERB);
+}
+function rotateClosedContourToStart(contourCmds, desiredStart, explicitCloseWanted, VERB) {
+    const { segs } = contourToSegments(contourCmds, VERB);
+    let idx = -1;
+    for (let i = 0; i < segs.length; i++) {
+        if (eqPt(segs[i].start, desiredStart)) {
+            idx = i;
+            break;
+        }
+    }
+    if (idx === -1) {
+        for (let i = 0; i < segs.length; i++) {
+            if (eqPt(segs[i].end, desiredStart)) {
+                idx = (i + 1) % segs.length;
+                break;
+            }
+        }
+    }
+    if (idx === -1)
+        return [...contourCmds];
+    const rotated = segs.slice(idx).concat(segs.slice(0, idx));
+    applyClosePolicy(rotated, desiredStart, explicitCloseWanted);
+    return segmentsToContourCmds(desiredStart, rotated, VERB);
+}
+function cmdsToVerbPoints(cmds, VERB) {
+    const out = [];
+    for (const cmd of cmds) {
+        const v = cmd[0];
+        if (v === VERB.MOVE)
+            out.push([0, [[cmd[1], cmd[2]]]]);
+        else if (v === VERB.LINE)
+            out.push([1, [[cmd[1], cmd[2]]]]);
+        else if (v === VERB.QUAD)
+            out.push([
+                2,
+                [
+                    [cmd[1], cmd[2]],
+                    [cmd[3], cmd[4]],
+                ],
+            ]);
+        else if (v === VERB.CUBIC)
+            out.push([
+                3,
+                [
+                    [cmd[1], cmd[2]],
+                    [cmd[3], cmd[4]],
+                    [cmd[5], cmd[6]],
+                ],
+            ]);
+        else if (v === VERB.CLOSE)
+            out.push([4, []]);
+        else
+            throw new Error(`Unexpected verb in cmds: ${v}`);
+    }
+    return out;
+}
+function wrapPath(pathkitPath) {
+    return { p: pathkitPath, meta: { moves: [] } };
+}
+function cloneWrap(h, PathKit) {
+    const p2 = PathKit.NewPath(h.p);
+    const out = wrapPath(p2);
+    out.meta.moves = h.meta?.moves ? h.meta.moves.map((m) => [m[0], m[1]]) : [];
+    return out;
+}
+function mergeMoves(aMoves, bMoves) {
+    const out = [];
+    const pushUnique = (pt) => {
+        for (const existing of out) {
+            if (eqPt(existing, pt))
+                return;
+        }
+        out.push(pt);
+    };
+    for (const m of aMoves || [])
+        pushUnique(normPt(m));
+    for (const m of bMoves || [])
+        pushUnique(normPt(m));
+    return out;
+}
+function bestStartMinYMinX(contourCmds, VERB) {
+    let best = null;
+    for (const cmd of contourCmds) {
+        const v = cmd[0];
+        const add = (x, y) => {
+            const p = [x, y];
+            if (!best) {
+                best = p;
+                return;
+            }
+            if (p[1] < best[1] - 1e-9)
+                best = p;
+            else if (Math.abs(p[1] - best[1]) < 1e-9 && p[0] < best[0] - 1e-9)
+                best = p;
+        };
+        if (v === VERB.MOVE)
+            add(cmd[1], cmd[2]);
+        else if (v === VERB.LINE)
+            add(cmd[1], cmd[2]);
+        else if (v === VERB.QUAD)
+            add(cmd[3], cmd[4]);
+        else if (v === VERB.CUBIC)
+            add(cmd[5], cmd[6]);
+    }
+    return best;
+}
+// proxy to for picosvg to interatc with pathkit
+function buildPathopsBackend(PathKit) {
+    const VERB = {
+        MOVE: PathKit.MOVE_VERB ?? 0,
+        LINE: PathKit.LINE_VERB ?? 1,
+        QUAD: PathKit.QUAD_VERB ?? 2,
+        CONIC: PathKit.CONIC_VERB ?? 3,
+        CUBIC: PathKit.CUBIC_VERB ?? 4,
+        CLOSE: PathKit.CLOSE_VERB ?? 5,
+    };
+    const FILL_EVENODD = PathKit?.FillType?.EVENODD ?? PathKit?.FillType?.EVEN_ODD ?? 1;
+    const FILL_WINDING = PathKit?.FillType?.WINDING ?? PathKit?.FillType?.NONZERO ?? 0;
+    function cmdsViaSvgRoundtrip(h) {
+        const svg = h.p.toSVGString();
+        const p2 = PathKit.FromSVGString(svg);
+        const cmds = p2 ? p2.toCmds() : [];
+        if (p2)
+            p2.delete?.();
+        return cmds;
+    }
+    function normalizeSortRotateContours(cmds, h, preferStrokeCanonical = false) {
+        const moves = (h.meta?.moves || []).map((m) => normPt([m[0], m[1]]));
+        const used = new Array(moves.length).fill(false);
+        // Build contour objects, but DO NOT normalize orientation yet.
+        const contourObjs = splitContours(cmds, VERB).map((c) => {
+            const explicitCloseWanted = explicitCloseWantedFromCmds(c, VERB);
+            const cc = ensureClosed(c, VERB);
+            const a = approxSignedAreaFromContourCmds(cc, VERB); // signed
+            return { cmds: cc, absA: Math.abs(a), explicitCloseWanted };
+        });
+        // Big-to-small ordering gives deterministic outer→inner ordering.
+        contourObjs.sort((x, y) => y.absA - x.absA);
+        // Enforce winding convention:
+        // - largest contour CCW (positive area)
+        // - all subsequent contours CW (negative area)
+        const ensureOrient = (obj, wantCCW) => {
+            const a = approxSignedAreaFromContourCmds(obj.cmds, VERB);
+            const isCCW = a > 0;
+            if (wantCCW !== isCCW) {
+                obj.cmds = reverseClosedContourKeepStart(obj.cmds, obj.explicitCloseWanted, VERB);
+            }
+        };
+        if (contourObjs.length) {
+            ensureOrient(contourObjs[0], true);
+            for (let i = 1; i < contourObjs.length; i++) {
+                ensureOrient(contourObjs[i], false);
+            }
+        }
+        // Rotate starts deterministically:
+        // 1) If we have recorded MOVE points, try to rotate contour to a move point that lies on it.
+        // 2) Otherwise, rotate to minY/minX point (helps stroke-ish paths)
+        for (const obj of contourObjs) {
+            let cc = obj.cmds;
+            for (let i = 0; i < moves.length; i++) {
+                if (used[i])
+                    continue;
+                const target = moves[i];
+                const { segs } = contourToSegments(cc, VERB);
+                const found = segs.some((s) => eqPt(s.start, target) || eqPt(s.end, target));
+                if (found) {
+                    used[i] = true;
+                    cc = rotateClosedContourToStart(cc, target, obj.explicitCloseWanted, VERB);
+                    break;
+                }
+            }
+            // If no move point was used, apply the deterministic start heuristic
+            if (preferStrokeCanonical) {
+                const best = bestStartMinYMinX(cc, VERB);
+                if (best) {
+                    cc = rotateClosedContourToStart(cc, best, obj.explicitCloseWanted, VERB);
+                }
+            }
+            obj.cmds = cc;
+        }
+        return contourObjs.flatMap((x) => x.cmds);
+    }
+    return {
+        create_path(fillTypeInt) {
+            const p = PathKit.NewPath();
+            p.setFillType(fillTypeInt === 1 ? FILL_EVENODD : FILL_WINDING);
+            return wrapPath(p);
+        },
+        clone_path(h) {
+            return cloneWrap(h, PathKit);
+        },
+        delete_path(h) {
+            h?.p?.delete?.();
+        },
+        get_fill_type(h) {
+            const ft = h.p.getFillType?.();
+            return ft === FILL_EVENODD ? 1 : 0;
+        },
+        set_fill_type(h, fillTypeInt) {
+            h.p.setFillType(fillTypeInt === 1 ? FILL_EVENODD : FILL_WINDING);
+            return true;
+        },
+        move_to(h, x, y) {
+            h.p.moveTo(x, y);
+            h.meta.moves.push(normPt([x, y]));
+        },
+        line_to(h, x, y) {
+            h.p.lineTo(x, y);
+        },
+        quad_to(h, x1, y1, x2, y2) {
+            h.p.quadTo(x1, y1, x2, y2);
+        },
+        cubic_to(h, x1, y1, x2, y2, x3, y3) {
+            h.p.cubicTo(x1, y1, x2, y2, x3, y3);
+        },
+        close(h) {
+            h.p.close();
+        },
+        simplify(h, fixWinding = false) {
+            try {
+                // 1) simplify in place
+                h.p.simplify();
+                // 2) normalize representation via SVG roundtrip
+                const svg = h.p.toSVGString();
+                const p2 = PathKit.FromSVGString(svg);
+                if (p2) {
+                    // replace underlying path handle
+                    h.p.delete?.();
+                    h.p = p2;
+                }
+                if (fixWinding)
+                    h.p.setFillType(FILL_WINDING);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        stroke(h, width, capInt, joinInt, miterLimit, dashArray, dashOffset) {
+            const Caps = PathKit.StrokeCap ?? {};
+            const Joins = PathKit.StrokeJoin ?? {};
+            const cap = capInt === 1
+                ? Caps.ROUND ?? 1
+                : capInt === 2
+                    ? Caps.SQUARE ?? 2
+                    : Caps.BUTT ?? 0;
+            const join = joinInt === 1
+                ? Joins.ROUND ?? 1
+                : joinInt === 2
+                    ? Joins.BEVEL ?? 2
+                    : Joins.MITER ?? 0;
+            const work = PathKit.NewPath(h.p);
+            try {
+                if (Array.isArray(dashArray) &&
+                    dashArray.length === 2 &&
+                    typeof work.dash === 'function') {
+                    work.dash(Number(dashArray[0]), Number(dashArray[1]), dashOffset || 0);
+                }
+                let stroked = work.stroke({
+                    width,
+                    cap,
+                    join,
+                    miter_limit: miterLimit,
+                });
+                if (!stroked || typeof stroked.toCmds !== 'function')
+                    stroked = work;
+                if (stroked !== work)
+                    work.delete?.();
+                const wrapped = wrapPath(stroked);
+                wrapped.meta.moves = [];
+                return wrapped;
+            }
+            catch {
+                const wrapped = wrapPath(work);
+                wrapped.meta.moves = [];
+                return wrapped;
+            }
+        },
+        convert_conics_to_quads(_h, _tol) {
+            // intentionally no-op
+        },
+        transform(h, a, b, c, d, e, f) {
+            const p = PathKit.NewPath(h.p);
+            p.transform(a, c, e, b, d, f, 0, 0, 1);
+            const wrapped = wrapPath(p);
+            wrapped.meta.moves = (h.meta?.moves || []).map(([x, y]) => normPt([a * x + c * y + e, b * x + d * y + f]));
+            return wrapped;
+        },
+        op(aHandle, bHandle, opInt) {
+            try {
+                const Ops = PathKit.PathOp ?? {};
+                const op = opInt === 1
+                    ? Ops.INTERSECT ?? 1
+                    : opInt === 2
+                        ? Ops.DIFFERENCE ?? 2
+                        : Ops.UNION ?? 0;
+                const out = PathKit.MakeFromOp(aHandle.p, bHandle.p, op);
+                if (!out)
+                    return null;
+                const wrapped = wrapPath(out);
+                wrapped.meta.moves = mergeMoves(aHandle.meta?.moves, bHandle.meta?.moves);
+                return wrapped;
+            }
+            catch {
+                return null;
+            }
+        },
+        bounds(h) {
+            const r = h.p.getBounds();
+            return [r.fLeft, r.fTop, r.fRight, r.fBottom];
+        },
+        area(h) {
+            try {
+                const cmds = cmdsViaSvgRoundtrip(h);
+                const contours = splitContours(cmds, VERB);
+                let total = 0;
+                for (const c of contours) {
+                    const cc = ensureClosed(c, VERB);
+                    total += Math.abs(approxSignedAreaFromContourCmds(cc, VERB));
+                }
+                return total;
+            }
+            catch {
+                return 0.0;
+            }
+        },
+        iter_segments(h) {
+            const cmds = cmdsViaSvgRoundtrip(h);
+            const preferStrokeCanonical = (h.meta?.moves?.length || 0) === 0;
+            const normalized = normalizeSortRotateContours(cmds, h, preferStrokeCanonical);
+            return cmdsToVerbPoints(normalized, VERB);
+        },
+    };
+}