git-hash-art 0.0.4 → 0.2.0

package/src/__tests__/render.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from "vitest";
+import { createCanvas } from "@napi-rs/canvas";
+import { renderHashArt } from "../lib/render";
+
+const TEST_HASH = "46192e59d42f741c761cbea79462a8b3815dd905";
+
+function createTestCtx(width = 128, height = 128) {
+  const canvas = createCanvas(width, height);
+  return canvas.getContext("2d") as unknown as CanvasRenderingContext2D;
+}
+
+describe("renderHashArt (core renderer)", () => {
+  it("renders without error on a provided context", () => {
+    const ctx = createTestCtx();
+    expect(() =>
+      renderHashArt(ctx, TEST_HASH, { width: 128, height: 128 }),
+    ).not.toThrow();
+  });
+
+  it("is deterministic — same hash + config produces identical pixel data", () => {
+    const canvas1 = createCanvas(64, 64);
+    const canvas2 = createCanvas(64, 64);
+    const config = { width: 64, height: 64, gridSize: 3 };
+
+    renderHashArt(
+      canvas1.getContext("2d") as unknown as CanvasRenderingContext2D,
+      TEST_HASH,
+      config,
+    );
+    renderHashArt(
+      canvas2.getContext("2d") as unknown as CanvasRenderingContext2D,
+      TEST_HASH,
+      config,
+    );
+
+    const buf1 = canvas1.toBuffer("image/png");
+    const buf2 = canvas2.toBuffer("image/png");
+    expect(buf1.equals(buf2)).toBe(true);
+  });
+
+  it("different hashes produce different output", () => {
+    const canvas1 = createCanvas(64, 64);
+    const canvas2 = createCanvas(64, 64);
+    const config = { width: 64, height: 64, gridSize: 3 };
+
+    renderHashArt(
+      canvas1.getContext("2d") as unknown as CanvasRenderingContext2D,
+      TEST_HASH,
+      config,
+    );
+    renderHashArt(
+      canvas2.getContext("2d") as unknown as CanvasRenderingContext2D,
+      "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+      config,
+    );
+
+    const buf1 = canvas1.toBuffer("image/png");
+    const buf2 = canvas2.toBuffer("image/png");
+    expect(buf1.equals(buf2)).toBe(false);
+  });
+
+  it("uses defaults when no config is provided", () => {
+    // Large default canvas — just verify it doesn't throw
+    const canvas = createCanvas(2048, 2048);
+    const ctx = canvas.getContext("2d") as unknown as CanvasRenderingContext2D;
+    expect(() => renderHashArt(ctx, TEST_HASH)).not.toThrow();
+  });
+
+  it("respects custom config values", () => {
+    const ctx = createTestCtx(256, 128);
+    expect(() =>
+      renderHashArt(ctx, TEST_HASH, {
+        width: 256,
+        height: 128,
+        layers: 2,
+        gridSize: 3,
+        baseOpacity: 0.5,
+      }),
+    ).not.toThrow();
+  });
+});

package/src/__tests__/shapes.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { createCanvas } from "@napi-rs/canvas";
+import { shapes } from "../lib/canvas/shapes";
+import { drawShape, enhanceShapeGeneration } from "../lib/canvas/draw";
+
+const TEST_HASH = "46192e59d42f741c761cbea79462a8b3815dd905";
+
+function createTestCtx(size = 256) {
+  const canvas = createCanvas(size, size);
+  return canvas.getContext("2d") as unknown as CanvasRenderingContext2D;
+}
+
+describe("all shapes render without crashing", () => {
+  const shapeNames = Object.keys(shapes);
+
+  it.each(shapeNames)("shape '%s' draws without error", (name) => {
+    const ctx = createTestCtx();
+    expect(() => shapes[name](ctx, 100)).not.toThrow();
+  });
+
+  it.each(shapeNames)("shape '%s' works through drawShape()", (name) => {
+    const ctx = createTestCtx();
+    expect(() =>
+      drawShape(ctx, name, 128, 128, {
+        fillColor: "#ff0000",
+        strokeColor: "#000000",
+        strokeWidth: 2,
+        size: 80,
+        rotation: 45,
+      }),
+    ).not.toThrow();
+  });
+
+  it.each(shapeNames)(
+    "shape '%s' works through enhanceShapeGeneration()",
+    (name) => {
+      const ctx = createTestCtx();
+      expect(() =>
+        enhanceShapeGeneration(ctx, name, 128, 128, {
+          fillColor: "#ff0000",
+          strokeColor: "#000000",
+          strokeWidth: 2,
+          size: 80,
+          rotation: 45,
+          proportionType: "GOLDEN_RATIO",
+        }),
+      ).not.toThrow();
+    },
+  );
+});
+
+describe("platonicSolid handles missing config.type gracefully", () => {
+  it("renders with no config at all", () => {
+    const ctx = createTestCtx();
+    expect(() => shapes["platonicSolid"](ctx, 100)).not.toThrow();
+  });
+
+  it("renders with explicit type", () => {
+    const ctx = createTestCtx();
+    expect(() =>
+      shapes["platonicSolid"](ctx, 100, { type: "tetrahedron" }),
+    ).not.toThrow();
+  });
+
+  it("renders with invalid type (falls back)", () => {
+    const ctx = createTestCtx();
+    expect(() =>
+      shapes["platonicSolid"](ctx, 100, { type: "nonexistent" }),
+    ).not.toThrow();
+  });
+});

