ebta-workflow-prod 4.1.4 → 4.1.5

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "ebta-workflow-prod",
     "private": false,
-    "version": "4.1.4",
+    "version": "4.1.5",
     "description": "",
     "license": "UNLICENSED",
     "author": "",

package/src/elements/CsColorPicker.tsx

@@ -4,9 +4,9 @@ import { FormElementProps, FormElementRegistration  } from "@vertigis/workflow";
 import { ColorInput, ColorPicker } from '@mantine/core';
 type ColorFormat = "hex" | "rgba" | "rgb" | "hsl" | "hsla";
 
-//import "@mantine/core/styles.css";
+import "@mantine/core/styles.css";
 //Causing shrink
-import "../styles/mantine-scoped.css";
+//import "../styles/mantine-scoped.css";
 import Color from "@arcgis/core/Color";
 
 
@@ -80,7 +80,7 @@ function CsColorPickerV2(props: CsColorPickerV2Props): React.ReactElement {
     };
 
     return (
-        <div className="vertigis-mantine-scope">
+
         <MantineProvider withStaticClasses withGlobalClasses classNamesPrefix="ebta-mantime">
             {componentType === "ColorInput" ? (
                 <ColorInput
@@ -107,7 +107,6 @@ function CsColorPickerV2(props: CsColorPickerV2Props): React.ReactElement {
                 />
             )}
         </MantineProvider>
-        </div>
     );
 }
 

package/src/elements/Timeline.tsx

@@ -2,7 +2,7 @@ import * as React from "react";
 import { FormElementProps, FormElementRegistration } from "@vertigis/workflow";
 import { Timeline as MainTimeLine, Text } from '@mantine/core';
 import { MantineProvider } from '@mantine/core';
