linked-rolls 0.0.1

package/lib/alignRolls.js

@@ -0,0 +1,49 @@
+import { dimensionOf } from "./Symbol";
+export function alignSymbols(rollA, rollB) {
+    // 1. Only musical-note anchors
+    const XA = rollA.filter(e => e.type === 'note').map(e => dimensionOf(e).horizontal.from);
+    const YB = rollB.filter(e => e.type === 'note').map(e => dimensionOf(e).horizontal.from);
+    // 2. Initial LSQ fit for x2 = A*x + B
+    let { A, B } = fitAffine(XA, YB);
+    let stretch = A, shift = B / A;
+    // 3. Refinement
+    for (let i = 0; i < 10; i++) {
+        const transformed = XA.map(x => stretch * (x + shift));
+        const pairs = [];
+        for (let tx of transformed) {
+            const nearest = findClosest(tx, YB);
+            if (Math.abs(tx - nearest) <= 3) {
+                pairs.push([(tx / stretch) - shift, nearest]);
+            }
+        }
+        if (pairs.length < 2)
+            break;
+        const [Xin, Yin] = unzip(pairs);
+        const { A: A2, B: B2 } = fitAffine(Xin, Yin);
+        const b2 = B2 / A2;
+        if (Math.abs(A2 - A) < 1e-6 && Math.abs(b2 - shift) < 1e-3)
+            break;
+        A = A2;
+        B = B2;
+        stretch = A;
+        shift = b2;
+    }
+    return { stretch: stretch, shift: shift };
+}
+const mean = (arr) => arr.reduce((acc, val) => acc + val, 0) / arr.length;
+function fitAffine(X, Y) {
+    const mx = mean(X), my = mean(Y);
+    let num = 0, den = 0;
+    X.forEach((x, i) => { num += (x - mx) * (Y[i] - my); den += (x - mx) ** 2; });
+    const A = den === 0 ? 1 : num / den;
+    const B = my - A * mx;
+    return { A, B };
+}
+function findClosest(val, arr) {
+    return arr.reduce((best, curr) => Math.abs(curr - val) < Math.abs(best - val) ? curr : best);
+}
+function unzip(p) {
+    const X = [], Y = [];
+    p.forEach(([x, y]) => { X.push(x); Y.push(y); });
+    return [X, Y];
+}

package/lib/alignSymbols.d.ts

@@ -0,0 +1,7 @@
+import { AnySymbol } from "./Symbol";
+type AlignmentResult = {
+    shift: number;
+    stretch: number;
+};
+export declare function alignSymbols(rollA: AnySymbol[], rollB: AnySymbol[]): AlignmentResult;
+export {};

package/lib/alignSymbols.js

@@ -0,0 +1,49 @@
+import { dimensionOf } from "./Symbol";
+export function alignSymbols(rollA, rollB) {
+    // 1. Only musical-note anchors
+    const XA = rollA.filter(e => e.type === 'note').map(e => dimensionOf(e).horizontal.from);
+    const YB = rollB.filter(e => e.type === 'note').map(e => dimensionOf(e).horizontal.from);
+    // 2. Initial LSQ fit for x2 = A*x + B
+    let { A, B } = fitAffine(XA, YB);
+    let stretch = A, shift = B / A;
+    // 3. Refinement
+    for (let i = 0; i < 10; i++) {
+        const transformed = XA.map(x => stretch * (x + shift));
+        const pairs = [];
+        for (let tx of transformed) {
+            const nearest = findClosest(tx, YB);
+            if (Math.abs(tx - nearest) <= 3) {
+                pairs.push([(tx / stretch) - shift, nearest]);
+            }
+        }
+        if (pairs.length < 2)
+            break;
+        const [Xin, Yin] = unzip(pairs);
+        const { A: A2, B: B2 } = fitAffine(Xin, Yin);
+        const b2 = B2 / A2;
+        if (Math.abs(A2 - A) < 1e-6 && Math.abs(b2 - shift) < 1e-3)
+            break;
+        A = A2;
+        B = B2;
+        stretch = A;
+        shift = b2;
+    }
+    return { stretch: stretch, shift: shift };
+}
+const mean = (arr) => arr.reduce((acc, val) => acc + val, 0) / arr.length;
+function fitAffine(X, Y) {
+    const mx = mean(X), my = mean(Y);
+    let num = 0, den = 0;
+    X.forEach((x, i) => { num += (x - mx) * (Y[i] - my); den += (x - mx) ** 2; });
+    const A = den === 0 ? 1 : num / den;
+    const B = my - A * mx;
+    return { A, B };
+}
+function findClosest(val, arr) {
+    return arr.reduce((best, curr) => Math.abs(curr - val) < Math.abs(best - val) ? curr : best);
+}
+function unzip(p) {
+    const X = [], Y = [];
+    p.forEach(([x, y]) => { X.push(x); Y.push(y); });
+    return [X, Y];
+}

