Release 1.8.0

.github/workflows/build.yml

@@ -43,7 +43,7 @@ jobs:
       - run: npm run build-language-server
       - run: npm run build-monaco
         id: test
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         if: ${{ failure() && steps.test.conclusion == 'failure' }}
         with: 
           name: test-results-web
@@ -69,7 +69,7 @@ jobs:
       - run: npm run build-csharp
       - run: npm run test-csharp
         id: test
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         if: ${{ failure() && steps.test.conclusion == 'failure' }}
         with: 
           name: test-results-csharp
@@ -108,7 +108,7 @@ jobs:
       - run: npm run build-kotlin
       - run: npm run test-kotlin
         id: test
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         if: ${{ failure() && steps.test.conclusion == 'failure' }}
         with: 
           name: test-results-kotlin

.github/workflows/publish.yml

@@ -14,7 +14,7 @@ jobs:
     steps:
       - run: touch dummy.txt
 
-      - uses: actions/cache@v4
+      - uses: actions/cache@v5
         id: cache
         with:
           path: dummy.txt

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coderline/alphatab-monorepo",
-    "version": "1.7.1",
+    "version": "1.8.0",
     "description": "Monorepo for alphaTab and its related packages",
     "private": true,
     "type": "module",
@@ -41,7 +41,6 @@
         "test-webpack": "npm run test --workspace=packages/webpack",
 
         "build-monaco": "npm run build --workspace=packages/monaco"