package/src/browser.ts

@@ -0,0 +1,105 @@
+/**
+ * Browser entry point for git-hash-art.
+ *
+ * This module has zero Node.js dependencies — it works with a standard
+ * HTMLCanvasElement or OffscreenCanvas and the native Canvas 2D API.
+ */
+import { renderHashArt } from "./lib/render";
+import type { GenerationConfig } from "./types";
+import { DEFAULT_CONFIG } from "./types";
+
+/**
+ * Render hash-derived art directly onto an HTMLCanvasElement.
+ *
+ * The canvas should already have the desired width/height set.
+ * Config width/height will be inferred from the canvas if not provided.
+ *
+ * @param canvas  - An HTMLCanvasElement (or OffscreenCanvas)
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ */
+function renderToCanvas(
+  canvas: HTMLCanvasElement | OffscreenCanvas,
+  gitHash: string,
+  config: Partial<GenerationConfig> = {},
+): void {
+  const ctx = canvas.getContext("2d") as CanvasRenderingContext2D;
+  if (!ctx) {
+    throw new Error("Failed to get 2D rendering context from canvas");
+  }
+
+  const finalConfig: Partial<GenerationConfig> = {
+    width: canvas.width,
+    height: canvas.height,
+    ...config,
+  };
+
+  renderHashArt(ctx, gitHash, finalConfig);
+}
+
+/**
+ * Render hash-derived art and return it as a Blob (browser-native).
+ *
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ * @returns A Promise that resolves to a PNG Blob
+ */
+async function generateImageBlob(
+  gitHash: string,
+  config: Partial<GenerationConfig> = {},
+): Promise<Blob> {
+  const finalConfig: GenerationConfig = { ...DEFAULT_CONFIG, ...config };
+  const { width, height } = finalConfig;
+
+  const canvas = new OffscreenCanvas(width, height);
+  const ctx = canvas.getContext("2d") as OffscreenCanvasRenderingContext2D;
+  if (!ctx) {
+    throw new Error("Failed to get 2D rendering context from OffscreenCanvas");
+  }
+
+  renderHashArt(
+    ctx as unknown as CanvasRenderingContext2D,
+    gitHash,
+    finalConfig,
+  );
+
+  return canvas.convertToBlob({ type: "image/png" });
+}
+
+/**
+ * Render hash-derived art and return it as a data URL string.
+ *
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ * @returns A data:image/png;base64,… string
+ */
+function generateDataURL(
+  gitHash: string,
+  config: Partial<GenerationConfig> = {},
+): string {
+  const finalConfig: GenerationConfig = { ...DEFAULT_CONFIG, ...config };
+  const { width, height } = finalConfig;
+
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get 2D rendering context");
+  }
+
+  renderHashArt(ctx, gitHash, finalConfig);
+
+  return canvas.toDataURL("image/png");
+}
+
+export {
+  renderToCanvas,
+  generateImageBlob,
+  generateDataURL,
+  renderHashArt,
+};
+export { PRESETS } from "./lib/constants";
+export type { GenerationConfig } from "./types";
+export { DEFAULT_CONFIG } from "./types";

package/src/index.ts

