@dsebastien/music-notation 0.0.0-stage → 0.1.0

package/dist/publish/auto.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The browser bundle (`music-notation.publish.min.js`): injects the styles and renders every
+ * notation block on the page, now and as it changes. Exposes the API as `window.MusicNotation`.
+ */
+import * as api from '../index.js';
+import { lookupGuitarVoicing } from '../voicings/index.js';
+declare global {
+    interface Window {
+        musicNotationLoaded?: boolean;
+        MusicNotation?: typeof api & {
+            lookupGuitarVoicing: typeof lookupGuitarVoicing;
+            stop: () => void;
+        };
+    }
+}

package/dist/publish/index.d.ts

@@ -0,0 +1,5 @@
+import type { RenderOptions } from '../blocks/renderers.js';
+/** Render every block not rendered yet (or changed, or whose rendering vanished) under `root`. */
+export declare function renderAll(root: ParentNode, options?: RenderOptions): number;
+/** Render now and whenever the page changes. Returns a function that stops watching. */
+export declare function autoRender(doc: Document, options?: RenderOptions): () => void;

package/dist/publish/index.js

@@ -0,0 +1,81 @@
+import {
+  LANGUAGES2,
+  renderBlock2
+} from "../chunks/index-b71brbpf.js";
+
+// src/publish/index.ts
+var SELECTOR = LANGUAGES2.map((l) => `pre > code.language-${l}`).join(", ");
+var MARK = "mpRendered";
+var SOURCE = "mpSource";
+var languageOf = (code) => LANGUAGES2.find((l) => code.classList.contains(`language-${l}`));
+function fingerprint(text) {
+  let hash = 5381;
+  for (let i = 0;i < text.length; i++)
+    hash = (hash * 33 ^ text.charCodeAt(i)) >>> 0;
+  return `${text.length}:${hash.toString(36)}`;
+}
+var renderingOf = (pre) => {
+  const next = pre.nextElementSibling;
+  return next?.classList.contains("mn-block") ? next : null;
+};
+function renderAll(root, options = {}) {
+  let count = 0;
+  root.querySelectorAll(SELECTOR).forEach((code) => {
+    const pre = code.parentElement;
+    const language = languageOf(code);
+    if (!pre?.parentElement || !language)
+      return;
+    const source = code.textContent ?? "";
+    const print = fingerprint(source);
+    const previous = renderingOf(pre);
+    if (pre.dataset[MARK] && pre.dataset[SOURCE] === print && previous)
+      return;
+    previous?.remove();
+    pre.style.removeProperty("display");
+    pre.dataset[SOURCE] = print;
+    pre.dataset[MARK] = "pending";
+    const holder = pre.ownerDocument.createElement("div");
+    const result = renderBlock2(language, source, holder, options);
+    pre.insertAdjacentElement("afterend", result.el);
+    if (!result.ok) {
+      pre.dataset[MARK] = "error";
+      return;
+    }
+    pre.style.display = "none";
+    pre.dataset[MARK] = "done";
+    count++;
+  });
+  return count;
+}
+function autoRender(doc, options = {}) {
+  renderAll(doc, options);
+  const view = doc.defaultView;
+  if (!view)
+    return () => {
+      return;
+    };
+  let scheduled = false;
+  let stopped = false;
+  const observer = new view.MutationObserver(() => {
+    if (scheduled || stopped)
+      return;
+    scheduled = true;
+    view.requestAnimationFrame(() => {
+      scheduled = false;
+      if (!stopped)
+        renderAll(doc, options);
+    });
+  });
+  observer.observe(doc.body, { childList: true, subtree: true, characterData: true });
+  return () => {
+    stopped = true;
+    observer.disconnect();
+  };
+}
+export {
+  autoRender,
+  renderAll
+};
+
+//# debugId=25709619E83183AF64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/publish/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/publish/index.ts"],
+  "sourcesContent": [
+    "/**\n * Obsidian Publish (and any page): turn `<pre><code class=\"language-chord\">` blocks into\n * notation. Idempotent (`data-mp-rendered`), follows the page as it changes (Publish swaps and\n * virtualises content), and hides the source only after a successful render.\n */\nimport { LANGUAGES, renderBlock } from '../render/render-block.js'\nimport type { NotationLanguage, RenderOptions } from '../blocks/renderers.js'\n\nconst SELECTOR = LANGUAGES.map((l) => `pre > code.language-${l}`).join(', ')\nconst MARK = 'mpRendered'\nconst SOURCE = 'mpSource'\n\nconst languageOf = (code: Element): NotationLanguage | undefined =>\n    LANGUAGES.find((l) => code.classList.contains(`language-${l}`))\n\n/** A short fingerprint of a block's source, to notice edits in place. */\nfunction fingerprint(text: string): string {\n    let hash = 5381\n    for (let i = 0; i < text.length; i++) hash = ((hash * 33) ^ text.charCodeAt(i)) >>> 0\n    return `${text.length}:${hash.toString(36)}`\n}\n\n/** The rendering that follows a `<pre>`, if it's still there. */\nconst renderingOf = (pre: HTMLElement): Element | null => {\n    const next = pre.nextElementSibling\n    return next?.classList.contains('mn-block') ? next : null\n}\n\n/** Render every block not rendered yet (or changed, or whose rendering vanished) under `root`. */\nexport function renderAll(root: ParentNode, options: RenderOptions = {}): number {\n    let count = 0\n    root.querySelectorAll(SELECTOR).forEach((code) => {\n        const pre = code.parentElement\n        const language = languageOf(code)\n        if (!pre?.parentElement || !language) return\n        const source = code.textContent ?? ''\n        const print = fingerprint(source)\n        const previous = renderingOf(pre)\n        if (pre.dataset[MARK] && pre.dataset[SOURCE] === print && previous) return\n        // New, edited, or its rendering was removed: (re)render from scratch.\n        previous?.remove()\n        pre.style.removeProperty('display')\n        pre.dataset[SOURCE] = print\n        pre.dataset[MARK] = 'pending'\n        const holder = pre.ownerDocument.createElement('div')\n        const result = renderBlock(language, source, holder, options)\n        pre.insertAdjacentElement('afterend', result.el)\n        if (!result.ok) {\n            // Leave the source visible; the error explains what's wrong.\n            pre.dataset[MARK] = 'error'\n            return\n        }\n        pre.style.display = 'none'\n        pre.dataset[MARK] = 'done'\n        count++\n    })\n    return count\n}\n\n/** Render now and whenever the page changes. Returns a function that stops watching. */\nexport function autoRender(doc: Document, options: RenderOptions = {}): () => void {\n    renderAll(doc, options)\n    const view = doc.defaultView\n    if (!view) return () => undefined\n    let scheduled = false\n    let stopped = false\n    const observer = new view.MutationObserver(() => {\n        if (scheduled || stopped) return\n        scheduled = true\n        // One pass per frame, however many mutations Publish makes.\n        view.requestAnimationFrame(() => {\n            scheduled = false\n            if (!stopped) renderAll(doc, options)\n        })\n    })\n    observer.observe(doc.body, { childList: true, subtree: true, characterData: true })\n    return () => {\n        stopped = true\n        observer.disconnect()\n    }\n}\n"
+  ],
+  "mappings": ";;;;;;AAQA,IAAM,WAAW,WAAU,IAAI,CAAC,MAAM,uBAAuB,GAAG,EAAE,KAAK,IAAI;AAC3E,IAAM,OAAO;AACb,IAAM,SAAS;AAEf,IAAM,aAAa,CAAC,SAChB,WAAU,KAAK,CAAC,MAAM,KAAK,UAAU,SAAS,YAAY,GAAG,CAAC;AAGlE,SAAS,WAAW,CAAC,MAAsB;AAAA,EACvC,IAAI,OAAO;AAAA,EACX,SAAS,IAAI,EAAG,IAAI,KAAK,QAAQ;AAAA,IAAK,QAAS,OAAO,KAAM,KAAK,WAAW,CAAC,OAAO;AAAA,EACpF,OAAO,GAAG,KAAK,UAAU,KAAK,SAAS,EAAE;AAAA;AAI7C,IAAM,cAAc,CAAC,QAAqC;AAAA,EACtD,MAAM,OAAO,IAAI;AAAA,EACjB,OAAO,MAAM,UAAU,SAAS,UAAU,IAAI,OAAO;AAAA;AAIlD,SAAS,SAAS,CAAC,MAAkB,UAAyB,CAAC,GAAW;AAAA,EAC7E,IAAI,QAAQ;AAAA,EACZ,KAAK,iBAAiB,QAAQ,EAAE,QAAQ,CAAC,SAAS;AAAA,IAC9C,MAAM,MAAM,KAAK;AAAA,IACjB,MAAM,WAAW,WAAW,IAAI;AAAA,IAChC,IAAI,CAAC,KAAK,iBAAiB,CAAC;AAAA,MAAU;AAAA,IACtC,MAAM,SAAS,KAAK,eAAe;AAAA,IACnC,MAAM,QAAQ,YAAY,MAAM;AAAA,IAChC,MAAM,WAAW,YAAY,GAAG;AAAA,IAChC,IAAI,IAAI,QAAQ,SAAS,IAAI,QAAQ,YAAY,SAAS;AAAA,MAAU;AAAA,IAEpE,UAAU,OAAO;AAAA,IACjB,IAAI,MAAM,eAAe,SAAS;AAAA,IAClC,IAAI,QAAQ,UAAU;AAAA,IACtB,IAAI,QAAQ,QAAQ;AAAA,IACpB,MAAM,SAAS,IAAI,cAAc,cAAc,KAAK;AAAA,IACpD,MAAM,SAAS,aAAY,UAAU,QAAQ,QAAQ,OAAO;AAAA,IAC5D,IAAI,sBAAsB,YAAY,OAAO,EAAE;AAAA,IAC/C,IAAI,CAAC,OAAO,IAAI;AAAA,MAEZ,IAAI,QAAQ,QAAQ;AAAA,MACpB;AAAA,IACJ;AAAA,IACA,IAAI,MAAM,UAAU;AAAA,IACpB,IAAI,QAAQ,QAAQ;AAAA,IACpB;AAAA,GACH;AAAA,EACD,OAAO;AAAA;AAIJ,SAAS,UAAU,CAAC,KAAe,UAAyB,CAAC,GAAe;AAAA,EAC/E,UAAU,KAAK,OAAO;AAAA,EACtB,MAAM,OAAO,IAAI;AAAA,EACjB,IAAI,CAAC;AAAA,IAAM,OAAO,MAAG;AAAA,MAAG;AAAA;AAAA,EACxB,IAAI,YAAY;AAAA,EAChB,IAAI,UAAU;AAAA,EACd,MAAM,WAAW,IAAI,KAAK,iBAAiB,MAAM;AAAA,IAC7C,IAAI,aAAa;AAAA,MAAS;AAAA,IAC1B,YAAY;AAAA,IAEZ,KAAK,sBAAsB,MAAM;AAAA,MAC7B,YAAY;AAAA,MACZ,IAAI,CAAC;AAAA,QAAS,UAAU,KAAK,OAAO;AAAA,KACvC;AAAA,GACJ;AAAA,EACD,SAAS,QAAQ,IAAI,MAAM,EAAE,WAAW,MAAM,SAAS,MAAM,eAAe,KAAK,CAAC;AAAA,EAClF,OAAO,MAAM;AAAA,IACT,UAAU;AAAA,IACV,SAAS,WAAW;AAAA;AAAA;",
+  "debugId": "25709619E83183AF64756E2164756E21",
+  "names": []
+}

