first working version

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -0,0 +1,56 @@
+# Violin chords
+
+Generate shapes of chords for violin
+
+## Instal
+
+```bash
+sudo yarn global add violin-chords
+# or
+sudo npm install -g violin-chords
+```
+
+## Use
+
+```bash
+violin-chords [note][accidental][chord]
+
+# e.g.
+
+violin-chords cmaj7
+violin-chords a#6
+violin-chords ebmaj7
+violin-chords g#+
+```
+
+### notes
+
+```
+c, d, e, f, g, a, b, h
+```
+We use German naming, i. e. a# === b === hb
+
+### accidentals (optional)
+
+```
+#, b
+```
+
+### chords
+
+```
+maj, min, +, 0, 6, 7, maj7, min7
+```
+
+## Output
+
+cmaj7
+
+![example output](example.png)
+
+- The numbers (in hex (a === 10, b === 11)) represent interval in semitones above tonic.  E.g. 0: tonic, 4: major third, 7: perfect fifth (dominant), b: major seventh.
+- The first line (without dots) represents empty strings. Lines have a semitone
+- It's up to the player to choose a comfortable fingering.
+  - choose all the numbers if possible, or as many as possible
+  - choose the more significant tones. e.g. `b` matters for the character cmaj7 more than `4` or `7`
+  - you may want 0 (tonic) at the lowest played string

bin/index.mjs

@@ -0,0 +1,20 @@
+#!/bin/sh
+":" //# comment; exec /usr/bin/env node --experimental-modules "$0" "$@"
+
+import Fingerboard from '../lib/Fingerboard.mjs';
+import help from '../lib/help.mjs';
+
+(function () {
+  const argv = process.argv.slice(2);
+
+  const fingerboard = new Fingerboard(25);
+
+  if (argv.length < 1) {
+    console.log(help());
+    return;
+  }
+
+  fingerboard.highlightChord(argv[0]);
+
+  console.log(fingerboard.draw());
+}());

lib/Fingerboard.mjs

@@ -0,0 +1,84 @@
+import { chords } from './chords.mjs'; // it is weird that we need to provide extension
+
+class FString { // becase String is taken
+  constructor(tune, threads) {
+    this.tune = tune % 12;
+    this.threads = Array(threads).fill(null);
+  }
+
+  highlightNote(i, symbol) {
+    this.threads[i] = symbol;
+  }
+}
+
+export default class Fingerboard {
+  constructor(threads) {
+    this.threads = threads;
+    this.iv = new FString(7, threads);
+    this.iii = new FString(14, threads);
+    this.ii = new FString(21, threads);
+    this.i = new FString(28, threads);
+  }
+
+  draw() {
+    let fingerboard = 'g d a e\n\n'
+    for (let i = 0; i < this.threads; i++) {
+      fingerboard += this.drawThread(i) + '\n';
+    }
+
+    return fingerboard;
+  }
+
+  drawThread(i) {
+    const empty = (i === 0) ? ' ' : '.';
+    const drawPoint = (string, i, empty) => string.threads[i] === null ? empty : string.threads[i];
+    return `${drawPoint(this.iv, i, empty)} ${drawPoint(this.iii, i, empty)} ${drawPoint(this.ii, i, empty)} ${drawPoint(this.i, i, empty)}`;
+  }
+
+  highlightNote(base, interval) {
+    [this.iv, this.iii, this.ii, this.i].forEach((string) => {
+      for (let i = 0; i < this.threads; i++) {
+        // console.log(i, string.tune, base, interval)
+        if ((i + string.tune) % 12 === (base + interval) % 12) {
+          string.highlightNote(i, interval.toString(16))
+        }
+      }
+    });
+  }
+
+  highlightChord(chord) {
+    const [base, intervals] = chord2numbers(chord);
+    intervals.forEach(interval => this.highlightNote(base, interval));
+  }
+}
+
+function note2number(note) {
+  const notes = {
+    c: 0,
+    d: 2,
+    e: 4,
+    f: 5,
+    g: 7,
+    a: 9,
+    b: 10,
+    h: 11,
+  }
+
+  if (note.length === 1) return notes[note];
+
+  const accidental2number = accidental => {
+    if (accidental === '#') return 1;
+    if (accidental === 'b') return 11;
+    throw new Error('invalid accidental (#, b)');
+  }
+
+  if (note.length === 2) return notes[note[0]] + accidental2number(note[1]) % 12;
+  throw new Error('invalid note name (c, d, e, f, g, a, b, h)');
+}
+
+function chord2numbers(chord) {
+  const separator = (['#', 'b'].includes(chord[1])) ? 2 : 1;
+  const note = chord.slice(0, separator);
+  const chordType = chord.slice(separator);
+  return [note2number(note), chords[chordType]];
+}

lib/chords.mjs

@@ -0,0 +1,10 @@
+export const chords = {
+  'maj': [0, 4, 7],
+  'min': [0, 3, 7],
+  '+': [0, 4, 8],
+  '0': [0, 3, 6, 9],
+  '6': [0, 4, 7, 9],
+  '7': [0, 4, 7, 10],
+  'maj7': [0, 4, 7, 11],
+  'min7': [0, 3, 7, 10],
+};

lib/help.mjs

@@ -0,0 +1,10 @@
+export default function help() {
+  return `usage:
+violin-chords [chord name]
+
+supported notes: c, d, e, f, g, a, b, h (please note that we use german naming: b is equivalent to a# and hb)
+supported accidentals: #, b
+supported chords: maj, min, +, 0, 6, 7, maj7, min7
+
+chord name examples: cmaj, dmin, f#+, abmin7, b0`;
+}

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "violin-chords",
+  "version": "0.0.1",
+  "description": "Shapes of violin chords.",
+  "author": "mrkvon <mrkvon@protonmail.com> (https://mrkvon.org)",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://git.mrkvon.org/mrkvon/violin-chords.git"
+  },
+  "homepage": "https://git.mrkvon.org/mrkvon/violin-chords",
+  "preferGlobal": true,
+  "main": "bin/index.mjs",
+  "bin": "bin/index.mjs",
+  "license": "MIT",
+  "keywords": [
+    "violin",
+    "chord",
+    "chords",
+    "music"
+  ]
+}