geomui 0.5.55 → 0.5.57

package/dist/Drawing.svelte

@@ -2,160 +2,135 @@
 	import TimeControl from './TimeControl.svelte';
 	import ZoomControl from './ZoomControl.svelte';
 	import LabelCheckbox from './LabelCheckbox.svelte';
-	import type {
-		tCanvasAdjust,
-		tLayers,
-		Figure,
-		tParamDef,
-		tParamVal,
-		tGeomFunc
-	} from 'geometrix';
+	import type { tCanvasAdjust, tLayers, Figure, tSimTime } from 'geometrix';
 	import {
 		colors,
 		canvas2point,
+		adjustCopy,
 		adjustCenter,
 		adjustRect,
 		adjustScale,
-		adjustTranslate,
-		mergeFaces
+		adjustTranslate
 	} from 'geometrix';
-	import { storePV } from './storePVal';
-	import { dLayers } from './drawingLayers';
+	import { sDraw } from './stateDrawing.svelte';
 	import { onMount } from 'svelte';
 
-	export let pDef: tParamDef;
-	export let fgeom: tGeomFunc;
-	export let optFaces: string[];
-	export let selFace: string;
-	export let zAdjust: tCanvasAdjust;
-	export let simTime = 0;
+	// 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;
 
-	const c_ParametrixAll = 'ParametrixAll';
-	let windowWidth: number;
+	// 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;
-	const canvas_size_min = 400;
 
 	// Canavas Figures
-	let aFigure: Figure;
 	let cAdjust: tCanvasAdjust;
-	//let zAdjust: tCanvasAdjust;
-	function canvasRedrawFull(iLayers: tLayers) {
-		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) {
-			//rGeome.logstr += emsg;
-			console.log(emsg);
+	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');
 		}
-		// extra drawing
-		//point(5, 5).draw(ctx1, cAdjust, 'green');
-		//point(5, 15).draw(ctx1, cAdjust, 'blue', 'rectangle');
 	}
-	function canvasRedrawZoom(iLayers: tLayers) {
-		const ctx2 = canvasZoom.getContext('2d')!;
-		ctx2.clearRect(0, 0, ctx2.canvas.width, ctx2.canvas.height);
-		try {
-			if (zAdjust === undefined || zAdjust.init === 0) {
-				zAdjust = aFigure.getAdjustZoom(ctx2.canvas.width, ctx2.canvas.height);
-				//console.log(`dbg047: init zAdjust: ${zAdjust.xMin} ${zAdjust.yMin}`);
+	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);
 			}
-			aFigure.draw(ctx2, zAdjust, iLayers);
-		} catch (emsg) {
-			//rGeome.logstr += emsg;
-			console.log(emsg);
 		}
 	}
 	function canvasSetSize() {
 		//console.log(`windowWidth: ${windowWidth}`);
-		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;
+		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($dLayers);
-		canvasRedrawZoom($dLayers);
-	}
-	let domInit = 0;
-	function checkFace(iFaces: string[], iFace: string): string {
-		let rFace = iFace;
-		if (iFaces.length === 0) {
-			console.log(`warn404: Drawing has an empty face list`);
-		} else {
-			//rFace = iFaces[0];
-			const FaceList2 = iFaces.slice();
-			FaceList2.push(c_ParametrixAll);
-			if (!FaceList2.includes(rFace)) {
-				//console.log(`warn403: Drawing has an invalid face ${rFace}`);
-				rFace = iFaces[0];
-			}
-		}
-		//console.log(iFaces);
-		//console.log(`dbg097: rFace ${rFace}`);
-		return rFace;
-	}
-	function geomRedrawSub(iSimTime: number, pVal: tParamVal, iFace: string, iLayers: tLayers) {
-		const FigList = fgeom(iSimTime, pVal).fig;
-		const FigListKeys = Object.keys(FigList);
-		const sFace = checkFace(FigListKeys, iFace);
-		selFace = sFace; // update input select
-		if (FigListKeys.includes(sFace)) {
-			aFigure = FigList[sFace];
-		} else {
-			aFigure = mergeFaces(FigList);
-		}
-		canvasRedrawFull(iLayers);
-		canvasRedrawZoom(iLayers);
+		canvasRedrawFull(pFig, sDraw.dLayers);
+		canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
 	}
