@k-l-lambda/lilypond-node 2.24.4

package/lib/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * LilyPond Node.js Native Addon
+ *
+ * TypeScript definitions for the lilypond-node package.
+ */
+
+/**
+ * Options for the engrave function
+ */
+export interface EngraveOptions {
+    /**
+     * Callback invoked when an SVG file is generated
+     * @param filename - The name of the SVG file (e.g., "output.svg")
+     * @param content - The SVG content as a string
+     */
+    onSVG?: (filename: string, content: string) => void;
+
+    /**
+     * Callback invoked when a MIDI file is generated
+     * @param filename - The name of the MIDI file (e.g., "output.midi")
+     * @param data - The MIDI data as an ArrayBuffer
+     */
+    onMIDI?: (filename: string, data: ArrayBuffer) => void;
+
+    /**
+     * Callback invoked for log messages from LilyPond
+     * @param message - The log message
+     */
+    log?: (message: string) => void;
+
+    /**
+     * Additional include paths for \include commands
+     */
+    includeFolders?: string[];
+}
+
+/**
+ * Engrave LilyPond code to SVG and/or MIDI
+ *
+ * @param lyCode - LilyPond source code
+ * @param options - Engrave options
+ * @returns Promise resolving to exit code (0 = success, 1 = warning, other = error)
+ *
+ * @example
+ * ```typescript
+ * import { engrave } from 'lilypond-node';
+ *
+ * const lyCode = `\\version "2.24.4"
+ * { c' d' e' f' g' }
+ * `;
+ *
+ * const result = await engrave(lyCode, {
+ *     onSVG: (filename, content) => {
+ *         console.log('SVG:', filename, content.length, 'bytes');
+ *     }
+ * });
+ *
+ * console.log('Exit code:', result);
+ * ```
+ */
+export function engrave(lyCode: string, options?: EngraveOptions): Promise<number>;
+
+/**
+ * Get the LilyPond data directory path
+ * @returns Path to LILYPOND_DATADIR
+ */
+export function getDataDir(): string;
+
+/**
+ * LilyPond version bundled with this package
+ */
+export const version: string;

package/lib/index.js

