@scorelabs/core 1.0.5 → 1.0.7

package/README.md

@@ -36,7 +36,7 @@ console.log(`Number of Parts: ${score.parts.length}`);
 The core model uses `NoteSet` to represent a collection of notes at a specific point data (e.g., a chord or a single note).
 
 ```typescript
-import { Note, NoteSet, Pitch, Duration } from '@scorelabs/core';
+import { Duration, Note, NoteSet, Pitch } from '@scorelabs/core';
 
 // Create a C4 quarter note
 const c4 = new Note(new Pitch('C', 4), Duration.Quarter);

package/dist/importers/MusicXMLParser.d.ts

@@ -12,8 +12,9 @@ export declare class MusicXMLParser {
     private currentSymbol;
     private instrumentPitchMap;
     private _domParser;
-    constructor(domParserInstance?: any);
+    constructor(domParserInstance?: DOMParser | any);
     private parseFromString;
+    static getXMLFromBinary(data: ArrayBuffer, domParser?: DOMParser | any): Promise<string>;
     parseBinary(data: ArrayBuffer): Promise<ScoreJSON>;
     parse(xmlString: string): ScoreJSON;
     private parseSubtitle;

package/dist/importers/MusicXMLParser.js

@@ -1,6 +1,6 @@
 import JSZip from 'jszip';
 import { getInstrumentByProgram } from '../models/Instrument';
-import { Clef, Duration, Accidental, Articulation, BarlineStyle, HairpinType, OttavaType, Ornament, Bowing, StemDirection, GlissandoType, NoteheadShape, Arpeggio, } from '../models/types';
+import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, } from '../models/types';
 /**
  * MusicXML Parser
  *
@@ -24,14 +24,17 @@ export class MusicXMLParser {
         }
         return this._domParser.parseFromString(xmlString, 'application/xml');
     }
-    async parseBinary(data) {
+    static async getXMLFromBinary(data, domParser) {
         const uint8 = new Uint8Array(data);
         if (uint8[0] === 0x50 && uint8[1] === 0x4b) {
             const zip = await JSZip.loadAsync(data);
             const containerXml = await zip.file('META-INF/container.xml')?.async('text');
             if (!containerXml)
                 throw new Error('Invalid MXL: Missing META-INF/container.xml');
-            const containerDoc = this.parseFromString(containerXml);
+            const _parser = domParser || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+            if (!_parser)
+                throw new Error('No DOMParser available');
+            const containerDoc = _parser.parseFromString(containerXml, 'application/xml');
             const rootfile = containerDoc.querySelector('rootfile');
             const fullPath = rootfile?.getAttribute('full-path');
             if (!fullPath)
@@ -39,13 +42,17 @@ export class MusicXMLParser {
             const scoreXml = await zip.file(fullPath)?.async('text');
             if (!scoreXml)
                 throw new Error(`Invalid MXL: Could not find file ${fullPath}`);
-            return this.parse(scoreXml);
+            return scoreXml;
         }
         else {
             const decoder = new TextDecoder();
-            return this.parse(decoder.decode(data));
+            return decoder.decode(data);
         }
     }
+    async parseBinary(data) {
+        const scoreXml = await MusicXMLParser.getXMLFromBinary(data, this._domParser);
+        return this.parse(scoreXml);
+    }
     parse(xmlString) {
         this.instrumentPitchMap.clear();
         // Strip potential BOM and leading garbage
@@ -788,22 +795,30 @@ export class MusicXMLParser {
                 else if (barStyle === 'dotted')
                     barlineStyle = BarlineStyle.Dotted;
             }
-            if (barline.querySelector('repeat'))
+            const repeatEl = barline.querySelector('repeat');
+            if (repeatEl) {
+                const direction = repeatEl.getAttribute('direction');
+                const times = repeatEl.getAttribute('times');
                 repeats.push({
-                    type: barline.querySelector('repeat')?.getAttribute('direction') === 'forward'
-                        ? 'start'
-                        : 'end',
+                    type: direction === 'forward' ? 'start' : 'end',
+                    times: times ? parseInt(times) : undefined,
                 });
+            }
             const ending = barline.querySelector('ending');
             if (ending) {
                 const type = ending.getAttribute('type');
-                const number = parseInt(ending.getAttribute('number') || '1');
+                const numberAttr = ending.getAttribute('number') || '1';
+                // Handle "1,2" or "1 2"
+                const numbers = numberAttr
+                    .split(/[,\s]+/)
+                    .map((n) => parseInt(n))
+                    .filter((n) => !isNaN(n));
                 if (type === 'start')
-                    volta = { type: 'start', number };
+                    volta = { type: 'start', numbers };
                 else if (type === 'stop')
-                    volta = { type: 'stop', number };
+                    volta = { type: 'stop', numbers };
                 else if (type === 'discontinue')
-                    volta = { type: 'both', number };
+                    volta = { type: 'both', numbers };
             }
         });
         return { repeats, volta, barlineStyle };

package/dist/models/Measure.d.ts

@@ -1,6 +1,6 @@
 import { Note, NoteJSON } from './Note';
 import { NoteSet, NoteSetJSON } from './NoteSet';
-import { TimeSignature, KeySignature, Duration, Repeat, Volta, Clef, Tempo, BarlineStyle } from './types';
+import { BarlineStyle, Clef, Duration, KeySignature, Repeat, Tempo, TimeSignature, Volta } from './types';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */

package/dist/models/Measure.js

@@ -1,6 +1,6 @@
 import { Note } from './Note';
 import { NoteSet } from './NoteSet';
-import { DURATION_VALUES, decomposeDuration, BarlineStyle, } from './types';
+import { BarlineStyle, DURATION_VALUES, decomposeDuration, } from './types';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */

package/dist/models/Note.d.ts

@@ -1,5 +1,5 @@
-import { Duration, Accidental, Articulation, Dynamic, Slur, Tuplet, Hairpin, Glissando, Arpeggio, Ottava, Pedal, Ornament, FretboardDiagram, NoteheadShape, Bowing, Lyric, StemDirection } from './types';
 import { Pitch } from './Pitch';
+import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types';
 /**
  * Represents a single note or rest in a measure.
  */

package/dist/models/Note.js

@@ -1,5 +1,5 @@
-import { Duration, Accidental, DURATION_VALUES, } from './types';
 import { Pitch } from './Pitch';
+import { Accidental, DURATION_VALUES, Duration, } from './types';
 /**
  * Represents a single note or rest in a measure.
  */

package/dist/models/Part.d.ts

@@ -1,7 +1,7 @@
-import { Staff, StaffJSON } from './Staff';
 import { Instrument } from './Instrument';
-import { Note } from './Note';
 import { Measure } from './Measure';
+import { Note } from './Note';
+import { Staff, StaffJSON } from './Staff';
 import { Duration } from './types';
 /**
  * Represents a musical part (instrument/voice) which can have multiple staves.

package/dist/models/Part.js

@@ -1,5 +1,5 @@
-import { Staff } from './Staff';
 import { PRESET_INSTRUMENTS } from './Instrument';
+import { Staff } from './Staff';
 /**
  * Represents a musical part (instrument/voice) which can have multiple staves.
  */

package/dist/models/Score.d.ts

@@ -1,8 +1,8 @@
-import { TimeSignature, KeySignature, Duration, Genre } from './types';
+import { Measure } from './Measure';
+import { NoteSet } from './NoteSet';
 import { Part, PartJSON } from './Part';
 import { Staff } from './Staff';
-import { NoteSet } from './NoteSet';
-import { Measure } from './Measure';
+import { Duration, Genre, KeySignature, TimeSignature } from './types';
 /**
  * Represents a complete musical score.
  */

package/dist/models/Score.js

@@ -1,5 +1,5 @@
-import { Duration, decomposeDuration, Genre } from './types';
 import { Part } from './Part';
+import { Duration, Genre, decomposeDuration } from './types';
 /**
  * Represents a complete musical score.
  */
@@ -275,7 +275,10 @@ export class Score {
         let i = 0;
         let blockStart = 0;
         const repeatCount = new Map();
-        while (i < measures.length) {
+        let safetyCounter = 0;
+        const MAX_SEQUENCE = 10000;
+        while (i < measures.length && safetyCounter < MAX_SEQUENCE) {
+            safetyCounter++;
             const m = measures[i];
             if (m.repeats.some((r) => r.type === 'start'))
                 blockStart = i;
@@ -294,7 +297,7 @@ export class Score {
                 if (nextEndIdx !== -1)
                     iteration = (repeatCount.get(nextEndIdx) || 0) + 1;
             }
-            if (m.volta && m.volta.number !== iteration) {
+            if (m.volta && !m.volta.numbers.includes(iteration)) {
                 i++;
                 continue;
             }

package/dist/models/Staff.d.ts

@@ -1,7 +1,7 @@
-import { Clef, Duration } from './types';
 import { Measure, MeasureJSON } from './Measure';
-import { Pitch } from './Pitch';
 import { Note } from './Note';
+import { Pitch } from './Pitch';
+import { Clef, Duration } from './types';
 /**
  * Represents a single staff (one set of 5 lines with a clef).
  */

package/dist/models/types.d.ts

@@ -140,7 +140,7 @@ export interface Repeat {
 }
 export interface Volta {
     type: 'start' | 'stop' | 'both';
-    number: number;
+    numbers: number[];
 }
 export declare enum BarlineStyle {
     Regular = "regular",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scorelabs/core",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Core logic and models for ScoreLabs music notation",
   "type": "module",
   "files": [
@@ -11,8 +11,8 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "scripts": {
@@ -23,7 +23,8 @@
     "release:minor": "npm version minor && npm publish --access public",
     "release:major": "npm version major && npm publish --access public",
     "release": "npm run release:patch",
-    "test": "vitest"
+    "test": "vitest",
+    "lint": "eslint ."
   },
   "dependencies": {
     "jszip": "^3.10.1"

package/dist/utils/tier.d.ts

@@ -1,36 +0,0 @@
-export declare const TOKEN_MODULUS = 17;
-export declare const EXPECTED_REMAINDER = 2;
-export declare const EXPIRATION_MS: number;
-export type UserTier = 'free' | 'premium';
-/**
- * Obfuscates the user's tier into a numeric token for the viewer.
- * The viewer expects token % 17 === 2 for premium access.
- */
-export declare function generateObfuscatedToken(tier: UserTier): number;
-/**
- * Packs token and timestamp into an obfuscated string.
- */
-export declare function packToken(token: number, timestamp: number, salt: string): string;
-/**
- * Unpacks the token string and validates the signature.
- */
-export declare function unpackToken(packed: string, salt: string): {
-    token: number;
-    timestamp: number;
-} | null;
-/**
- * Returns the effective numeric token, checking for expiration.
- */
-export declare function getEffectiveToken(user: any): number;
-/**
- * Returns the effective tier from the obfuscated token
- */
-export declare function getTierFromUser(user: any): UserTier;
-/**
- * Returns true only if the user has a valid, non-expired premium token.
- */
-export declare function isUserPremium(user: any): boolean;
-/**
- * Returns true only if the user has a valid, non-expired free token.
- */
-export declare function isUserFree(user: any): boolean;

package/dist/utils/tier.js

@@ -1,112 +0,0 @@
-export const TOKEN_MODULUS = 17;
-export const EXPECTED_REMAINDER = 2;
-export const EXPIRATION_MS = 24 * 60 * 60 * 1000;
-/**
- * Obfuscates the user's tier into a numeric token for the viewer.
- * The viewer expects token % 17 === 2 for premium access.
- */
-export function generateObfuscatedToken(tier) {
-    const isPremium = tier === 'premium';
-    let base = Math.floor(Math.random() * 8999) + 1000;
-    if (isPremium) {
-        // Ensure token % 17 === 2
-        return base - (base % TOKEN_MODULUS) + EXPECTED_REMAINDER;
-    }
-    else {
-        // Ensure token % 17 !== 2
-        const result = base;
-        return result % TOKEN_MODULUS === EXPECTED_REMAINDER ? result + 1 : result;
-    }
-}
-/**
- * Packs token and timestamp into an obfuscated string.
- */
-export function packToken(token, timestamp, salt) {
-    // Use a more robust numeric salt
-    const saltNum = salt
-        .split('')
-        .reduce((acc, char, i) => acc + char.charCodeAt(0) * (i + 1), 0);
-    // Pack components
-    const tHex = token.toString(16);
-    // Obfuscate time using XOR with salt and token
-    const timeKey = (saltNum ^ token) % 1000000;
-    const oTime = (BigInt(timestamp) ^ BigInt(timeKey)).toString(16);
-    // Create a signature that binds token, time and salt
-    const sigPayload = `${token}:${timestamp}:${salt}`;
-    let sig = 0;
-    for (let i = 0; i < sigPayload.length; i++) {
-        sig = (sig << 5) - sig + sigPayload.charCodeAt(i);
-        sig |= 0; // Convert to 32bit integer
-    }
-    const sHex = Math.abs(sig).toString(16);
-    return `${tHex}-${oTime}-${sHex}`;
-}
-/**
- * Unpacks the token string and validates the signature.
- */
-export function unpackToken(packed, salt) {
-    try {
-        const [tHex, oTime, sHex] = packed.split('-');
-        if (!tHex || !oTime || !sHex)
-            return null;
-        const token = parseInt(tHex, 16);
-        const saltNum = salt
-            .split('')
-            .reduce((acc, char, i) => acc + char.charCodeAt(0) * (i + 1), 0);
-        const timeKey = (saltNum ^ token) % 1000000;
-        const timestamp = Number(BigInt(parseInt(oTime, 16)) ^ BigInt(timeKey));
-        // Validate signature
-        const sigPayload = `${token}:${timestamp}:${salt}`;
-        let sig = 0;
-        for (let i = 0; i < sigPayload.length; i++) {
-            sig = (sig << 5) - sig + sigPayload.charCodeAt(i);
-            sig |= 0;
-        }
-        const expectedSig = Math.abs(sig).toString(16);
-        if (sHex !== expectedSig)
-            return null;
-        return { token, timestamp };
-    }
-    catch (e) {
-        return null;
-    }
-}
-/**
- * Returns the effective numeric token, checking for expiration.
- */
-export function getEffectiveToken(user) {
-    if (!user)
-        return 0;
-    const accessToken = user.accessToken || user.access_token;
-    if (!accessToken) {
-        return 0;
-    }
-    const salt = (user.uuid || user.id || 'default-salt').toString();
-    const unpacked = unpackToken(accessToken, salt);
-    if (!unpacked)
-        return 0;
-    const now = Date.now();
-    if (now - unpacked.timestamp >= EXPIRATION_MS || now < unpacked.timestamp) {
-        return 0; // Expired
-    }
-    return unpacked.token;
-}
-/**
- * Returns the effective tier from the obfuscated token
- */
-export function getTierFromUser(user) {
-    const token = getEffectiveToken(user);
-    return token % TOKEN_MODULUS === EXPECTED_REMAINDER ? 'premium' : 'free';
-}
-/**
- * Returns true only if the user has a valid, non-expired premium token.
- */
-export function isUserPremium(user) {
-    return getTierFromUser(user) === 'premium';
-}
-/**
- * Returns true only if the user has a valid, non-expired free token.
- */
-export function isUserFree(user) {
-    return getTierFromUser(user) === 'free';
-}