@cadit-app/maker-chips 0.2.1

package/README.md

@@ -0,0 +1,107 @@
+# @cadit-app/maker-chips
+
+Generate customizable maker chips with various patterns and optional embedded QR codes. Perfect for multi-color 3D printing.
+
+![Makerchip Maker Preview](images/preview.png)
+
+## Features
+
+- **20 Pattern Styles**: Choose from a variety of decorative chip patterns
+- **Customizable Dimensions**: Adjust radius, height, and edge rounding
+- **Center Circle**: Add a center circle for additional customization
+- **Multi-Color 3D Printing**: 3MF export with separate parts for multi-extruder printers
+- **Assembly Modes**: Flat preview or assembled for printing
+- **CLI Support**: Generate models directly from the command line
+
+## Usage
+
+### Open in CADit
+
+Open this design in [CADit](https://app.cadit.app) to customize and generate your maker chip with a visual interface.
+
+### Command Line
+
+Generate 3D models directly from the command line:
+
+```bash
+# Install dependencies
+pnpm install
+
+# Generate a .glb file (3D model)
+pnpm build:glb
+
+# Generate a .3mf file (for multi-color 3D printing)
+pnpm build:3mf
+
+# Generate with custom parameters
+npx tsx cli.ts my-chip.glb --radius 25 --markings makerChipV5
+npx tsx cli.ts my-chip.3mf --markings makerChipV10 --assembly printable
+```
+
+### CLI Options
+
+```
+Usage:
+  npx tsx cli.ts <output.[glb|3mf]> [options]
+
+Output Formats:
+  .glb   3D model (GLTF binary)
+  .3mf   3D model for multi-color printing
+
+Options:
+  -r, --radius <number>        Chip radius in mm (default: 20)
+  -h, --height <number>        Extrusion height in mm (default: 3)
+  --rounding <number>          Edge rounding radius in mm (default: 1)
+  --center-radius <number>     Center circle radius in mm (default: 14)
+  -a, --assembly <type>        Assembly type: flat or printable (default: flat)
+  -m, --markings <pattern>     Pattern style (default: makerChipV1)
+  --help                       Show this help
+
+Examples:
+  npx tsx cli.ts chip.glb
+  npx tsx cli.ts chip.3mf --markings makerChipV5 --radius 25
+  npx tsx cli.ts chip.glb -m makerChipV10 -a printable
+```
+
+### Available Patterns
+
+The following pattern styles are available:
+
+`makerChipV1`, `makerChipV2`, `makerChipV3`, `makerChipV4`, `makerChipV5`,
+`makerChipV6`, `makerChipV7`, `makerChipV8`, `makerChipV9`, `makerChipV10`,
+`makerChipV11`, `makerChipV12`, `makerChipV13`, `makerChipV14`, `makerChipV15`,
+`makerChipV16`, `makerChipV17`, `makerChipV18`, `makerChipV19`, `makerChipV20`
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| radius | number | 20 | Chip radius in millimeters |
+| height | number | 3 | Extrusion height in millimeters |
+| roundingRadius | number | 1 | Edge rounding radius in millimeters |
+| centerCircleRadius | number | 14 | Center circle radius in millimeters |
+| assemblyType | choice | flat | Assembly mode: flat (preview) or printable |
+| markings | buttonGrid | makerChipV1 | Pattern style selection |
+
+## Multi-Color Printing
+
+The 3MF export includes separate parts assigned to different extruders:
+- Part 1: Base disk (Extruder 1)
+- Part 2: Center circle (Extruder 2)
+- Part 3: Pattern/marking (Extruder 3)
+
+This works with slicers like Bambu Studio, PrusaSlicer, and Cura.
+
+## Attribution
+
+This project is based on [Makerchip Maker Chip](https://makerworld.com/en/models/415825-makerchip-maker-chip) by K2_Kevin.
+
+The original maker chip designs were manually converted to SVG and used as a starting point for this parametric generator.
+
+**License**: [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/)
+
+---
+
+<p align="center">
+  <sub>Created with <a href="https://cadit.app">CADit</a> - The open platform for code-based 3D models.</sub>
+</p>

package/cadit.json

@@ -0,0 +1,28 @@
+{
+  "name": "Makerchip Maker",
+  "description": "Generate customizable maker chips with various patterns and optional embedded QR codes. Features 20 decorative patterns and multi-color 3MF export for 3D printing.",
+  "entryPoint": "src/main.ts",
+  "tags": ["maker-chip", "patterns", "3d-printing", "multi-color", "customizable"],
+  "category": "Tools",
+  "license": {
+    "type": "CC BY-NC-SA 4.0",
+    "url": "https://creativecommons.org/licenses/by-nc-sa/4.0/"
+  },
+  "author": {
+    "name": "CADit"
+  },
+  "attribution": {
+    "isDerivative": true,
+    "originalAuthor": "K2_Kevin",
+    "originalAuthorUrl": "https://makerworld.com/en/@K2_Kevin",
+    "sourceUrl": "https://makerworld.com/en/models/415825-makerchip-maker-chip",
+    "description": "Original maker chip designs by K2_Kevin were manually converted to SVG and used as a starting point."
+  },
+  "images": [
+    {
+      "path": "images/preview.png",
+      "alt": "Makerchip Maker Preview",
+      "isPrimary": true
+    }
+  ]
+}

package/cli.ts

@@ -0,0 +1,218 @@
+#!/usr/bin/env npx tsx
+/**
+ * CLI for generating Makerchip models
+ * 
+ * Usage:
+ *   npx tsx cli.ts output.glb
+ *   npx tsx cli.ts output.3mf
+ *   npx tsx cli.ts output.glb --radius 25 --markings makerChipV5
+ */
+
+import { extname, basename } from 'path';
+import { writeFile, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { parseArgs } from 'util';
+import type { Manifold } from '@cadit-app/manifold-3d';
+
+const SUPPORTED_FORMATS = ['.glb', '.3mf'] as const;
+type OutputFormat = (typeof SUPPORTED_FORMATS)[number];
+
+// Parse command line arguments
+const { values, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    radius: { type: 'string', short: 'r', default: '20' },
+    height: { type: 'string', short: 'h', default: '3' },
+    rounding: { type: 'string', default: '1' },
+    'center-radius': { type: 'string', default: '14' },
+    assembly: { type: 'string', short: 'a', default: 'flat' },
+    markings: { type: 'string', short: 'm', default: 'makerChipV1' },
+    // QR Code embedded params
+    'qr-enabled': { type: 'boolean', default: false },
+    'qr-content': { type: 'string', default: 'https://cadit.app' },
+    'qr-size': { type: 'string', default: '18' },
+    'qr-height': { type: 'string', default: '1' },
+    // Image Extrude embedded params
+    'image-enabled': { type: 'boolean', default: false },
+    'image-file': { type: 'string' },
+    'image-mode': { type: 'string', default: 'sample' },
+    'image-height': { type: 'string', default: '1' },
+    'image-max-width': { type: 'string', default: '18' },
+    help: { type: 'boolean', default: false },
+  },
+});
+
+if (values.help || positionals.length === 0) {
+  console.log(`
+Makerchip Generator CLI
+
+Usage:
+  npx tsx cli.ts <output.[glb|3mf]> [options]
+
+Output Formats:
+  .glb   3D model (GLTF binary)
+  .3mf   3D model for multi-color printing
+
+Chip Options:
+  -r, --radius <number>        Chip radius in mm (default: 20)
+  -h, --height <number>        Extrusion height in mm (default: 3)
+  --rounding <number>          Edge rounding radius in mm (default: 1)
+  --center-radius <number>     Center circle radius in mm (default: 14)
+  -a, --assembly <type>        Assembly type: flat or printable (default: flat)
+  -m, --markings <pattern>     Pattern style (default: makerChipV1)
+
+QR Code Options (embedded maker):
+  --qr-enabled                 Enable QR code generation
+  --qr-content <text>          QR code content (default: https://cadit.app)
+  --qr-size <number>           QR code size in mm (default: 18)
+  --qr-height <number>         QR code extrusion height in mm (default: 1)
+
+Image Extrude Options (embedded maker):
+  --image-enabled              Enable image extrusion
+  --image-file <path>          Path to image file (SVG, PNG, JPG)
+  --image-mode <trace|sample>  Processing mode (default: sample)
+  --image-height <number>      Extrusion height in mm (default: 1)
+  --image-max-width <number>   Maximum width in mm (default: 18)
+
+General:
+  --help                       Show this help
+
+Available Patterns:
+  makerChipV1 through makerChipV20
+
+Examples:
+  npx tsx cli.ts chip.glb
+  npx tsx cli.ts chip.3mf --markings makerChipV5 --radius 25
+  npx tsx cli.ts chip.glb -m makerChipV10 -a printable
+  npx tsx cli.ts chip.glb --qr-enabled --qr-content "Hello World"
+  npx tsx cli.ts chip.glb --image-enabled --image-file logo.svg
+`);
+  process.exit(0);
+}
+
+const outputFile = positionals[0];
+const ext = extname(outputFile).toLowerCase() as OutputFormat;
+
+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 (must happen before importing maker modules)
+  const manifoldModule = await import('@cadit-app/manifold-3d');
+  await manifoldModule.default();
+
+  console.log('Loading Makerchip module...');
+
+  // Import the Makerchip generator
+  const makerchipModule = await import('./src/main');
+  const { getDefaults } = await import('@cadit-app/script-params');
+  const { qrCodeParamsSchema } = await import('@cadit-app/qr-code/src/params');
+  const { imageExtrudeParamsSchema } = await import('@cadit-app/image-extrude/src/params');
+
+  // Get defaults from the embedded makers' schemas
+  const qrCodeDefaults = getDefaults(qrCodeParamsSchema);
+  const imageExtrudeDefaults = getDefaults(imageExtrudeParamsSchema);
+
+  // Build QR code embedded params
+  const qrCodeSettings = {
+    enabled: values['qr-enabled'] ?? false,
+    showSettings: false,
+    params: {
+      ...qrCodeDefaults,
+      text: values['qr-content'] || qrCodeDefaults.text,
+      size: parseFloat(values['qr-size'] || String(qrCodeDefaults.size)),
+      extrudeDepth: parseFloat(values['qr-height'] || String(qrCodeDefaults.extrudeDepth)),
+    },
+  };
+
+  // Build image extrude embedded params
+  const imageExtrudeSettings = {
+    enabled: values['image-enabled'] ?? false,
+    showSettings: false,
+    params: {
+      ...imageExtrudeDefaults,
+      mode: values['image-mode'] || imageExtrudeDefaults.mode,
+      height: parseFloat(values['image-height'] || String(imageExtrudeDefaults.height)),
+      maxWidth: parseFloat(values['image-max-width'] || String(imageExtrudeDefaults.maxWidth)),
+    },
+  };
+
+  // Load image file if specified
+  if (values['image-enabled'] && values['image-file']) {
+    const imagePath = values['image-file'];
+    if (existsSync(imagePath)) {
+      const imageData = await readFile(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';
+      imageExtrudeSettings.params.imageFile = {
+        dataUrl: `data:${mimeType};base64,${base64}`,
+        fileType: mimeType,
+        fileName: basename(imagePath),
+      };
+      console.log(`Loaded image: ${imagePath}`);
+    } else {
+      console.warn(`Warning: Image file not found: ${imagePath}`);
+    }
+  }
+
+  const params = {
+    radius: parseFloat(values.radius || '20'),
+    height: parseFloat(values.height || '3'),
+    roundingRadius: parseFloat(values.rounding || '1'),
+    centerCircleRadius: parseFloat(values['center-radius'] || '14'),
+    assemblyType: values.assembly || 'flat',
+    markings: values.markings || 'makerChipV1',
+    qrCodeSettings,
+    imageExtrudeSettings,
+  };
+
+  console.log('Generating Makerchip with params:', {
+    ...params,
+    qrCodeSettings: { enabled: qrCodeSettings.enabled, text: qrCodeSettings.params.text },
+    imageExtrudeSettings: { enabled: imageExtrudeSettings.enabled, hasImage: !!imageExtrudeSettings.params.imageFile?.dataUrl },
+  });
+
+  if (ext === '.3mf') {
+    // Use the 3MF exporter directly
+    const { threeMfExport } = await import('./src/threeMfExport');
+    const result = await threeMfExport(params as any);
+    await writeFile(outputFile, Buffer.from(result.data as ArrayBuffer));
+    console.log(`✓ Generated ${outputFile}`);
+  } else {
+    // Generate the manifold for GLB
+    const result = await makerchipModule.default(params) as Manifold;
+
+    if (!result || typeof (result as any).getMesh !== 'function') {
+      console.error('Error: Script did not return a valid Manifold object');
+      process.exit(1);
+    }
+
+    console.log('Converting to GLTF document...');
+
+    // Convert to GLTF document
+    const { manifoldToGLTFDoc } = await import('@cadit-app/manifold-3d/lib/scene-builder.js');
+    const exportModel = await import('@cadit-app/manifold-3d/lib/export-model.js');
+    const doc = await manifoldToGLTFDoc(result as any);
+
+    console.log(`Exporting to ${outputFile}...`);
+
+    // Export to file
+    await exportModel.writeFile(outputFile, doc);
+
+    console.log(`✓ Generated ${outputFile}`);
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message || err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@cadit-app/maker-chips",
+  "version": "0.2.1",
+  "description": "Customizable maker chip generator with patterns and embedded QR codes",
+  "type": "module",
+  "main": "src/main.ts",
+  "dependencies": {
+    "@cadit-app/script-params": "^0.4.1",
+    "@cadit-app/svg-sampler": "^0.1.0",
+    "@cadit-app/qr-code": "^0.5.1",
+    "@cadit-app/image-extrude": "^0.3.2",
+    "@jscadui/3mf-export": "^0.5.0",
+    "fflate": "^0.8.2"
+  },
+  "peerDependencies": {
+    "@cadit-app/manifold-3d": "^3.0.0"
+  },
+  "devDependencies": {
+    "@cadit-app/manifold-3d": "^3.3.2",
+    "@types/node": "^25.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "cadit",
+    "maker-chip",
+    "3d-printing",
+    "parametric",
+    "qr-code"
+  ],
+  "author": {
+    "name": "CADit"
+  },
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "generate": "npx tsx cli.ts",
+    "build:glb": "npx tsx cli.ts output.glb",
+    "build:3mf": "npx tsx cli.ts output.3mf"
+  }
+}

package/scripts/generate-embedded-svgs.cjs

@@ -0,0 +1,57 @@
+/**
+ * Script to generate embedded SVGs from the images folder
+ * Run with: node scripts/generate-embedded-svgs.cjs
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const imagesDir = path.join(__dirname, '../src/images');
+const outputFile = path.join(__dirname, '../src/embeddedSvgs.ts');
+
+// Get all SVG files
+const svgFiles = fs.readdirSync(imagesDir)
+  .filter(f => f.endsWith('.svg'))
+  .sort((a, b) => {
+    // Sort numerically by version number
+    const numA = parseInt(a.match(/v(\d+)/)?.[1] || '0');
+    const numB = parseInt(b.match(/v(\d+)/)?.[1] || '0');
+    return numA - numB;
+  });
+
+// Generate TypeScript content
+let content = `/**
+ * Embedded SVG images for maker chip patterns.
+ * Auto-generated by scripts/generate-embedded-svgs.cjs
+ */
+
+export const embeddedSvgs: Record<string, string> = {\n`;
+
+for (const file of svgFiles) {
+  const svgContent = fs.readFileSync(path.join(imagesDir, file), 'utf-8');
+  // Convert filename to key: makerchip-v1.svg -> makerChipV1
+  const key = file
+    .replace('.svg', '')
+    .replace(/makerchip-v(\d+)/, (_, num) => `makerChipV${num}`);
+  
+  // Escape backticks and convert to template literal
+  const escapedContent = svgContent.replace(/`/g, '\\`').replace(/\$/g, '\\$');
+  content += `  ${key}: \`${escapedContent}\`,\n`;
+}
+
+content += `};\n\n`;
+
+// Generate data URL versions for button grid display
+content += `/**
+ * SVG data URLs for button grid display
+ */
+export const svgDataUrls: Record<string, string> = Object.fromEntries(
+  Object.entries(embeddedSvgs).map(([key, svg]) => [
+    key,
+    \`data:image/svg+xml;base64,\${typeof btoa !== 'undefined' ? btoa(svg) : Buffer.from(svg).toString('base64')}\`
+  ])
+);
+`;
+
+fs.writeFileSync(outputFile, content);
+console.log(`Generated ${outputFile} with ${svgFiles.length} SVGs`);