package/dist/render/dom.d.ts

@@ -0,0 +1,12 @@
+/** DOM and SVG helpers. Everything is created in the host's document (popout windows, Publish). */
+export declare const SVG_NS = "http://www.w3.org/2000/svg";
+type Attributes = Record<string, string | number | undefined>;
+/** An SVG element with attributes and children. */
+export declare function svg(doc: Document, tag: string, attrs?: Attributes, children?: (Element | null)[]): SVGElement;
+/** An SVG <text>. */
+export declare function svgText(doc: Document, text: string, attrs?: Attributes): SVGElement;
+/** An HTML element with a class and optional text. */
+export declare function html<K extends keyof HTMLElementTagNameMap>(doc: Document, tag: K, cls?: string, text?: string): HTMLElementTagNameMap[K];
+/** A root <svg> sized by its viewBox, scaling with the container up to its natural width. */
+export declare function svgRoot(doc: Document, width: number, height: number, cls: string, label: string): SVGElement;
+export {};

package/dist/render/render-block.d.ts

@@ -0,0 +1,14 @@
+/** Render a notation block into a host element. Never throws: errors render inline. */
+import { type NotationLanguage, type RenderOptions } from '../blocks/renderers.js';
+export declare const LANGUAGES: NotationLanguage[];
+export declare const isNotationLanguage: (language: string) => language is NotationLanguage;
+export interface RenderResult {
+    ok: boolean;
+    /** The block's container, appended to the host. */
+    el: HTMLElement;
+    /** The message shown when ok is false. */
+    error: string | null;
+    /** Removes what was rendered. */
+    destroy(): void;
+}
+export declare function renderBlock(language: NotationLanguage, source: string, host: HTMLElement, options?: RenderOptions): RenderResult;