-import "../styles/mantine-scoped.css";
+//import "../styles/mantine-scoped.css";
 
 /**
  * The generic type argument provided to `FormElementProps<T>` controls the type
@@ -41,7 +41,7 @@ function Timeline(props: TimelineProps): React.ReactElement {
     const { itemDetails, iconSize, lineWidth, active, color, reverseActive } = props;
     iconSize * 0.6
     return (
-        <div className="vertigis-mantine-scope">
+
             <MantineProvider>
                 <MainTimeLine active={active} bulletSize={iconSize} lineWidth={lineWidth} color={color} reverseActive={reverseActive}>
 
@@ -64,7 +64,6 @@ function Timeline(props: TimelineProps): React.ReactElement {
                 </MainTimeLine>
 
             </MantineProvider>
-        </div>
     );
 }
 

package/src/index.ts

@@ -41,6 +41,3 @@ export { default as DrapGeometryActivity } from "./activities/DrapGeometry";
 export { default as SampleActivity } from "./activities/Sample";
 export { default as SampleInputRegistration } from "./elements/SampleInput";
 
-
-
-export { default as SimplifyGeometryActivity } from "./activities/SimplifyGeometry";

package/src/activities/SimplifyGeometry.ts

@@ -1,239 +0,0 @@
-import type { IActivityHandler } from "@vertigis/workflow";
-
-import Polygon from "@arcgis/core/geometry/Polygon";
-import SpatialReference from "@arcgis/core/geometry/SpatialReference";
-
-
-/** An interface that defines the inputs of the activity. */
-interface SimplifyGeometryInputs {
-    /**
-     * @displayName Geometry
-     * @description The geometry to be simplified.
-     * @required
-     */
-    geometry: Polygon;
-
-    /**
-     * @displayName Vertex Limit
-     * @description The maximum number of vertices allowed in the simplified geometry.
-     */
-    vertlimit?: number;
-}
-
-/** An interface that defines the outputs of the activity. */
-interface SimplifyGeometryOutputs {
-    /**
-     * @description The result of the activity.
-     */
-    result: Polygon;
-}
-
-/**
- * @displayName SimplifyGeometry
- * @category Custom Activities
- * @description Simplify geometry - covering the whole geometry and increase minimum extra area, under required vertex amount.
- */
-export default class SimplifyGeometryActivity implements IActivityHandler {
-    /** Perform the execution logic of the activity. */
-
-    execute(inputs: SimplifyGeometryInputs): SimplifyGeometryOutputs {
-
-        // Clone the whole result so we never touch the original $permitFeature.result
-        let simplifyresult = inputs.geometry;
-        let limit = inputs.vertlimit || 30;
-
-        let ring = simplifyresult.rings[0];
-
-        if (ring.length > limit) {
-            ring = coveringSimplify(ring, limit);
-
-            simplifyresult.rings[0] = ring;
-        }
-
-        return { result: simplifyresult };
-
-
-
-
-        // ---- geometry helpers ----
-        function cross(o, a, b) {
-            return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
-        }
-        function triangleArea(a, b, c) {
-            return Math.abs(cross(a, b, c)) / 2;
-        }
-        function signedArea(points) {
-            var area = 0, n = points.length;
-            for (var i = 0; i < n; i++) {
-                var p1 = points[i], p2 = points[(i + 1) % n];
-                area += p1[0] * p2[1] - p2[0] * p1[1];
-            }
-            return area / 2;
-        }
-
-        // orientation: >0 CCW turn, <0 CW turn, 0 collinear
-        function orient(a, b, c) {
-            var v = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
-            if (v > 1e-9) return 1;
-            if (v < -1e-9) return -1;
-            return 0;
-        }
-
-        // true only for a PROPER crossing (interior intersection), not shared endpoints/touching
-        function properlyIntersects(p1, p2, p3, p4) {
-            var d1 = orient(p3, p4, p1);
-            var d2 = orient(p3, p4, p2);
-            var d3 = orient(p1, p2, p3);
-            var d4 = orient(p1, p2, p4);
-            return (d1 !== d2 && d1 !== 0 && d2 !== 0) && (d3 !== d4 && d3 !== 0 && d4 !== 0);
-        }
-
-        // does chording out vertex i (prev->next) cross any OTHER edge of
-        // the polygon? Required check — without it, concave removal can
-        // fold the polygon over itself into a self-intersecting bowtie on
-        // complex shapes (forks, interchanges, multiple concavities).
-        function chordIsSafe(pts, i) {
-            var n = pts.length;
-            var prev = pts[(i - 1 + n) % n];
-            var next = pts[(i + 1) % n];
-
-            for (var k = 0; k < n; k++) {
-                var a = pts[k];
-                var b = pts[(k + 1) % n];
-                if (k === (i - 1 + n) % n || k === i) continue; // the two edges being replaced
-                if (properlyIntersects(prev, next, a, b)) return false;
-            }
-            return true;
-        }
-
-        // Remove reflex (concave) vertices, cheapest-area first, but only
-        // when the resulting chord doesn't self-intersect the polygon.
-        // Chording a safe concave notch always ADDS area outside the
-        // original shape, so coverage is preserved automatically.
-        function removeReflexVertices(points, maxVertices) {
-            var pts = points.slice();
-            var orientSign = signedArea(pts) >= 0 ? 1 : -1;
-
-            var progress = true;
-            while (pts.length > maxVertices && progress) {
-                progress = false;
-                var n = pts.length;
-                var candidates = [];
-
-                for (var i = 0; i < n; i++) {
-                    var prev = pts[(i - 1 + n) % n];
-                    var curr = pts[i];
-                    var next = pts[(i + 1) % n];
-                    var c = cross(prev, curr, next);
-                    var isReflexOrFlat = c * orientSign <= 1e-9;
-                    if (isReflexOrFlat) {
-                        candidates.push({ idx: i, area: triangleArea(prev, curr, next) });
-                    }
-                }
-
-                candidates.sort(function (a, b) { return a.area - b.area; });
-
-                for (var ci = 0; ci < candidates.length; ci++) {
-                    var idx = candidates[ci].idx;
-                    if (chordIsSafe(pts, idx)) {
-                        pts.splice(idx, 1);
-                        progress = true;
-                        break; // recompute fresh each removal since indices shift
-                    }
-                }
-            }
-
-            return pts;
-        }
-
-        // Infinite-line intersection of (p1,p2) and (p3,p4).
-        function lineIntersection(p1, p2, p3, p4) {
-            var x1 = p1[0], y1 = p1[1], x2 = p2[0], y2 = p2[1];
-            var x3 = p3[0], y3 = p3[1], x4 = p4[0], y4 = p4[1];
-            var denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
-            if (Math.abs(denom) < 1e-9) return [(x2 + x3) / 2, (y2 + y3) / 2];
-            var pxNum = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4);
-            var pyNum = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4);
-            return [pxNum / denom, pyNum / denom];
-        }
-
-        // Standard monotone-chain convex hull — guaranteed simple and
-        // guaranteed to cover any input point set, regardless of how tangled
-        // the remaining shape is. Used as a safe fallback.
-        function convexHull(points) {
-            var sorted = points.slice().sort(function (a, b) { return a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]; });
-            var pts = [];
-            for (var i = 0; i < sorted.length; i++) {
-                var p = sorted[i], prev = pts[pts.length - 1];
-                if (!prev || prev[0] !== p[0] || prev[1] !== p[1]) pts.push(p);
-            }
-            var n = pts.length;
-            if (n < 3) return pts.slice();
-            var lower = [];
-            for (var i2 = 0; i2 < n; i2++) {
-                while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], pts[i2]) <= 0) lower.pop();
-                lower.push(pts[i2]);
-            }
-            var upper = [];
-            for (var i3 = n - 1; i3 >= 0; i3--) {
-                while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], pts[i3]) <= 0) upper.pop();
-                upper.push(pts[i3]);
-            }
-            lower.pop(); upper.pop();
-            return lower.concat(upper);
-        }
-
-        // Reduce an already-convex polygon to maxVertices by selecting
-        // maxVertices of its edges (evenly spaced) as infinite support lines
-        // and intersecting consecutive ones. Always contains the input.
-        function reduceConvexBySupportLines(points, maxVertices) {
-            var n = points.length;
-            if (n <= maxVertices) return points.slice();
-            var chosen = [];
-            for (var k = 0; k < maxVertices; k++) chosen.push(Math.floor((k * n) / maxVertices));
-            var newPts = [];
-            for (var k2 = 0; k2 < maxVertices; k2++) {
-                var iPrevEdge = chosen[(k2 - 1 + maxVertices) % maxVertices];
-                var iCurrEdge = chosen[k2];
-                var a1 = points[iPrevEdge], a2 = points[(iPrevEdge + 1) % n];
-                var b1 = points[iCurrEdge], b2 = points[(iCurrEdge + 1) % n];
-                newPts.push(lineIntersection(a1, a2, b1, b2));
-            }
-            return newPts;
-        }
-
-        // Simplify a ring to at most maxVertices points, guaranteeing the
-        // result is both SIMPLE (no self-intersections) and always covers
-        // (contains) the original shape.
-        function coveringSimplify(ring, maxVertices) {
-            var first = ring[0], last = ring[ring.length - 1];
-            var isClosed = first[0] === last[0] && first[1] === last[1];
-            var open = isClosed ? ring.slice(0, ring.length - 1) : ring.slice();
-            var budgetOpen = isClosed ? maxVertices - 1 : maxVertices;
-
-            if (open.length <= budgetOpen) return ring.slice();
-
-            var afterReflex = removeReflexVertices(open, budgetOpen);
-
-            var result;
-            if (afterReflex.length > budgetOpen) {
-                // Couldn't safely get all the way there via reflex removal
-                // (or the remainder is genuinely convex) — fall back to the
-                // convex hull, which is always simple and always covers.
-                var hull = convexHull(afterReflex);
-                result = hull.length > budgetOpen
-                    ? reduceConvexBySupportLines(hull, budgetOpen)
-                    : hull;
-            } else {
-                result = afterReflex;
-            }
-
-            return isClosed ? result.concat([result[0]]) : result;
-        }
-
-
-        return {
-            result: simplifyresult
-        };
-    }
-}