@greenblacksky/honmoon 0.0.0-stage → 0.4.1

package/src/lib/drills/verdict.ts

@@ -0,0 +1,241 @@
+import { honmoon } from '../store/honmoon.svelte';
+import { STRINGS, placesFor } from '../music/bass';
+import { bothNames, degName, keyName, mdoName, noteName, pcOf } from '../music/notes';
+import { chDef, ivDef } from '../music/intervals';
+import { scaleDef, degPretty, scaleName, scaleNotes, noteText } from '../music/scales';
+import { barCounting, beatsText, restName, rvalDef } from '../music/rhythm';
+import { anA } from '../util/text';
+import type { Q, Question } from './questions';
+import type { DrillState } from './runtime.svelte';
+
+/** What the answer panel says: the headline, and the lines under it. */
+export interface Verdict {
+  ok: boolean;
+  txt: string;
+  subs: string[];
+}
+
+const plural = (count: number, word: string) => count + ' ' + word + (count === 1 ? '' : 's');
+/** The note at a tapped place on the neck. */
+const pcAtCell = (cell: { s: number; f: number }) => pcOf(STRINGS[cell.s].open + cell.f);
+
+type Pref = 'sharp' | 'flat';
+
+function degreeVerdict(
+  q: Q<'mdo'> | Q<'deg2fb'> | Q<'singdeg'>,
+  state: DrillState,
+  pref: Pref,
+): Verdict {
+  const ok = state.ok;
+  const rightAnswer = q.kind === 'mdo' && q.from === 'syll' ? noteName(q.pc, 'en', pref) : q.ask;
+  let headline = ok ? 'Correct' : rightAnswer;
+  if (q.kind === 'singdeg') {
+    headline = ok ? 'Marked clean' : 'Marked missed';
+  }
+  if (q.kind === 'deg2fb' && !ok && state.wrongCell) {
+    const tappedPc = pcAtCell(state.wrongCell);
+    headline =
+      'That is ' +
+      noteName(tappedPc, 'en', pref) +
+      ', the ' +
+      degName(tappedPc, q.keyPc, pref) +
+      ' of this key';
+  }
+  const explanation =
+    'In ' +
+    keyName(q.keyPc) +
+    ': ' +
+    noteName(q.pc, 'en', pref) +
+    ' is ' +
+    degName(q.pc, q.keyPc, pref) +
+    ' · ' +
+    mdoName(q.pc, q.keyPc, pref);
+  return { ok, txt: headline, subs: [explanation] };
+}
+function valueVerdict(q: Q<'rvalue'>, ok: boolean): Verdict {
+  const name = q.rest ? restName(q.u) : rvalDef(q.u).n;
+  const explanation = name + ' · ' + beatsText(q.u) + ' in 4/4 · ' + plural(q.u, 'sixteenth');
+  return { ok, txt: ok ? 'Correct' : beatsText(q.u), subs: [explanation] };
+}
+function barVerdict(q: Q<'rcount'> | Q<'rhear'> | Q<'rfill'>, ok: boolean): Verdict {
+  let headline: string;
+  if (ok) {
+    headline = 'Correct';
+  } else if (q.kind === 'rcount') {
+    headline = barCounting(q.bar);
+  } else if (q.kind === 'rfill') {
+    headline = q.miss.r ? restName(q.miss.u) : rvalDef(q.miss.u).n;
+  } else {
+    headline = 'That was a different bar';
+  }
+  return { ok, txt: headline, subs: ['Count it: ' + barCounting(q.bar)] };
+}
+function tapVerdictText(q: Q<'rtap'>, ok: boolean): Verdict {
+  const grade = q.grade || { got: 0, n: 0, extra: 0, mean: 0 };
+  let headline: string;
+  if (q.newBest) {
+    headline = 'New best — ' + q.playedAt + ' bpm';
+  } else if (q.tv === 'clean') {
+    headline = 'Tight';
+  } else if (q.tv === 'sloppy') {
+    headline = 'All there, a little loose';
+  } else if (grade.got < grade.n) {
+    headline = grade.n - grade.got + ' missed';
+  } else {
+    headline = plural(grade.extra, 'extra tap');
+  }
+  const averageOffMs = Math.round(grade.mean * 1000);
+  const subs = [
+    q.playedAt +
+      ' bpm · ' +
+      grade.got +
+      ' of ' +
+      grade.n +
+      ' landed' +
+      (grade.extra ? ', ' + grade.extra + ' extra' : '') +
+      (grade.got ? ' · average ' + averageOffMs + ' ms off' : ''),
+  ];
+  if (q.nextBpm && q.nextBpm !== q.playedAt) {
+    subs.push(
+      q.nextBpm > q.playedAt!
+        ? 'Nudging up to ' + q.nextBpm + ' bpm — press − if that is too much.'
+        : 'Easing back to ' + q.nextBpm + ' bpm. Tempo you can hold beats tempo you can survive.',
+    );
+  }
+  return { ok, txt: headline, subs };
+}
+function intervalVerdict(
+  q: Q<'ivhear'> | Q<'ivsee'> | Q<'singit'> | Q<'ivbuild'>,
+  state: DrillState,
+): Verdict {
+  const ok = state.ok;
+  const interval = ivDef(q.semis);
+  let headline: string;
+  if (ok) {
+    headline = 'Correct';
+  } else if (q.kind === 'ivbuild') {
+    const fretsUp = state.wrongCell ? state.wrongCell.f - q.base.f : 0;
+    const whatYouTapped =
+      fretsUp < 0 ? 'That is below the root' : 'That is ' + plural(fretsUp, 'fret');
+    headline = whatYouTapped + ' — ' + anA(interval.n.toLowerCase()) + ' is ' + q.semis;
+  } else {
+    headline = interval.n;
+  }
+  return { ok, txt: headline, subs: [interval.n + ' · ' + q.semis + ' semitones · ' + interval.c] };
+}
+function scaleHeadline(q: Question & { sid: string }, ok: boolean): string {
+  switch (q.kind) {
+    case 'scbuild':
+      return ok
+        ? 'Clean run'
+        : 'Finished with ' + q.misses + ' wrong ' + (q.misses === 1 ? 'tap' : 'taps');
+    case 'scwrong':
+      return ok ? 'Correct' : 'The moved note was the ' + degPretty(q.shape.pos[q.bad].deg.deg);
+    case 'scplay':
+      return ok ? 'Marked clean' : 'Marked missed';
+    case 'scwrite': {
+      const rightStaff = q.sopts.findIndex((staff) => staff.ok); // exactly one is right
+      return ok ? 'Correct' : 'It was staff ' + (rightStaff + 1);
+    }
+    default:
+      if (ok) {
+        return 'Correct';
+      }
+      return 'choices' in q ? q.choices.filter((choice) => choice.ok)[0].t : '';
+  }
+}
+/** The plain note questions: naming, finding and playing a note. */
+function noteVerdict(q: Question, state: DrillState, pref: Pref): Verdict {
+  const ok = state.ok;
+  let headline: string;
+  if (ok) {
+    headline = state.octaveOff ? 'Right note, different octave' : 'Correct';
+  } else if (q.kind === 'name2fb') {
+    /* Skipping leaves no tapped cell, and this line used to read it blind and
+       throw, which took the whole answer panel down with it. */
+    headline = state.wrongCell
+      ? 'That was ' +
+        bothNames(pcAtCell(state.wrongCell), pref) +
+        ' — the answer is fret ' +
+        q.pos.f
+      : 'Fret ' + q.pos.f + ' on the ' + STRINGS[q.pos.s].n + ' string';
+  } else if (q.kind === 'play' && state.played != null) {
+    headline =
+      'Heard ' + bothNames(pcOf(state.played), pref) + ' — wanted ' + bothNames(q.pc, pref);
+  } else {
+    headline = bothNames((q as { pc: number }).pc, pref);
+  }
+  const subs: string[] = [];
+  if (q.kind === 'play' && q.sys !== 'staff' && !ok) {
+    const where = placesFor(q.pc)
+      .slice(0, 3)
+      .map((pos) => STRINGS[pos.s].n + ' ' + pos.f)
+      .join(', ');
+    if (where) {
+      subs.push('Try: ' + where);
+    }
+  }
+  if (state.requeued) {
+    subs.push('Back again later in this session.');
+  }
+  return { ok, txt: headline, subs };
+}
+
+/** What the answer panel says for a question once it is answered. */
+export function verdictOf(q: Question, state: DrillState): Verdict {
+  const ok = state.ok;
+  const pref = honmoon.settings.pref;
+  switch (q.kind) {
+    case 'mdo':
+    case 'deg2fb':
+    case 'singdeg':
+      return degreeVerdict(q, state, pref);
+    case 'rvalue':
+      return valueVerdict(q, ok);
+    case 'rcount':
+    case 'rhear':
+    case 'rfill':
+      return barVerdict(q, ok);
+    case 'rtap':
+      return tapVerdictText(q, ok);
+    case 'ivhear':
+    case 'ivsee':
+    case 'singit':
+    case 'ivbuild':
+      return intervalVerdict(q, state);
+    case 'chhear': {
+      const chord = chDef(q.cid);
+      const intervals = chord.iv.map((semis) => ivDef(semis).ab).join(' ');
+      return {
+        ok,
+        txt: ok ? 'Correct' : chord.n,
+        subs: [chord.n + ' · ' + intervals + ' from the root'],
+      };
+    }
+    case 'earscale': {
+      const scale = scaleDef(q.sid);
+      const degrees = scale.dg.map(degPretty).join(' ');
+      return {
+        ok,
+        txt: ok ? 'Correct' : scale.n,
+        subs: [scale.n + ' · ' + degrees + ' · ' + scale.d],
+      };
+    }
+    case 'staffkey': {
+      let headline: string;
+      if (ok) {
+        headline = 'Correct';
+      } else if (state.wrongKey != null) {
+        headline = 'That was ' + noteName(pcOf(state.wrongKey), 'en', pref);
+      } else {
+        headline = noteName(q.pc, 'en', pref);
+      }
+      return { ok, txt: headline, subs: [bothNames(q.pc, pref)] };
+    }
+  }
+  if (q.kind.startsWith('sc') && 'sid' in q) {
+    const notes = scaleNotes(q.sid, q.root).map(noteText).join(' ');
+    return { ok, txt: scaleHeadline(q, ok), subs: [scaleName(q.sid, q.root) + ' · ' + notes] };
+  }
+  return noteVerdict(q, state, pref);
+}

