@cadit-app/image-extrude 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CADit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# @cadit-app/image-extrude
+
+Extrude 3D shapes from SVG or bitmap images. Supports both tracing (for raster images) and sampling (for SVGs).
+
+![Image Extrude Preview](images/preview.png)
+
+## Features
+
+- **Trace mode**: Convert any bitmap image (PNG, JPG) to 3D by tracing edges (browser only)
+- **Sample mode**: High-fidelity conversion of SVG files to 3D
+- **Configurable size**: Set maximum width to control output dimensions
+- **Despeckle**: Remove small artifacts during tracing
+- **CLI support**: Generate GLB and 3MF files from command line (SVG sample mode)
+
+> **Note:** Trace mode for bitmap images currently only works in the browser (CADit). 
+> The CLI only supports SVG files with sample mode.
+
+## Installation
+
+```bash
+npm install @cadit-app/image-extrude
+```
+
+## Usage
+
+### As a CADit Script
+
+Import this script in [CADit](https://cadit.app) by adding the GitHub repository URL.
+
+### CLI Usage
+
+```bash
+# Generate GLB from default star shape
+npx tsx cli.ts output.glb
+
+# Generate from a specific image
+npx tsx cli.ts output.glb --image=logo.svg --height=2 --maxWidth=50
+
+# Generate 3MF
+npx tsx cli.ts output.3mf --image=photo.png --mode=trace
+```
+
+### CLI Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--image=<path>` | Path to image file (SVG, PNG, JPG) | Built-in star |
+| `--height=<mm>` | Extrusion height in mm | 1 |
+| `--maxWidth=<mm>` | Maximum width in mm | 50 |
+| `--mode=<trace\|sample>` | Processing mode | trace |
+| `--despeckle=<size>` | Despeckle size for tracing | 2 |
+
+### Programmatic Usage
+
+```typescript
+import imageExtrude from '@cadit-app/image-extrude';
+
+// Use the defineParams API
+const result = await imageExtrude.main({
+  mode: 'trace',
+  imageFile: {
+    dataUrl: 'data:image/png;base64,...',
+    fileType: 'image/png',
+    fileName: 'logo.png'
+  },
+  height: 2,
+  maxWidth: 50,
+  despeckleSize: 2
+});
+```
+
+### Creating CrossSections for Embedding
+
+```typescript
+import { makeCrossSection } from '@cadit-app/image-extrude';
+
+const crossSection = await makeCrossSection({
+  imageFile: { dataUrl: '...', fileType: 'image/svg+xml' },
+  mode: 'sample',
+  maxWidth: 30
+});
+
+// Use in your own maker
+const manifold = crossSection.extrude(5);
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `mode` | `'trace' \| 'sample'` | Trace for bitmaps, Sample for SVGs |
+| `imageFile` | `object` | Image data with dataUrl, fileType, fileName |
+| `height` | `number` | Extrusion height in mm |
+| `maxWidth` | `number` | Maximum width in mm |
+| `despeckleSize` | `number` | Remove spots smaller than this (trace only) |
+
+## License
+
+MIT

package/cadit.json

@@ -0,0 +1,20 @@
+{
+  "name": "Image Extrude",
+  "description": "Extrude 3D shapes from SVG or bitmap images. Supports both tracing (for raster images) and sampling (for SVGs). Perfect for creating custom 3D prints from logos, icons, or artwork.",
+  "entryPoint": "src/main.ts",
+  "tags": ["image", "svg", "trace", "extrude", "3d-printing", "logo"],
+  "category": "Tools",
+  "license": {
+    "type": "MIT"
+  },
+  "author": {
+    "name": "CADit"
+  },
+  "images": [
+    {
+      "path": "images/preview.png",
+      "alt": "Image Extrude Preview",
+      "isPrimary": true
+    }
+  ]
+}

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env npx tsx
+/**
+ * CLI for @cadit-app/image-extrude
+ *
+ * Usage:
+ *   npx tsx cli.ts [output.glb|output.3mf] [options]
+ *
+ * Examples:
+ *   npx tsx cli.ts output.glb
+ *   npx tsx cli.ts output.3mf --image=logo.svg --height=2
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG"}

package/dist/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env npx tsx
+/**
+ * CLI for @cadit-app/image-extrude
+ *
+ * Usage:
+ *   npx tsx cli.ts [output.glb|output.3mf] [options]
+ *
+ * Examples:
+ *   npx tsx cli.ts output.glb
+ *   npx tsx cli.ts output.3mf --image=logo.svg --height=2
+ */
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { resolve, extname, basename } from 'path';
+import { parseArgs } from 'util';
+const SUPPORTED_FORMATS = ['.glb', '.3mf'];
+// Parse command line arguments
+const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+        image: { type: 'string', short: 'i' },
+        height: { type: 'string', short: 'h' },
+        maxWidth: { type: 'string', short: 'w' },
+        mode: { type: 'string', short: 'm' },
+        despeckle: { type: 'string', short: 'd' },
+        help: { type: 'boolean' },
+    },
+});
+if (values.help || positionals.length === 0) {
+    console.log(`
+@cadit-app/image-extrude CLI
+
+Usage: npx tsx cli.ts <output.[glb|3mf]> [options]
+
+Options:
+  -i, --image <path>        Path to image file (SVG, PNG, JPG)
+  -h, --height <mm>         Extrusion height in mm (default: 1)
+  -w, --maxWidth <mm>       Maximum width in mm (default: 50)
+  -m, --mode <trace|sample> Processing mode (default: trace)
+  -d, --despeckle <size>    Despeckle size for tracing (default: 2)
+  --help                    Show this help
+
+Examples:
+  npx tsx cli.ts output.glb
+  npx tsx cli.ts output.glb --image logo.svg --height 2
+  npx tsx cli.ts output.3mf --image photo.png --mode trace
+`);
+    process.exit(0);
+}
+const outputFile = positionals[0];
+const ext = extname(outputFile).toLowerCase();
+if (!SUPPORTED_FORMATS.includes(ext)) {
+    console.error(`Error: Output file must have one of these extensions: ${SUPPORTED_FORMATS.join(', ')}`);
+    console.error(`Got: ${ext}`);
+    process.exit(1);
+}
+async function main() {
+    console.log('Initializing manifold...');
+    // Initialize manifold-3d
+    const manifold = await import('@cadit-app/manifold-3d');
+    await manifold.default();
+    // Now import the maker
+    const { default: imageExtrudeMaker } = await import('./src/main');
+    const { imageExtrudeParamsSchema } = await import('./src/params');
+    console.log('Generating image extrusion...');
+    // Build params from defaults and CLI options
+    const defaultParams = {};
+    for (const [key, param] of Object.entries(imageExtrudeParamsSchema)) {
+        defaultParams[key] = param.default;
+    }
+    // Load default image from images folder if no image specified
+    const defaultImagePath = resolve(import.meta.dirname, 'images', 'cookiecad-logo-dark.svg');
+    const imagePath = values.image && existsSync(values.image) ? values.image : defaultImagePath;
+    // Override with CLI options
+    if (values.height) {
+        defaultParams.height = parseFloat(values.height);
+    }
+    if (values.maxWidth) {
+        defaultParams.maxWidth = parseFloat(values.maxWidth);
+    }
+    // Default to 'sample' mode for CLI (trace requires additional WASM setup for non-SVG)
+    if (values.mode && (values.mode === 'trace' || values.mode === 'sample')) {
+        defaultParams.mode = values.mode;
+    }
+    else if (!values.mode && imagePath.endsWith('.svg')) {
+        defaultParams.mode = 'sample'; // Default to sample for SVGs in CLI
+    }
+    if (values.despeckle) {
+        defaultParams.despeckleSize = parseFloat(values.despeckle);
+    }
+    if (existsSync(imagePath)) {
+        const imageData = readFileSync(imagePath);
+        const base64 = imageData.toString('base64');
+        const imageExt = extname(imagePath).toLowerCase();
+        const mimeType = imageExt === '.svg' ? 'image/svg+xml' :
+            imageExt === '.png' ? 'image/png' :
+                imageExt === '.jpg' || imageExt === '.jpeg' ? 'image/jpeg' :
+                    'application/octet-stream';
+        defaultParams.imageFile = {
+            dataUrl: `data:${mimeType};base64,${base64}`,
+            fileType: mimeType,
+            fileName: basename(imagePath)
+        };
+    }
+    console.log('Parameters:', {
+        mode: defaultParams.mode,
+        height: defaultParams.height,
+        maxWidth: defaultParams.maxWidth,
+        despeckleSize: defaultParams.despeckleSize,
+        hasImage: !!defaultParams.imageFile?.dataUrl
+    });
+    // Generate the model
+    const result = await imageExtrudeMaker(defaultParams);
+    if (ext === '.glb') {
+        // Export as GLB
+        const mesh = result.getMesh();
+        const { Document, NodeIO } = await import('@gltf-transform/core');
+        const document = new Document();
+        const buffer = document.createBuffer();
+        const scene = document.createScene();
+        const node = document.createNode();
+        scene.addChild(node);
+        // Create mesh
+        const primitive = document.createPrimitive();
+        // Position accessor
+        const positions = new Float32Array(mesh.vertProperties);
+        const positionAccessor = document.createAccessor()
+            .setType('VEC3')
+            .setBuffer(buffer)
+            .setArray(positions);
+        primitive.setAttribute('POSITION', positionAccessor);
+        // Index accessor
+        const indices = new Uint32Array(mesh.triVerts);
+        const indexAccessor = document.createAccessor()
+            .setType('SCALAR')
+            .setBuffer(buffer)
+            .setArray(indices);
+        primitive.setIndices(indexAccessor);
+        // Material
+        const material = document.createMaterial()
+            .setBaseColorFactor([0.2, 0.8, 0.6, 1.0]);
+        primitive.setMaterial(material);
+        const gltfMesh = document.createMesh().addPrimitive(primitive);
+        node.setMesh(gltfMesh);
+        const io = new NodeIO();
+        const glb = await io.writeBinary(document);
+        writeFileSync(resolve(outputFile), glb);
+        console.log(`Wrote ${outputFile}`);
+    }
+    else if (ext === '.3mf') {
+        // Export as 3MF
+        const { create3mfArrayBuffer } = await import('./src/threeMfExport');
+        const buffer = await create3mfArrayBuffer([result]);
+        writeFileSync(resolve(outputFile), Buffer.from(buffer));
+        console.log(`Wrote ${outputFile}`);
+    }
+}
+main().catch(err => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/dist/src/crossSectionUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CrossSection utility functions
+ */
+import { CrossSection } from '@cadit-app/manifold-3d/manifoldCAD';
+/**
+ * Centers a CrossSection at the origin based on its bounding box
+ */
+export declare function centerCrossSection(crossSection: CrossSection): CrossSection;
+/**
+ * Scales a CrossSection to fit within a maximum size while maintaining aspect ratio
+ */
+export declare function scaleToMaxSize(crossSection: CrossSection, maxSize: number): CrossSection;
+//# sourceMappingURL=crossSectionUtils.d.ts.map

package/dist/src/crossSectionUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossSectionUtils.d.ts","sourceRoot":"","sources":["../../src/crossSectionUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,GAAG,YAAY,CAK3E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,CAUxF"}

package/dist/src/crossSectionUtils.js

@@ -0,0 +1,25 @@
+/**
+ * CrossSection utility functions
+ */
+/**
+ * Centers a CrossSection at the origin based on its bounding box
+ */
+export function centerCrossSection(crossSection) {
+    const bounds = crossSection.bounds();
+    const centerX = (bounds.min[0] + bounds.max[0]) / 2;
+    const centerY = (bounds.min[1] + bounds.max[1]) / 2;
+    return crossSection.translate([-centerX, -centerY]);
+}
+/**
+ * Scales a CrossSection to fit within a maximum size while maintaining aspect ratio
+ */
+export function scaleToMaxSize(crossSection, maxSize) {
+    const bounds = crossSection.bounds();
+    const width = bounds.max[0] - bounds.min[0];
+    const height = bounds.max[1] - bounds.min[1];
+    const maxDim = Math.max(width, height);
+    if (maxDim <= 0)
+        return crossSection;
+    const scale = maxSize / maxDim;
+    return crossSection.scale([scale, scale]);
+}

package/dist/src/main.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @cadit-app/image-extrude
+ *
+ * Extrude 3D shapes from SVG or bitmap images.
+ * Uses the defineParams API from @cadit-app/script-params.
+ */
+import type { Manifold } from '@cadit-app/manifold-3d/manifoldCAD';
+export { sampleSvg, traceImage } from './tracing';
+export { renderSvgToBitmapDataUrl } from './resvg';
+export { makeCrossSection } from './makeCrossSection';
+/**
+ * Main entry point using defineParams
+ */
+declare const _default: import("@cadit-app/script-params").ScriptModule<any, Promise<Manifold>>;
+export default _default;
+//# sourceMappingURL=main.d.ts.map

package/dist/src/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAgB,MAAM,oCAAoC,CAAC;AAQjF,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;GAEG;;AACH,wBAqDG"}

package/dist/src/main.js

@@ -0,0 +1,70 @@
+/**
+ * @cadit-app/image-extrude
+ *
+ * Extrude 3D shapes from SVG or bitmap images.
+ * Uses the defineParams API from @cadit-app/script-params.
+ */
+import { defineParams } from '@cadit-app/script-params';
+import { imageExtrudeParamsSchema } from './params';
+import { sampleSvg, traceImage } from './tracing';
+import { renderSvgToBitmapDataUrl } from './resvg';
+import { fetchImageAsDataUrl } from './utils';
+import { createEmptyManifold } from './manifoldUtils';
+// Re-export for external use
+export { sampleSvg, traceImage } from './tracing';
+export { renderSvgToBitmapDataUrl } from './resvg';
+export { makeCrossSection } from './makeCrossSection';
+/**
+ * Main entry point using defineParams
+ */
+export default defineParams({
+    params: imageExtrudeParamsSchema,
+    main: async (params) => {
+        const typedParams = params;
+        let { mode, height } = typedParams;
+        let imageFile = typedParams.imageFile;
+        // If imageFile has imageUrl but not dataUrl, fetch and convert to dataUrl
+        if (imageFile && !imageFile.dataUrl && imageFile.imageUrl) {
+            try {
+                imageFile = {
+                    ...imageFile,
+                    dataUrl: await fetchImageAsDataUrl(imageFile.imageUrl)
+                };
+            }
+            catch (err) {
+                console.warn('Failed to fetch imageUrl:', err);
+                return createEmptyManifold();
+            }
+        }
+        if (!imageFile || !imageFile.dataUrl) {
+            console.warn('No valid image file provided.');
+            return createEmptyManifold();
+        }
+        // Adjust mode if sample is selected for non-SVG
+        if (mode === 'sample' && !imageFile.fileType?.includes('svg')) {
+            console.warn('Sample mode selected for non-SVG file. Defaulting to Trace mode.');
+            mode = 'trace';
+        }
+        let crossSection;
+        try {
+            if (mode === 'trace') {
+                // if svg, render svg to bitmap and then trace
+                const isSvg = imageFile.fileType?.includes('svg');
+                const dataUrl = isSvg ? await renderSvgToBitmapDataUrl(imageFile.dataUrl) : imageFile.dataUrl;
+                crossSection = await traceImage(dataUrl, {
+                    maxWidth: typedParams.maxWidth,
+                    despeckleSize: typedParams.despeckleSize
+                });
+            }
+            else {
+                // mode is 'sample', and fileType is guaranteed to be svg+xml
+                crossSection = await sampleSvg(imageFile.dataUrl, typedParams.maxWidth);
+            }
+        }
+        catch (error) {
+            console.error(`Error during image processing (mode: ${mode}):`, error);
+            return createEmptyManifold();
+        }
+        return crossSection.extrude(height);
+    },
+});

package/dist/src/makeCrossSection.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a CrossSection from image parameters
+ * Exported for external use (e.g., embedding in other makers)
+ */
+import type { CrossSection } from '@cadit-app/manifold-3d/manifoldCAD';
+import { ImageExtrudeParams } from './params';
+export type MakeCrossSectionOptions = {
+    imageFile: ImageExtrudeParams['imageFile'];
+    mode: 'trace' | 'sample';
+    maxWidth?: number;
+    despeckleSize?: number;
+};
+/**
+ * Creates a CrossSection from image data
+ * This is the main function for embedding in other makers
+ */
+export declare function makeCrossSection(options: MakeCrossSectionOptions): Promise<CrossSection>;
+//# sourceMappingURL=makeCrossSection.d.ts.map

package/dist/src/makeCrossSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeCrossSection.d.ts","sourceRoot":"","sources":["../../src/makeCrossSection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAK9C,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAC3C,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,YAAY,CAAC,CAkC9F"}

package/dist/src/makeCrossSection.js

@@ -0,0 +1,42 @@
+/**
+ * Create a CrossSection from image parameters
+ * Exported for external use (e.g., embedding in other makers)
+ */
+import { sampleSvg, traceImage } from './tracing';
+import { renderSvgToBitmapDataUrl } from './resvg';
+import { fetchImageAsDataUrl } from './utils';
+/**
+ * Creates a CrossSection from image data
+ * This is the main function for embedding in other makers
+ */
+export async function makeCrossSection(options) {
+    let { imageFile, mode, maxWidth, despeckleSize } = options;
+    // If imageFile has imageUrl but not dataUrl, fetch and convert
+    if (imageFile && !imageFile.dataUrl && imageFile.imageUrl) {
+        imageFile = {
+            ...imageFile,
+            dataUrl: await fetchImageAsDataUrl(imageFile.imageUrl)
+        };
+    }
+    if (!imageFile?.dataUrl) {
+        throw new Error('No valid image file provided');
+    }
+    // Adjust mode if sample is selected for non-SVG
+    if (mode === 'sample' && !imageFile.fileType?.includes('svg')) {
+        console.warn('Sample mode selected for non-SVG file. Defaulting to Trace mode.');
+        mode = 'trace';
+    }
+    if (mode === 'trace') {
+        // if svg, render svg to bitmap and then trace
+        const isSvg = imageFile.fileType?.includes('svg');
+        const dataUrl = isSvg ? await renderSvgToBitmapDataUrl(imageFile.dataUrl) : imageFile.dataUrl;
+        return traceImage(dataUrl, {
+            maxWidth,
+            despeckleSize
+        });
+    }
+    else {
+        // mode is 'sample', and fileType is guaranteed to be svg+xml
+        return sampleSvg(imageFile.dataUrl, maxWidth);
+    }
+}

package/dist/src/manifoldUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Manifold utility functions
+ */
+import { Manifold } from '@cadit-app/manifold-3d/manifoldCAD';
+/**
+ * Creates an empty manifold (a very small cube that will be invisible)
+ */
+export declare function createEmptyManifold(): Manifold;
+//# sourceMappingURL=manifoldUtils.d.ts.map

package/dist/src/manifoldUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifoldUtils.d.ts","sourceRoot":"","sources":["../../src/manifoldUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAgB,MAAM,oCAAoC,CAAC;AAE5E;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,QAAQ,CAG9C"}

package/dist/src/manifoldUtils.js

@@ -0,0 +1,11 @@
+/**
+ * Manifold utility functions
+ */
+import { CrossSection } from '@cadit-app/manifold-3d/manifoldCAD';
+/**
+ * Creates an empty manifold (a very small cube that will be invisible)
+ */
+export function createEmptyManifold() {
+    // Create a tiny box that's essentially invisible
+    return CrossSection.square([0.001, 0.001], true).extrude(0.001);
+}

package/dist/src/params.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Parameter schema for the Image Extrude generator.
+ */
+/**
+ * Value type for image parameters.
+ * Matches the ImageFileValue type from @cadit-app/script-params.
+ * TODO: Import from script-params once version with ImageFileValue is published.
+ */
+export interface ImageFileValue {
+    /** Remote URL to fetch the image from (e.g., HTTP URL or relative path). */
+    imageUrl?: string;
+    /** Base64-encoded data URL of the image content. */
+    dataUrl?: string;
+    /** MIME type of the image (e.g., 'image/svg+xml', 'image/png'). */
+    fileType?: string;
+    /** Original filename of the image. */
+    fileName?: string;
+}
+export declare const imageExtrudeParamsSchema: {
+    mode: {
+        type: "choice";
+        label: string;
+        options: {
+            value: string;
+            label: string;
+        }[];
+        default: string;
+    };
+    imageFile: {
+        type: "image";
+        label: string;
+        default: ImageFileValue;
+    };
+    height: {
+        type: "number";
+        label: string;
+        default: number;
+        min: number;
+    };
+    maxWidth: {
+        type: "number";
+        label: string;
+        default: number;
+        min: number;
+    };
+    despeckleSize: {
+        type: "number";
+        label: string;
+        default: number;
+        min: number;
+    };
+};
+export type ImageExtrudeParams = {
+    mode: 'trace' | 'sample';
+    imageFile: ImageFileValue;
+    height: number;
+    maxWidth: number;
+    despeckleSize: number;
+};
+//# sourceMappingURL=params.d.ts.map

package/dist/src/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/params.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;iBAkB5B,cAAc;;;;;;;;;;;;;;;;;;;;CAoBtB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC"}

package/dist/src/params.js

@@ -0,0 +1,44 @@
+/**
+ * Parameter schema for the Image Extrude generator.
+ */
+// Default SVG - a simple star shape
+const defaultSvgDataUrl = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMDAgMTAwIj48cG9seWdvbiBwb2ludHM9IjUwLDUgNjEsMzkgOTcsMzkgNjgsMjIgNzksOTUgNTAsNzAgMjEsOTUgMzIsNjIgMywzOSAzOSwzOSIgZmlsbD0iYmxhY2siLz48L3N2Zz4=';
+export const imageExtrudeParamsSchema = {
+    mode: {
+        type: 'choice',
+        label: 'Mode',
+        options: [
+            { value: 'trace', label: 'Trace' },
+            { value: 'sample', label: 'Sample (SVG only)' },
+        ],
+        default: 'trace',
+    },
+    imageFile: {
+        type: 'image',
+        label: 'Image File',
+        default: {
+            imageUrl: '',
+            dataUrl: defaultSvgDataUrl,
+            fileType: 'image/svg+xml',
+            fileName: 'star.svg'
+        },
+    },
+    height: {
+        type: 'number',
+        label: 'Extrusion Height (mm)',
+        default: 1,
+        min: 0.1,
+    },
+    maxWidth: {
+        type: 'number',
+        label: 'Maximum Width (mm)',
+        default: 50,
+        min: 0.1,
+    },
+    despeckleSize: {
+        type: 'number',
+        label: 'Despeckle Size (Tracing only)',
+        default: 2,
+        min: 0.1,
+    },
+};

package/dist/src/resvg.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SVG to bitmap rendering using resvg-wasm
+ */
+/**
+ * Renders an SVG Data URL to a PNG Data URL using resvg-wasm.
+ */
+export declare const renderSvgToBitmapDataUrl: (svgDataUrl: string, options?: {
+    maxWidth?: number;
+}) => Promise<string>;
+//# sourceMappingURL=resvg.d.ts.map

package/dist/src/resvg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resvg.d.ts","sourceRoot":"","sources":["../../src/resvg.ts"],"names":[],"mappings":"AAAA;;GAEG;AA+BH;;GAEG;AACH,eAAO,MAAM,wBAAwB,GACnC,YAAY,MAAM,EAClB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KAC9B,OAAO,CAAC,MAAM,CAuBhB,CAAC"}