package/lib/asJsonLd.d.ts

@@ -0,0 +1,3 @@
+import { Edition } from "./Edition";
+export declare const referenceTypes: string[];
+export declare const asJsonLd: (edition: Edition) => any;

package/lib/asJsonLd.js

@@ -0,0 +1,67 @@
+import { exportDate } from "./importJsonLd";
+// for these keys, references by id will be inserted
+// rather than the object itself.
+export const referenceTypes = [
+    'premises',
+    'delete',
+    'comprehends'
+];
+const asIDArray = (arr) => {
+    return arr.map(e => e.id);
+};
+const asJsonLdEntity = (obj) => {
+    if (obj instanceof Date) {
+        return exportDate(obj);
+    }
+    const result = {};
+    if ('asJSON' in obj && typeof obj['asJSON'] === 'function') {
+        return asJsonLdEntity(obj['asJSON']());
+    }
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'function' || typeof value === 'undefined') {
+            // ignore
+        }
+        else if (referenceTypes.includes(key)) {
+            if (!Array.isArray(value)) {
+                console.error(`Expected array for key ${key}, got ${value}`);
+            }
+            else {
+                result[key] = asIDArray(value);
+            }
+        }
+        else if (key === 'assigned'
+            && (result['@type'] === 'derivation'
+                || result['@type'] === 'carrierAssignment')) {
+            result['assigned'] = value.id;
+        }
+        else if (key === 'type') {
+            result['@type'] = value;
+        }
+        else if (key === 'id') {
+            result['@id'] = value;
+        }
+        else if (Array.isArray(value)) {
+            result[key] = value.map(v => (typeof v === 'object') ? asJsonLdEntity(v) : v);
+        }
+        else if (typeof value === 'object') {
+            result[key] = asJsonLdEntity(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+export const asJsonLd = (edition) => {
+    const result = {
+        '@context': [
+            'https://linked-rolls.org/rollo/1.0/edition.jsonld',
+            {
+                '@base': edition.base
+            }
+        ],
+        '@type': "Edition",
+        ...asJsonLdEntity(edition)
+    };
+    return result;
+};

package/lib/asMIDISpans.d.ts

@@ -0,0 +1,23 @@
+import { MidiFile } from "midifile-ts";
+export declare function midiTickToMilliseconds(ticks: number, microsecondsPerBeat: number, ppq: number): number;
+interface Span<T extends string> {
+    type: T;
+    id: string;
+    onset: number;
+    offset: number;
+    onsetMs: number;
+    offsetMs: number;
+    link?: string;
+}
+export interface NoteSpan extends Span<'note'> {
+    pitch: number;
+    velocity: number;
+    channel: number;
+}
+export interface SustainSpan extends Span<'sustain'> {
+}
+export interface SoftSpan extends Span<'soft'> {
+}
+export type AnySpan = NoteSpan | SustainSpan | SoftSpan;
+export declare const asSpans: (file: MidiFile, readLinks?: boolean) => AnySpan[];
+export {};

package/lib/asMIDISpans.js

@@ -0,0 +1,111 @@
+import { MIDIControlEvents } from "midifile-ts";
+const isNoteOn = (event) => event.type === 'channel' && event.subtype === 'noteOn';
+const isNoteOff = (event) => event.type === 'channel' && event.subtype === 'noteOff';
+const isPedalOn = (event) => (event.type === 'channel'
+    && event.subtype === 'controller'
+    && event.controllerType === MIDIControlEvents.SUSTAIN
+    && event.value > 63);
+const isPedalOff = (event) => (event.type === 'channel'
+    && event.subtype === 'controller'
+    && event.controllerType === MIDIControlEvents.SUSTAIN
+    && event.value <= 63);
+const isSoftPedalOn = (event) => {
+    return event.type === 'channel'
+        && event.subtype === 'controller'
+        && event.controllerType === MIDIControlEvents.SOFT_PEDAL
+        && event.value > 63;
+};
+const isSoftPedalOff = (event) => {
+    return event.type === 'channel'
+        && event.subtype === 'controller'
+        && event.controllerType === MIDIControlEvents.SOFT_PEDAL
+        && event.value <= 63;
+};
+export function midiTickToMilliseconds(ticks, microsecondsPerBeat, ppq) {
+    const beats = ticks / ppq;
+    return (beats * microsecondsPerBeat) / 1000;
+}
+export const asSpans = (file, readLinks = false) => {
+    const resultingSpans = [];
+    const tempoMap = [];
+    const currentSpans = [];
+    let bufferedMetaText;
+    for (let i = 0; i < file.tracks.length; i++) {
+        const track = file.tracks[i];
+        let currentTime = 0;
+        for (const event of track) {
+            currentTime += event.deltaTime;
+            if (event.type === 'meta' && event.subtype === 'setTempo') {
+                tempoMap.push({
+                    atTick: currentTime,
+                    microsecondsPerBeat: event.microsecondsPerBeat
+                });
+            }
+            if (readLinks && event.type === 'meta' && event.subtype === 'text') {
+                bufferedMetaText = event.text;
+            }
+            else if (isNoteOn(event) || isPedalOn(event) || isSoftPedalOn(event)) {
+                const type = isNoteOn(event) ? 'note' : isPedalOn(event) ? 'sustain' : 'soft';
+                const currentTempo = tempoMap.slice().reverse().find(tempo => tempo.atTick <= currentTime);
+                if (!currentTempo) {
+                    console.log('No tempo event found. Skipping');
+                    continue;
+                }
+                const onsetMs = midiTickToMilliseconds(currentTime, currentTempo.microsecondsPerBeat, file.header.ticksPerBeat);
+                const link = bufferedMetaText;
+                if (type === 'note') {
+                    const pitch = event.noteNumber;
+                    currentSpans.push({
+                        type,
+                        id: `${i}-${currentTime}-${pitch}`,
+                        onset: currentTime,
+                        offset: 0,
+                        velocity: event.velocity,
+                        pitch,
+                        channel: i,
+                        onsetMs,
+                        offsetMs: 0,
+                        link
+                    });
+                }
+                else {
+                    currentSpans.push({
+                        type,
+                        id: `${i}-${currentTime}-${type}`,
+                        onset: currentTime,
+                        offset: 0,
+                        onsetMs,
+                        offsetMs: 0,
+                        link
+                    });
+                }
+                bufferedMetaText = undefined;
+            }
+            else if (isNoteOff(event) || isPedalOff(event) || isSoftPedalOff(event)) {
+                const type = isNoteOff(event) ? 'note' : isPedalOff(event) ? 'sustain' : 'soft';
+                const currentTempo = tempoMap.slice().reverse().find(tempo => tempo.atTick <= currentTime);
+                if (!currentTempo) {
+                    console.log('No tempo event found. Skipping');
+                    continue;
+                }
+                const counterpart = isNoteOff(event)
+                    ? currentSpans.find(e => e.type === 'note' && e.pitch === event.noteNumber)
+                    : currentSpans.find(e => e.type === type);
+                if (!counterpart) {
+                    console.log('Found an off event of type', type, 'at', currentTime, 'without a previous on.', 'Event:', event, 'Current spans: ', currentSpans.map(span => span.type).join(' '));
+                    continue;
+                }
+                counterpart.offset = currentTime;
+                counterpart.offsetMs = midiTickToMilliseconds(currentTime, currentTempo.microsecondsPerBeat, file.header.ticksPerBeat);
+                if (bufferedMetaText && counterpart.link) {
+                    counterpart.link += ` ${bufferedMetaText}`;
+                }
+                resultingSpans.push(counterpart);
+                currentSpans.splice(currentSpans.indexOf(counterpart), 1);
+            }
+        }
+    }
+    return resultingSpans
+        .filter(span => span.offsetMs > span.onsetMs)
+        .sort((a, b) => a.onset - b.onset);
+};

package/lib/aton/AtonParser.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Original code by Craig Stuart Sapp <craig@ccrma.stanford.edu>.
+ */
+interface ParserOptions {
+    forceKeyCase?: 'lowercase' | 'uppercase';
+    onlyChildToRoot?: boolean;
+}
+interface ParserState {
+    action?: any;
+    label?: any;
+    labelbegin?: any;
+    labelend?: any;
+    curobj: any;
+    curobjname?: any;
+    curkey?: any;
+    ocurkey?: any;
+    newkey?: any;
+    onewkey?: any;
+    newvalue?: any;
+    linenum?: any;
+    node: any[];
+    typer?: any;
+    output?: any;
+    keycase?: 'lowercase' | 'uppercase';
+}
+export declare class AtonParser {
+    options: ParserOptions;
+    constructor(options?: ParserOptions);
+    /**
+     * parse ATON content and return the JSON that it describes.
+     */
+    parse(str: string): any;
+    /**
+    * Parse ATON data from a list of individual records.
+    */
+    private parseRecordArray;
+    /**
+     * Read an individual ATON record and process
+     * according to the state given as the second parameter.
+     */
+    parseRecord(line: string, state: ParserState): void;
+    /**
+     * Remove whitespace from beginning and ending of value.
+     * If the type should be cast to another form, also do that.
+     */
+    cleanParameter(v: ParserState): void;
+}
+export {};

package/lib/aton/AtonParser.js

@@ -0,0 +1,245 @@
+/**
+ * Original code by Craig Stuart Sapp <craig@ccrma.stanford.edu>.
+ */
+const defaultOptions = {
+    onlyChildToRoot: false
+};
+export class AtonParser {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.options = options || defaultOptions;
+    }
+    /**
+     * parse ATON content and return the JSON that it describes.
+     */
+    parse(str) {
+        const output = this.parseRecordArray(str.split(/\n/));
+        if (this.options.onlyChildToRoot) {
+            const keys = Object.keys(output);
+            if ((keys.length === 1) && (typeof output[keys[0]] === 'object')) {
+                return output[keys[0]];
+            }
+        }
+        return output;
+    }
+    /**
+    * Parse ATON data from a list of individual records.
+    */
+    parseRecordArray(records) {
+        if (records.length === 0)
+            return;
+        const state = {
+            curobj: {},
+            output: {},
+            node: [],
+            keycase: this.options.forceKeyCase
+        };
+        state.curobj = state.output;
+        for (let i = 0; i < records.length; i++) {
+            state.linenum = i + 1;
+            try {
+                this.parseRecord(records[i], state);
+            }
+            catch (error) {
+                console.log(error);
+                return;
+            }
+        }
+        // Remove whitespace around last property value:
+        this.cleanParameter(state);
+        return state.curobj;
+    }
+    ;
+    /**
+     * Read an individual ATON record and process
+     * according to the state given as the second parameter.
+     */
+    parseRecord(line, state) {
+        //console.log('parsing record', line)
+        let matches;
+        if (line.match(/^@{5,}|^@+\s|^@{1,4}$/)) {
+            // Filter out comment lines.
+            return;
+        }
+        else if ((typeof state.curkey === 'undefined') && line.match(/^[^@]|^$/)) {
+            // Ignore unassociated text.
+            return;
+        }
+        else if (matches = line.match(/^@@[^@ ]/)) {
+            // Control message.
+            // End current property.
+            this.cleanParameter(state);
+            state.curkey = undefined;
+            state.ocurkey = undefined;
+            if (matches = line.match(/^@@(BEGIN|START)\s*:\s*(.*)\s*$/i)) {
+                state.label = matches[2];
+                //console.log(state.label)
+                if (typeof state.curobj[state.label] === 'undefined') {
+                    // create a new object and enter into it
+                    state.curobj[state.label] = {};
+                    state.node.push({ label: state.label, startline: state.linenum });
+                    state.curobj = state.curobj[state.label];
+                }
+                else if (state.curobj[state.label] instanceof Array) {
+                    // Append at end of array of objects with same v.label and
+                    // update the array index in the last v.node entry.
+                    state.curobj[state.label].push({});
+                    state.node.push({});
+                    state.node[state.node.length - 1].index = state.curobj[state.label].length - 1;
+                    state.node[state.node.length - 1].label = state.label;
+                    state.node[state.node.length - 1].startline = state.linenum;
+                    state.curobj = state.curobj[state.label][state.curobj[state.label].length - 1];
+                }
+                else {
+                    // Single string value already exists. Convert it to an array
+                    // and then append new object and enter it.
+                    // var temp = state.curobj[state.label];
+                    state.curobj[state.label] = [state.curobj[state.label], {}];
+                    state.node.push({});
+                    state.node[state.node.length - 1].index = state.curobj[state.label].length - 1;
+                    state.node[state.node.length - 1].label = state.label;
+                    state.node[state.node.length - 1].startline = state.linenum;
+                    state.curobj = state.curobj[state.label][state.curobj[state.label].length - 1];
+                }
+            }
+            else if (matches = line.match(/^@@(END|STOP)\s*:?\s*(.*)\s*$/i)) {
+                // End an object, so go back to the parent.
+                if (typeof state.curkey !== 'undefined') {
+                    // clean whitespace of last read property:
+                    state.curobj[state.curkey] = state.curobj[state.curkey].replace(/^\s+|\s+$/g, '');
+                    state.curkey = undefined;
+                    state.ocurkey = undefined;
+                }
+                state.action = matches[1];
+                state.labelend = matches[2];
+                state.labelbegin = state.node[state.node.length - 1].label;
+                if (typeof state.node[state.node.length - 1].startline === 'undefined') {
+                    throw new Error('No start for ' + state.action + ' tag on line '
+                        + state.node[state.node.length - 1].startline + ': ' + line);
+                    state.output = {};
+                    // return v.output;
+                }
+                if (typeof state.labelend !== 'undefined') {
+                    // ensure that the v.label begin/end tags match
+                    if ((state.labelbegin !== state.labelend) && (state.labelend !== "")) {
+                        throw new Error('Labels do not match on lines '
+                            + state.node[state.node.length - 1].startline + ' and '
+                            + state.linenum + ': "' + state.labelbegin
+                            + '" compared to "' + state.labelend + '".');
+                    }
+                }
+                // Go back to the parent object.
+                if (!state.node) {
+                    throw new Error('Error on line ' + state.linenum +
+                        ': already at object root.');
+                }
+                state.node.pop();
+                state.curobj = state.node.reduce(function (obj, x) {
+                    return (obj[x.label] instanceof Array) ?
+                        obj[x.label][x.index] : obj[x.label];
+                }, state.output);
+            }
+            else if (matches = line.match(/^@@TYPE\s*:\s*([^:]+)\s*:\s*(.*)\s*$/i)) {
+                // Automatic property value conversion.
+                state.typer[matches[1]] = matches[2];
+            }
+        }
+        else if (matches = line.match(/^@([^\s:@][^:]*)\s*:\s*(.*)\s*$/)) {
+            // New property
+            state.newkey = matches[1];
+            state.onewkey = state.newkey;
+            state.newvalue = matches[2];
+            this.cleanParameter(state);
+            if (state.keycase === 'uppercase') {
+                state.ocurkey = state.newkey;
+                state.curkey = state.newkey.toUpperCase();
+            }
+            else if (state.keycase === 'lowercase') {
+                state.ocurkey = state.newkey;
+                state.curkey = state.newkey.toLowerCase();
+            }
+            else {
+                state.ocurkey = state.newkey;
+                state.curkey = state.newkey;
+            }
+            if (typeof state.curobj[state.curkey] === 'undefined') {
+                // create a new property
+                state.curobj[state.curkey] = state.newvalue;
+            }
+            else if (state.curobj[state.curkey] instanceof Array) {
+                // append next object to end of array
+                state.curobj[state.curkey].push(state.newvalue);
+            }
+            else {
+                // convert property value to array, and then append
+                state.curobj[state.curkey] = [state.curobj[state.curkey], state.newvalue];
+            }
+        }
+        else if (typeof state.curkey !== 'undefined') {
+            // Continuing value from property started previously
+            // If the line starts with a backslash, remove it since it is an
+            //escape for the "@" sign or a literal "\" at the start of a line:
+            // \@some data line   -=>  @some data line
+            // \\@some data line  -=>  \@some data line
+            // Only "@" and "\@" at the start of the line need to be esacaped;
+            // otherwise, all other "@" and "\" characters are literal.
+            // If another property marker is used other than "@", then that
+            // character (or string) needs to be backslash escaped at the
+            // start of a multi-line value line.
+            if (line.charAt(0) !== '@') {
+                if (line.slice(0, 2) === '\\@') {
+                    line = line.slice(1);
+                }
+                if (line.slice(0, 3) === '\\\\@') {
+                    line = line.slice(1);
+                }
+                if (state.curobj && state.curobj[state.curkey] instanceof Array) {
+                    state.curobj[state.curkey][state.curobj[state.curkey].length - 1] += '\n' + line;
+                }
+                else {
+                    state.curobj[state.curkey] += '\n' + line;
+                }
+            }
+        }
+    }
+    ;
+    /**
+     * Remove whitespace from beginning and ending of value.
+     * If the type should be cast to another form, also do that.
+     */
+    cleanParameter(v) {
+        if ((typeof v.curkey !== 'undefined') && v.curobj && v.curobj[v.curkey]) {
+            var value;
+            if (v.curobj[v.curkey] instanceof Array) {
+                value = v.curobj[v.curkey][v.curobj[v.curkey].length - 1];
+            }
+            else if (typeof v.curobj[v.curkey] === 'string') {
+                value = v.curobj[v.curkey];
+            }
+            value = value.replace(/^\s+|\s+$/g, '');
+            if (v.typer && (typeof v.typer[v.ocurkey] !== 'undefined')) {
+                var newtype = v.typer[v.ocurkey];
+                if (newtype.match(/number/i)) {
+                    value = Number(value);
+                }
+                else if (newtype.match(/integer/i)) {
+                    value = parseInt(value);
+                }
+                else if (newtype.match(/json/i)) {
+                    value = JSON.parse(value);
+                }
+            }
+            if (v.curobj[v.curkey] instanceof Array) {
+                v.curobj[v.curkey][v.curobj[v.curkey].length - 1] = value;
+            }
+            else if (typeof v.curobj[v.curkey] === 'string') {
+                v.curobj[v.curkey] = value;
+            }
+        }
+    }
+}

package/lib/aton/AtonParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/aton/AtonParser.test.js

@@ -0,0 +1,16 @@
+import { expect, test } from 'vitest';
+import { AtonParser } from './AtonParser';
+test('it import ATON files correctly', () => {
+    const parser = new AtonParser();
+    const result = parser.parse(`
+@key1: value1
+@@START: key2
+@key2a: value2a
+@key2b: value2b
+@key2c: value2c
+@@END: key2
+@key3: value3`);
+    expect(result.key1).toBe('value1');
+    expect(result.key2.key2a).toBe('value2a');
+    expect(result.key3).toBe('value3');
+});