Merge pull request #94 from adorableio/ts-refactors

Refactors on top of typescript

Author: rylnd

index.d.ts

@@ -0,0 +1,9 @@
+type ImageType = 'eyes' | 'nose' | 'mouth';
+type FaceParts = ImageType | 'color';
+
+interface Face {
+  color: string;
+  eyes: string;
+  nose: string;
+  mouth: string;
+}

package.json

@@ -6,17 +6,18 @@
     "node": "9.4.x"
   },
   "scripts": {
-    "test": "mocha --exit",
+    "test": "TS_NODE_FILES=true mocha --exit",
     "build": "tsc && npm run build:assets",
     "build:assets": "cp -r {src,dist}/img",
     "dev": "concurrently --kill-others --prefix=name --names=server,eslint --prefix-colors=green,magenta \"npm run dev:server\" \"npm run dev:lint\"",
-    "dev:server": "onchange -i -k 'src/**/*.ts' -- ts-node test/server.ts",
+    "dev:server": "TS_NODE_FILES=true onchange -i -k 'src/**/*.ts' -- ts-node test/server.ts",
     "dev:lint": "onchange -i -k 'src/**/*.ts' -- tslint -t stylish 'src/**/*.ts'",
     "prepublishOnly": "npm run build"
   },
   "author": "",
   "license": "MIT",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],

src/index.ts

@@ -1,3 +1,4 @@
-import routes from './routes/avatars';
+import routes from './routes';
 
 export default routes;
+(module as any).exports = routes;

src/lib/hashingFunctions.ts

@@ -1,29 +1,10 @@
-const _addition = (a, b) => {
-  return a + b;
-};
+const isEven: (num: number) => boolean = num => num % 2 === 0;
 
-const _subtraction = (a, b) => {
-  return a - b;
-};
+export const sum: (array: number[]) => number = arr =>
+  arr.reduce((a, b) => a + b, 0);
 
-const _multiplication = (a, b) => {
-  return a * b;
-};
-
-export const sum = array => {
-  return array.reduce(_addition, 0);
-};
-
-export const sumAndDiff = array => {
-  return array.reduce((prev, curr, index) => {
-    if (index % 2 === 0) {
-      return _addition(prev, curr);
-    } else {
-      return _subtraction(prev, curr);
-    }
-  }, 0);
-};
-
-export const product = array => {
-  return array.reduce(_multiplication, 1);
-};
+export const sumAndDiff: (array: number[]) => number = array =>
+  array.reduce(
+    (prev, curr, index) => (isEven(index) ? prev + curr : prev - curr),
+    0,
+  );

src/lib/imageFiles.ts

@@ -1,32 +1,23 @@
 import fs from 'fs';
 import path from 'path';
 
-const DEFAULT_IMAGE_DIR = path.join(__dirname, '..', 'img');
+const IMAGE_DIR = path.join(__dirname, '..', 'img');
 
-export const dirFor = (type, imageDir = DEFAULT_IMAGE_DIR) => {
-  if (type) {
-    return path.join(imageDir, type);
-  }
+const imageFiles: (path: string) => string[] = p =>
+  fs.readdirSync(p).filter(fileName => fileName.match(/\.png$/));
 
-  return imageDir;
-};
+const imageDir: (type: ImageType) => string = type =>
+  type ? path.join(IMAGE_DIR, type) : IMAGE_DIR;
 
-export const allNames = (type, imageDir = DEFAULT_IMAGE_DIR) => {
-  return fs
-    .readdirSync(dirFor(type, imageDir))
-    .filter(imageFileName => {
-      return imageFileName.match(/\.png/);
-    })
-    .map(imageFileName => {
-      return imageFileName.replace(/\.png/, '');
-    });
-};
+export const allNames: (type: ImageType) => string[] = type =>
+  imageFiles(imageDir(type)).map(imageFileName =>
+    imageFileName.replace(/\.png/, ''),
+  );
 
