geomui 0.5.52 → 0.5.56

package/dist/Drawing.svelte

@@ -1,235 +1,269 @@
-<script>import TimeControl from "./TimeControl.svelte";
-import ZoomControl from "./ZoomControl.svelte";
-import LabelCheckbox from "./LabelCheckbox.svelte";
-import {
-  colors,
-  canvas2point,
-  adjustCenter,
-  adjustRect,
-  adjustScale,
-  adjustTranslate,
-  mergeFaces
-} from "geometrix";
-import { storePV } from "./storePVal";
-import { dLayers } from "./drawingLayers";
-import { onMount } from "svelte";
-export let pDef;
-export let fgeom;
-export let optFaces;
-export let selFace;
-export let zAdjust;
-export let simTime = 0;
-const c_ParametrixAll = "ParametrixAll";
-let windowWidth;
-let canvasFull;
-let canvasZoom;
-const canvas_size_min = 400;
-let aFigure;
-let cAdjust;
-function canvasRedrawFull(iLayers) {
-  const ctx1 = canvasFull.getContext("2d");
-  ctx1.clearRect(0, 0, ctx1.canvas.width, ctx1.canvas.height);
-  try {
-    cAdjust = aFigure.getAdjustFull(ctx1.canvas.width, ctx1.canvas.height);
-    aFigure.draw(ctx1, cAdjust, iLayers);
-  } catch (emsg) {
-    console.log(emsg);
-  }
-}
-function canvasRedrawZoom(iLayers) {
-  const ctx2 = canvasZoom.getContext("2d");
-  ctx2.clearRect(0, 0, ctx2.canvas.width, ctx2.canvas.height);
-  try {
-    if (zAdjust === void 0 || zAdjust.init === 0) {
-      zAdjust = aFigure.getAdjustZoom(ctx2.canvas.width, ctx2.canvas.height);
-    }
-    aFigure.draw(ctx2, zAdjust, iLayers);
-  } catch (emsg) {
-    console.log(emsg);
-  }
-}
-function canvasSetSize() {
-  const ctx1 = canvasFull.getContext("2d");
-  const canvas_size = Math.max(0.4 * windowWidth, canvas_size_min);
-  ctx1.canvas.width = canvas_size;
-  ctx1.canvas.height = canvas_size;
-}
-function canvasResize() {
-  canvasSetSize();
-  canvasRedrawFull($dLayers);
-  canvasRedrawZoom($dLayers);
-}
-let domInit = 0;
-function checkFace(iFaces, iFace) {
-  let rFace = iFace;
-  if (iFaces.length === 0) {
-    console.log(`warn404: Drawing has an empty face list`);
-  } else {
-    const FaceList2 = iFaces.slice();
-    FaceList2.push(c_ParametrixAll);
-    if (!FaceList2.includes(rFace)) {
-      rFace = iFaces[0];
-    }
-  }
-  return rFace;
-}
-function geomRedrawSub(iSimTime, pVal, iFace, iLayers) {
-  const FigList = fgeom(iSimTime, pVal).fig;
-  const FigListKeys = Object.keys(FigList);
-  const sFace = checkFace(FigListKeys, iFace);
-  selFace = sFace;
-  if (FigListKeys.includes(sFace)) {
-    aFigure = FigList[sFace];
-  } else {
-    aFigure = mergeFaces(FigList);
-  }
-  canvasRedrawFull(iLayers);
-  canvasRedrawZoom(iLayers);
-}
-function geomRedraw(iSimTime, iFace) {
-  geomRedrawSub(iSimTime, $storePV[pDef.partName], iFace, $dLayers);
-}
-onMount(() => {
-  canvasSetSize();
-  geomRedraw(simTime, selFace);
-  domInit = 1;
-});
-$: {
-  if (domInit === 1) {
-    geomRedrawSub(simTime, $storePV[pDef.partName], selFace, $dLayers);
-  }
-}
-function zoomClick(event) {
-  switch (event.detail.action) {
-    case "zoomInit":
-      zAdjust.init = 0;
-      break;
-    case "zoomIn":
-      zAdjust = adjustScale(0.7, zAdjust);
-      break;
-    case "zoomOut":
-      zAdjust = adjustScale(1.3, zAdjust);
-      break;
-    case "moveLeft":
-      zAdjust.xMin += -0.2 * zAdjust.xyDiff;
-      break;
-    case "moveRight":
-      zAdjust.xMin += 0.2 * zAdjust.xyDiff;
-      break;
-    case "moveUp":
-      zAdjust.yMin += 0.2 * zAdjust.xyDiff;
-      break;
-    case "moveDown":
-      zAdjust.yMin += -0.2 * zAdjust.xyDiff;
-      break;
-    default:
-      console.log(`ERR423: ${event.detail.action} has no case!`);
-  }
-  canvasRedrawZoom($dLayers);
-}
-const mouseDelayMax = 3e3;
-const mouseDiffClick = 10;
-const mouseDiffRatioSelect = 3;
-let mouseF = { timestamp: 0, offsetX: 0, offsetY: 0 };
-function cFullMouseDn(eve) {
-  if (eve.button === 0) {
-    mouseF.timestamp = Date.now();
-    mouseF.offsetX = eve.offsetX;
-    mouseF.offsetY = eve.offsetY;
-  }
-}
-function cFullMouseUp(eve) {
-  if (eve.button === 0) {
-    if (Date.now() - mouseF.timestamp < mouseDelayMax) {
-      const diffX = Math.abs(mouseF.offsetX - eve.offsetX);
-      const diffY = Math.abs(mouseF.offsetY - eve.offsetY);
-      if (diffX < mouseDiffClick && diffY < mouseDiffClick) {
-        const [px, py] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
-        zAdjust = adjustCenter(px, py, zAdjust);
-        geomRedraw(simTime, selFace);
-      }
-      if (diffX > mouseDiffClick && diffY > mouseDiffClick) {
-        const diffRatio1 = diffX / diffY;
-        const diffRatio2 = 1 / diffRatio1;
-        if (diffRatio1 < mouseDiffRatioSelect && diffRatio2 < mouseDiffRatioSelect) {
-          const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
-          const [p2x, p2y] = canvas2point(mouseF.offsetX, mouseF.offsetY, cAdjust);
-          zAdjust = adjustRect(p1x, p1y, p2x, p2y, canvas_size_min, canvas_size_min);
-          geomRedraw(simTime, selFace);
-        }
-      }
-    } else {
-      console.log(`Warn205: ignore ${eve.offsetX} ${eve.offsetY} because too slow`);
-    }
-  }
-}
-function cFullMouseMove(eve) {
-  const ctx1 = canvasFull.getContext("2d");
-  if (eve.buttons === 1) {
-    const diffX = eve.offsetX - mouseF.offsetX;
-    const diffY = eve.offsetY - mouseF.offsetY;
-    canvasRedrawFull($dLayers);
-    ctx1.beginPath();
-    ctx1.rect(mouseF.offsetX, mouseF.offsetY, diffX, diffY);
-    ctx1.strokeStyle = colors.mouse;
-    ctx1.stroke();
-  }
-  if ($dLayers.ruler) {
-    const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
-    ctx1.clearRect(5, 5, 200, 25);
-    ctx1.font = "15px Arial";
-    ctx1.fillStyle = colors.ruler;
-    ctx1.fillText(`x: ${p1x.toFixed(4)} y: ${p1y.toFixed(4)}`, 5, 20);
-  }
-}
-let mouseZx;
-let mouseZy;
-let mouseZadjust;
-function cZoomMouseDn(eve) {
-  if (eve.button === 0) {
-    const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, zAdjust);
-    mouseZx = p1x;
-    mouseZy = p1y;
-    mouseZadjust = structuredClone(zAdjust);
-  }
-}
-function cZoomMouseMove(eve) {
-  if (eve.buttons === 1) {
-    const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, mouseZadjust);
-    zAdjust = adjustTranslate(mouseZx, mouseZy, p2x, p2y, mouseZadjust);
-    canvasRedrawZoom($dLayers);
-  } else {
-    if ($dLayers.ruler) {
-      const ctx2 = canvasZoom.getContext("2d");
-      const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, zAdjust);
-      ctx2.clearRect(5, 5, 200, 25);
-      ctx2.font = "15px Arial";
-      ctx2.fillStyle = colors.ruler;
-      ctx2.fillText(`x: ${p2x.toFixed(4)} y: ${p2y.toFixed(4)}`, 5, 20);
-    }
-  }
-}
-function cZoomWheel(eve) {
-  if (eve.deltaY > 0) {
-    zAdjust = adjustScale(0.7, zAdjust);
-  } else {
-    zAdjust = adjustScale(1.3, zAdjust);
-  }
-  canvasRedrawZoom($dLayers);
-}
+<script lang="ts">
+	import TimeControl from './TimeControl.svelte';
+	import ZoomControl from './ZoomControl.svelte';
+	import LabelCheckbox from './LabelCheckbox.svelte';
+	import type { tCanvasAdjust, tLayers, Figure, tSimTime } from 'geometrix';
+	import {
+		colors,
+		canvas2point,
+		adjustCopy,
+		adjustCenter,
+		adjustRect,
+		adjustScale,
+		adjustTranslate
+	} from 'geometrix';
+	import { sDraw } from './stateDrawing.svelte';
+	import { onMount } from 'svelte';
+
+	// props
+	interface Props {
+		pDefSim: tSimTime;
+		pFig: Figure;
+		simTime?: number;
+	}
+	let { pDefSim, pFig, simTime = $bindable(0) }: Props = $props();
+
+	// const
+	const canvas_size_min = 400;
+	const canvas_size_max = 1200;
+
+	// state
+	let windowWidth: number = $state(canvas_size_min); // TODO5: $state is not needed, but otherwise svelte complains
+	// those internal states are bound: no need of $state
+	let canvasFull: HTMLCanvasElement;
+	let canvasZoom: HTMLCanvasElement;
+
+	// Canavas Figures
+	let cAdjust: tCanvasAdjust;
+	function canvasRedrawFull(iFig: Figure, iLayers: tLayers) {
+		if (canvasFull) {
+			const ctx1 = canvasFull.getContext('2d')!;
+			ctx1.clearRect(0, 0, ctx1.canvas.width, ctx1.canvas.height);
+			try {
+				cAdjust = iFig.getAdjustFull(ctx1.canvas.width, ctx1.canvas.height);
+				iFig.draw(ctx1, cAdjust, iLayers);
+			} catch (emsg) {
+				//rGeome.logstr += emsg;
+				console.log(emsg);
+			}
+			// extra drawing
+			//point(5, 5).draw(ctx1, cAdjust, 'green');
+			//point(5, 15).draw(ctx1, cAdjust, 'blue', 'rectangle');
+		}
+	}
+	function canvasRedrawZoom(iFig: Figure, iZAdjust: tCanvasAdjust, iLayers: tLayers) {
+		if (canvasZoom) {
+			const ctx2 = canvasZoom.getContext('2d')!;
+			ctx2.clearRect(0, 0, ctx2.canvas.width, ctx2.canvas.height);
+			try {
+				if (iZAdjust === undefined || iZAdjust.init === 0) {
+					iZAdjust = iFig.getAdjustZoom(ctx2.canvas.width, ctx2.canvas.height);
+					//console.log(`dbg047: init iZAdjust: ${iZAdjust.xMin} ${iZAdjust.yMin}`);
+				}
+				iFig.draw(ctx2, iZAdjust, iLayers);
+			} catch (emsg) {
+				//rGeome.logstr += emsg;
+				console.log(emsg);
+			}
+		}
+	}
+	function canvasSetSize() {
+		//console.log(`windowWidth: ${windowWidth}`);
+		const ctxF = canvasFull.getContext('2d')!;
+		const ctxZ = canvasZoom.getContext('2d')!;
+		const canvas_size = Math.min(Math.max(0.4 * windowWidth, canvas_size_min), canvas_size_max);
+		ctxF.canvas.width = canvas_size;
+		ctxF.canvas.height = canvas_size;
+		ctxZ.canvas.width = canvas_size;
+		ctxZ.canvas.height = canvas_size;
+		// initialize zAdjust
+		sDraw.canvasZWidth = canvas_size;
+		if (sDraw.zAdjust.init === 0) {
+			sDraw.zAdjust = pFig.getAdjustZoom(ctxZ.canvas.width, ctxZ.canvas.height);
+		}
+	}
+	function canvasResize() {
+		canvasSetSize();
+		canvasRedrawFull(pFig, sDraw.dLayers);
+		canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
+	}
+	function geomRedraw(iFig: Figure, iZAdjust: tCanvasAdjust, iLayers: tLayers) {
+		canvasRedrawFull(iFig, iLayers);
+		canvasRedrawZoom(iFig, iZAdjust, iLayers);
+	}
+	// initialization
+	onMount(() => {
+		canvasSetSize();
+	});
+	// reactivity on pFig, zAdjust and dLayers
+	$effect(() => {
+		geomRedraw(pFig, sDraw.zAdjust, sDraw.dLayers);
+	});
+
+	// actions
+	// Zoom stories
+	function zoomClick(action: string) {
+		//console.log(`dbg094: ${action}`);
+		const ctx2 = canvasZoom.getContext('2d')!;
+		switch (action) {
+			case 'zoomInit':
+				sDraw.zAdjust = pFig.getAdjustZoom(ctx2.canvas.width, ctx2.canvas.height);
+				break;
+			case 'zoomIn':
+				sDraw.zAdjust = adjustScale(0.7, sDraw.zAdjust);
+				break;
+			case 'zoomOut':
+				sDraw.zAdjust = adjustScale(1.3, sDraw.zAdjust);
+				break;
+			case 'moveLeft':
+				sDraw.zAdjust.xMin += -0.2 * sDraw.zAdjust.xyDiff;
+				break;
+			case 'moveRight':
+				sDraw.zAdjust.xMin += 0.2 * sDraw.zAdjust.xyDiff;
+				break;
+			case 'moveUp':
+				sDraw.zAdjust.yMin += 0.2 * sDraw.zAdjust.xyDiff;
+				break;
+			case 'moveDown':
+				sDraw.zAdjust.yMin += -0.2 * sDraw.zAdjust.xyDiff;
+				break;
+			default:
+				console.log(`ERR423: ${action} has no case!`);
+		}
+		canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
+	}
+	// zoom functions on the canvasFull
+	interface tMouse {
+		timestamp: number;
+		offsetX: number;
+		offsetY: number;
+	}
+	const mouseDelayMax = 3000; // only action if mouse-up occurs less than 3000 ms after mouse-down
+	const mouseDiffClick = 10; // if diffX and diffY are smaller than 10 pixel then it's a click
+	const mouseDiffRatioSelect = 3; // The selection must be more or less a square
+	let mouseF: tMouse = { timestamp: 0, offsetX: 0, offsetY: 0 };
+	function cFullMouseDn(eve: MouseEvent) {
+		//console.log(`dbg131: cFullMouseDn ${eve.offsetX} ${eve.offsetY} ${eve.button}`);
+		// left click
+		if (eve.button === 0) {
+			mouseF.timestamp = Date.now();
+			mouseF.offsetX = eve.offsetX;
+			mouseF.offsetY = eve.offsetY;
+			//const ctx1 = canvasFull.getContext('2d') as CanvasRenderingContext2D;
+			//const [px, py] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
+			//point(px, py).draw(ctx1, cAdjust, colors.mouse, 'rectangle');
+		}
+	}
+	function cFullMouseUp(eve: MouseEvent) {
+		//console.log(`dbg139: cFullMouseUp ${eve.offsetX} ${eve.offsetY} ${eve.button}`);
+		// left click
+		if (eve.button === 0) {
+			//const ctx1 = canvasFull.getContext('2d') as CanvasRenderingContext2D;
+			//const [px, py] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
+			//point(px, py).draw(ctx1, cAdjust, colors.mouse, 'circle');
+			if (Date.now() - mouseF.timestamp < mouseDelayMax) {
+				const diffX = Math.abs(mouseF.offsetX - eve.offsetX);
+				const diffY = Math.abs(mouseF.offsetY - eve.offsetY);
+				if (diffX < mouseDiffClick && diffY < mouseDiffClick) {
+					//console.log(`dbg160: a click at ${eve.offsetX} ${eve.offsetY}`);
+					const [px, py] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
+					sDraw.zAdjust = adjustCenter(px, py, sDraw.zAdjust);
+					geomRedraw(pFig, sDraw.zAdjust, sDraw.dLayers);
+				}
+				if (diffX > mouseDiffClick && diffY > mouseDiffClick) {
+					const diffRatio1 = diffX / diffY;
+					const diffRatio2 = 1.0 / diffRatio1;
+					if (diffRatio1 < mouseDiffRatioSelect && diffRatio2 < mouseDiffRatioSelect) {
+						//console.log(`dbg160: a selection at ${eve.offsetX} ${eve.offsetY}`);
+						const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
+						const [p2x, p2y] = canvas2point(mouseF.offsetX, mouseF.offsetY, cAdjust);
+						const ctx2 = canvasZoom.getContext('2d')!;
+						const w2 = ctx2.canvas.width;
+						sDraw.zAdjust = adjustRect(p1x, p1y, p2x, p2y, w2, w2);
+						geomRedraw(pFig, sDraw.zAdjust, sDraw.dLayers);
+					}
+				}
+			} else {
+				console.log(`Warn205: ignore ${eve.offsetX} ${eve.offsetY} because too slow`);
+			}
+		}
+	}
+	// just drawing a rectangle to help zooming
+	function cFullMouseMove(eve: MouseEvent) {
+		//console.log(`dbg179: cFullMouseMove ${eve.offsetX} ${eve.offsetY} ${eve.buttons}`);
+		if (canvasFull) {
+			const ctx1 = canvasFull.getContext('2d')!;
+			// left click
+			if (eve.buttons === 1) {
+				const diffX = eve.offsetX - mouseF.offsetX;
+				const diffY = eve.offsetY - mouseF.offsetY;
+				canvasRedrawFull(pFig, sDraw.dLayers);
+				//const ctx1 = canvasFull.getContext('2d') as CanvasRenderingContext2D;
+				ctx1.beginPath();
+				ctx1.rect(mouseF.offsetX, mouseF.offsetY, diffX, diffY);
+				ctx1.strokeStyle = colors.mouse;
+				ctx1.stroke();
+			}
+			// mouse position
+			if (sDraw.dLayers.ruler) {
+				const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
+				ctx1.clearRect(5, 5, 200, 25);
+				ctx1.font = '15px Arial';
+				ctx1.fillStyle = colors.ruler;
+				ctx1.fillText(`x: ${p1x.toFixed(4)} y: ${p1y.toFixed(4)}`, 5, 20);
+			}
+		}
+	}
+	// translate Zoom drawing
+	let mouseZx: number;
+	let mouseZy: number;
+	let mouseZadjust: tCanvasAdjust;
+	function cZoomMouseDn(eve: MouseEvent) {
+		//console.log(`dbg231: cZoomMouseDn ${eve.offsetX} ${eve.offsetY} ${eve.button}`);
+		// left click
+		if (eve.button === 0) {
+			const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, sDraw.zAdjust);
+			mouseZx = p1x; // point
+			mouseZy = p1y;
+			mouseZadjust = adjustCopy(sDraw.zAdjust); // deepCopy
+			//const ctx2 = canvasZoom.getContext('2d') as CanvasRenderingContext2D;
+			//const [px, py] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
+			//point(px, py).draw(ctx2, cAdjust, colors.mouse, 'rectangle');
+		}
+	}
+	function cZoomMouseMove(eve: MouseEvent) {
+		//console.log(`dbg202: cZoomMouseMove ${eve.offsetX} ${eve.offsetY} ${eve.buttons}`);
+		// left click
+		if (eve.buttons === 1) {
+			const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, mouseZadjust);
+			sDraw.zAdjust = adjustTranslate(mouseZx, mouseZy, p2x, p2y, mouseZadjust);
+			canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
+		} else {
+			// mouse position
+			if (sDraw.dLayers.ruler && canvasZoom) {
+				const ctx2 = canvasZoom.getContext('2d')!;
+				const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, sDraw.zAdjust);
+				ctx2.clearRect(5, 5, 200, 25);
+				ctx2.font = '15px Arial';
+				ctx2.fillStyle = colors.ruler;
+				ctx2.fillText(`x: ${p2x.toFixed(4)} y: ${p2y.toFixed(4)}`, 5, 20);
+			}
+		}
+	}
+	function cZoomWheel(eve: WheelEvent) {
+		eve.preventDefault();
+		if (eve.deltaY > 0) {
+			sDraw.zAdjust = adjustScale(0.7, sDraw.zAdjust);
+		} else {
+			sDraw.zAdjust = adjustScale(1.3, sDraw.zAdjust);
+		}
+		canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
+	}
 </script>
 