package/src/lib/index.ts

@@ -0,0 +1,117 @@
+/* @greenblacksky/honmoon — everything the three apps (Mira, Rumi, Zoey) share.
+   Logic and data are plain TypeScript; the screens and widgets are Svelte
+   components under ui/. Import what you need from the package root. */
+
+/* store */
+export * from './store/types';
+export {
+  honmoon,
+  DEF,
+  configureStore,
+  addNormalizer,
+  card,
+  mastery,
+  record,
+  queueSave,
+  save,
+  saveLocal,
+  setSetting,
+  payload,
+  load,
+  apply,
+  resetProgress,
+  exportText,
+  importText,
+  syncLabel,
+} from './store/honmoon.svelte';
+export { FirebaseSync, type SyncAdapter, type FirebaseSyncOptions } from './store/sync';
+
+/* music */
+export * from './music/notes';
+export * from './music/bass';
+export * from './music/scales';
+export * from './music/clefs';
+export * from './music/intervals';
+export * from './music/voice';
+export * from './music/rhythm';
+
+/* notation */
+export * from './notation/glyphs';
+export * from './notation/staff';
+export * from './notation/fretboard';
+export * from './notation/keyboard';
+export * from './notation/rhythmsvg';
+export * from './notation/tab';
+export { IC, type IconName } from './notation/icons';
+
+/* audio */
+export { ac, acIfAny, audioGate } from './audio/context';
+export * from './audio/synth';
+export * from './audio/rhythmplay';
+export * from './audio/metronome.svelte';
+export * from './audio/mic';
+export { nsdfPitch, decimate } from './audio/pitch';
+
+/* learning */
+export * from './learn/pools';
+export * from './learn/session';
+export * from './drills/defs';
+export * from './drills/registry.svelte';
+export * from './drills/questions';
+export * from './drills/runtime.svelte';
+
+/* navigation */
+export * from './nav.svelte';
+
+/* utilities */
+export * from './util/random';
+export * from './util/text';
+export * from './util/list';
+
+/* progress and descriptions */
+export * from './learn/progress';
+export { describeCard } from './learn/describe';
+export { verdictOf, type Verdict } from './drills/verdict';
+
+/* ui: building blocks */
+export { installTapFix } from './ui/tapfix';
+export { hscroll, fretFrac, type HScrollParams } from './ui/actions';
+export { follow, kbFollow, kbFollowStop } from './ui/keyfollow.svelte';
+export * from './ui/scaleboard';
+export * from './ui/types';
+export { GLOSS, LEARN, DEGQ, DEGTABS } from './ui/refdata';
+export { default as Shell } from './ui/Shell.svelte';
+export { default as Fretboard } from './ui/Fretboard.svelte';
+export { default as Keyboard } from './ui/Keyboard.svelte';
+export { default as StaffRun } from './ui/StaffRun.svelte';
+export { default as RhythmBar } from './ui/RhythmBar.svelte';
+export { default as Chips } from './ui/Chips.svelte';
+export { default as Stat } from './ui/Stat.svelte';
+export { default as BackBar } from './ui/BackBar.svelte';
+export { default as BassRow } from './ui/BassRow.svelte';
+export { default as AccRow } from './ui/AccRow.svelte';
+export { default as DataCard } from './ui/DataCard.svelte';
+export { default as MetronomePanel } from './ui/MetronomePanel.svelte';
+
+/* ui: screens */
+export { default as PracticeHome } from './ui/screens/PracticeHome.svelte';
+export { default as FamilyScreen } from './ui/screens/FamilyScreen.svelte';
+export { default as ScalesScreen } from './ui/screens/ScalesScreen.svelte';
+export { default as DrillScreen } from './ui/screens/DrillScreen.svelte';
+export { default as SessionDone } from './ui/screens/SessionDone.svelte';
+export { default as StatsScreen } from './ui/screens/StatsScreen.svelte';
+export { default as SetupScreen } from './ui/screens/SetupScreen.svelte';
+export { default as StaffMap } from './ui/screens/StaffMap.svelte';
+export { default as RhythmRef } from './ui/screens/RhythmRef.svelte';
+export { default as IntervalRef } from './ui/screens/IntervalRef.svelte';
+export { default as DegreesRef } from './ui/screens/DegreesRef.svelte';
+export { default as Glossary } from './ui/screens/Glossary.svelte';
+export { default as Explorer } from './ui/screens/Explorer.svelte';
+export { default as LearnIndex } from './ui/screens/LearnIndex.svelte';
+export { default as TapCalibration } from './ui/screens/TapCalibration.svelte';
+export { default as MetronomeScreen } from './ui/screens/MetronomeScreen.svelte';
+
+/* warm-ups */
+export * from './music/warmups';
+export { vCueLen, vPlayOnce } from './audio/voiceplay';
+export { installDefaultNormalizers } from './store/normalize';