package/dist/styles.d.ts

@@ -0,0 +1,4 @@
+/** The library's stylesheet, for hosts that inject it themselves. */
+export declare const STYLES: string;
+/** Add the stylesheet to a document once. */
+export declare function injectStyles(doc: Document): void;

package/dist/theory/chord-symbol.d.ts

@@ -0,0 +1,10 @@
+export interface ParsedChord {
+    symbol: string;
+    root: string;
+    quality: string;
+    bass: string | null;
+    /** "F Sharp Minor 7", "C Major over G". */
+    name: string;
+}
+/** Parse a chord symbol; null when it isn't one. */
+export declare function parseChord(symbol: string): ParsedChord | null;

package/dist/theory/note-set.d.ts

@@ -0,0 +1,32 @@
+export type NoteLabel = 'notes' | 'degrees' | 'intervals' | 'fingers' | 'none';
+export interface NoteSetMember {
+    chroma: number;
+    /** As spelled by the chord, scale or list ("Bb", not "A#"). */
+    name: string;
+    /** 1-based position in the chord or scale; null for a plain list. */
+    degree: number | null;
+    /** "1P", "3m", "5P"…; null for a plain list. */
+    interval: string | null;
+}
+export interface NoteSet {
+    /** "A minor pentatonic", "Cmaj7", or the notes as written. */
+    title: string;
+    members: NoteSetMember[];
+    /** Chroma of the root; null for a plain list. */
+    root: number | null;
+    /** Exact pitches (MIDI), when the notes were given with octaves ("C4 E4 G4"). */
+    pitches: number[] | null;
+    preferFlats: boolean;
+}
+/** The member a pitch belongs to, if any. */
+export declare const memberOf: (set: NoteSet, midi: number) => NoteSetMember | undefined;
+/** tonal's "3m", "5d", "4A", "1P" → how musicians write them: "b3", "b5", "#4", "R". */
+export declare function intervalLabel(interval: string): string;
+/** Text shown on a highlighted note. */
+export declare function labelOf(member: NoteSetMember, label: NoteLabel, finger?: string): string;
+/** Notes of a chord symbol ("Cmaj7", "C/G"); null when tonal doesn't know it. */
+export declare function chordNoteSet(symbol: string): NoteSet | null;
+/** Notes of a scale ("A minor pentatonic", "D dorian"); null when tonal doesn't know it. */
+export declare function scaleNoteSet(name: string): NoteSet | null;
+/** An explicit list: "A C E" (pitch classes) or "A3 C4 E4" (exact pitches). */
+export declare function listNoteSet(text: string): NoteSet | null;