-export const allPaths = (type, imageDir = DEFAULT_IMAGE_DIR) => {
-  const dir = dirFor(type, imageDir);
-  return allNames(type, imageDir).map(name => path.join(dir, name + '.png'));
+export const allPaths: (type: ImageType) => string[] = type => {
+  const dir = imageDir(type);
+  return imageFiles(dir).map(file => path.join(dir, file));
 };
 
-export const pathFor = (type, fileName, imageDir = DEFAULT_IMAGE_DIR) => {
-  return path.join(dirFor(type, imageDir), fileName + '.png');
-};
+export const pathTo: (type: ImageType, name: string) => string = (type, name) =>
+  path.join(imageDir(type), name + '.png');

src/lib/potato.ts

@@ -1,4 +1,3 @@
-// our libs
 import { sumAndDiff } from './hashingFunctions';
 import { allPaths } from './imageFiles';
 import SlotMachine from './slotMachine';
@@ -23,8 +22,7 @@ class Potato {
     private mouthMachine = new SlotMachine(allPaths('mouth'), sumAndDiff),
   ) {}
 
-  // Construct Faces Parts
-  parts(string) {
+  parts(string): Face {
     return {
       color: this.colorMachine.pull(string),
       eyes: this.eyesMachine.pull(string),

src/lib/slotMachine.ts

@@ -1,29 +1,25 @@
 import { sum } from './hashingFunctions';
 
 class SlotMachine<T> {
-  private slots: T[];
   private numSlots: number;
-  private hashingFn: (items: number[]) => number;
 
-  constructor(slots: T[], hashingFn?) {
-    this.slots = slots;
-    this.numSlots = this.slots.length;
-    this.hashingFn = hashingFn || sum;
+  constructor(private slots: T[], private hash = sum) {
+    this.numSlots = slots.length;
   }
 
   pull(string) {
     const str = string.replace(/\.(png|jpg|gif|)$/g, '');
     const stringArray = str.split('');
-    return this.slots[this._indexFor(stringArray)];
+    return this.slots[this.indexFor(stringArray)];
   }
 
-  _indexFor(array) {
-    const intArray = array.map(this._getCharInt);
-    const index = (this.hashingFn(intArray) + intArray.length) % this.numSlots;
+  private indexFor(array) {
+    const intArray = array.map(this.getCharInt);
+    const index = (this.hash(intArray) + intArray.length) % this.numSlots;
     return Math.abs(index);
   }
 
-  _getCharInt(char) {
+  private getCharInt(char) {
     return parseInt(char.charCodeAt(0) || 0, 10);
   }
 }

src/routes/avatars.ts

@@ -0,0 +1,63 @@
+import Router from 'express';
+import uuid from 'uuid';
+
+import { allNames, pathTo } from '../lib/imageFiles';
+import { combine } from '../lib/imager';
+import potato from '../lib/potato';
+
+const imageTypes: ImageType[] = ['eyes', 'nose', 'mouth'];
+
+const router = Router();
+
+const sendImage = ({ stdout, response }) => {
+  response.setHeader('Expires', new Date(Date.now() + 604800000));
+  response.setHeader('Content-Type', 'image/png');
+  stdout.pipe(response);
+};
+
+router.get('/list', (req, res) => {
+  const face = {};
+  imageTypes.forEach(type => (face[type] = allNames(type)));
+
+  return res.set('Content-Type', 'application/json').send({ face });
+});
+
+router.get('/:size?/random', (req, res) => {
+  const faceParts = potato.parts(uuid.v4());
+
+  return combine(faceParts, req.params.size, (err, stdout) =>
+    sendImage({ stdout, response: res }),
+  );
+});
+
+router.get('/:size?/:id', (req, res, next) => {
+  const faceParts = potato.parts(req.params.id);
+
+  return combine(faceParts, req.params.size, (err, stdout) =>
+    sendImage({ stdout, response: res }),
+  );
+});
+
+router.get('/face/:eyes/:nose/:mouth/:color/:size?', (req, res, next) => {
+  const faceParts = { color: `#${req.params.color}` };
+
+  imageTypes.forEach(type => {
+    const requestedName = req.params[type];
+    const names = allNames(type);
+    let name = names[0];
+
+    if (names.includes(requestedName)) {
+      name = requestedName;
+    } else if (requestedName === 'x') {
+      name = '';
+    }
+
+    faceParts[type] = pathTo(type, name);
+  });
+
+  return combine(faceParts, req.params.size, (err, stdout) =>
+    sendImage({ stdout, response: res }),
+  );
+});
+
+export default router;