-
     },
     "devDependencies": {
         "concurrently": "^9.2.1"

packages/alphatab/.env

@@ -1,2 +1,2 @@
 FORCE_COLOR=1
-NODE_OPTIONS=--expose-gc
+NODE_OPTIONS=--expose-gc

packages/alphatab/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coderline/alphatab",
-    "version": "1.7.1",
+    "version": "1.8.0",
     "description": "alphaTab is a music notation and guitar tablature rendering library",
     "keywords": [
         "guitar",
@@ -58,23 +58,23 @@
         "test-accept-reference": "tsx scripts/accept-new-reference-files.ts"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.2.6",
+        "@biomejs/biome": "^2.3.11",
         "@coderline/alphaskia": "^3.4.135",
         "@coderline/alphaskia-linux": "^3.4.135",
         "@coderline/alphaskia-windows": "^3.4.135",
         "@types/chai": "^5.2.3",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^24.10.0",
+        "@types/node": "^25.0.6",
         "assert": "^2.1.0",
-        "chai": "^6.2.1",
+        "chai": "^6.2.2",
         "chalk": "^5.6.2",
         "jest-snapshot": "^30.2.0",
         "mocha": "^11.7.5",
-        "rimraf": "^6.1.0",
+        "rimraf": "^6.1.2",
         "tslib": "^2.8.1",
-        "tsx": "^4.20.6",
+        "tsx": "^4.21.0",
         "typescript": "^5.9.3",
-        "vite": "^7.2.6",
+        "vite": "^7.3.1",
         "vite-plugin-static-copy": "^3.1.4"
     },
     "files": [

packages/alphatab/scripts/JsonDeclarationEmitter.ts

@@ -7,7 +7,7 @@ import * as ts from 'typescript';
 import createEmitter, { generateFile } from './EmitterBase';
 import { getTypeWithNullableInfo, type TypeWithNullableInfo } from './TypeSchema';
 
-function createDefaultJsonTypeNode(checker: ts.TypeChecker, type: TypeWithNullableInfo, isNullable: boolean) {
+function createDefaultJsonTypeNode(checker: ts.TypeChecker, type: TypeWithNullableInfo, isNullable: boolean): ts.TypeNode {
     if (isNullable) {
         const notNullable = createDefaultJsonTypeNode(checker, type, false);
         return ts.factory.createUnionTypeNode([notNullable, ts.factory.createLiteralTypeNode(ts.factory.createNull())]);

packages/alphatab/scripts/Serializer.setProperty.ts

@@ -170,6 +170,10 @@ function generateSetPropertyBody(serializable: TypeSchema, importer: (name: stri
                     `${mapValueTypeInfo.typeAsString}.fromJson(v)`,
                     ts.SyntaxKind.CallExpression
                 );
+
+                if(!mapValueTypeInfo.isOptional && !mapValueTypeInfo.isNullable) {
+                    mapValue = ts.factory.createNonNullExpression(mapValue);
+                }
             } else {
                 itemSerializer = `${mapValueTypeInfo.typeAsString}Serializer`;
                 importer(itemSerializer, findSerializerModule(mapValueTypeInfo));
@@ -181,15 +185,17 @@ function generateSetPropertyBody(serializable: TypeSchema, importer: (name: stri
                 .filter(t => t.tagName.text === 'json_add')
                 .map(t => t.comment ?? '')[0] as string;
 
-            caseStatements.push(
-                assignField(
-                    ts.factory.createNewExpression(
-                        ts.factory.createIdentifier('Map'),
-                        prop.type.typeArguments!.map(t => t.createTypeNode()),
-                        []
+            if(!prop.isReadOnly) {
+                caseStatements.push(
+                    assignField(
+                        ts.factory.createNewExpression(
+                            ts.factory.createIdentifier('Map'),
+                            prop.type.typeArguments!.map(t => t.createTypeNode()),
+                            []
+                        )
                     )
-                )
-            );
+                );
+            }
 
             caseStatements.push(
                 ts.factory.createExpressionStatement(

packages/alphatab/scripts/Serializer.toJson.ts

@@ -1,5 +1,5 @@
-import * as ts from 'typescript';
 import { createNodeFromSource, setMethodBody } from '@coderline/alphatab-transpiler/src/BuilderHelpers';
+import * as ts from 'typescript';
 import { findSerializerModule } from './Serializer.common';
 import type { TypeSchema } from './TypeSchema';
 
@@ -30,7 +30,7 @@ function generateToJsonBody(serializable: TypeSchema, importer: (name: string, m
         const fieldName = prop.name;
         const jsonName = prop.jsonNames.filter(n => n !== '')[0];
 
-        if (!jsonName || prop.isReadOnly) {
+        if (!jsonName || prop.isJsonReadOnly) {
             continue;
         }
 
@@ -153,6 +153,17 @@ function generateToJsonBody(serializable: TypeSchema, importer: (name: string, m
                 }`,
                     ts.SyntaxKind.Block
                 );
+            } else if(prop.type.typeArguments![1].isArray && prop.type.typeArguments![1].arrayItemType!.isPrimitiveType) {
+                serializeBlock = createNodeFromSource<ts.Block>(
+                    `{
+                        const m = new Map<string, unknown>();
+                        o.set(${JSON.stringify(jsonName)}, m);
+                        for(const [k, v] of obj.${fieldName}!) {
+                            m.set(k.toString(), v);
+                        }
+                    }`,
+                    ts.SyntaxKind.Block
+                );
             } else {
                 const itemSerializer = `${prop.type.typeArguments![1].typeAsString}Serializer`;
                 importer(itemSerializer, findSerializerModule(prop.type.typeArguments![1]));

packages/alphatab/scripts/TypeSchema.ts

@@ -62,7 +62,8 @@ export function buildTypeSchema(program: ts.Program, input: ts.ClassDeclaration)
                         asRaw,
                         partialNames: !!jsDoc.find(t => t.tagName.text === 'json_partial_names'),
                         target: jsDoc.find(t => t.tagName.text === 'target')?.comment as string,
-                        isReadOnly: !!jsDoc.find(t => t.tagName.text === 'json_read_only'),
+                        isJsonReadOnly: isReadonly,
+                        isReadOnly: propertyDeclaration.modifiers!.some(m => m.kind == ts.SyntaxKind.ReadonlyKeyword),
                         name: (member.name as ts.Identifier).text,
                         jsDocTags: jsDoc,
                         type: getTypeWithNullableInfo(
@@ -379,6 +380,7 @@ export interface TypeProperty {
     jsonNames: string[];
     asRaw: boolean;
     target?: string;
+    isJsonReadOnly: boolean;
     isReadOnly: boolean;
 }
 

packages/alphatab/scripts/smufl-metadata.ts

@@ -1,39 +1,40 @@
 import fs from 'node:fs';
-import url from 'node:url';
 import path from 'node:path';
-import { MusicFontSymbol } from '../src/model/MusicFontSymbol';
-import { SmuflMetrics } from '../src/SmuflMetrics';
+import url from 'node:url';
+import { EngravingSettings } from '@coderline/alphatab/EngravingSettings';
+import { MusicFontSymbol } from '@coderline/alphatab/model/MusicFontSymbol';
+import { SmuflMetadata } from '@coderline/alphatab/SmuflMetadata';
 
 const input = process.argv[2];
 const output = process.argv[3];
 
-const metadata = JSON.parse(await fs.promises.readFile(input, 'utf-8'));
+const metadata: SmuflMetadata = JSON.parse(await fs.promises.readFile(input, 'utf-8'));
 
-const outputMetadata = {
+const outputMetadata:SmuflMetadata = {
     engravingDefaults: metadata.engravingDefaults,
-    glyphBBoxes: {},
-    glyphsWithAnchors: {}
+    glyphBBoxes: {} as SmuflMetadata['glyphBBoxes'],
+    glyphsWithAnchors: {} as SmuflMetadata['glyphsWithAnchors']
 };
 
 const alphaTabUsedGlyphs = new Set<string>();
 for(const [_,name] of Object.entries(MusicFontSymbol).filter(e => typeof e[1] === "string")) {
     alphaTabUsedGlyphs.add(name.toString().toLowerCase());
 }
 
-for(const [k,_] of SmuflMetrics.smuflNameToGlyphNameMapping) {
+for(const [k,_] of EngravingSettings.smuflNameToGlyphNameMapping) {
     alphaTabUsedGlyphs.add(k.toLowerCase());
 }
 
-for(const name of Object.keys(metadata.glyphBBoxes)) {
+for(const name of Object.keys(metadata.glyphBBoxes!)) {
     if(alphaTabUsedGlyphs.has(name.toLowerCase())) {
-        const alphaTabName = SmuflMetrics.smuflNameToGlyphNameMapping.has(name) ? SmuflMetrics.smuflNameToGlyphNameMapping.get(name)! : name;
-        outputMetadata.glyphBBoxes[alphaTabName] = metadata.glyphBBoxes[name];
+        const alphaTabName = EngravingSettings.smuflNameToGlyphNameMapping.has(name) ? EngravingSettings.smuflNameToGlyphNameMapping.get(name)! : name;
+        outputMetadata.glyphBBoxes![alphaTabName] = metadata.glyphBBoxes![name];
     }
 }
 
 for(const name of Object.keys(metadata.glyphsWithAnchors)) {
     if(alphaTabUsedGlyphs.has(name.toLowerCase())) {
-        const alphaTabName = SmuflMetrics.smuflNameToGlyphNameMapping.has(name) ? SmuflMetrics.smuflNameToGlyphNameMapping.get(name)! : name;
+        const alphaTabName = EngravingSettings.smuflNameToGlyphNameMapping.has(name) ? EngravingSettings.smuflNameToGlyphNameMapping.get(name)! : name;
         outputMetadata.glyphsWithAnchors[alphaTabName] = metadata.glyphsWithAnchors[name];
     }
 }
@@ -44,7 +45,7 @@ await fs.promises.writeFile(output,
 
 if(process.argv[4] === 'true') {
     const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
-    const smuflMetricsFile = path.resolve(__dirname, '..', 'src', 'SmuflMetrics.ts');
+    const smuflMetricsFile = path.resolve(__dirname, '..', 'src', 'EngravingSettings.ts');
     let source = await fs.promises.readFile(smuflMetricsFile, 'utf-8');
     const beginMarker = 'begin bravura_alphatab_metadata';
     const endMarker = 'end bravura_alphatab_metadata';