package/dist/theory/pitch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pitch classes and note names. A pitch class is a chroma: 0 = C … 11 = B. Names accept ASCII
+ * (`#`, `b`) and Unicode (`♯`, `♭`) accidentals.
+ */
+export declare const SHARP_NAMES: readonly ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+export declare const FLAT_NAMES: readonly ["C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B"];
+/** "C#", "Db", "D♭", "E" → 0..11; null when it isn't a note name. */
+export declare function chromaOf(name: string): number | null;
+/** A note with its octave, scientific pitch notation ("C4" = MIDI 60); null when invalid. */
+export declare function midiOf(note: string): number | null;
+/** Name of a pitch class, with sharps or flats. Non-integers are rounded. */
+export declare const nameOf: (chroma: number, preferFlats?: boolean) => string;
+export interface ChordSymbolParts {
+    root: string;
+    /** Everything between the root and the bass: "m7", "6/9", "". */
+    suffix: string;
+    bass: string | null;
+}
+/**
+ * "F♯m7/C#" → root F#, suffix m7, bass C#. A slash starts a bass only when a note name follows
+ * ("C6/9" has no bass). ♯ and ♭ become # and b.
+ */
+export declare function splitChordSymbol(symbol: string): ChordSymbolParts | null;
+/** "C4" for MIDI 60. */
+export declare const noteOf: (midi: number, preferFlats?: boolean) => string;
+/** Whether a name is spelled with a flat ("Bb", "E♭"). */
+export declare const isFlat: (name: string) => boolean;

package/dist/theory/transpose.d.ts

@@ -0,0 +1,9 @@
+/** Whether a key ("F", "Bb", "Dm") is written with flats. */
+export declare function keyPrefersFlats(key: string): boolean;
+/**
+ * Transpose a chord symbol ("F#m7/C#", +2 → "G#m7/D#"). Spelling follows `preferFlats`, or the
+ * symbol's own when not given. Text that isn't a chord symbol comes back unchanged.
+ */
+export declare function transposeChord(symbol: string, semitones: number, preferFlats?: boolean): string;
+/** Transpose a key ("Am", +3 → "Cm"), spelled the way that key is usually written. */
+export declare function transposeKey(key: string, semitones: number): string;

package/dist/voicings/index.d.ts

@@ -0,0 +1,6 @@
+import type { FrettedVoicing } from '../chord/guitar.js';
+/** Finds the n-th voicing (0-based) of a chord symbol; null when unknown. */
+export type VoicingLookup = (symbol: string, index: number) => FrettedVoicing | null;
+export declare const lookupGuitarVoicing: VoicingLookup;
+/** How many voicings the database has for a symbol. */
+export declare function voicingCount(symbol: string): number;