package/src/lib/learn/describe.ts

@@ -0,0 +1,72 @@
+import { honmoon } from '../store/honmoon.svelte';
+import { STRINGS } from '../music/bass';
+import { bothNames, degName, keyName, noteName, pcOf } from '../music/notes';
+import { clefDef, parseST } from '../music/clefs';
+import { chDef, ivDef } from '../music/intervals';
+import { restName, rvalDef } from '../music/rhythm';
+import { parseSC, scaleDef, scaleName } from '../music/scales';
+import { parseMD } from './pools';
+
+const BAR_DRILL_WORDS: Record<string, string> = {
+  count: 'counting a bar',
+  fill: 'completing a bar',
+  hear: 'hearing a bar',
+  tap: 'tapping a bar',
+};
+function describeRhythm(id: string): string {
+  const [, kind, value] = id.split(':');
+  if (kind === 'v') {
+    return 'Rhythm — ' + rvalDef(+value).n;
+  }
+  if (kind === 'r') {
+    return 'Rhythm — ' + restName(+value);
+  }
+  return 'Rhythm — ' + (BAR_DRILL_WORDS[kind] || kind);
+}
+
+/** A card id in words, for the session summary and the weakest-spots list. */
+export function describeCard(id: string): string {
+  const pref = honmoon.settings.pref;
+  const rest = id.slice(3);
+  switch (id.slice(0, 3)) {
+    case 'sc:': {
+      const { sid, root } = parseSC(id);
+      return scaleName(sid, root);
+    }
+    case 'iv:':
+      return 'Interval — ' + ivDef(+rest).n;
+    case 'ch:':
+      return 'Chord by ear — ' + chDef(rest).n;
+    case 'fb:': {
+      const [, stringPart, fretPart] = id.split(':');
+      const string = STRINGS[+stringPart];
+      const pc = pcOf(string.open + +fretPart);
+      return string.n + ' string, fret ' + fretPart + ' — ' + bothNames(pc, pref);
+    }
+    case 'st:': {
+      const { clef, m } = parseST(id);
+      return 'On the ' + clefDef(clef).n.toLowerCase() + ' staff — ' + bothNames(pcOf(m), pref);
+    }
+    case 'md:': {
+      const { keyPc, pc } = parseMD(id);
+      const note = noteName(pc, 'en', pref);
+      return 'In ' + keyName(keyPc) + ' — ' + note + ', the ' + degName(pc, keyPc, pref);
+    }
+    case 'rh:':
+      return describeRhythm(id);
+    case 'pl:':
+      return 'Playing ' + bothNames(+rest, pref);
+    case 'se:': {
+      const scale = scaleDef(rest);
+      return 'Scale by ear — ' + (scale ? scale.n : rest);
+    }
+    case 'tr:':
+      return 'Naming ' + bothNames(+rest, pref);
+    default:
+      /* A card type with no description of its own used to fall into the line
+         above and be read as a pitch class, which turned "se:dorian" into
+         "Naming undefined · undefined". Printing the id looks daft; printing
+         nonsense confidently is worse. */
+      return id;
+  }
+}

