Weather

src/app.d.ts

@@ -32,7 +32,8 @@ declare global {
 		description?: string
 	}
 
-	type Points = [number, number][]
+	type Point = [number, number]
+	type Points = Point[]
 
 	type JSONValue = { [x: string]: string }
 

src/lib/api/githubApi.ts

@@ -0,0 +1,83 @@
+import { error } from "@sveltejs/kit";
+import { EXTERNAL_CODE_LANGS, getLangShortName } from "../data/codeLangData";
+
+export async function ghGet(url: string, token: string) {
+  return await fetch(url, {
+    method: "GET",
+    mode: "cors",
+    credentials: "same-origin",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2022-11-28",
+    },
+  });
+}
+
+async function extractLanguageData(data: JSONArray, token: string) {
+  try {
+    const urls: string[] = data.flatMap((repo) => repo.languages_url);
+    const collated: Record<string, number>[] = [];
+    await Promise.all(
+      urls.map(async (url: string) => {
+        const response = await ghGet(url, token);
+        const data = (await response.json()) as Record<string, number>;
+        if (data) {
+          collated.push(data);
+        }
+      }),
+    );
+    return parseLanguageObject(collated);
+  } catch {
+    error(500, "Error parsing coding language data from github");
+  }
+}
+
+export async function getGhLanguageData(url: string, token: string) {
+  try {
+    const response = await ghGet(url, token);
+    const data = (await response.json()) as JSONArray;
+    const languages = await extractLanguageData(data, token);
+    return languages;
+  } catch {
+    error(500, "Error retrieving data from github");
+  }
+}
+
+export function parseLanguageObject(
+  data: Record<string, number>[],
+): Record<string, number> {
+  let total = 0;
+  const parsed: Record<string, number> = {};
+  for (const languages of data) {
+    for (const language of Object.keys(languages)) {
+      const lang = getLangShortName(language);
+      if (parsed[lang]) {
+        // use proportional lines of code intead
+        // parsed[lang] += parsed[key];
+        parsed[lang] += 1;
+      } else {
+        // use proportional lines of code intead
+        // parsed[lang] = parsed[key];
+        parsed[lang] = 1;
+      }
+      // total += parsed[key];
+      total += 1;
+    }
+  }
+
+  for (const language of Object.keys(EXTERNAL_CODE_LANGS)) {
+    const lang = getLangShortName(language);
+    if (parsed[lang]) {
+      parsed[lang] += EXTERNAL_CODE_LANGS[language];
+    } else {
+      parsed[lang] = EXTERNAL_CODE_LANGS[language];
+    }
+    total += EXTERNAL_CODE_LANGS[language];
+  }
+
+  for (const language of Object.keys(parsed)) {
+    parsed[language] = parsed[language] / total;
+  }
+  return parsed;
+}

src/lib/canvas/Animator.ts

@@ -0,0 +1,9 @@
+export abstract class Animator {
+	ctx: CanvasRenderingContext2D;
+
+	constructor(context: CanvasRenderingContext2D) {
+		this.ctx = context;
+	}
+
+	abstract animate(): void;
+}

src/lib/canvas/Artist.ts

@@ -0,0 +1,68 @@
+import { drawLine } from "$lib/canvas/canvasUtils";
+
+export class Artist {
+	ctx: CanvasRenderingContext2D;
+	rootX: number;
+	rootY: number;
+	startX: number;
+	startY: number;
+	endX: number;
+	endY: number;
+
+	constructor(context: CanvasRenderingContext2D, x: number, y: number) {
+		this.startX = x;
+		this.startY = y;
+		this.endX = x;
+		this.endY = y;
+		this.rootX = x;
+		this.rootY = y;
+		this.ctx = context;
+	}
+
+	reset(xOffset: number, yOffset: number) {
+		this.startX = this.rootX + xOffset;
+		this.startY = this.rootY + yOffset;
+	}
+
+	drawNextLine(xOffset: number, yOffset: number) {
+		this.endX = this.startX + xOffset;
+		this.endY = this.startY + yOffset;
+		drawLine(this.ctx, this.startX, this.startY, this.endX, this.endY);
+		this.startX = this.endX;
+		this.startY = this.endY;
+	}
+
+	drawShape(
+		points: Points,
+		reflect: boolean,
+		xOffset: number,
+		yOffset: number,
+		lineWidth: number,
+		stroke?: string,
+		fill?: string | CanvasGradient,
+	) {
+		this.ctx.beginPath();
+		this.ctx.moveTo(this.startX, this.startY);
+		points.forEach((p) => this.drawNextLine(p[0], p[1]));
+		if (reflect) {
+			this.reset(xOffset, yOffset);
+			points.forEach((p) => this.drawReflection(p[0], p[1]));
+		}
+		this.ctx.closePath();
+
+		if (stroke) {
+			this.ctx.lineCap = "round";
+			this.ctx.lineWidth = lineWidth;
+			this.ctx.strokeStyle = stroke;
+			this.ctx.stroke();
+		}
+		if (fill) {
+			this.ctx.fillStyle = fill;
+			this.ctx.fill();
+		}
+	}
+
+	drawReflection(xOffset: number, yOffset: number) {
+		this.drawNextLine(xOffset * -1, yOffset);
+	}
+}

src/lib/canvas/canvasUtils.ts

@@ -0,0 +1,44 @@
+export function drawCircle(
+  context: CanvasRenderingContext2D,
+  x: number,
+  y: number,
+  radius: number,
+  stroke?: string,
+  fill?: string | CanvasGradient,
+) {
+  context.beginPath();
+  context.arc(x, y, radius, 0, Math.PI * 2, false);
+  if (stroke) {
+    context.strokeStyle = stroke;
+    context.stroke();
+  }
+  if (fill) {
+    context.fillStyle = fill;
+    context.fill();
+  }
+  context.closePath();
+}
+
+export function drawLine(
+  context: CanvasRenderingContext2D,
+  startX: number,
+  startY: number,
+  endX: number,
+  endY: number,
+) {
+  context.lineTo(startX, startY);
+  context.lineTo(endX, endY);
+}
+
+export function drawLineAtAngle(
+  context: CanvasRenderingContext2D,
+  x: number,
+  y: number,
+  length: number,
+  angle: number,
+) {
+  const offsetX = length * Math.cos(angle);
+  const offsetY = length * Math.sin(angle);
+  context.moveTo(x, y);
+  context.lineTo(x - offsetX, y - offsetY);
+}