-	function geomRedraw(iSimTime: number, iFace: string) {
-		geomRedrawSub(iSimTime, $storePV[pDef.partName], iFace, $dLayers);
+	function geomRedraw(iFig: Figure, iZAdjust: tCanvasAdjust, iLayers: tLayers) {
+		canvasRedrawFull(iFig, iLayers);
+		canvasRedrawZoom(iFig, iZAdjust, iLayers);
 	}
+	// initialization
 	onMount(() => {
-		// initial drawing
 		canvasSetSize();
-		geomRedraw(simTime, selFace);
-		//paramChange();
-		domInit = 1;
 	});
-	// reactivity on simTime, $storePV and layers
-	$: {
-		if (domInit === 1) {
-			geomRedrawSub(simTime, $storePV[pDef.partName], selFace, $dLayers);
-		}
-	}
+	// reactivity on pFig, zAdjust and dLayers
+	$effect(() => {
+		geomRedraw(pFig, sDraw.zAdjust, sDraw.dLayers);
+	});
+
+	// actions
 	// Zoom stories
-	function zoomClick(event: CustomEvent<{ action: string }>) {
-		//console.log(`dbg094: ${event.detail.action}`);
-		switch (event.detail.action) {
+	function zoomClick(action: string) {
+		//console.log(`dbg094: ${action}`);
+		const ctx2 = canvasZoom.getContext('2d')!;
+		switch (action) {
 			case 'zoomInit':
-				zAdjust.init = 0;
+				sDraw.zAdjust = pFig.getAdjustZoom(ctx2.canvas.width, ctx2.canvas.height);
 				break;
 			case 'zoomIn':
-				zAdjust = adjustScale(0.7, zAdjust);
+				sDraw.zAdjust = adjustScale(0.7, sDraw.zAdjust);
 				break;
 			case 'zoomOut':
-				zAdjust = adjustScale(1.3, zAdjust);
+				sDraw.zAdjust = adjustScale(1.3, sDraw.zAdjust);
 				break;
 			case 'moveLeft':
-				zAdjust.xMin += -0.2 * zAdjust.xyDiff;
+				sDraw.zAdjust.xMin += -0.2 * sDraw.zAdjust.xyDiff;
 				break;
 			case 'moveRight':
-				zAdjust.xMin += 0.2 * zAdjust.xyDiff;
+				sDraw.zAdjust.xMin += 0.2 * sDraw.zAdjust.xyDiff;
 				break;
 			case 'moveUp':
-				zAdjust.yMin += 0.2 * zAdjust.xyDiff;
+				sDraw.zAdjust.yMin += 0.2 * sDraw.zAdjust.xyDiff;
 				break;
 			case 'moveDown':
-				zAdjust.yMin += -0.2 * zAdjust.xyDiff;
+				sDraw.zAdjust.yMin += -0.2 * sDraw.zAdjust.xyDiff;
 				break;
 			default:
-				console.log(`ERR423: ${event.detail.action} has no case!`);
+				console.log(`ERR423: ${action} has no case!`);
 		}
-		canvasRedrawZoom($dLayers);
+		canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
 	}
 	// zoom functions on the canvasFull
 	interface tMouse {
@@ -192,8 +167,8 @@
 				if (diffX < mouseDiffClick && diffY < mouseDiffClick) {
 					//console.log(`dbg160: a click at ${eve.offsetX} ${eve.offsetY}`);
 					const [px, py] = canvas2point(eve.offsetX, eve.offsetY, cAdjust);
-					zAdjust = adjustCenter(px, py, zAdjust);
-					geomRedraw(simTime, selFace);
+					sDraw.zAdjust = adjustCenter(px, py, sDraw.zAdjust);
+					geomRedraw(pFig, sDraw.zAdjust, sDraw.dLayers);
 				}
 				if (diffX > mouseDiffClick && diffY > mouseDiffClick) {
 					const diffRatio1 = diffX / diffY;
@@ -202,8 +177,10 @@
 						//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);
-						zAdjust = adjustRect(p1x, p1y, p2x, p2y, canvas_size_min, canvas_size_min);
-						geomRedraw(simTime, selFace);
+						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 {
@@ -214,25 +191,27 @@
 	// just drawing a rectangle to help zooming
 	function cFullMouseMove(eve: MouseEvent) {
 		//console.log(`dbg179: cFullMouseMove ${eve.offsetX} ${eve.offsetY} ${eve.buttons}`);
-		const ctx1 = canvasFull.getContext('2d')!;
-		// left click
-		if (eve.buttons === 1) {
-			const diffX = eve.offsetX - mouseF.offsetX;
-			const diffY = eve.offsetY - mouseF.offsetY;
-			canvasRedrawFull($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 ($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);
+		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
@@ -243,10 +222,10 @@
 		//console.log(`dbg231: cZoomMouseDn ${eve.offsetX} ${eve.offsetY} ${eve.button}`);
 		// left click
 		if (eve.button === 0) {
-			const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, zAdjust);
+			const [p1x, p1y] = canvas2point(eve.offsetX, eve.offsetY, sDraw.zAdjust);
 			mouseZx = p1x; // point
 			mouseZy = p1y;
-			mouseZadjust = structuredClone(zAdjust); // deepCopy
+			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');
@@ -257,13 +236,13 @@
 		// left click
 		if (eve.buttons === 1) {
 			const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, mouseZadjust);
-			zAdjust = adjustTranslate(mouseZx, mouseZy, p2x, p2y, mouseZadjust);
-			canvasRedrawZoom($dLayers);
+			sDraw.zAdjust = adjustTranslate(mouseZx, mouseZy, p2x, p2y, mouseZadjust);
+			canvasRedrawZoom(pFig, sDraw.zAdjust, sDraw.dLayers);
 		} else {
 			// mouse position
-			if ($dLayers.ruler) {
+			if (sDraw.dLayers.ruler && canvasZoom) {
 				const ctx2 = canvasZoom.getContext('2d')!;
-				const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, zAdjust);
+				const [p2x, p2y] = canvas2point(eve.offsetX, eve.offsetY, sDraw.zAdjust);
 				ctx2.clearRect(5, 5, 200, 25);
 				ctx2.font = '15px Arial';
 				ctx2.fillStyle = colors.ruler;
@@ -272,26 +251,19 @@
 		}
 	}
 	function cZoomWheel(eve: WheelEvent) {
+		eve.preventDefault();
 		if (eve.deltaY > 0) {
-			zAdjust = adjustScale(0.7, zAdjust);
+			sDraw.zAdjust = adjustScale(0.7, sDraw.zAdjust);
 		} else {
-			zAdjust = adjustScale(1.3, zAdjust);
+			sDraw.zAdjust = adjustScale(1.3, sDraw.zAdjust);
 		}
-		canvasRedrawZoom($dLayers);
+		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
@@ -299,14 +271,14 @@
 			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>
@@ -316,11 +288,11 @@
 			width={canvas_size_min}
 			height={canvas_size_min}
 			bind:this={canvasZoom}
-			on:mousedown={cZoomMouseDn}
-			on:mousemove={cZoomMouseMove}
-			on:wheel|preventDefault={cZoomWheel}
+			onmousedown={cZoomMouseDn}
+			onmousemove={cZoomMouseMove}
+			onwheel={cZoomWheel}
 		></canvas>
-		<ZoomControl on:myevent={zoomClick} />
+		<ZoomControl {zoomClick} />
 	</div>
 </section>
 
@@ -332,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,26 +1,8 @@
-import type { tCanvasAdjust, tParamDef, tGeomFunc } from 'geometrix';
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const Drawing: $$__sveltets_2_IsomorphicComponent<{
-    pDef: tParamDef;
-    fgeom: tGeomFunc;
-    optFaces: string[];
-    selFace: string;
-    zAdjust: tCanvasAdjust;
+import type { Figure, tSimTime } from 'geometrix';
+declare const Drawing: import("svelte").Component<{
+    pDefSim: tSimTime;
+    pFig: Figure;
     simTime?: number;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type Drawing = InstanceType<typeof Drawing>;
+}, {}, "simTime">;
+type Drawing = ReturnType<typeof Drawing>;
 export default Drawing;

package/dist/DrawingList.svelte

@@ -1,11 +1,13 @@
 <script lang="ts">
 	import type { tParamDef } from 'geometrix';
 	import ModalImg from './ModalImg.svelte';
-	//import { onMount } from 'svelte';
-	//import { browser } from '$app/environment';
 	import { base } from '$app/paths';
 
-	export let pDef: tParamDef;
+	// props
+	interface Props {
+		pDef: tParamDef;
+	}
+	let { pDef }: Props = $props();
 
 	// helper function
 	function getSvgList(ipDef: tParamDef): string[] {
@@ -17,36 +19,26 @@
 		}
 		return rList;
 	}
-	function getSvgList2(partName: string): string[] {
-		// fake using partName. partName is needed for the reactivity
-		if (partName === 'impossible_part_name') {
-			//console.log(`dummy022: partName ${partName}`);
-		}
-		const lList = getSvgList(pDef);
-		const rList2: string[] = [];
-		for (const svg of lList) {
-			rList2.push(`${base}/pgdsvg/${svg}`);
-		}
-		return rList2;
-	}
-	// initialization
-	let lSvg: string[] = [];
-	// reactivity
-	$: lSvg = getSvgList2(pDef.partName);
-	// modalImg
-	let modalImg = false;
-	let svgPath: string;
+
+	// state
+	let sModalImg: boolean = $state(false);
+	let sSvgPath: string = $state('');
+
+	// derived
+	let dSvgList: string[] = $derived(getSvgList(pDef).map((iSvg) => `${base}/pgdsvg/${iSvg}`));
+
+	// actions
 	function showSvg(iSvgPath: string) {
-		svgPath = iSvgPath;
-		//console.log(`dbg231: svgPath: ${svgPath}`);
-		modalImg = true;
+		sSvgPath = iSvgPath;
+		//console.log(`dbg231: sSvgPath: ${sSvgPath}`);
+		sModalImg = true;
 	}
 </script>
 
 <section>
-	<ModalImg bind:modalOpen={modalImg} {svgPath} />
-	{#each lSvg as iSvg}
-		<button on:click={() => showSvg(iSvg)}>
+	<ModalImg bind:modalOpen={sModalImg} svgPath={sSvgPath} />
+	{#each dSvgList as iSvg}
+		<button onclick={() => showSvg(iSvg)}>
 			<img src={iSvg} alt={iSvg} />
 		</button>
 	{/each}

package/dist/DrawingList.svelte.d.ts

@@ -1,21 +1,6 @@
 import type { tParamDef } from 'geometrix';
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const DrawingList: $$__sveltets_2_IsomorphicComponent<{
+declare const DrawingList: import("svelte").Component<{
     pDef: tParamDef;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type DrawingList = InstanceType<typeof DrawingList>;
+}, {}, "">;
+type DrawingList = ReturnType<typeof DrawingList>;
 export default DrawingList;