package/src/lib/learn/pools.ts

@@ -0,0 +1,44 @@
+import { MKEYS, pcOf } from '../music/notes';
+import { accOn, allowedPc, positions } from '../music/bass';
+import { enabledScales } from '../music/scales';
+
+/* ---------------- card pools ----------------
+   Every card id carries its own meaning, and the prefixes are kept exactly as
+   Fretboard Fluency had them so old progress still lines up:
+     fb:s:f    a position on the neck          st:m / st:clef:m  a note on a staff
+     tr:pc     naming a pitch class            pl:pc  playing a pitch class
+     md:k:pc   a note in a key                 rh:…   rhythm
+     iv:n      an interval                     ch:id  a chord
+     se:id     a scale by ear                  sc:id:root  a scale in a key */
+
+const PITCH_CLASSES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+const MAJOR_SCALE_STEPS = [0, 2, 4, 5, 7, 9, 11];
+
+/** Pitch classes in rotation, for translating between letters and solfège. */
+export function pcs(): { pc: number; id: string }[] {
+  return PITCH_CLASSES.filter(allowedPc).map((pc) => ({ pc, id: 'tr:' + pc }));
+}
+/** Pitch classes you can actually reach at this range, for "play that note" —
+    the answer is the right note in any octave, so the card is the pitch class. */
+export function playPcs(): { pc: number; id: string }[] {
+  const reachable = new Set(positions().map((pos) => pcOf(pos.m)));
+  return [...reachable].sort((a, b) => a - b).map((pc) => ({ pc, id: 'pl:' + pc }));
+}
+export function parseMD(id: string): { keyPc: number; pc: number } {
+  const parts = id.split(':');
+  return { keyPc: +parts[1], pc: +parts[2] };
+}
+/** The degrees asked about in movable-do cards: all twelve when the black
+    notes are on, otherwise the seven of the major scale. */
+export function mdoRels(): number[] {
+  return accOn() ? [...PITCH_CLASSES] : [...MAJOR_SCALE_STEPS];
+}
+export function mdoCards(): string[] {
+  const degrees = mdoRels();
+  return MKEYS.flatMap((key) =>
+    degrees.map((degree) => 'md:' + key.pc + ':' + pcOf(key.pc + degree)),
+  );
+}
+export function scalearCards(): string[] {
+  return enabledScales().map((scale) => 'se:' + scale.id);
+}