@@ -0,0 +1,125 @@
+/**
+ * LilyPond Node.js Native Addon
+ *
+ * A Node.js native addon for LilyPond music engraving.
+ * Converts LilyPond notation to SVG and MIDI output.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Find the module root directory
+const moduleRoot = path.join(__dirname, '..');
+
+// Possible locations for the native addon
+const addonPaths = [
+    // Development build location
+    path.join(moduleRoot, 'build', 'Release', 'lilypond.node'),
+    path.join(moduleRoot, 'build', 'Debug', 'lilypond.node'),
+    // cmake-js default output
+    path.join(moduleRoot, 'build', 'lilypond.node'),
+    // Legacy output location
+    path.join(moduleRoot, 'output', 'lilypond.node'),
+];
+
+// Find and load the native addon
+let addon = null;
+let addonPath = null;
+
+for (const p of addonPaths) {
+    if (fs.existsSync(p)) {
+        addonPath = p;
+        break;
+    }
+}
+
+if (!addonPath) {
+    throw new Error(
+        'LilyPond native addon not found. ' +
+        'Please run "npm run build" to compile the addon.'
+    );
+}
+
+// Set up LILYPOND_DATADIR if not already set
+if (!process.env.LILYPOND_DATADIR) {
+    const sharePaths = [
+        // Output directory has complete build artifacts
+        path.join(moduleRoot, 'output', 'share', 'lilypond', 'current'),
+        // Package share directory (for npm install)
+        path.join(moduleRoot, 'share', 'lilypond', 'current'),
+    ];
+
+    for (const p of sharePaths) {
+        if (fs.existsSync(p)) {
+            process.env.LILYPOND_DATADIR = p;
+            break;
+        }
+    }
+
+    if (!process.env.LILYPOND_DATADIR) {
+        throw new Error(
+            'LilyPond data directory not found. ' +
+            'Please set LILYPOND_DATADIR or run "npm run postinstall".'
+        );
+    }
+}
+
+// Load the addon
+addon = require(addonPath);
+
+/**
+ * Engrave LilyPond code to SVG and/or MIDI
+ *
+ * @param {string} lyCode - LilyPond source code
+ * @param {Object} [options] - Engrave options
+ * @param {Function} [options.onSVG] - Callback for SVG output: (filename, content) => void
+ * @param {Function} [options.onMIDI] - Callback for MIDI output: (filename, data) => void
+ * @param {Function} [options.log] - Callback for log messages: (message) => void
+ * @param {string[]} [options.includeFolders] - Additional include paths for \include commands
+ * @returns {Promise<number>} Promise resolving to exit code (0 = success, 1 = warning, other = error)
+ *
+ * @example
+ * const lilypond = require('lilypond-node');
+ *
+ * const lyCode = `\\version "2.24.4"
+ * { c' d' e' f' g' }
+ * `;
+ *
+ * lilypond.engrave(lyCode, {
+ *     onSVG: (filename, content) => {
+ *         console.log('SVG:', filename, content.length, 'bytes');
+ *     },
+ *     onMIDI: (filename, data) => {
+ *         console.log('MIDI:', filename, data.byteLength, 'bytes');
+ *     },
+ *     log: (msg) => console.log(msg)
+ * }).then((code) => {
+ *     console.log('Finished with code:', code);
+ * });
+ */
+function engrave(lyCode, options = {}) {
+    if (typeof lyCode !== 'string') {
+        return Promise.reject(new TypeError('lyCode must be a string'));
+    }
+
+    return addon.engrave(lyCode, options);
+}
+
+/**
+ * Get the LilyPond data directory path
+ * @returns {string} Path to LILYPOND_DATADIR
+ */
+function getDataDir() {
+    return process.env.LILYPOND_DATADIR;
+}
+
+/**
+ * LilyPond version
+ */
+const version = '2.24.4';
+
+module.exports = {
+    engrave,
+    getDataDir,
+    version,
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@k-l-lambda/lilypond-node",
+  "version": "2.24.4",
+  "description": "LilyPond music engraving as a Node.js native addon",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "install": "node scripts/install.js",
+    "build": "cmake-js build",
+    "rebuild": "cmake-js rebuild",
+    "clean": "cmake-js clean",
+    "test": "node test/test.js",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "lilypond",
+    "music",
+    "engraving",
+    "notation",
+    "svg",
+    "midi",
+    "sheet-music"
+  ],
+  "author": "K.L. Lambda",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/k.l.lambda/lilypond.git"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/k.l.lambda/lilypond/-/issues"
+  },
+  "homepage": "https://gitlab.com/k.l.lambda/lilypond#readme",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "cmake-js": "^7.3.0"
+  },
+  "binary": {
+    "host": "https://gitlab.com/k.l.lambda/lilypond/-/jobs/artifacts",
+    "remote_path": "/{version}/raw",
+    "package_name": "lilypond-node-{platform}-{arch}-node{node_abi}.tar.gz"
+  },
+  "files": [
+    "lib/",
+    "scripts/"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * Install script for lilypond-node
+ *
+ * Downloads prebuilt binary from GitLab artifacts or falls back to source build.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+const pkg = require('../package.json');
+const moduleRoot = path.join(__dirname, '..');
+
+// Check if prebuilt binary already exists
+const outputDir = path.join(moduleRoot, 'output');
+const addonPath = path.join(outputDir, 'lilypond.node');
+
+if (fs.existsSync(addonPath)) {
+    console.log('lilypond-node: Prebuilt binary already exists.');
+    process.exit(0);
+}
+
+// Platform detection
+const platform = process.platform;
+const arch = process.arch;
+const nodeVersion = process.versions.node.split('.')[0];
+
+console.log(`lilypond-node: Installing for ${platform}-${arch} (Node ${nodeVersion})`);
+
+// Check supported platform
+if (platform !== 'linux' || arch !== 'x64') {
+    console.error(`lilypond-node: Unsupported platform: ${platform}-${arch}`);
+    console.error('Currently only linux-x64 is supported.');
+    console.error('You can try building from source with: npm run build');
+    process.exit(1);
+}
+
+if (parseInt(nodeVersion) < 22) {
+    console.error(`lilypond-node: Node.js ${nodeVersion} is not supported.`);
+    console.error('Please use Node.js 22 or later.');
+    process.exit(1);
+}
+
+// GitLab artifacts URL
+// Format: https://gitlab.com/k.l.lambda/lilypond/-/jobs/artifacts/develop/raw/lilypond-node-linux-x64.tar.gz?job=node-addon-linux-x64
+const gitlabProject = 'k.l.lambda/lilypond';
+const branch = 'develop';
+const artifactName = `lilypond-node-linux-x64.tar.gz`;
+const jobName = 'node-addon-linux-x64';
+
+const downloadUrl = `https://gitlab.com/${gitlabProject}/-/jobs/artifacts/${branch}/raw/${artifactName}?job=${jobName}`;
+
+console.log(`lilypond-node: Downloading prebuilt binary...`);
+console.log(`  URL: ${downloadUrl}`);
+
+// Download function with redirect support
+function download(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+
+        function handleResponse(response) {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                // Follow redirect
+                https.get(response.headers.location, handleResponse).on('error', reject);
+                return;
+            }
+
+            if (response.statusCode !== 200) {
+                reject(new Error(`Download failed: HTTP ${response.statusCode}`));
+                return;
+            }
+
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }
+
+        https.get(url, handleResponse).on('error', reject);
+    });
+}
+
+async function install() {
+    const tarPath = path.join(moduleRoot, artifactName);
+
+    try {
+        // Download
+        await download(downloadUrl, tarPath);
+        console.log('lilypond-node: Download complete.');
+
+        // Extract
+        console.log('lilypond-node: Extracting...');
+        fs.mkdirSync(outputDir, { recursive: true });
+
+        execSync(`tar xzf "${tarPath}" -C "${moduleRoot}"`, { stdio: 'inherit' });
+
+        // Clean up
+        fs.unlinkSync(tarPath);
+
+        // Verify
+        if (fs.existsSync(addonPath)) {
+            console.log('lilypond-node: Installation complete.');
+        } else {
+            throw new Error('Addon not found after extraction');
+        }
+    } catch (err) {
+        console.error(`lilypond-node: Failed to download prebuilt binary.`);
+        console.error(`  Error: ${err.message}`);
+        console.error('');
+        console.error('You can try building from source:');
+        console.error('  1. Clone the full lilypond repo');
+        console.error('  2. cd node-addon && npm run build');
+        process.exit(1);
+    }
+}
+
+install();