package/src/assembly.ts

@@ -0,0 +1,105 @@
+/**
+ * Assembly utilities for composing Makerchip shapes.
+ */
+
+import type { Manifold } from '@cadit-app/manifold-3d';
+import { roundedDisk, generateMarkingShape, generateCenterDisk } from './disk';
+import type { MakerChipParams } from './params';
+import qrCodeMaker from '@cadit-app/qr-code';
+import imageExtrudeMaker from '@cadit-app/image-extrude';
+
+export type AssemblyType = 'flat' | 'printable';
+
+/**
+ * Assembles all shapes for the Makerchip.
+ * 
+ * @param params - The parameters for the Makerchip
+ * @param assemblyType - 'flat' for preview/export, 'printable' for 3D printing
+ * @returns An array of Manifold shapes
+ */
+export async function assembleMakerchipShapes(
+  params: MakerChipParams,
+  assemblyType: AssemblyType
+): Promise<Manifold[]> {
+  // Create chip base
+  const disk = roundedDisk({
+    radius: params.radius,
+    roundingRadius: params.roundingRadius,
+    height: params.height,
+  });
+
+  // Create marking pattern
+  const marking = await generateMarkingShape({
+    shapeName: params.markings,
+    radius: params.radius,
+    roundingRadius: params.roundingRadius,
+    height: params.height,
+  });
+
+  // Create center disk
+  const centerDisk = generateCenterDisk({
+    centerCircleRadius: params.centerCircleRadius,
+    height: params.height,
+  });
+
+  // Generate QR code if enabled
+  let qrCode: Manifold | undefined;
+  if (params.qrCodeSettings?.enabled) {
+    try {
+      // qrCodeMaker is a callable ScriptModule - call it directly with params
+      qrCode = await qrCodeMaker(params.qrCodeSettings.params) as Manifold;
+    } catch (error) {
+      console.error('Error generating QR code:', error);
+    }
+  }
+
+  // Generate image extrude if enabled
+  let imageExtrude: Manifold | undefined;
+  if (params.imageExtrudeSettings?.enabled) {
+    try {
+      // imageExtrudeMaker is a callable ScriptModule - call it directly with params
+      imageExtrude = await imageExtrudeMaker(params.imageExtrudeSettings.params) as Manifold;
+    } catch (error) {
+      console.error('Error generating image extrude:', error);
+    }
+  }
+
+  const allShapes: Manifold[] = [];
+
+  if (assemblyType === 'flat') {
+    // Spread shapes out for preview
+    const offset = 2 * params.radius + 1;
+    allShapes.push(disk);
+    allShapes.push(marking.translate([offset, 0, 0]));
+    allShapes.push(centerDisk.translate([0, offset, 0]));
+    
+    if (qrCode) {
+      const qrSize = params.qrCodeSettings.params.size || 18;
+      allShapes.push(qrCode.translate([-(params.radius + qrSize / 2 + 1), 0, 0]));
+    }
+    
+    if (imageExtrude) {
+      const bounds = imageExtrude.boundingBox();
+      const height = bounds.max[1] - bounds.min[1];
+      allShapes.push(imageExtrude.translate([0, -(params.radius + height / 2 + 1), 0]));
+    }
+  } else if (assemblyType === 'printable') {
+    // Stack shapes for printing
+    allShapes.push(disk);
+    allShapes.push(centerDisk);
+    allShapes.push(marking);
+    
+    if (qrCode) {
+      // QR code is always on top
+      const zTranslate = params.height - qrCode.boundingBox().max[2];
+      allShapes.push(qrCode.translate([0, 0, zTranslate]));
+    }
+    
+    if (imageExtrude) {
+      // Image extrude is always on bottom (flip it)
+      allShapes.push(imageExtrude.mirror([1, 0, 0]));
+    }
+  }
+
+  return allShapes;
+}

