git-hash-art 0.0.2 → 0.0.4

package/src/lib/{utils.js → utils.ts}

@@ -1,10 +1,15 @@
 import { shapes } from "./canvas/shapes";
 
-export function gitHashToSeed(gitHash) {
+export function gitHashToSeed(gitHash: string): number {
   return parseInt(gitHash.slice(0, 8), 16);
 }
 
-export function getRandomFromHash(hash, index, min, max) {
+export function getRandomFromHash(
+  hash: string,
+  index: number,
+  min: number,
+  max: number,
+): number {
   const hexPair = hash.substr((index * 2) % hash.length, 2);
   const decimal = parseInt(hexPair, 16);
   return min + (decimal / 255) * (max - min);
@@ -20,18 +25,41 @@ export const Proportions = {
   PHI: (1 + Math.sqrt(5)) / 2,
 };
 
+export type ProportionType = keyof typeof Proportions;
+
+interface Pattern {
+  type: string;
+  config: any; // You might want to define a more specific type for config
+}
+
+interface LayerConfig {
+  baseSize: number;
+  baseOpacity?: number;
+  opacityReduction?: number;
+  rotationOffset?: number;
+  proportionType?: ProportionType;
+}
+
 // Pattern combination utilities
 export class PatternCombiner {
-  static getProportionalSize(baseSize, proportion) {
+  static getProportionalSize(baseSize: number, proportion: number): number {
     return baseSize * proportion;
   }
 
-  static centerPattern(ctx, width, height) {
+  static centerPattern(
+    ctx: CanvasRenderingContext2D,
+    width: number,
+    height: number,
+  ): void {
     ctx.translate(width / 2, height / 2);
   }
 
   // Combines sacred geometry patterns with proper proportions
-  static layerPatterns(ctx, patterns, config) {
+  static layerPatterns(
+    ctx: CanvasRenderingContext2D,
+    patterns: Pattern[],
+    config: LayerConfig,
+  ): void {
     const {
       baseSize,
       baseOpacity = 0.6,
@@ -43,7 +71,7 @@ export class PatternCombiner {
     patterns.forEach((pattern, index) => {
       const size = this.getProportionalSize(
         baseSize,
-        Math.pow(Proportions[proportionType], index)
+        Math.pow(Proportions[proportionType], index),
       );
       const opacity = Math.max(0.1, baseOpacity - index * opacityReduction);
       const rotation = rotationOffset * index;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "target": "ES2020",
+    "module": "ES2020",
+    "lib": ["ES2020", "DOM"],
+    "strict": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["global.d.ts", "src/**/*"]
+}

package/eslint.config.mjs

@@ -1,29 +0,0 @@
-import { FlatCompat } from "@eslint/eslintrc";
-import js from "@eslint/js";
-import globals from "globals";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all,
-});
-
-export default [
-  ...compat.extends("eslint:recommended"),
-  {
-    languageOptions: {
-      globals: {
-        ...globals.browser,
-        ...globals.node,
-      },
-
-      ecmaVersion: 12,
-      sourceType: "module",
-    },
-    rules: {},
-  },
-];

package/src/lib/canvas/shapes/sacred.js

@@ -1,173 +0,0 @@
-import { createCirclePoints } from "./utils";
-
-export const drawFlowerOfLife = (ctx, size) => {
-  const radius = size / 6;
-  const centers = [
-    { x: 0, y: 0 },
-    { x: radius * Math.sqrt(3), y: 0 },
-    { x: radius * Math.sqrt(3) / 2, y: 1.5 * radius },
-    { x: -radius * Math.sqrt(3) / 2, y: 1.5 * radius },
-    { x: -radius * Math.sqrt(3), y: 0 },
-    { x: -radius * Math.sqrt(3) / 2, y: -1.5 * radius },
-    { x: radius * Math.sqrt(3) / 2, y: -1.5 * radius }
-  ];
-
-  ctx.beginPath();
-  centers.forEach(center => {
-    ctx.moveTo(center.x + radius, center.y);
-    ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
-  });
-};
-
-export const drawTreeOfLife = (ctx, size) => {
-  const radius = size / 12;
-  const spacing = radius * 2.5;
-  
-  // Sephirot positions (traditional layout)
-  const positions = [
-    { x: 0, y: -spacing * 2 },    // Kether
-    { x: -spacing, y: -spacing },  // Chokmah
-    { x: spacing, y: -spacing },   // Binah
-    { x: -spacing, y: 0 },        // Chesed
-    { x: spacing, y: 0 },         // Geburah
-    { x: 0, y: 0 },              // Tiphereth
-    { x: -spacing, y: spacing },  // Netzach
-    { x: spacing, y: spacing },   // Hod
-    { x: 0, y: spacing * 2 },    // Yesod
-    { x: 0, y: spacing * 3 }     // Malkuth
-  ];
-
-  // Draw circles
-  ctx.beginPath();
-  positions.forEach(pos => {
-    ctx.moveTo(pos.x + radius, pos.y);
-    ctx.arc(pos.x, pos.y, radius, 0, Math.PI * 2);
-  });
-
-  // Draw connecting lines
-  ctx.moveTo(positions[0].x, positions[0].y);
-  positions.forEach((pos, i) => {
-    if (i > 0) {
-      positions.slice(i + 1).forEach(nextPos => {
-        ctx.moveTo(pos.x, pos.y);
-        ctx.lineTo(nextPos.x, nextPos.y);
-      });
-    }
-  });
-};
-
-export const drawMetatronsCube = (ctx, size) => {
-  const radius = size / 3;
-  
-  // Create 13 points - one center and 12 vertices of an icosahedron
-  
-  // const phi = (1 + Math.sqrt(5)) / 2; // Golden ratio
-  
-  const vertices = [
-    { x: 0, y: 0 }, // Center point
-    ...createCirclePoints(0, 0, radius, 6), // Inner hexagon
-    ...createCirclePoints(0, 0, radius * 1.5, 6) // Outer hexagon
-  ];
-
-  ctx.beginPath();
-  // Draw all connecting lines
-  vertices.forEach((v1, i) => {
-    vertices.slice(i + 1).forEach(v2 => {
-      ctx.moveTo(v1.x, v1.y);
-      ctx.lineTo(v2.x, v2.y);
-    });
-  });
-};
-
-export const drawSriYantra = (ctx, size) => {
-  const radius = size / 2;
-  ctx.beginPath();
-
-  // Draw outer triangles
-  for (let i = 0; i < 9; i++) {
-    const angle = (i / 9) * Math.PI * 2;
-    const x1 = Math.cos(angle) * radius;
-    const y1 = Math.sin(angle) * radius;
-    const x2 = Math.cos(angle + Math.PI / 9) * radius;
-    const y2 = Math.sin(angle + Math.PI / 9) * radius;
-    
-    ctx.moveTo(0, 0);
-    ctx.lineTo(x1, y1);
-    ctx.lineTo(x2, y2);
-    ctx.lineTo(0, 0);
-  }
-
-  // Draw inner triangles
-  const innerRadius = radius * 0.6;
-  for (let i = 0; i < 9; i++) {
-    const angle = (i / 9) * Math.PI * 2 + Math.PI / 18;
-    const x1 = Math.cos(angle) * innerRadius;
-    const y1 = Math.sin(angle) * innerRadius;
-    const x2 = Math.cos(angle + Math.PI / 9) * innerRadius;
-    const y2 = Math.sin(angle + Math.PI / 9) * innerRadius;
-    
-    ctx.moveTo(0, 0);
-    ctx.lineTo(x1, y1);
-    ctx.lineTo(x2, y2);
-    ctx.lineTo(0, 0);
-  }
-};
-
-export const drawSeedOfLife = (ctx, size) => {
-  const radius = size / 4;
-  const centers = [
-    { x: 0, y: 0 },
-    ...createCirclePoints(0, 0, radius * 2, 6)
-  ];
-
-  ctx.beginPath();
-  centers.forEach(center => {
-    ctx.moveTo(center.x + radius, center.y);
-    ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
-  });
-};
-
-export const drawVesicaPiscis = (ctx, size) => {
-  const radius = size / 3;
-  ctx.beginPath();
-  
-  // Draw two overlapping circles
-  ctx.arc(-radius/2, 0, radius, 0, Math.PI * 2);
-  ctx.arc(radius/2, 0, radius, 0, Math.PI * 2);
-};
-
-export const drawTorus = (ctx, size) => {
-  const outerRadius = size / 2;
-  const innerRadius = size / 4;
-  const steps = 36;
-  
-  ctx.beginPath();
-  for (let i = 0; i < steps; i++) {
-    const angle1 = (i / steps) * Math.PI * 2;
-    // const angle2 = ((i + 1) / steps) * Math.PI * 2;
-    
-    for (let j = 0; j < steps; j++) {
-      const phi1 = (j / steps) * Math.PI * 2;
-      const phi2 = ((j + 1) / steps) * Math.PI * 2;
-      
-      const x1 = (outerRadius + innerRadius * Math.cos(phi1)) * Math.cos(angle1);
-      const y1 = (outerRadius + innerRadius * Math.cos(phi1)) * Math.sin(angle1);
-      const x2 = (outerRadius + innerRadius * Math.cos(phi2)) * Math.cos(angle1);
-      const y2 = (outerRadius + innerRadius * Math.cos(phi2)) * Math.sin(angle1);
-      
-      ctx.moveTo(x1, y1);
-      ctx.lineTo(x2, y2);
-    }
-  }
-};
-
-// Add to the existing shapes map
-export const sacredShapes = {
-  // flowerOfLife: drawFlowerOfLife,
-  // treeOfLife: drawTreeOfLife,
-  metatronsCube: drawMetatronsCube,
-  sriYantra: drawSriYantra,
-  seedOfLife: drawSeedOfLife,
-  vesicaPiscis: drawVesicaPiscis,
-  torus: drawTorus
-};

package/src/lib/canvas/shapes/utils.js

@@ -1,37 +0,0 @@
-export const degToRad = (degrees) => (degrees * Math.PI) / 180;
-
-export const applyTransforms = (ctx, size, config) => {
-  ctx.save();
-  ctx.translate(0, 0);
-  if (config.rotation) {
-    ctx.rotate(degToRad(config.rotation));
-  }
-  ctx.lineWidth = config.lineWidth;
-  ctx.strokeStyle = config.strokeStyle;
-  ctx.fillStyle = config.fillStyle;
-};
-
-export const restoreContext = (ctx) => {
-  ctx.restore();
-};
-
-// Animation configuration stub for future use
-export const createAnimationConfig = (type) => ({
-  enabled: false,
-  duration: 1000,
-  easing: "linear",
-  type,
-  // Add more animation-specific properties as needed
-});
-
-export const createCirclePoints = (cx, cy, radius, segments) => {
-  const points = [];
-  for (let i = 0; i < segments; i++) {
-    const angle = (i / segments) * Math.PI * 2;
-    points.push({
-      x: cx + Math.cos(angle) * radius,
-      y: cy + Math.sin(angle) * radius,
-    });
-  }
-  return points;
-};