@inditextech/weave-sdk 0.55.1 → 0.56.0

package/dist/sdk.cjs

@@ -18239,6 +18239,9 @@ function memoize(fn) {
 		return result;
 	};
 }
+function isIOS() {
+	return /iPad|iPhone|iPod/.test(navigator.userAgent) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
+}
 
 //#endregion
 //#region src/actions/selection-tool/constants.ts
@@ -19542,8 +19545,8 @@ var WeaveNodesSelectionPlugin = class extends WeavePlugin {
 		let transformerAttrs = { ...this.config.selection };
 		const currentAttrs = this.tr.getAttrs();
 		Object.keys(currentAttrs).forEach((key) => {
-			if (["rotationSnaps", "enabledAnchors"].includes(key)) this.tr.setAttr(key, []);
-			else this.tr.setAttr(key, void 0);
+			if (["rotationSnaps", "enabledAnchors"].includes(key)) this.tr?.setAttr(key, []);
+			else this.tr?.setAttr(key, void 0);
 		});
 		if (nodesSelected === 1) {
 			transformerAttrs = (0, import_merge.default)(transformerAttrs, nodes[0].getTransformerProperties());
@@ -19554,8 +19557,8 @@ var WeaveNodesSelectionPlugin = class extends WeavePlugin {
 			for (const node of nodes) anchorsArrays.push(node.allowedAnchors());
 			transformerAttrs.enabledAnchors = intersectArrays(anchorsArrays);
 		}
-		this.tr.setAttrs(transformerAttrs);
-		this.tr.forceUpdate();
+		this.tr?.setAttrs(transformerAttrs);
+		this.tr?.forceUpdate();
 	}
 	setSelectedNodes(nodes) {
 		this.tr.setNodes(nodes);
@@ -20599,15 +20602,15 @@ var WeaveReconciler = class {
 					child,
 					beforeChild
 				}, "insertBefore ");
-				if (parentInstance instanceof konva.default.Layer) {
-					parentInstance.add(child);
-					const beforeChildZIndex = beforeChild.zIndex();
-					child.zIndex(beforeChildZIndex - 1);
-				}
-				if (parentInstance instanceof konva.default.Group) {
-					parentInstance.add(child);
-					const beforeChildZIndex = beforeChild.zIndex();
-					child.zIndex(beforeChildZIndex - 1);
+				if (parentInstance instanceof konva.default.Layer || parentInstance instanceof konva.default.Group) {
+					const children = parentInstance.getChildren();
+					const fromIndex = children.indexOf(child);
+					const toIndex = children.indexOf(beforeChild);
+					if (fromIndex === -1 || toIndex === -1) return;
+					children.splice(fromIndex, 1);
+					const adjustedIndex = fromIndex < toIndex ? toIndex - 1 : toIndex;
+					parentInstance.getChildren().splice(adjustedIndex, 0, child);
+					parentInstance.children = parentInstance.getChildren();
 				}
 			},
 			appendChild(parentInstance, child) {
@@ -21565,7 +21568,6 @@ var WeaveZIndexManager = class {
 	}
 	moveUp(instance) {
 		this.logger.debug(`Moving instance with id [${instance.getAttrs().id}], up one step of z-index`);
-		instance.moveUp();
 		const handler = this.instance.getNodeHandler(instance.getAttrs().nodeType);
 		if (handler) {
 			const nodeState = handler.serialize(instance);
@@ -21574,7 +21576,6 @@ var WeaveZIndexManager = class {
 	}
 	moveDown(instance) {
 		this.logger.debug(`Moving instance with id [${instance.getAttrs().id}], down one step of z-index`);
-		instance.moveDown();
 		const handler = this.instance.getNodeHandler(instance.getAttrs().nodeType);
 		if (handler) {
 			const nodeState = handler.serialize(instance);
@@ -21585,7 +21586,6 @@ var WeaveZIndexManager = class {
 		const nodes = Array.isArray(instances) ? instances : [instances];
 		const nodesDescending = nodes.toSorted((a, b) => b.zIndex() - a.zIndex());
 		for (const node of nodesDescending) {
-			node.moveToBottom();
 			const handler = this.instance.getNodeHandler(node.getAttrs().nodeType);
 			if (handler) {
 				const nodeState = handler.serialize(node);
@@ -21597,7 +21597,6 @@ var WeaveZIndexManager = class {
 		const nodes = Array.isArray(instances) ? instances : [instances];
 		const nodesAscending = nodes.toSorted((a, b) => a.zIndex() - b.zIndex());
 		for (const node of nodesAscending) {
-			node.moveToTop();
 			const handler = this.instance.getNodeHandler(node.getAttrs().nodeType);
 			if (handler) {
 				const nodeState = handler.serialize(node);
@@ -21924,7 +21923,7 @@ var WeaveRegisterManager = class {
 
 //#endregion
 //#region package.json
-var version = "0.55.1";
+var version = "0.56.0";
 
 //#endregion
 //#region src/managers/setup.ts
@@ -22125,6 +22124,25 @@ var WeaveStoreManager = class {
 	}
 };
 
+//#endregion
+//#region src/plugins/stage-grid/constants.ts
+const WEAVE_STAGE_GRID_KEY = "stageGrid";
+const WEAVE_GRID_TYPES = {
+	["LINES"]: "lines",
+	["DOTS"]: "dots"
+};
+const WEAVE_GRID_DEFAULT_SIZE = 50;
+const WEAVE_GRID_DEFAULT_TYPE = WEAVE_GRID_TYPES.LINES;
+const WEAVE_GRID_DEFAULT_COLOR = "rgba(0,0,0,0.1)";
+const WEAVE_GRID_DEFAULT_ORIGIN_COLOR = "rgba(255,0,0,0.1)";
+const WEAVE_GRID_DEFAULT_STROKE = .5;
+const WEAVE_GRID_DEFAULT_MAJOR_LINE_RATIO = 4;
+const WEAVE_GRID_DEFAULT_RADIUS = 1;
+const WEAVE_GRID_DEFAULT_MAJOR_DOT_RATIO = 2;
+const WEAVE_GRID_DEFAULT_MAJOR_EVERY = 10;
+const WEAVE_GRID_DEFAULT_DOT_MAX_DOTS_PER_AXIS = 250;
+const WEAVE_GRID_LAYER_ID = "gridLayer";
+
 //#endregion
 //#region src/managers/export.ts
 var WeaveExportManager = class {
@@ -22133,9 +22151,30 @@ var WeaveExportManager = class {
 		this.logger = this.instance.getChildLogger("export-manager");
 		this.logger.debug("Export manager created");
 	}
+	fitKonvaPixelRatio(sw, sh, targetPR = 1, maxArea = 16777216) {
+		if (sw <= 0 || sh <= 0) return {
+			pixelRatio: 0,
+			outW: 0,
+			outH: 0
+		};
+		const desiredArea = sw * sh * targetPR * targetPR;
+		let pr = targetPR;
+		if (desiredArea > maxArea) pr = Math.sqrt(maxArea / (sw * sh));
+		const outW = Math.max(1, Math.floor(sw * pr));
+		const outH = Math.max(1, Math.floor(sh * pr));
+		return {
+			pixelRatio: pr,
+			outW,
+			outH
+		};
+	}
 	exportNodes(nodes, boundingNodes, options) {
 		return new Promise((resolve) => {
 			const { format: format$2 = __inditextech_weave_types.WEAVE_EXPORT_FORMATS.PNG, padding = 0, pixelRatio = 1, backgroundColor = __inditextech_weave_types.WEAVE_EXPORT_BACKGROUND_COLOR } = options;
+			this.getNodesSelectionPlugin()?.disable();
+			this.getNodesDistanceSnappingPlugin()?.disable();
+			this.getNodesEdgeSnappingPlugin()?.disable();
+			this.getStageGridPlugin()?.disable();
 			const stage = this.instance.getStage();
 			const mainLayer = this.instance.getMainLayer();
 			const originalPosition = {
@@ -22181,19 +22220,25 @@ var WeaveExportManager = class {
 				}
 				mainLayer.add(exportGroup);
 				const backgroundRect = background.getClientRect();
+				stage.batchDraw();
+				const { pixelRatio: finalPixelRatio } = this.fitKonvaPixelRatio(Math.round(backgroundRect.width), Math.round(backgroundRect.height), pixelRatio);
 				exportGroup.toImage({
 					x: Math.round(backgroundRect.x),
 					y: Math.round(backgroundRect.y),
 					width: Math.round(backgroundRect.width),
 					height: Math.round(backgroundRect.height),
 					mimeType: format$2,
-					pixelRatio,
+					pixelRatio: finalPixelRatio,
 					quality: options.quality ?? 1,
 					callback: (img) => {
 						exportGroup.destroy();
 						stage.position(originalPosition);
 						stage.scale(originalScale);
 						stage.batchDraw();
+						this.getNodesSelectionPlugin()?.enable();
+						this.getNodesDistanceSnappingPlugin()?.enable();
+						this.getNodesEdgeSnappingPlugin()?.enable();
+						this.getStageGridPlugin()?.enable();
 						resolve(img);
 					}
 				});
@@ -22211,6 +22256,22 @@ var WeaveExportManager = class {
 		canvas.remove();
 		return URL;
 	}
+	getNodesSelectionPlugin() {
+		const selectionPlugin = this.instance.getPlugin(WEAVE_NODES_SELECTION_KEY);
+		return selectionPlugin;
+	}
+	getStageGridPlugin() {
+		const gridPlugin = this.instance.getPlugin(WEAVE_STAGE_GRID_KEY);
+		return gridPlugin;
+	}
+	getNodesEdgeSnappingPlugin() {
+		const snappingPlugin = this.instance.getPlugin(WEAVE_NODES_EDGE_SNAPPING_PLUGIN_KEY);
+		return snappingPlugin;
+	}
+	getNodesDistanceSnappingPlugin() {
+		const snappingPlugin = this.instance.getPlugin(WEAVE_NODES_DISTANCE_SNAPPING_PLUGIN_KEY);
+		return snappingPlugin;
+	}
 };
 
 //#endregion
@@ -25025,6 +25086,11 @@ var WeaveFrameNode = class extends WeaveNode {
 //#endregion
 //#region src/nodes/stroke/constants.ts
 const WEAVE_STROKE_NODE_TYPE = "stroke";
+const WEAVE_STROKE_NODE_DEFAULT_CONFIG = {
+	smoothingFactor: .1,
+	resamplingSpacing: 2,
+	pressureScale: 1
+};
 
 //#endregion
 //#region src/nodes/stroke/stroke.ts
@@ -25033,45 +25099,145 @@ var WeaveStrokeNode = class extends WeaveNode {
 	constructor(params) {
 		super();
 		const { config } = params ?? {};
-		this.config = { transform: { ...config?.transform } };
+		this.config = (0, import_merge.default)(WEAVE_STROKE_NODE_DEFAULT_CONFIG, config);
+	}
+	resamplePoints(pts, spacing) {
+		if (pts.length < 2) return pts;
+		const resampled = [pts[0]];
+		for (let i = 1; i < pts.length; i++) {
+			let last = resampled[resampled.length - 1];
+			const current = pts[i];
+			const segDist = this.dist(last, current);
+			if (segDist === 0) continue;
+			let remaining = segDist;
+			while (remaining >= spacing) {
+				const t = spacing / segDist;
+				const newPt = this.lerpPoint(last, current, t);
+				resampled.push(newPt);
+				last = newPt;
+				remaining = this.dist(last, current);
+			}
+		}
+		return resampled;
+	}
+	dist(a, b) {
+		const dx = b.x - a.x, dy = b.y - a.y;
+		return Math.hypot(dx, dy);
 	}
-	drawStroke(strokeElements, prevLineWidth, context, shape) {
-		const strokeWidth = shape.getAttrs().strokeWidth ?? 1;
-		const l = strokeElements.length - 1;
-		if (strokeElements.length >= 3) {
-			const prevPoint = strokeElements[l - 1];
-			const actualPoint = strokeElements[l];
-			const xc = (actualPoint.x + prevPoint.x) / 2;
-			const yc = (actualPoint.y + prevPoint.y) / 2;
-			context.lineWidth = Math.log(actualPoint.pressure + 1) * strokeWidth + prevLineWidth * .8;
-			context.quadraticCurveTo(strokeElements[l - 1].x, strokeElements[l - 1].y, xc, yc);
-			return context.lineWidth;
-		} else {
-			const point = strokeElements[l];
-			context.lineWidth = Math.log(point.pressure + 1) * strokeWidth;
-			return context.lineWidth;
+	lerpPoint(a, b, t) {
+		return {
+			x: a.x + (b.x - a.x) * t,
+			y: a.y + (b.y - a.y) * t,
+			pressure: a.pressure + (b.pressure - a.pressure) * t
+		};
+	}
+	buildPolygonFromPressure(pts, baseWidth) {
+		if (pts.length < 2) return [];
+		const left = [];
+		const right = [];
+		for (let i = 0; i < pts.length; i++) {
+			const p = pts[i];
+			const w = (baseWidth + p.pressure * this.config.pressureScale) / 2;
+			let dx, dy;
+			if (i === 0) {
+				dx = pts[1].x - p.x;
+				dy = pts[1].y - p.y;
+			} else if (i === pts.length - 1) {
+				dx = p.x - pts[i - 1].x;
+				dy = p.y - pts[i - 1].y;
+			} else {
+				dx = pts[i + 1].x - pts[i - 1].x;
+				dy = pts[i + 1].y - pts[i - 1].y;
+			}
+			const len = Math.hypot(dx, dy) || 1;
+			const nx = -dy / len;
+			const ny = dx / len;
+			left.push({
+				x: p.x + nx * w,
+				y: p.y + ny * w
+			});
+			right.push({
+				x: p.x - nx * w,
+				y: p.y - ny * w
+			});
 		}
+		const reversed = right.toReversed();
+		return left.concat(reversed);
+	}
+	dashSegments(pts, pattern) {
+		const segments = [];
+		let patIndex = 0;
+		let patDist = pattern[patIndex];
+		let draw = true;
+		let segPts = [pts[0]];
+		for (let i = 1; i < pts.length; i++) {
+			let d = this.dist(pts[i - 1], pts[i]);
+			while (d >= patDist) {
+				const t = patDist / d;
+				const mid = this.lerpPoint(pts[i - 1], pts[i], t);
+				segPts.push(mid);
+				if (draw) segments.push(segPts);
+				draw = !draw;
+				patIndex = (patIndex + 1) % pattern.length;
+				patDist = pattern[patIndex];
+				segPts = [mid];
+				d -= patDist;
+				pts[i - 1] = mid;
+			}
+			segPts.push(pts[i]);
+			patDist -= d;
+		}
+		if (draw && segPts.length > 1) segments.push(segPts);
+		return segments;
+	}
+	catmullRomSpline(pts, spacing) {
+		const curvePoints = [];
+		for (let i = 0; i < pts.length - 1; i++) {
+			const p0 = pts[i - 1] || pts[i];
+			const p1 = pts[i];
+			const p2 = pts[i + 1];
+			const p3 = pts[i + 2] || p2;
+			for (let t = 0; t < 1; t += spacing) {
+				const t2 = t * t;
+				const t3 = t2 * t;
+				const x = .5 * (2 * p1.x + (-p0.x + p2.x) * t + (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 + (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3);
+				const y = .5 * (2 * p1.y + (-p0.y + p2.y) * t + (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 + (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3);
+				const pressure = .5 * (2 * p1.pressure + (-p0.pressure + p2.pressure) * t + (2 * p0.pressure - 5 * p1.pressure + 4 * p2.pressure - p3.pressure) * t2 + (-p0.pressure + 3 * p1.pressure - 3 * p2.pressure + p3.pressure) * t3);
+				curvePoints.push({
+					x,
+					y,
+					pressure
+				});
+			}
+		}
+		return curvePoints;
 	}
 	onRender(props) {
 		const stroke = new konva.default.Shape({
 			...props,
 			name: "node",
-			sceneFunc: (context, shape) => {
-				context.beginPath();
-				context.strokeStyle = shape.getAttrs().stroke ?? "black";
-				context.setLineDash(shape.getAttrs().dash || []);
-				context.lineCap = shape.getAttrs().lineCap ?? "round";
-				context.lineJoin = shape.getAttrs().lineJoin ?? "round";
+			sceneFunc: (ctx, shape) => {
 				const strokeElements = shape.getAttrs().strokeElements;
 				if (strokeElements.length === 0) return;
-				context.moveTo(strokeElements[0].x, strokeElements[0].y);
-				let prevLineWidth = 0;
-				const strokePath = [];
-				strokeElements.forEach((point) => {
-					strokePath.push(point);
-					prevLineWidth = this.drawStroke(strokePath, prevLineWidth, context, shape);
+				if (strokeElements.length < 2) return;
+				const color = shape.getAttrs().stroke ?? "black";
+				const strokeWidth = shape.getAttrs().strokeWidth ?? 1;
+				const smoothPoints = this.catmullRomSpline(strokeElements, this.config.smoothingFactor);
+				const evenlySpaced = this.resamplePoints(smoothPoints, this.config.resamplingSpacing);
+				const dashes = this.dashSegments(evenlySpaced, shape.getAttrs().dash || []);
+				dashes.forEach((segment) => {
+					const poly = this.buildPolygonFromPressure(segment, strokeWidth);
+					if (!poly.length) return;
+					ctx.beginPath();
+					ctx.moveTo(poly[0].x, poly[0].y);
+					for (let i = 1; i < poly.length; i++) ctx.lineTo(poly[i].x, poly[i].y);
+					ctx.strokeStyle = color;
+					ctx.lineCap = shape.getAttrs().lineCap ?? "butt";
+					ctx.lineJoin = shape.getAttrs().lineJoin ?? "miter";
+					ctx.closePath();
+					ctx.fillStyle = color;
+					ctx.fill();
 				});
-				context.strokeShape(shape);
 			},
 			dashEnabled: false,
 			hitFunc: (context, shape) => {
@@ -26602,15 +26768,18 @@ const BRUSH_TOOL_STATE = {
 	["IDLE"]: "idle",
 	["DEFINE_STROKE"]: "defineStroke"
 };
+const BRUSH_TOOL_DEFAULT_CONFIG = { interpolationSteps: 10 };
 
 //#endregion
 //#region src/actions/brush-tool/brush-tool.ts
 var WeaveBrushToolAction = class extends WeaveAction {
 	initialized = false;
+	rawPoints = [];
 	onPropsChange = void 0;
 	onInit = void 0;
-	constructor() {
+	constructor(params) {
 		super();
+		this.config = (0, import_merge.default)(BRUSH_TOOL_DEFAULT_CONFIG, params?.config ?? {});
 		this.initialized = false;
 		this.state = BRUSH_TOOL_STATE.INACTIVE;
 		this.strokeId = null;
@@ -26655,7 +26824,8 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			this.handleStartStroke(pointPressure);
 			e.evt.stopPropagation();
 		};
-		stage.on("pointerdown touchstart", handlePointerDown);
+		if (isIOS()) stage.on("touchstart", handlePointerDown);
+		else stage.on("pointerdown", handlePointerDown);
 		const handlePointerMove = (e) => {
 			if (this.state !== BRUSH_TOOL_STATE.DEFINE_STROKE) return;
 			if (this.getZoomPlugin()?.isPinching()) return;
@@ -26664,14 +26834,16 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			this.handleMovement(pointPressure);
 			e.evt.stopPropagation();
 		};
-		stage.on("pointermove touchmove", handlePointerMove);
+		if (isIOS()) stage.on("touchmove", handlePointerMove);
+		else stage.on("pointermove", handlePointerMove);
 		const handlePointerUp = (e) => {
 			if (this.state !== BRUSH_TOOL_STATE.DEFINE_STROKE) return;
 			if (this.getZoomPlugin()?.isPinching()) return;
 			this.handleEndStroke();
 			e.evt.stopPropagation();
 		};
-		stage.on("pointerup touchend", handlePointerUp);
+		if (isIOS()) stage.on("touchend", handlePointerUp);
+		else stage.on("pointerup", handlePointerUp);
 		this.initialized = true;
 	}
 	setState(state) {
@@ -26729,17 +26901,44 @@ var WeaveBrushToolAction = class extends WeaveAction {
 		}
 		this.setState(BRUSH_TOOL_STATE.DEFINE_STROKE);
 	}
+	catmullRom1D(p0, p1, p2, p3, t) {
+		const t2 = t * t;
+		const t3 = t2 * t;
+		return .5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3 * p1 - 3 * p2 + p3) * t3);
+	}
+	smoothInterpolation(last4Points, steps) {
+		const [p0, p1, p2, p3] = last4Points;
+		const pts = [];
+		for (let i = 0; i <= steps; i++) {
+			const t = i / steps;
+			pts.push({
+				x: this.catmullRom1D(p0.x, p1.x, p2.x, p3.x, t),
+				y: this.catmullRom1D(p0.y, p1.y, p2.y, p3.y, t),
+				pressure: this.catmullRom1D(p0.pressure, p1.pressure, p2.pressure, p3.pressure, t)
+			});
+		}
+		return pts;
+	}
 	handleMovement(pressure) {
 		if (this.state !== BRUSH_TOOL_STATE.DEFINE_STROKE) return;
 		const tempStroke = this.instance.getStage().findOne(`#${this.strokeId}`);
 		if (this.measureContainer && tempStroke) {
 			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.measureContainer);
-			const newStrokeElements = [...tempStroke.getAttrs().strokeElements];
-			newStrokeElements.push({
+			const currentPoint = {
 				x: mousePoint.x - tempStroke.x(),
 				y: mousePoint.y - tempStroke.y(),
 				pressure
-			});
+			};
+			this.rawPoints.push(currentPoint);
+			let newStrokeElements = [...tempStroke.getAttrs().strokeElements];
+			const smoothPoints = [];
+			if (isIOS()) if (this.rawPoints.length >= 4) {
+				const last4 = this.rawPoints.slice(-4);
+				const interpolatedPts = this.smoothInterpolation(last4, this.config.interpolationSteps);
+				smoothPoints.push(...interpolatedPts);
+			} else smoothPoints.push(currentPoint);
+			else smoothPoints.push(currentPoint);
+			newStrokeElements = [...newStrokeElements, ...smoothPoints];
 			const box = this.getBoundingBox(newStrokeElements);
 			tempStroke.setAttrs({
 				width: box.width,
@@ -26776,6 +26975,7 @@ var WeaveBrushToolAction = class extends WeaveAction {
 				if (realNode) realNode.destroy();
 				if (tempStroke.getAttrs().strokeElements.length >= 3) this.instance.addNode(nodeHandler.serialize(tempStroke), this.container?.getAttrs().id);
 			}
+			this.rawPoints = [];
 			this.clickPoint = null;
 			stage.container().style.cursor = "crosshair";
 			stage.container().tabIndex = 1;
@@ -26811,6 +27011,7 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			if (node) selectionPlugin.setSelectedNodes([node]);
 			this.instance.triggerAction(SELECTION_TOOL_ACTION_NAME);
 		}
+		this.rawPoints = [];
 		this.clickPoint = null;
 		this.setState(BRUSH_TOOL_STATE.INACTIVE);
 	}
@@ -28041,25 +28242,6 @@ var WeaveAlignNodesToolAction = class extends WeaveAction {
 	}
 };
 
-//#endregion
-//#region src/plugins/stage-grid/constants.ts
-const WEAVE_STAGE_GRID_KEY = "stageGrid";
-const WEAVE_GRID_TYPES = {
-	["LINES"]: "lines",
-	["DOTS"]: "dots"
-};
-const WEAVE_GRID_DEFAULT_SIZE = 50;
-const WEAVE_GRID_DEFAULT_TYPE = WEAVE_GRID_TYPES.LINES;
-const WEAVE_GRID_DEFAULT_COLOR = "rgba(0,0,0,0.1)";
-const WEAVE_GRID_DEFAULT_ORIGIN_COLOR = "rgba(255,0,0,0.1)";
-const WEAVE_GRID_DEFAULT_STROKE = .5;
-const WEAVE_GRID_DEFAULT_MAJOR_LINE_RATIO = 4;
-const WEAVE_GRID_DEFAULT_RADIUS = 1;
-const WEAVE_GRID_DEFAULT_MAJOR_DOT_RATIO = 2;
-const WEAVE_GRID_DEFAULT_MAJOR_EVERY = 10;
-const WEAVE_GRID_DEFAULT_DOT_MAX_DOTS_PER_AXIS = 250;
-const WEAVE_GRID_LAYER_ID = "gridLayer";
-
 //#endregion
 //#region src/plugins/stage-grid/stage-grid.ts
 var WeaveStageGridPlugin = class extends WeavePlugin {
@@ -29833,6 +30015,7 @@ exports.ALIGN_NODES_TOOL_STATE = ALIGN_NODES_TOOL_STATE
 exports.ARROW_TOOL_ACTION_NAME = ARROW_TOOL_ACTION_NAME
 exports.ARROW_TOOL_STATE = ARROW_TOOL_STATE
 exports.BRUSH_TOOL_ACTION_NAME = BRUSH_TOOL_ACTION_NAME
+exports.BRUSH_TOOL_DEFAULT_CONFIG = BRUSH_TOOL_DEFAULT_CONFIG
 exports.BRUSH_TOOL_STATE = BRUSH_TOOL_STATE
 exports.COPY_PASTE_NODES_PLUGIN_STATE = COPY_PASTE_NODES_PLUGIN_STATE
 exports.ELLIPSE_TOOL_ACTION_NAME = ELLIPSE_TOOL_ACTION_NAME
@@ -29908,6 +30091,7 @@ exports.WEAVE_STAGE_DEFAULT_MODE = WEAVE_STAGE_DEFAULT_MODE
 exports.WEAVE_STAGE_GRID_KEY = WEAVE_STAGE_GRID_KEY
 exports.WEAVE_STAGE_NODE_TYPE = WEAVE_STAGE_NODE_TYPE
 exports.WEAVE_STAR_NODE_TYPE = WEAVE_STAR_NODE_TYPE
+exports.WEAVE_STROKE_NODE_DEFAULT_CONFIG = WEAVE_STROKE_NODE_DEFAULT_CONFIG
 exports.WEAVE_STROKE_NODE_TYPE = WEAVE_STROKE_NODE_TYPE
 exports.WEAVE_TEXT_NODE_TYPE = WEAVE_TEXT_NODE_TYPE
 exports.WEAVE_USERS_POINTERS_KEY = WEAVE_USERS_POINTERS_KEY
@@ -29981,6 +30165,7 @@ exports.getVisibleNodesInViewport = getVisibleNodesInViewport
 exports.hasFrames = hasFrames
 exports.hasImages = hasImages
 exports.intersectArrays = intersectArrays
+exports.isIOS = isIOS
 exports.isInShadowDOM = isInShadowDOM
 exports.isNodeInSelection = isNodeInSelection
 exports.memoize = memoize