@visactor/vrender-core 1.1.11-alpha.0 → 1.1.11

package/dist/index.es.js

@@ -9475,6 +9475,8 @@ const ATTRIBUTE_CATEGORY = {
     shadowColor: UpdateCategory.PAINT,
     x: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
     y: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    dx: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
+    dy: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
     scaleX: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
     scaleY: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
     angle: UpdateCategory.TRANSFORM | UpdateCategory.BOUNDS,
@@ -11036,6 +11038,9 @@ class Graphic extends Node {
             this.setShadowGraphic(value);
         }
     }
+    static needsShapeUpdate(graphic, key) {
+        return graphic.needUpdateTag(key);
+    }
     needUpdateTags(keys, k = GRAPHIC_UPDATE_TAG_KEY) {
         for (let i = 0; i < k.length; i++) {
             const attrKey = k[i];
@@ -13533,21 +13538,21 @@ let Line$1 = class Line extends Graphic {
         return aabbBounds;
     }
     updateLineAABBBoundsByPoints(attribute, lineTheme, aabbBounds, graphic) {
-        const { points = lineTheme.points, connectedType } = attribute;
+        const { points = lineTheme.points } = attribute;
         const b = aabbBounds;
         points.forEach(p => {
-            if (p.defined !== false || connectedType === 'connect') {
+            if (p.defined !== false) {
                 b.add(p.x, p.y);
             }
         });
         return b;
     }
     updateLineAABBBoundsBySegments(attribute, lineTheme, aabbBounds, graphic) {
-        const { segments = lineTheme.segments, connectedType } = attribute;
+        const { segments = lineTheme.segments } = attribute;
         const b = aabbBounds;
         segments.forEach(s => {
             s.points.forEach(p => {
-                if (p.defined !== false || connectedType === 'connect') {
+                if (p.defined !== false) {
                     b.add(p.x, p.y);
                 }
             });
@@ -13913,9 +13918,22 @@ class Glyph extends Graphic {
         return bounds;
     }
     needUpdateTags(keys) {
+        for (const key of keys) {
+            if (this.needUpdateTag(key)) {
+                return true;
+            }
+        }
         return false;
     }
     needUpdateTag(key) {
+        if (ATTRIBUTE_CATEGORY[key] === UpdateCategory.PAINT) {
+            return false;
+        }
+        for (const child of this.subGraphic) {
+            if (Graphic.needsShapeUpdate(child, key)) {
+                return true;
+            }
+        }
         return false;
     }
     hasLegacyStateDefinitions() {
@@ -15887,7 +15905,14 @@ function createPath(attributes) {
     return new Path(attributes);
 }
 
-const AREA_UPDATE_TAG_KEY = ['segments', 'points', 'curveType', 'curveTension', ...GRAPHIC_UPDATE_TAG_KEY];
+const AREA_UPDATE_TAG_KEY = [
+    'segments',
+    'points',
+    'curveType',
+    'curveTension',
+    'connectedType',
+    ...GRAPHIC_UPDATE_TAG_KEY
+];
 class Area extends Graphic {
     constructor(params) {
         super(params);
@@ -15936,6 +15961,9 @@ class Area extends Graphic {
         const b = aabbBounds;
         points.forEach(p => {
             var _a, _b;
+            if (p.defined === false) {
+                return;
+            }
             b.add(p.x, p.y);
             b.add((_a = p.x1) !== null && _a !== void 0 ? _a : p.x, (_b = p.y1) !== null && _b !== void 0 ? _b : p.y);
         });
@@ -15947,6 +15975,9 @@ class Area extends Graphic {
         segments.forEach(s => {
             s.points.forEach(p => {
                 var _a, _b;
+                if (p.defined === false) {
+                    return;
+                }
                 b.add(p.x, p.y);
                 b.add((_a = p.x1) !== null && _a !== void 0 ? _a : p.x, (_b = p.y1) !== null && _b !== void 0 ? _b : p.y);
             });
@@ -24859,6 +24890,142 @@ function drawSegItem(ctx, curve, endPercent, params) {
     }
 }
 
+function getAreaPointRuns(points, connectedType, startPoint) {
+    const runs = [];
+    if (!points.some(p => p.defined === false)) {
+        const run = startPoint ? [startPoint, ...points] : points;
+        if (run.length) {
+            runs.push(run);
+        }
+        return { runs, tail: run[run.length - 1] };
+    }
+    let run = startPoint ? [startPoint] : [];
+    for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        if (point.defined !== false) {
+            run.push(point);
+        }
+        else if (connectedType !== 'connect') {
+            if (run.length) {
+                runs.push(run);
+            }
+            run = [];
+        }
+    }
+    if (run.length) {
+        runs.push(run);
+    }
+    return { runs, tail: run[run.length - 1] };
+}
+function joinAreaPaths(paths) {
+    var _a;
+    if (paths.length === 1) {
+        return paths[0];
+    }
+    const curves = [];
+    for (let i = 0; i < paths.length; i++) {
+        const next = paths[i].curves;
+        if (curves.length) {
+            const previous = curves[curves.length - 1];
+            const gap = new LineCurve((_a = previous.p3) !== null && _a !== void 0 ? _a : previous.p1, next[0].p0);
+            gap.defined = false;
+            gap.originP1 = previous.originP2;
+            gap.originP2 = next[0].originP1;
+            curves.push(gap);
+        }
+        for (let j = 0; j < next.length; j++) {
+            curves.push(next[j]);
+        }
+    }
+    const path = paths[paths.length - 1];
+    path.curves = curves;
+    path.length = NaN;
+    return path;
+}
+function compileAreaRuns(runs, curveType, curveTension, sourceSegmentIndex, topStart, bottomStart) {
+    var _a, _b, _c, _d;
+    const tops = [];
+    const bottoms = [];
+    const bottomType = curveType === 'stepBefore' ? 'stepAfter' : curveType === 'stepAfter' ? 'stepBefore' : curveType;
+    for (let i = 0; i < runs.length; i++) {
+        const points = runs[i];
+        const startPoint = i === 0 ? topStart : undefined;
+        if (points.length < 2 - Number(!!startPoint)) {
+            continue;
+        }
+        const bottomPoints = [];
+        for (let j = points.length - 1; j >= 0; j--) {
+            const p = points[j];
+            bottomPoints.push({ x: (_a = p.x1) !== null && _a !== void 0 ? _a : p.x, y: (_b = p.y1) !== null && _b !== void 0 ? _b : p.y });
+        }
+        if (i === 0 && bottomStart) {
+            bottomPoints.push({ x: (_c = bottomStart.x1) !== null && _c !== void 0 ? _c : bottomStart.x, y: (_d = bottomStart.y1) !== null && _d !== void 0 ? _d : bottomStart.y });
+        }
+        const top = calcLineCache(points, curveType, { startPoint, curveTension });
+        const bottom = calcLineCache(bottomPoints, bottomType, { curveTension });
+        if ((top === null || top === void 0 ? void 0 : top.curves.length) && (bottom === null || bottom === void 0 ? void 0 : bottom.curves.length)) {
+            tops.push(top);
+            bottoms.push(bottom);
+        }
+    }
+    if (!tops.length) {
+        return null;
+    }
+    return {
+        top: joinAreaPaths(tops),
+        bottom: joinAreaPaths(bottoms.reverse()),
+        sourceSegmentIndex,
+        direction: Direction.ROW
+    };
+}
+function calcAreaCache(points, segments, curveType, connectedType, curveTension) {
+    var _a;
+    const caches = [];
+    let tail;
+    let topTail;
+    let first;
+    let last;
+    const count = segments ? segments.length : 1;
+    for (let i = 0; i < count; i++) {
+        const segmentPoints = segments ? segments[i].points : points !== null && points !== void 0 ? points : [];
+        const result = getAreaPointRuns(segmentPoints, connectedType);
+        const canContinue = connectedType === 'connect' || ((_a = segmentPoints[0]) === null || _a === void 0 ? void 0 : _a.defined) !== false;
+        if (result.runs.length) {
+            first = first !== null && first !== void 0 ? first : result.runs[0][0];
+            const lastRun = result.runs[result.runs.length - 1];
+            last = lastRun[lastRun.length - 1];
+        }
+        const cache = compileAreaRuns(result.runs, curveType, curveTension, i, canContinue ? topTail : undefined, canContinue ? tail : undefined);
+        if (cache) {
+            caches.push(cache);
+        }
+        if (result.tail) {
+            tail = result.tail;
+            const lastRun = result.runs[result.runs.length - 1];
+            topTail =
+                cache && (result.runs.length === 1 || lastRun.length > 1) ? { x: cache.top.endX, y: cache.top.endY } : tail;
+        }
+        else if (connectedType !== 'connect' && segmentPoints.length) {
+            tail = topTail = undefined;
+        }
+    }
+    if (!caches.length) {
+        return null;
+    }
+    let direction = Direction.ROW;
+    if (last.x1 != null) {
+        const dx = abs(last.x - first.x);
+        const dy = abs(last.y - first.y);
+        if (last.y1 == null || (Number.isFinite(dx + dy) && dy >= dx)) {
+            direction = Direction.COLUMN;
+        }
+    }
+    for (let i = 0; i < caches.length; i++) {
+        caches[i].direction = direction;
+    }
+    return segments ? caches : caches[0];
+}
+
 function drawEachCurve(path, curve, lastCurve, defined0, offsetX, offsetY, offsetZ) {
     var _a;
     let p0 = curve.p0;
@@ -24994,31 +25161,27 @@ function drawIncrementalSegments(path, lastSeg, segments, params) {
     });
 }
 function drawIncrementalAreaSegments(path, lastSeg, segments, params) {
-    const { offsetX = 0, offsetY = 0 } = params || {};
-    const { points } = segments;
-    const definedPointsList = [];
-    for (let i = 0; i < points.length; i++) {
-        if (points[i].defined === false) ;
-    }
-    definedPointsList.push(points);
-    definedPointsList.forEach((points, i) => {
-        var _a, _b, _c, _d;
-        const startP = lastSeg && i === 0 ? lastSeg.points[lastSeg.points.length - 1] : points[0];
-        path.moveTo(startP.x + offsetX, startP.y + offsetY);
-        points.forEach(p => {
-            if (p.defined === false) {
-                path.moveTo(p.x + offsetX, p.y + offsetY);
-                return;
-            }
-            path.lineTo(p.x + offsetX, p.y + offsetY);
-        });
-        for (let i = points.length - 1; i >= 0; i--) {
-            const p = points[i];
+    var _a, _b;
+    const { offsetX = 0, offsetY = 0, connectedType = 'none' } = params || {};
+    const startPoint = params && 'startPoint' in params
+        ? params.startPoint
+        : lastSeg && getAreaPointRuns(lastSeg.points, connectedType).tail;
+    const { runs } = getAreaPointRuns(segments.points, connectedType, startPoint);
+    for (let i = 0; i < runs.length; i++) {
+        const points = runs[i];
+        if (points.length < 2) {
+            continue;
+        }
+        path.moveTo(points[0].x + offsetX, points[0].y + offsetY);
+        for (let j = 1; j < points.length; j++) {
+            path.lineTo(points[j].x + offsetX, points[j].y + offsetY);
+        }
+        for (let j = points.length - 1; j >= 0; j--) {
+            const p = points[j];
             path.lineTo((_a = p.x1) !== null && _a !== void 0 ? _a : p.x, (_b = p.y1) !== null && _b !== void 0 ? _b : p.y);
         }
-        path.lineTo((_c = startP.x1) !== null && _c !== void 0 ? _c : startP.x, (_d = startP.y1) !== null && _d !== void 0 ? _d : startP.y);
         path.closePath();
-    });
+    }
 }
 
 class DefaultCanvasLineRender extends BaseRender {
@@ -25447,7 +25610,6 @@ class DefaultCanvasAreaRender extends BaseRender {
         _runStroke();
     }
     drawShape(area, context, x, y, drawContext, params, fillCb, strokeCb) {
-        var _a, _b, _c, _d, _e, _f;
         const areaAttribute = getTheme(area, params === null || params === void 0 ? void 0 : params.theme).area;
         const { fill = areaAttribute.fill, stroke = areaAttribute.stroke, fillOpacity = areaAttribute.fillOpacity, z = areaAttribute.z, strokeOpacity = areaAttribute.strokeOpacity, curveTension = areaAttribute.curveTension, connectedType = areaAttribute.connectedType } = area.attribute;
         const data = this.valid(area, areaAttribute, fillCb, strokeCb);
@@ -25461,104 +25623,24 @@ class DefaultCanvasAreaRender extends BaseRender {
         if (closePath && curveType === 'linear') {
             curveType = 'linearClosed';
         }
-        function parsePoint(points, connectedType) {
-            if (connectedType !== 'connect') {
-                return points;
-            }
-            return points.filter(p => p.defined !== false);
-        }
         if (clipRange === 1 && !segments && !points.some(p => p.defined === false) && curveType === 'linear') {
             return this.drawLinearAreaHighPerformance(area, context, !!fill, doStroke, fillOpacity, strokeOpacity, x, y, areaAttribute, drawContext, params, fillCb, strokeCb);
         }
         if (area.shouldUpdateShape()) {
-            if (segments && segments.length) {
-                let startPoint;
-                let lastTopSeg;
-                const topCaches = segments
-                    .map((seg, index) => {
-                    if (seg.points.length <= 1) {
-                        if (index === 0) {
-                            seg.points[0] && (lastTopSeg = { endX: seg.points[0].x, endY: seg.points[0].y });
-                            return null;
-                        }
-                    }
-                    if (index === 1) {
-                        startPoint = { x: lastTopSeg.endX, y: lastTopSeg.endY };
-                    }
-                    else if (index > 1) {
-                        startPoint.x = lastTopSeg.endX;
-                        startPoint.y = lastTopSeg.endY;
-                    }
-                    const data = calcLineCache(parsePoint(seg.points, connectedType), curveType, {
-                        startPoint,
-                        curveTension
-                    });
-                    lastTopSeg = data;
-                    return data;
-                })
-                    .filter(item => !!item);
-                let lastBottomSeg;
-                const bottomCaches = [];
-                for (let i = segments.length - 1; i >= 0; i--) {
-                    const points = segments[i].points;
-                    const bottomPoints = [];
-                    for (let i = points.length - 1; i >= 0; i--) {
-                        bottomPoints.push({
-                            x: (_a = points[i].x1) !== null && _a !== void 0 ? _a : points[i].x,
-                            y: (_b = points[i].y1) !== null && _b !== void 0 ? _b : points[i].y
-                        });
-                    }
-                    if (i !== 0) {
-                        const lastSegmentPoints = segments[i - 1].points;
-                        const endPoint = lastSegmentPoints[lastSegmentPoints.length - 1];
-                        endPoint &&
-                            bottomPoints.push({
-                                x: (_c = endPoint.x1) !== null && _c !== void 0 ? _c : endPoint.x,
-                                y: (_d = endPoint.y1) !== null && _d !== void 0 ? _d : endPoint.y
-                            });
-                    }
-                    if (bottomPoints.length > 1) {
-                        lastBottomSeg = calcLineCache(parsePoint(bottomPoints, connectedType), curveType === 'stepBefore' ? 'stepAfter' : curveType === 'stepAfter' ? 'stepBefore' : curveType, { curveTension });
-                        bottomCaches.unshift(lastBottomSeg);
-                    }
-                }
-                area.cacheArea = bottomCaches.map((item, index) => ({
-                    top: topCaches[index],
-                    bottom: item
-                }));
-            }
-            else if (points && points.length) {
-                const topPoints = parsePoint(points, connectedType);
-                const bottomPoints = [];
-                for (let i = topPoints.length - 1; i >= 0; i--) {
-                    bottomPoints.push({
-                        x: (_e = topPoints[i].x1) !== null && _e !== void 0 ? _e : topPoints[i].x,
-                        y: (_f = topPoints[i].y1) !== null && _f !== void 0 ? _f : topPoints[i].y
-                    });
-                }
-                const topCache = calcLineCache(topPoints, curveType, { curveTension });
-                const bottomCache = calcLineCache(bottomPoints, curveType === 'stepBefore' ? 'stepAfter' : curveType === 'stepAfter' ? 'stepBefore' : curveType, { curveTension });
-                area.cacheArea = { top: topCache, bottom: bottomCache };
-            }
-            else {
-                area.cacheArea = null;
-                area.clearUpdateShapeTag();
-                return;
-            }
+            area.cacheArea = calcAreaCache(points, segments, curveType, connectedType, curveTension);
             area.clearUpdateShapeTag();
         }
+        if (!area.cacheArea) {
+            return;
+        }
         if (Array.isArray(area.cacheArea)) {
-            const segments = area.attribute.segments.filter(item => item.points.length);
-            if (segments[0].points.length === 1) {
-                segments.shift();
-            }
             if (clipRange === 1) {
                 let skip = false;
-                area.cacheArea.forEach((cache, index) => {
+                area.cacheArea.forEach(cache => {
                     if (skip) {
                         return;
                     }
-                    skip = this.drawSegmentItem(context, cache, doFill, fillOpacity, doStroke, strokeOpacity, segments[index], [areaAttribute, area.attribute], clipRange, x, y, z, area, drawContext, fillCb, strokeCb);
+                    skip = this.drawSegmentItem(context, cache, doFill, fillOpacity, doStroke, strokeOpacity, segments[cache.sourceSegmentIndex], [areaAttribute, area.attribute], clipRange, x, y, z, area, drawContext, fillCb, strokeCb);
                 });
             }
             else {
@@ -25566,7 +25648,7 @@ class DefaultCanvasAreaRender extends BaseRender {
                 const totalDrawLength = clipRange * totalLength;
                 let drawedLengthUntilLast = 0;
                 let skip = false;
-                area.cacheArea.forEach((cache, index) => {
+                area.cacheArea.forEach(cache => {
                     if (skip) {
                         return;
                     }
@@ -25574,7 +25656,7 @@ class DefaultCanvasAreaRender extends BaseRender {
                     const _cr = (totalDrawLength - drawedLengthUntilLast) / curSegLength;
                     drawedLengthUntilLast += curSegLength;
                     if (_cr > 0) {
-                        skip = this.drawSegmentItem(context, cache, doFill, fillOpacity, doStroke, strokeOpacity, segments[index], [areaAttribute, area.attribute], min(_cr, 1), x, y, z, area, drawContext, fillCb, strokeCb);
+                        skip = this.drawSegmentItem(context, cache, doFill, fillOpacity, doStroke, strokeOpacity, segments[cache.sourceSegmentIndex], [areaAttribute, area.attribute], min(_cr, 1), x, y, z, area, drawContext, fillCb, strokeCb);
                     }
                 });
             }
@@ -25591,6 +25673,7 @@ class DefaultCanvasAreaRender extends BaseRender {
         return this._drawSegmentItem(context, cache, fill, fillOpacity, stroke, strokeOpacity, attribute, defaultAttribute, clipRange, offsetX, offsetY, offsetZ, area, drawContext, fillCb, strokeCb);
     }
     _drawSegmentItem(context, cache, fill, fillOpacity, stroke, strokeOpacity, attribute, defaultAttribute, clipRange, offsetX, offsetY, offsetZ, area, drawContext, fillCb, strokeCb) {
+        var _a;
         if (!(cache &&
             cache.top &&
             cache.bottom &&
@@ -25602,34 +25685,7 @@ class DefaultCanvasAreaRender extends BaseRender {
         }
         context.beginPath();
         const ret = false;
-        const { points, segments } = area.attribute;
-        let direction = Direction.ROW;
-        let endP;
-        let startP;
-        if (segments) {
-            const endSeg = segments[segments.length - 1];
-            const startSeg = segments[0];
-            startP = startSeg.points[0];
-            endP = endSeg.points[endSeg.points.length - 1];
-        }
-        else {
-            startP = points[0];
-            endP = points[points.length - 1];
-        }
-        const xTotalLength = abs(endP.x - startP.x);
-        const yTotalLength = abs(endP.y - startP.y);
-        if (endP.x1 == null) {
-            direction = Direction.ROW;
-        }
-        else if (endP.y1 == null) {
-            direction = Direction.COLUMN;
-        }
-        else if (!Number.isFinite(xTotalLength + yTotalLength)) {
-            direction = Direction.ROW;
-        }
-        else {
-            direction = xTotalLength > yTotalLength ? Direction.ROW : Direction.COLUMN;
-        }
+        const direction = (_a = cache.direction) !== null && _a !== void 0 ? _a : cache.top.direction;
         drawAreaSegments(context, cache, clipRange, {
             offsetX,
             offsetY,
@@ -27270,6 +27326,21 @@ function createMiniappApp(options = {}) {
     return new MiniappEntry(options);
 }
 
+function previousPoint(segments, index, connectedType) {
+    for (let i = index - 1; i >= 0; i--) {
+        const points = segments[i].points;
+        for (let j = points.length - 1; j >= 0; j--) {
+            const point = points[j];
+            if (point.defined !== false) {
+                return point;
+            }
+            if (connectedType !== 'connect') {
+                return undefined;
+            }
+        }
+    }
+    return undefined;
+}
 class DefaultIncrementalCanvasAreaRender extends DefaultCanvasAreaRender {
     constructor() {
         super(...arguments);
@@ -27283,7 +27354,7 @@ class DefaultIncrementalCanvasAreaRender extends DefaultCanvasAreaRender {
                 return;
             }
             const areaAttribute = getTheme(area).area;
-            const { fill = areaAttribute.fill, fillOpacity = areaAttribute.fillOpacity, opacity = areaAttribute.opacity, visible = areaAttribute.visible } = area.attribute;
+            const { fill = areaAttribute.fill, fillOpacity = areaAttribute.fillOpacity, opacity = areaAttribute.opacity, visible = areaAttribute.visible, connectedType = areaAttribute.connectedType } = area.attribute;
             const fVisible = fillVisible(opacity, fillOpacity, fill);
             const doFill = runFill(fill);
             if (!(area.valid && visible)) {
@@ -27295,22 +27366,33 @@ class DefaultIncrementalCanvasAreaRender extends DefaultCanvasAreaRender {
             if (!(fVisible || fillCb)) {
                 return;
             }
-            for (let i = startAtIdx; i < startAtIdx + length; i++) {
-                this.drawIncreaseSegment(area, context, segments[i - 1], segments[i], area.attribute.segments[i], [areaAttribute, area.attribute], x, y);
+            const endIndex = Math.min(startAtIdx + length, segments.length);
+            for (let i = startAtIdx; i < endIndex; i++) {
+                if (!segments[i].points.some(p => p.defined !== false)) {
+                    continue;
+                }
+                this.drawIncreaseSegment(area, context, segments[i - 1], segments[i], area.attribute.segments[i], [areaAttribute, area.attribute], x, y, { connectedType, startPoint: previousPoint(segments, i, connectedType) });
             }
         }
         else {
             super.drawShape(area, context, x, y, drawContext, params, fillCb);
         }
     }
-    drawIncreaseSegment(area, context, lastSeg, seg, attribute, defaultAttribute, offsetX, offsetY) {
+    drawIncreaseSegment(area, context, lastSeg, seg, attribute, defaultAttribute, offsetX, offsetY, continuity) {
+        var _a, _b;
         if (!seg) {
             return;
         }
+        const connectedType = (_b = (_a = continuity === null || continuity === void 0 ? void 0 : continuity.connectedType) !== null && _a !== void 0 ? _a : area.attribute.connectedType) !== null && _b !== void 0 ? _b : getTheme(area).area.connectedType;
+        const startPoint = continuity
+            ? continuity.startPoint
+            : lastSeg && getAreaPointRuns(lastSeg.points, connectedType).tail;
         context.beginPath();
         drawIncrementalAreaSegments(context.camera ? context : context.nativeContext, lastSeg, seg, {
             offsetX,
-            offsetY
+            offsetY,
+            connectedType,
+            startPoint
         });
         context.setShadowBlendStyle && context.setShadowBlendStyle(area, attribute, defaultAttribute);
         context.setCommonStyle(area, attribute, offsetX, offsetY, defaultAttribute);

package/es/common/area-cache.d.ts

@@ -0,0 +1,11 @@
+import { type IPointLike } from '@visactor/vutils';
+import type { IAreaCacheItem, IAreaSegment, ICurveType, IDirection } from '../interface';
+export interface AreaRenderCacheItem extends IAreaCacheItem {
+    sourceSegmentIndex: number;
+    direction: IDirection;
+}
+export declare function getAreaPointRuns(points: IPointLike[], connectedType: 'none' | 'connect', startPoint?: IPointLike): {
+    runs: IPointLike[][];
+    tail: IPointLike;
+};
+export declare function calcAreaCache(points: IPointLike[] | undefined, segments: IAreaSegment[] | undefined, curveType: ICurveType, connectedType: 'none' | 'connect', curveTension: number): AreaRenderCacheItem | AreaRenderCacheItem[] | null;

package/es/common/area-cache.js

@@ -0,0 +1,113 @@
+import { abs } from "@visactor/vutils";
+
+import { Direction } from "./enums";
+
+import { calcLineCache } from "./segment";
+
+import { LineCurve } from "./segment/curve/line";
+
+export function getAreaPointRuns(points, connectedType, startPoint) {
+    const runs = [];
+    if (!points.some((p => !1 === p.defined))) {
+        const run = startPoint ? [ startPoint, ...points ] : points;
+        return run.length && runs.push(run), {
+            runs: runs,
+            tail: run[run.length - 1]
+        };
+    }
+    let run = startPoint ? [ startPoint ] : [];
+    for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        !1 !== point.defined ? run.push(point) : "connect" !== connectedType && (run.length && runs.push(run), 
+        run = []);
+    }
+    return run.length && runs.push(run), {
+        runs: runs,
+        tail: run[run.length - 1]
+    };
+}
+
+function joinAreaPaths(paths) {
+    var _a;
+    if (1 === paths.length) return paths[0];
+    const curves = [];
+    for (let i = 0; i < paths.length; i++) {
+        const next = paths[i].curves;
+        if (curves.length) {
+            const previous = curves[curves.length - 1], gap = new LineCurve(null !== (_a = previous.p3) && void 0 !== _a ? _a : previous.p1, next[0].p0);
+            gap.defined = !1, gap.originP1 = previous.originP2, gap.originP2 = next[0].originP1, 
+            curves.push(gap);
+        }
+        for (let j = 0; j < next.length; j++) curves.push(next[j]);
+    }
+    const path = paths[paths.length - 1];
+    return path.curves = curves, path.length = NaN, path;
+}
+
+function compileAreaRuns(runs, curveType, curveTension, sourceSegmentIndex, topStart, bottomStart) {
+    var _a, _b, _c, _d;
+    const tops = [], bottoms = [], bottomType = "stepBefore" === curveType ? "stepAfter" : "stepAfter" === curveType ? "stepBefore" : curveType;
+    for (let i = 0; i < runs.length; i++) {
+        const points = runs[i], startPoint = 0 === i ? topStart : void 0;
+        if (points.length < 2 - Number(!!startPoint)) continue;
+        const bottomPoints = [];
+        for (let j = points.length - 1; j >= 0; j--) {
+            const p = points[j];
+            bottomPoints.push({
+                x: null !== (_a = p.x1) && void 0 !== _a ? _a : p.x,
+                y: null !== (_b = p.y1) && void 0 !== _b ? _b : p.y
+            });
+        }
+        0 === i && bottomStart && bottomPoints.push({
+            x: null !== (_c = bottomStart.x1) && void 0 !== _c ? _c : bottomStart.x,
+            y: null !== (_d = bottomStart.y1) && void 0 !== _d ? _d : bottomStart.y
+        });
+        const top = calcLineCache(points, curveType, {
+            startPoint: startPoint,
+            curveTension: curveTension
+        }), bottom = calcLineCache(bottomPoints, bottomType, {
+            curveTension: curveTension
+        });
+        (null == top ? void 0 : top.curves.length) && (null == bottom ? void 0 : bottom.curves.length) && (tops.push(top), 
+        bottoms.push(bottom));
+    }
+    return tops.length ? {
+        top: joinAreaPaths(tops),
+        bottom: joinAreaPaths(bottoms.reverse()),
+        sourceSegmentIndex: sourceSegmentIndex,
+        direction: Direction.ROW
+    } : null;
+}
+
+export function calcAreaCache(points, segments, curveType, connectedType, curveTension) {
+    var _a;
+    const caches = [];
+    let tail, topTail, first, last;
+    const count = segments ? segments.length : 1;
+    for (let i = 0; i < count; i++) {
+        const segmentPoints = segments ? segments[i].points : null != points ? points : [], result = getAreaPointRuns(segmentPoints, connectedType), canContinue = "connect" === connectedType || !1 !== (null === (_a = segmentPoints[0]) || void 0 === _a ? void 0 : _a.defined);
+        if (result.runs.length) {
+            first = null != first ? first : result.runs[0][0];
+            const lastRun = result.runs[result.runs.length - 1];
+            last = lastRun[lastRun.length - 1];
+        }
+        const cache = compileAreaRuns(result.runs, curveType, curveTension, i, canContinue ? topTail : void 0, canContinue ? tail : void 0);
+        if (cache && caches.push(cache), result.tail) {
+            tail = result.tail;
+            const lastRun = result.runs[result.runs.length - 1];
+            topTail = cache && (1 === result.runs.length || lastRun.length > 1) ? {
+                x: cache.top.endX,
+                y: cache.top.endY
+            } : tail;
+        } else "connect" !== connectedType && segmentPoints.length && (tail = topTail = void 0);
+    }
+    if (!caches.length) return null;
+    let direction = Direction.ROW;
+    if (null != last.x1) {
+        const dx = abs(last.x - first.x), dy = abs(last.y - first.y);
+        (null == last.y1 || Number.isFinite(dx + dy) && dy >= dx) && (direction = Direction.COLUMN);
+    }
+    for (let i = 0; i < caches.length; i++) caches[i].direction = direction;
+    return segments ? caches : caches[0];
+}
+//# sourceMappingURL=area-cache.js.map