@@ -1,208 +1,54 @@
-import { createCanvas } from "canvas";
-import fs from "fs";
-import path from "path";
-import { SacredColorScheme } from "./lib/canvas/colors";
-import { enhanceShapeGeneration } from "./lib/canvas/draw";
-import { shapes } from "./lib/canvas/shapes";
-import { getRandomFromHash } from "./lib/utils";
+import { createCanvas } from "@napi-rs/canvas";
+import * as fs from "fs";
+import * as path from "path";
+import { renderHashArt } from "./lib/render";
+import type { GenerationConfig } from "./types";
+import { DEFAULT_CONFIG } from "./types";
 
 /**
- * Generate an abstract art image from a git hash with custom configuration
- * @param {string} gitHash - The git hash to use as a seed
- * @param {ArtConfig} [config={}] - Configuration options
- * @returns {Buffer} PNG buffer of the generated image
+ * Generate an abstract art PNG buffer from a git hash (Node.js only).
+ *
+ * Uses @napi-rs/canvas under the hood to create an off-screen canvas,
+ * renders the hash-derived art, and returns the result as a PNG Buffer.
+ *
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ * @returns PNG buffer of the generated image
  */
-function generateImageFromHash(gitHash: string, config = {}) {
-  // Default configuration
-  const defaultConfig = {
-    width: 2048,
-    height: 2048,
-    gridSize: 12,
-    layers: 2,
-    minShapeSize: 20,
-    maxShapeSize: 600,
-    baseOpacity: 0.8,
-    opacityReduction: 0.4,
-    shapesPerLayer: 0,
-  };
-
-  // Merge provided config with defaults
-  const finalConfig = { ...defaultConfig, ...config };
-  const {
-    width,
-    height,
-    gridSize,
-    layers,
-    minShapeSize,
-    maxShapeSize,
-    baseOpacity,
-    opacityReduction,
-  } = finalConfig;
-
-  // Calculate shapes per layer based on grid size if not provided
-  finalConfig.shapesPerLayer =
-    finalConfig.shapesPerLayer || Math.floor(gridSize * gridSize * 1.5);
+function generateImageFromHash(
+  gitHash: string,
+  config: Partial<GenerationConfig> = {},
+): Buffer {
+  const finalConfig: GenerationConfig = { ...DEFAULT_CONFIG, ...config };
+  const { width, height } = finalConfig;
 
   const canvas = createCanvas(width, height);
   const ctx = canvas.getContext("2d") as unknown as CanvasRenderingContext2D;
 
-  const colorScheme = new SacredColorScheme(gitHash);
-  const colors = colorScheme.getColorPalette("chakra");
-
-  // Create a gradient background
-  const gradient = ctx.createLinearGradient(0, 0, width, height);
-  gradient.addColorStop(0, colorScheme.baseScheme[0]);
-  gradient.addColorStop(1, colorScheme.baseScheme[1]);
-  ctx.fillStyle = gradient;
-  ctx.fillRect(0, 0, width, height);
-
-  const shapeNames = Object.keys(shapes);
-
-  const cellWidth = width / gridSize;
-  const cellHeight = height / gridSize;
-
-  // Scale shape sizes based on canvas dimensions
-  const scaleFactor = Math.min(width, height) / 1024;
-  const adjustedMinSize = minShapeSize * scaleFactor;
-  const adjustedMaxSize = maxShapeSize * scaleFactor;
-
-  for (let layer = 0; layer < layers; layer++) {
-    const numShapes =
-      finalConfig.shapesPerLayer +
-      Math.floor(
-        getRandomFromHash(gitHash, layer, 0, finalConfig.shapesPerLayer / 2),
-      );
-    const layerOpacity = baseOpacity - layer * opacityReduction;
-
-    for (let i = 0; i < numShapes; i++) {
-      const gridX = Math.floor(i / gridSize);
-      const gridY = i % gridSize;
-
-      const cellOffsetX = getRandomFromHash(
-        gitHash,
-        layer * numShapes + i * 2,
-        0,
-        cellWidth,
-      );
-      const cellOffsetY = getRandomFromHash(
-        gitHash,
-        layer * numShapes + i * 2 + 1,
-        0,
-        cellHeight,
-      );
-
-      const x = gridX * cellWidth + cellOffsetX;
-      const y = gridY * cellHeight + cellOffsetY;
-
-      const shape =
-        shapeNames[
-          Math.floor(
-            getRandomFromHash(
-              gitHash,
-              layer * numShapes + i * 3,
-              0,
-              shapeNames.length,
-            ),
-          )
-        ];
-      const size =
-        adjustedMinSize +
-        getRandomFromHash(
-          gitHash,
-          layer * numShapes + i * 4,
-          0,
-          adjustedMaxSize - adjustedMinSize,
-        );
-      const rotation = getRandomFromHash(
-        gitHash,
-        layer * numShapes + i * 5,
-        0,
-        360,
-      );
-
-      const fillColorIndex = Math.floor(
-        getRandomFromHash(
-          gitHash,
-          layer * numShapes + i * 6,
-          0,
-          Object.keys(colors).length,
-        ),
-      );
-      const strokeColorIndex = Math.floor(
-        getRandomFromHash(
-          gitHash,
-          layer * numShapes + i * 7,
-          0,
-          Object.keys(colors).length,
-        ),
-      );
-
-      ctx.globalAlpha = layerOpacity;
-      // drawShape(
-      //   ctx,
-      //   shape,
-      //   x,
-      //   y,
-      //   colors[fillColorIndex],
-      //   colors[strokeColorIndex],
-      //   2 * scaleFactor,
-      //   size,
-      //   rotation
-      // );
-
-      enhanceShapeGeneration(ctx, shape, x, y, {
-        fillColor: Object.values(colors)[fillColorIndex],
-        strokeColor: Object.values(colors)[strokeColorIndex],
-        strokeWidth: 1.5 * scaleFactor,
-        size,
-        rotation,
-        // Optionally add pattern combinations
-        // patterns:
-        //   Math.random() > 0.7 ? PatternPresets.cosmicTree(size) : [],
-        proportionType: "GOLDEN_RATIO",
-      });
-    }
-
-    // Add connecting lines scaled to canvas size
-    ctx.globalAlpha = 0.2;
-    ctx.strokeStyle = Object.values(colors)[Object.keys(colors).length - 1];
-    ctx.lineWidth = 1 * scaleFactor;
-
-    const numLines = Math.floor((15 * (width * height)) / (1024 * 1024));
-    for (let i = 0; i < numLines; i++) {
-      const x1 = getRandomFromHash(gitHash, i * 4, 0, width);
-      const y1 = getRandomFromHash(gitHash, i * 4 + 1, 0, height);
-      const x2 = getRandomFromHash(gitHash, i * 4 + 2, 0, width);
-      const y2 = getRandomFromHash(gitHash, i * 4 + 3, 0, height);
-
-      ctx.beginPath();
-      ctx.moveTo(x1, y1);
-      ctx.lineTo(x2, y2);
-      ctx.stroke();
-    }
-  }
+  renderHashArt(ctx, gitHash, finalConfig);
 
   return canvas.toBuffer("image/png");
 }
 
 /**
- * Save the generated image to a file
- * @param {Buffer} imageBuffer - The PNG buffer of the generated image
- * @param {string} outputDir - The directory to save the image
- * @param {string} gitHash - The git hash used to generate the image
- * @param {string} [label=''] - Label for the output file
- * @param {number} width - The width of the generated image
- * @param {number} height - The height of the generated image
- * @returns {string} Path to the saved image
+ * Save the generated image to a file (Node.js only).
+ *
+ * @param imageBuffer - The PNG buffer of the generated image
+ * @param outputDir   - The directory to save the image
+ * @param gitHash     - The git hash used to generate the image
+ * @param label       - Optional label for the output filename
+ * @param width       - The width of the generated image
+ * @param height      - The height of the generated image
+ * @returns Path to the saved image
  */
 function saveImageToFile(
-  imageBuffer: string,
+  imageBuffer: Buffer,
   outputDir: string,
-  gitHash: string | any[],
+  gitHash: string,
   label = "",
-  width: any,
-  height: any,
-) {
+  width: number,
+  height: number,
+): string {
   if (!fs.existsSync(outputDir)) {
     fs.mkdirSync(outputDir, { recursive: true });
   }
@@ -218,14 +64,7 @@ function saveImageToFile(
   return outputPath;
 }
 
-export { generateImageFromHash, saveImageToFile };
-
-// Usage example:
-/*
-import { generateImageFromHash, saveImageToFile } from 'git-hash-art';
-
-const gitHash = '1234567890abcdef1234567890abcdef12345678';
-const imageBuffer = generateImageFromHash(gitHash, { width: 1024, height: 1024 });
-const savedImagePath = saveImageToFile(imageBuffer, './output', gitHash, 'example', 1024, 1024);
-console.log(`Image saved to: ${savedImagePath}`);
-*/
+export { generateImageFromHash, saveImageToFile, renderHashArt };
+export { PRESETS } from "./lib/constants";
+export type { GenerationConfig } from "./types";
+export { DEFAULT_CONFIG } from "./types";