package/src/crossSectionUtils.ts

@@ -0,0 +1,42 @@
+/**
+ * CrossSection utility functions for scaling and centering.
+ */
+
+import type { CrossSection, Vec2 } from '@cadit-app/manifold-3d';
+
+/**
+ * Scales a cross-section to fit within the specified width and height,
+ * maintaining aspect ratio and centering the result.
+ */
+export function scaleToSizeAndCenter(
+  crossSection: CrossSection,
+  targetWidth: number,
+  targetHeight: number
+): CrossSection {
+  const bounds = crossSection.bounds();
+  const currentWidth = bounds.max[0] - bounds.min[0];
+  const currentHeight = bounds.max[1] - bounds.min[1];
+
+  if (currentWidth === 0 || currentHeight === 0) {
+    return crossSection;
+  }
+
+  // Calculate scale to fit within target dimensions
+  const scaleX = targetWidth / currentWidth;
+  const scaleY = targetHeight / currentHeight;
+  const scale = Math.min(scaleX, scaleY);
+
+  // Scale the cross-section
+  const scaled = crossSection.scale([scale, scale]);
+
+  // Get new bounds after scaling
+  const scaledBounds = scaled.bounds();
+  const scaledWidth = scaledBounds.max[0] - scaledBounds.min[0];
+  const scaledHeight = scaledBounds.max[1] - scaledBounds.min[1];
+
+  // Center the result
+  const offsetX = -scaledBounds.min[0] - scaledWidth / 2;
+  const offsetY = -scaledBounds.min[1] - scaledHeight / 2;
+
+  return scaled.translate([offsetX, offsetY]);
+}