@karaplay/file-coder 1.1.0

package/dist/ncntokar.browser.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * Browser-compatible NCN to KAR converter
+ * Works with File API and ArrayBuffers instead of fs
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserCursorReader = void 0;
+exports.readBufferTextTIS620 = readBufferTextTIS620;
+exports.splitLinesKeepEndings = splitLinesKeepEndings;
+exports.trimLineEndings = trimLineEndings;
+exports.createMetaEvent = createMetaEvent;
+exports.createEndOfTrack = createEndOfTrack;
+exports.parseLyricBuffer = parseLyricBuffer;
+exports.buildKaraokeTrackBrowser = buildKaraokeTrackBrowser;
+exports.buildMetadataTracksBrowser = buildMetadataTracksBrowser;
+exports.convertNcnToKarBrowser = convertNcnToKarBrowser;
+exports.fileToBuffer = fileToBuffer;
+exports.downloadBuffer = downloadBuffer;
+const iconv = __importStar(require("iconv-lite"));
+const grapheme_splitter_1 = __importDefault(require("grapheme-splitter"));
+const midi_file_1 = require("midi-file");
+/**
+ * Reads text from buffer as TIS-620 (Thai encoding)
+ */
+function readBufferTextTIS620(buffer) {
+    return iconv.decode(buffer, "tis-620");
+}
+/**
+ * Splits text into lines while keeping line endings
+ */
+function splitLinesKeepEndings(text) {
+    return text.match(/[^\n]*\n|[^\n]+$/g) || [];
+}
+/**
+ * Removes line endings from a string
+ */
+function trimLineEndings(s) {
+    return s.replace(/[\r\n]+$/g, "");
+}
+/**
+ * Creates a MIDI meta event with TIS-620 encoding for Thai text
+ */
+function createMetaEvent(subtype, deltaTime, text) {
+    const tis620Bytes = iconv.encode(text, 'tis-620');
+    const metaTypeMap = {
+        'text': 0x01,
+        'trackName': 0x03,
+        'copyrightNotice': 0x02,
+        'instrumentName': 0x04,
+        'lyrics': 0x05,
+        'marker': 0x06,
+        'cuePoint': 0x07,
+    };
+    const metatypeByte = metaTypeMap[subtype];
+    if (metatypeByte !== undefined) {
+        return {
+            deltaTime,
+            type: 'unknownMeta',
+            metatypeByte: metatypeByte,
+            data: Array.from(tis620Bytes)
+        };
+    }
+    return { deltaTime, type: subtype, text };
+}
+/**
+ * Creates an end-of-track MIDI event
+ */
+function createEndOfTrack(deltaTime = 0) {
+    return { deltaTime, type: "endOfTrack" };
+}
+/**
+ * Simple cursor reader for browser
+ */
+class BrowserCursorReader {
+    constructor(buf) {
+        this.buf = buf;
+        this.off = 0;
+    }
+    readU16LE() {
+        if (this.off + 2 > this.buf.length)
+            return null;
+        const v = this.buf.readUInt16LE(this.off);
+        this.off += 2;
+        return v;
+    }
+    readU8() {
+        if (this.off + 1 > this.buf.length)
+            return null;
+        const v = this.buf[this.off];
+        this.off += 1;
+        return v;
+    }
+    remaining() {
+        return this.buf.length - this.off;
+    }
+}
+exports.BrowserCursorReader = BrowserCursorReader;
+/**
+ * Parses lyric buffer to extract metadata (title, artist, lyrics)
+ */
+function parseLyricBuffer(lyricBuffer) {
+    const lyricText = readBufferTextTIS620(lyricBuffer);
+    const linesWithEndings = splitLinesKeepEndings(lyricText);
+    if (linesWithEndings.length < 2) {
+        throw new Error("Lyric file has too few lines (need title and artist).");
+    }
+    const songTitle = trimLineEndings(linesWithEndings[0] ?? "");
+    const artistName = trimLineEndings(linesWithEndings[1] ?? "");
+    let fullLyric = "";
+    const lyricLines = [];
+    for (let i = 4; i < linesWithEndings.length; i++) {
+        fullLyric += linesWithEndings[i];
+        const trimmed = trimLineEndings(linesWithEndings[i]);
+        if (trimmed && trimmed.length > 0) {
+            lyricLines.push(trimmed);
+        }
+    }
+    return {
+        title: songTitle,
+        artist: artistName,
+        fullLyric,
+        lines: lyricLines
+    };
+}
+/**
+ * Builds karaoke track with timing information (browser version)
+ */
+function buildKaraokeTrackBrowser(metadata, cursorBuffer, ticksPerBeat) {
+    const karaokeTrack = [];
+    const warnings = [];
+    karaokeTrack.push(createMetaEvent("trackName", 0, "Words"));
+    karaokeTrack.push(createMetaEvent("text", 0, "@T" + metadata.title));
+    karaokeTrack.push(createMetaEvent("text", 0, "@T" + metadata.artist));
+    const cursor = new BrowserCursorReader(cursorBuffer);
+    const splitter = new grapheme_splitter_1.default();
+    let previousAbsoluteTimestamp = 0;
+    const lyricsWithEndings = splitLinesKeepEndings(metadata.fullLyric);
+    for (let i = 4; i < lyricsWithEndings.length; i++) {
+        const trimmed = trimLineEndings(lyricsWithEndings[i]);
+        if (!trimmed || trimmed.length === 0)
+            continue;
+        const lineForTiming = "/" + trimmed;
+        const graphemes = splitter.splitGraphemes(lineForTiming);
+        for (const g of graphemes) {
+            let absoluteTimestamp = previousAbsoluteTimestamp;
+            for (const _cp of Array.from(g)) {
+                const v = cursor.readU16LE();
+                if (v === null) {
+                    warnings.push("ran out of timing info; reusing previous timestamp");
+                    absoluteTimestamp = previousAbsoluteTimestamp;
+                }
+                else {
+                    absoluteTimestamp = v;
+                }
+            }
+            absoluteTimestamp = Math.floor(absoluteTimestamp * (ticksPerBeat / 24));
+            if (absoluteTimestamp < previousAbsoluteTimestamp) {
+                warnings.push("timestamp out of order - clamping");
+                absoluteTimestamp = previousAbsoluteTimestamp;
+            }
+            const relativeTimestamp = absoluteTimestamp - previousAbsoluteTimestamp;
+            karaokeTrack.push(createMetaEvent("text", relativeTimestamp, g));
+            previousAbsoluteTimestamp = absoluteTimestamp;
+        }
+    }
+    const terminator = cursor.readU8();
+    if (terminator === null) {
+        warnings.push("EOF without terminator while reading timing info");
+    }
+    else {
+        const leftover = cursor.remaining();
+        if (terminator !== 0xff || leftover > 0) {
+            warnings.push(`${leftover} bytes (${leftover / 2} values) of unused timing info, or timing info ended without 0xFF terminator`);
+        }
+    }
+    karaokeTrack.push(createEndOfTrack(0));
+    return { track: karaokeTrack, warnings };
+}
+/**
+ * Builds additional metadata tracks (Lyric, Artist, SongTitle)
+ */
+function buildMetadataTracksBrowser(metadata) {
+    const lyricTrack = [
+        createMetaEvent("trackName", 0, "Lyric"),
+        createMetaEvent("text", 0, metadata.fullLyric),
+        createEndOfTrack(0),
+    ];
+    const artistTrack = [
+        createMetaEvent("trackName", 0, "Artist"),
+        createMetaEvent("text", 0, metadata.artist),
+        createEndOfTrack(0),
+    ];
+    const titleTrack = [
+        createMetaEvent("trackName", 0, "SongTitle"),
+        createMetaEvent("text", 0, metadata.title),
+        createEndOfTrack(0),
+    ];
+    return { lyricTrack, artistTrack, titleTrack };
+}
+/**
+ * Browser-compatible NCN to KAR conversion
+ * Works with buffers instead of file paths
+ */
+function convertNcnToKarBrowser(options) {
+    const warnings = [];
+    try {
+        // Parse MIDI
+        const midi = (0, midi_file_1.parseMidi)(options.midiBuffer);
+        const ticksPerBeat = midi.header && midi.header.ticksPerBeat;
+        if (!ticksPerBeat) {
+            throw new Error("Only ticks-per-beat MIDI timing is supported (SMPTE timing not supported).");
+        }
+        // Parse lyric buffer
+        const metadata = parseLyricBuffer(options.lyricBuffer);
+        // Build karaoke track
+        const { track: karaokeTrack, warnings: karaokeWarnings } = buildKaraokeTrackBrowser(metadata, options.cursorBuffer, ticksPerBeat);
+        warnings.push(...karaokeWarnings);
+        // Build metadata tracks
+        const { lyricTrack, artistTrack, titleTrack } = buildMetadataTracksBrowser(metadata);
+        // Insert tracks as second track (index 1)
+        const originalTracks = midi.tracks || [];
+        const newTracks = originalTracks.slice();
+        newTracks.splice(1, 0, karaokeTrack, lyricTrack, artistTrack, titleTrack);
+        midi.tracks = newTracks;
+        // Write output
+        const outBytes = (0, midi_file_1.writeMidi)(midi);
+        const karBuffer = Buffer.from(outBytes);
+        return {
+            success: true,
+            karBuffer,
+            fileName: options.outputFileName || 'output.kar',
+            metadata,
+            warnings
+        };
+    }
+    catch (error) {
+        throw new Error(`Browser NCN to KAR conversion failed: ${error.message}`);
+    }
+}
+/**
+ * Helper to convert File to Buffer for browser use
+ */
+async function fileToBuffer(file) {
+    const arrayBuffer = await file.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}
+/**
+ * Helper to download buffer as file in browser
+ */
+function downloadBuffer(buffer, fileName, mimeType = 'audio/midi') {
+    const blob = new Blob([new Uint8Array(buffer)], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = fileName;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}

package/dist/ncntokar.d.ts

@@ -0,0 +1,88 @@
+/**
+ * NCN (.mid + .lyr + .cur) -> .kar (MIDI with embedded karaoke/lyric/title/artist tracks)
+ * - .lyr decoded as TIS-620 (Thai encoding)
+ * - meta events use midi-file format: { deltaTime, type: <subtype>, text }
+ */
+export interface ConversionOptions {
+    inputMidi: string;
+    inputLyr: string;
+    inputCur: string;
+    outputKar: string;
+    appendTitles?: boolean;
+    titlesFile?: string;
+}
+export interface SongMetadata {
+    title: string;
+    artist: string;
+    fullLyric: string;
+    lines: string[];
+}
+export declare class CursorReader {
+    private buf;
+    private off;
+    constructor(buf: Buffer);
+    readU16LE(): number | null;
+    readU8(): number | null;
+    remaining(): number;
+    eof(): boolean;
+}
+/**
+ * Reads a file and decodes it as TIS-620 (Thai encoding)
+ */
+export declare function readFileTextTIS620(filePath: string): string;
+/**
+ * Splits text into lines while keeping line endings
+ */
+export declare function splitLinesKeepEndings(text: string): string[];
+/**
+ * Removes line endings from a string
+ */
+export declare function trimLineEndings(s: string): string;
+/**
+ * Creates a MIDI meta event with TIS-620 encoding for Thai text
+ */
+export declare function metaEvent(subtype: string, deltaTime: number, text: string): any;
+/**
+ * Creates an end-of-track MIDI event
+ */
+export declare function endOfTrack(deltaTime?: number): any;
+/**
+ * Validates that a file exists and is readable
+ */
+export declare function ensureReadableFile(filePath: string): void;
+/**
+ * Ensures output file doesn't exist and creates directory if needed
+ */
+export declare function ensureOutputDoesNotExist(filePath: string, createDir?: boolean): void;
+/**
+ * Parses lyric file and extracts metadata (title, artist, lyrics)
+ */
+export declare function parseLyricFile(lyricFilePath: string): SongMetadata;
+/**
+ * Builds karaoke track with timing information
+ */
+export declare function buildKaraokeTrack(metadata: SongMetadata, cursorBuffer: Buffer, ticksPerBeat: number): {
+    track: any[];
+    warnings: string[];
+};
+/**
+ * Builds additional metadata tracks (Lyric, Artist, SongTitle)
+ */
+export declare function buildMetadataTracks(metadata: SongMetadata): {
+    lyricTrack: any[];
+    artistTrack: any[];
+    titleTrack: any[];
+};
+/**
+ * Main conversion function: converts NCN files (.mid + .lyr + .cur) to .kar format
+ */
+export declare function convertNcnToKar(options: ConversionOptions): {
+    success: boolean;
+    outputFile: string;
+    warnings: string[];
+    metadata: SongMetadata;
+};
+/**
+ * CLI-compatible function that uses hard-coded paths (for backward compatibility)
+ */
+export declare function convertWithDefaults(inputMidi: string, inputLyr: string, inputCur: string, outputKar: string): void;