-<svelte:window bind:innerWidth={windowWidth} on:resize={canvasResize} />
+// TODO: onresize is not triggered when the window is maximized
+<svelte:window bind:innerWidth={windowWidth} onresize={canvasResize} />
 <section>
-	<h2>
-		Drawing
-		<select bind:value={selFace}>
-			{#each optFaces as optFace}
-				<option value={optFace}>{optFace}</option>
-			{/each}
-			<option value={c_ParametrixAll}>All faces merged</option>
-		</select>
-	</h2>
 	<LabelCheckbox />
 	<div class="rack">
 		<canvas
@@ -237,14 +271,14 @@ function cZoomWheel(eve) {
 			width={canvas_size_min}
 			height={canvas_size_min}
 			bind:this={canvasFull}
-			on:mousedown={cFullMouseDn}
-			on:mouseup={cFullMouseUp}
-			on:mousemove={cFullMouseMove}
-		/>
+			onmousedown={cFullMouseDn}
+			onmouseup={cFullMouseUp}
+			onmousemove={cFullMouseMove}
+		></canvas>
 		<TimeControl
-			tMax={pDef.sim.tMax}
-			tStep={pDef.sim.tStep}
-			tUpdate={pDef.sim.tUpdate}
+			tMax={pDefSim.tMax}
+			tStep={pDefSim.tStep}
+			tUpdate={pDefSim.tUpdate}
 			bind:simTime
 		/>
 	</div>
@@ -254,11 +288,11 @@ function cZoomWheel(eve) {
 			width={canvas_size_min}
 			height={canvas_size_min}
 			bind:this={canvasZoom}
-			on:mousedown={cZoomMouseDn}
-			on:mousemove={cZoomMouseMove}
-			on:wheel|preventDefault={cZoomWheel}
-		/>
-		<ZoomControl on:myevent={zoomClick} />
+			onmousedown={cZoomMouseDn}
+			onmousemove={cZoomMouseMove}
+			onwheel={cZoomWheel}
+		></canvas>
+		<ZoomControl {zoomClick} />
 	</div>
 </section>
 
@@ -270,27 +304,6 @@ $canvas-point: grey;
 	colorCanvasPoint: $canvas-point;
 }
 */
-section > h2 {
-  color: grey;
-  margin: 1rem 0.5rem 0;
-}
-
-section > h2 > select {
-  /*display: inline-block;*/
-  height: 1.6rem;
-  /*width: 1.6rem;*/
-  color: darkBlue;
-  font-size: 0.8rem;
-  font-weight: 400;
-  padding: 0.2rem 0.4rem 0.2rem;
-  border-style: solid;
-  border-width: 0.1rem;
-  border-radius: 0.2rem;
-  border-color: darkBlue;
-  margin: 0.5rem;
-  background-color: lightBlue;
-}
-
 section > div.rack {
   display: inline-block;
   margin: 0 1rem 0;

package/dist/Drawing.svelte.d.ts

@@ -1,24 +1,8 @@
-import { SvelteComponent } from "svelte";
-import type { tCanvasAdjust, tParamDef, tGeomFunc } from 'geometrix';
-declare const __propDef: {
-    props: {
-        pDef: tParamDef;
-        fgeom: tGeomFunc;
-        optFaces: string[];
-        selFace: string;
-        zAdjust: tCanvasAdjust;
-        simTime?: number;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-    exports?: {} | undefined;
-    bindings?: string | undefined;
-};
-export type DrawingProps = typeof __propDef.props;
-export type DrawingEvents = typeof __propDef.events;
-export type DrawingSlots = typeof __propDef.slots;
-export default class Drawing extends SvelteComponent<DrawingProps, DrawingEvents, DrawingSlots> {
-}
-export {};
+import type { Figure, tSimTime } from 'geometrix';
+declare const Drawing: import("svelte").Component<{
+    pDefSim: tSimTime;
+    pFig: Figure;
+    simTime?: number;
+}, {}, "simTime">;
+type Drawing = ReturnType<typeof Drawing>;
+export default Drawing;