package/scripts/postinstall.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for lilypond-node
+ *
+ * This script sets up the LilyPond share directory with required files:
+ * - scm/ - Scheme modules (including build-generated files)
+ * - ly/ - LilyPond include files
+ * - ps/ - PostScript support files
+ * - fonts/ - Music fonts (optional, can use system fonts)
+ *
+ * Note: For development, the output/ directory contains the complete build.
+ * For npm install, files should be copied from the build output.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const moduleRoot = path.join(__dirname, '..');
+const shareDir = path.join(moduleRoot, 'share', 'lilypond', 'current');
+
+// Check if output directory already exists (development build)
+const outputShare = path.join(moduleRoot, 'output', 'share', 'lilypond', 'current');
+if (fs.existsSync(outputShare)) {
+    console.log('LilyPond postinstall: Using existing output directory.');
+    console.log(`  LILYPOND_DATADIR: ${outputShare}`);
+    process.exit(0);
+}
+
+// Source directories (relative to module root)
+const sourceDirs = ['scm', 'ly', 'ps'];
+
+console.log('LilyPond postinstall: Setting up share directory...');
+
+// Create share directory structure
+const dirs = ['share', 'share/lilypond', 'share/lilypond/current'];
+for (const dir of dirs) {
+    const fullPath = path.join(moduleRoot, dir);
+    if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        console.log('  Created:', dir);
+    }
+}
+
+// Copy source directories to share
+for (const dir of sourceDirs) {
+    const srcPath = path.join(moduleRoot, dir);
+    const destPath = path.join(shareDir, dir);
+
+    if (!fs.existsSync(srcPath)) {
+        console.log(`  Warning: Source directory not found: ${dir}`);
+        continue;
+    }
+
+    if (fs.existsSync(destPath)) {
+        console.log(`  Skip: ${dir} (already exists)`);
+        continue;
+    }
+
+    // Copy directory recursively
+    copyDirSync(srcPath, destPath);
+    console.log(`  Copied: ${dir}`);
+}
+
+// Create scm/lily/ subdirectory for Guile module loading
+// Guile expects modules in (lily xxx) to be at scm/lily/xxx.scm
+const scmSrcDir = path.join(shareDir, 'scm');
+const lilyModuleDir = path.join(scmSrcDir, 'lily');
+if (fs.existsSync(scmSrcDir) && !fs.existsSync(lilyModuleDir)) {
+    fs.mkdirSync(lilyModuleDir, { recursive: true });
+    // Copy all .scm files from scm/ to scm/lily/
+    const scmFiles = fs.readdirSync(scmSrcDir).filter(f => f.endsWith('.scm'));
+    for (const file of scmFiles) {
+        fs.copyFileSync(path.join(scmSrcDir, file), path.join(lilyModuleDir, file));
+    }
+    console.log(`  Created: scm/lily/ module directory (${scmFiles.length} files)`);
+}
+
+// Check for fonts
+const fontsDir = path.join(shareDir, 'fonts');
+if (!fs.existsSync(fontsDir)) {
+    console.log('');
+    console.log('  Note: Fonts directory not found.');
+    console.log('  You may need to copy fonts from a LilyPond installation:');
+    console.log('    cp -r /usr/share/lilypond/*/fonts ' + shareDir + '/');
+    console.log('  Or set LILYPOND_DATADIR to a system LilyPond installation.');
+}
+
+// Check for build-generated files
+const fontEncodings = path.join(lilyModuleDir, 'font-encodings.scm');
+if (!fs.existsSync(fontEncodings)) {
+    console.log('');
+    console.log('  Warning: font-encodings.scm not found.');
+    console.log('  This file is generated during the LilyPond build process.');
+    console.log('  For development, run: make -C build');
+    console.log('  Then copy: cp -r build/out/share/lilypond/current/* share/lilypond/current/');
+}
+
+console.log('');
+console.log('LilyPond postinstall complete.');
+
+/**
+ * Recursively copy a directory
+ */
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}