start packaging

packages/tonal/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@strudel/tonal",
+  "version": "0.0.1",
+  "description": "Tonal functions for strudel",
+  "main": "tonal.mjs",
+  "type": "module",
+  "scripts": {
+    "test": "mocha --colors"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tidalcycles/strudel.git"
+  },
+  "keywords": [
+    "tidalcycles",
+    "strudel",
+    "pattern",
+    "livecoding",
+    "algorave"
+  ],
+  "author": "Felix Roos <flix91@gmail.com>",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/tidalcycles/strudel/issues"
+  },
+  "homepage": "https://github.com/tidalcycles/strudel#readme"
+}

packages/tonal/test/tonal.test.mjs

@@ -0,0 +1,9 @@
+import { strict as assert } from 'assert';
+import '../tonal.mjs'; // need to import this to add prototypes
+import { pure } from '../../core/strudel.mjs';
+
+describe('tonal', () => {
+  it('Should run tonal functions ', () => {
+    assert.deepStrictEqual(pure('c3').scale('C major').scaleTranspose(1)._firstCycleValues, ['D3']);
+  });
+});

packages/tonal/tonal.mjs

@@ -0,0 +1,89 @@
+import { Note, Interval, Scale } from '@tonaljs/tonal';
+import { Pattern as _Pattern } from '../core/strudel.mjs';
+import { mod, tokenizeNote } from '../../packages/core/util.mjs';
+
+const Pattern = _Pattern; // as any;
+
+// transpose note inside scale by offset steps
+// function scaleTranspose(scale: string, offset: number, note: string) {
+export function scaleTranspose(scale, offset, note) {
+  let [tonic, scaleName] = Scale.tokenize(scale);
+  let { notes } = Scale.get(`${tonic} ${scaleName}`);
+  notes = notes.map((note) => Note.get(note).pc); // use only pc!
+  offset = Number(offset);
+  if (isNaN(offset)) {
+    throw new Error(`scale offset "${offset}" not a number`);
+  }
+  const { pc: fromPc, oct = 3 } = Note.get(note);
+  const noteIndex = notes.indexOf(fromPc);
+  if (noteIndex === -1) {
+    throw new Error(`note "${note}" is not in scale "${scale}"`);
+  }
+  let i = noteIndex,
+    o = oct,
+    n = fromPc;
+  const direction = Math.sign(offset);
+  // TODO: find way to do this smarter
+  while (Math.abs(i - noteIndex) < Math.abs(offset)) {
+    i += direction;
+    const index = mod(i, notes.length);
+    if (direction < 0 && n[0] === 'C') {
+      o += direction;
+    }
+    n = notes[index];
+    if (direction > 0 && n[0] === 'C') {
+      o += direction;
+    }
+  }
+  return n + o;
+}
+
+// Pattern.prototype._transpose = function (intervalOrSemitones: string | number) {
+Pattern.prototype._transpose = function (intervalOrSemitones) {
+  return this._withEvent((event) => {
+    const interval = !isNaN(Number(intervalOrSemitones))
+      ? Interval.fromSemitones(intervalOrSemitones /*  as number */)
+      : String(intervalOrSemitones);
+    if (typeof event.value === 'number') {
+      const semitones = typeof interval === 'string' ? Interval.semitones(interval) || 0 : interval;
+      return event.withValue(() => event.value + semitones);
+    }
+    // TODO: move simplify to player to preserve enharmonics
+    // tone.js doesn't understand multiple sharps flats e.g. F##3 has to be turned into G3
+    return event.withValue(() => Note.simplify(Note.transpose(event.value, interval)));
+  });
+};
+
+// example: transpose(3).late(0.2) will be equivalent to compose(transpose(3), late(0.2))
+// TODO: add Pattern.define(name, function, options) that handles all the meta programming stuff
+// TODO: find out how to patternify this function when it's standalone
+// e.g. `stack(c3).superimpose(transpose(slowcat(7, 5)))` or
+// or even `stack(c3).superimpose(transpose.slowcat(7, 5))` or
+
+Pattern.prototype._scaleTranspose = function (offset /* : number | string */) {
+  return this._withEvent((event) => {
+    if (!event.context.scale) {
+      throw new Error('can only use scaleTranspose after .scale');
+    }
+    if (typeof event.value !== 'string') {
+      throw new Error('can only use scaleTranspose with notes');
+    }
+    return event.withValue(() => scaleTranspose(event.context.scale, Number(offset), event.value));
+  });
+};
+Pattern.prototype._scale = function (scale /* : string */) {
+  return this._withEvent((event) => {
+    let note = event.value;
+    const asNumber = Number(note);
+    if (!isNaN(asNumber)) {
+      let [tonic, scaleName] = Scale.tokenize(scale);
+      const { pc, oct = 3 } = Note.get(tonic);
+      note = scaleTranspose(pc + ' ' + scaleName, asNumber, pc + oct);
+    }
+    return event.withValue(() => note).setContext({ ...event.context, scale });
+  });
+};
+
+Pattern.prototype.define('transpose', (a, pat) => pat.transpose(a), { composable: true, patternified: true });
+Pattern.prototype.define('scale', (a, pat) => pat.scale(a), { composable: true, patternified: true });
+Pattern.prototype.define('scaleTranspose', (a, pat) => pat.scaleTranspose(a), { composable: true, patternified: true });

packages/tonal/voicings.mjs

@@ -0,0 +1,50 @@
+import { Pattern as _Pattern, stack, Hap, reify } from '../core/strudel.mjs';
+import _voicings from 'chord-voicings';
+const { dictionaryVoicing, minTopNoteDiff, lefthand } = _voicings;
+
+const getVoicing = (chord, lastVoicing, range = ['F3', 'A4']) =>
+  dictionaryVoicing({
+    chord,
+    dictionary: lefthand,
+    range,
+    picker: minTopNoteDiff,
+    lastVoicing,
+  });
+
+const Pattern = _Pattern;
+
+Pattern.prototype.fmapNested = function (func) {
+  return new Pattern((span) =>
+    this.query(span)
+      .map((event) =>
+        reify(func(event))
+          .query(span)
+          .map((hap) => new Hap(event.whole, event.part, hap.value, hap.context)),
+      )
+      .flat(),
+  );
+};
+
+Pattern.prototype.voicings = function (range) {
+  let lastVoicing;
+  if (!range?.length) {
+    // allows to pass empty array, if too lazy to specify range
+    range = ['F3', 'A4'];
+  }
+  return this.fmapNested((event) => {
+    lastVoicing = getVoicing(event.value, lastVoicing, range);
+    return stack(...lastVoicing)._withContext(() => ({
+      locations: event.context.locations || [],
+    }));
+  });
+};
+
+Pattern.prototype._rootNotes = function (octave = 2) {
+  return this.fmap((value) => {
+    const [_, root] = value.match(/^([a-gA-G][b#]?).*$/);
+    return root + octave;
+  });
+};
+
+Pattern.prototype.define('voicings', (range, pat) => pat.voicings(range), { composable: true });
+Pattern.prototype.define('rootNotes', (oct, pat) => pat.rootNotes(oct), { composable: true, patternified: true });