package/src/lib/learn/progress.ts

@@ -0,0 +1,100 @@
+import { honmoon, mastery } from '../store/honmoon.svelte';
+import { dayKey, todayKey } from '../util/text';
+import { positions } from '../music/bass';
+import { staffNotes } from '../music/clefs';
+import { earCards } from '../music/intervals';
+import { scaleCards } from '../music/scales';
+import { pcs, playPcs, scalearCards } from './pools';
+import { drillDef, famDrills, groupDef } from '../drills/registry.svelte';
+import type { DrillDef } from '../drills/defs';
+
+const MAX_MASTERY = 5;
+/** Mastery summed over some cards, as a percentage of all of them being solid. */
+function masteryPercent(ids: string[]): number {
+  const total = ids.reduce((sum, id) => sum + mastery(id), 0);
+  return Math.round((100 * total) / (ids.length * MAX_MASTERY));
+}
+
+/** The cards a drill is measured over. */
+function cardsMeasuredBy(drill: DrillDef): string[] {
+  const asIds = (items: { id: string }[]) => items.map((item) => item.id);
+  switch (drill.kind) {
+    case 'earscale':
+      return scalearCards();
+    case 'ear':
+      return earCards();
+    case 'translate':
+      return asIds(pcs());
+    case 'staff2name':
+    case 'staffkey':
+      return asIds(staffNotes());
+    case 'play':
+      return drill.sys === 'staff' ? asIds(staffNotes()) : asIds(playPcs());
+    default:
+      return asIds(positions());
+  }
+}
+/** How solid a drill's cards are, as a percentage of full mastery. */
+export function drillMastery(id: string): { pct: number; n: number } {
+  const drill = drillDef(id);
+  if (!drill) {
+    return { pct: 0, n: 0 };
+  }
+  const ids = cardsMeasuredBy(drill);
+  if (!ids.length) {
+    return { pct: 0, n: 0 };
+  }
+  return { pct: masteryPercent(ids), n: ids.length };
+}
+/** How solid the scale-and-key pairs in rotation are. */
+export function scaleDrillMastery(): number {
+  const ids = scaleCards();
+  return ids.length ? masteryPercent(ids) : 0;
+}
+export function famMastery(familyKey: string): { pct: number; n: number } {
+  const drills = famDrills(familyKey);
+  if (!drills.length) {
+    return { pct: 0, n: 0 };
+  }
+  /* (The original added scale mastery as an object's missing .pct here, which
+     made the family's figure NaN and hid it. It is a plain number now.) */
+  const isScaleFamily = groupDef(familyKey)?.k === 'scale';
+  let total = 0;
+  for (const drill of drills) {
+    total += isScaleFamily ? scaleDrillMastery() : drillMastery(drill.id).pct;
+  }
+  return { pct: Math.round(total / drills.length), n: drills.length };
+}
+
+/** Don't count back further than this many days. */
+const MAX_STREAK = 400;
+/** Consecutive days with at least one answer, counting today only once it has one. */
+export function streakDays(): number {
+  const day = new Date();
+  let streak = 0;
+  for (;;) {
+    const key = dayKey(day);
+    if (honmoon.daily[key] && honmoon.daily[key].n > 0) {
+      streak++;
+      day.setDate(day.getDate() - 1);
+    } else if (streak === 0 && key === todayKey()) {
+      // nothing yet today: the streak can still be yesterday's
+      day.setDate(day.getDate() - 1);
+    } else {
+      break;
+    }
+    if (streak > MAX_STREAK) {
+      break;
+    }
+  }
+  return streak;
+}
+export function totals(): { n: number; c: number; acc: number } {
+  let answers = 0;
+  let correct = 0;
+  for (const key in honmoon.daily) {
+    answers += honmoon.daily[key].n;
+    correct += honmoon.daily[key].c;
+  }
+  return { n: answers, c: correct, acc: answers ? Math.round((100 * correct) / answers) : 0 };
+}