linked-rolls 0.5.0 → 0.6.0

package/lib/validate.js

@@ -1,7 +1,5 @@
 import Ajv from "ajv";
 import * as schema from "./schema.json";
-import { idOf } from "./Assumption";
-import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
 const ajv = new Ajv({
     strict: false,
     formats: {
@@ -10,62 +8,3 @@ const ajv = new Ajv({
 });
 const validate = ajv.compile(schema);
 export { validate };
-const missingReference = {
-    alignedWith: 'alignment-reference-missing',
-    before: 'before-reference-missing',
-    after: 'after-reference-missing'
-};
-const problemsIn = (version, perforations) => {
-    const ids = new Set(perforations.map(p => p.id));
-    const report = (symbol, problem) => ({ version, symbol, problem });
-    const missingReferences = perforations
-        .flatMap(p => placementsOf(p)
-        .filter(({ reference }) => !ids.has(idOf(reference)))
-        .map(({ relation }) => report(p.id, missingReference[relation])));
-    const selfPlaced = perforations
-        .filter(p => placementsOf(p).some(({ reference }) => idOf(reference) === p.id))
-        .map(p => report(p.id, 'placed-relative-to-itself'));
-    const placedSeveralWays = perforations
-        .filter(p => placementsOf(p).length > 1)
-        .map(p => report(p.id, 'placed-several-ways'));
-    const missingPartners = perforations
-        .filter(p => p.pairedWith && !ids.has(idOf(p.pairedWith)))
-        .map(p => report(p.id, 'partner-missing'));
-    const selfPaired = perforations
-        .filter(p => p.pairedWith && idOf(p.pairedWith) === p.id)
-        .map(p => report(p.id, 'paired-with-itself'));
-    const pairs = pairsAmong(perforations);
-    const pairsOf = (p) => pairs.filter(pair => pair.includes(p));
-    const inSeveralPairs = perforations
-        .filter(p => pairsOf(p).length > 1)
-        .map(p => report(p.id, 'in-several-pairs'));
-    const placedOnBothSides = pairs
-        .filter(([one, other]) => placementsOf(one).length > 0 && placementsOf(other).length > 0)
-        .flatMap(pair => pair.map(p => report(p.id, 'pair-placed-on-both-sides')));
-    return [
-        ...missingReferences, ...selfPlaced, ...placedSeveralWays,
-        ...missingPartners, ...selfPaired, ...inSeveralPairs, ...placedOnBothSides
-    ];
-};
-/**
- * Where the placements and pairings of the edition cannot hold as
- * stated, version by version: a reference or partner absent from the
- * version, a perforation placed relative to itself or in several ways
- * at once, one claimed by several pairs, or a pair whose members are
- * both placed and so cannot keep their distance and follow their
- * references at once.
- */
-export const constraintProblems = (view) => view.edition.versions.flatMap(version => problemsIn(version.id, view.snapshot(version.id).filter(isPerforation)));
-const isExpression = (symbol) => symbol.type === 'expression';
-/**
- * The expressions of the edition whose type the tracker bar does not
- * read, version by version. The roll names its system; a type from
- * another system, or a misspelt one, means nothing on it.
- */
-export const unknownExpressionTypes = (view, bar) => {
-    const known = new Set(bar.expressionTypes);
-    return view.edition.versions.flatMap(version => view.snapshot(version.id)
-        .filter(isExpression)
-        .filter(symbol => !known.has(symbol.expressionType))
-        .map(symbol => ({ version: version.id, symbol: symbol.id, expressionType: symbol.expressionType })));
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {
@@ -16,8 +16,8 @@
       "default": "./lib/index.js"
     },
     "./welte-t100": {
-      "types": "./lib/systems/welteT100.d.ts",
-      "default": "./lib/systems/welteT100.js"
+      "types": "./lib/systems/welteT100/system.d.ts",
+      "default": "./lib/systems/welteT100/system.js"
     },
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
@@ -41,7 +41,7 @@
     "welte-t100-emulator": "file:../welte-t100"
   },
   "peerDependencies": {
-    "welte-t100-emulator": "^0.3.0"
+    "welte-t100-emulator": "^0.4.0"
   },
   "peerDependenciesMeta": {
     "welte-t100-emulator": {

package/lib/alignFeatures.d.ts

@@ -1,12 +0,0 @@
-import { AnyFeature } from "./Feature";
-import { TrackerBar } from "./TrackerBar";
-type AlignmentResult = {
-    shift: number;
-    stretch: number;
-};
-/**
- * Align two rolls by computing independent linear fits of each roll's note-onset positions
- * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
- */
-export declare function alignFeatures(rollA: AnyFeature[], rollB: AnyFeature[], bar?: TrackerBar): AlignmentResult;
-export {};

package/lib/alignFeatures.js

@@ -1,55 +0,0 @@
-import { welteT100 } from "./TrackerBar";
-const isNoteOn = (bar) => (feature) => {
-    return feature.type === 'Hole' && bar.meaningOf(feature.vertical.from)?.type === 'note';
-};
-/**
- * Fit a line: position = alpha * index + beta via least squares.
- */
-function fitIndexToPosition(indices, positions) {
-    const n = indices.length;
-    const meanIdx = indices.reduce((s, i) => s + i, 0) / n;
-    const meanPos = positions.reduce((s, p) => s + p, 0) / n;
-    let num = 0;
-    let den = 0;
-    for (let i = 0; i < n; i++) {
-        const d = indices[i] - meanIdx;
-        num += d * (positions[i] - meanPos);
-        den += d * d;
-    }
-    const alpha = den === 0 ? 1 : num / den;
-    const beta = meanPos - alpha * meanIdx;
-    return { alpha, beta };
-}
-/**
- * Selects the first and last N elements of an array (or fewer if length is smaller).
- */
-function selectEnds(arr, count) {
-    const n = arr.length;
-    if (count * 2 >= n)
-        return arr.slice();
-    return arr.slice(0, count).concat(arr.slice(n - count, n));
-}
-/**
- * Align two rolls by computing independent linear fits of each roll's note-onset positions
- * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
- */
-export function alignFeatures(rollA, rollB, bar = welteT100) {
-    // 1. Extract note-onset positions
-    const isNote = isNoteOn(bar);
-    const allXA = rollA.filter(isNote).map(f => f.horizontal.from);
-    const allXB = rollB.filter(isNote).map(f => f.horizontal.from);
-    // 2. Determine segment size (e.g. 10% of notes, min 5)
-    const segCount = Math.max(5, Math.floor(allXA.length * 0.1));
-    // 3. Select only first and last segments
-    const XA = selectEnds(allXA, segCount);
-    const idxA = XA.map((_, i) => i);
-    const XB = selectEnds(allXB, segCount);
-    const idxB = XB.map((_, i) => i);
-    // 4. Fit index->position for each roll on selected ends
-    const { alpha: alphaA, beta: betaA } = fitIndexToPosition(idxA, XA);
-    const { alpha: alphaB, beta: betaB } = fitIndexToPosition(idxB, XB);
-    // 5. Derive stretch and shift such that x2 = (x1 + shift) * stretch
-    const stretch = alphaB / alphaA;
-    const shift = betaB / stretch - betaA;
-    return { stretch, shift };
-}