@karaplay/file-coder 1.1.0

package/dist/ncntokar.js

@@ -0,0 +1,340 @@
+"use strict";
+/**
+ * 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 }
+ */
+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.CursorReader = void 0;
+exports.readFileTextTIS620 = readFileTextTIS620;
+exports.splitLinesKeepEndings = splitLinesKeepEndings;
+exports.trimLineEndings = trimLineEndings;
+exports.metaEvent = metaEvent;
+exports.endOfTrack = endOfTrack;
+exports.ensureReadableFile = ensureReadableFile;
+exports.ensureOutputDoesNotExist = ensureOutputDoesNotExist;
+exports.parseLyricFile = parseLyricFile;
+exports.buildKaraokeTrack = buildKaraokeTrack;
+exports.buildMetadataTracks = buildMetadataTracks;
+exports.convertNcnToKar = convertNcnToKar;
+exports.convertWithDefaults = convertWithDefaults;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const iconv = __importStar(require("iconv-lite"));
+const grapheme_splitter_1 = __importDefault(require("grapheme-splitter"));
+const midi_file_1 = require("midi-file");
+class CursorReader {
+    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;
+    }
+    eof() {
+        return this.off >= this.buf.length;
+    }
+}
+exports.CursorReader = CursorReader;
+/**
+ * Reads a file and decodes it as TIS-620 (Thai encoding)
+ */
+function readFileTextTIS620(filePath) {
+    const buf = fs.readFileSync(filePath);
+    return iconv.decode(buf, "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 metaEvent(subtype, deltaTime, text) {
+    // Encode text back to TIS-620 bytes (original encoding) to preserve Thai characters
+    const tis620Bytes = iconv.encode(text, 'tis-620');
+    // Map subtype to metatypeByte
+    const metaTypeMap = {
+        'text': 0x01,
+        'trackName': 0x03,
+        'copyrightNotice': 0x02,
+        'instrumentName': 0x04,
+        'lyrics': 0x05,
+        'marker': 0x06,
+        'cuePoint': 0x07,
+    };
+    const metatypeByte = metaTypeMap[subtype];
+    if (metatypeByte !== undefined) {
+        // Use unknownMeta with proper metatypeByte to write TIS-620 bytes correctly
+        return {
+            deltaTime,
+            type: 'unknownMeta',
+            metatypeByte: metatypeByte,
+            data: Array.from(tis620Bytes)
+        };
+    }
+    // Fallback to standard format for other types
+    return { deltaTime, type: subtype, text };
+}
+/**
+ * Creates an end-of-track MIDI event
+ */
+function endOfTrack(deltaTime = 0) {
+    return { deltaTime, type: "endOfTrack" };
+}
+/**
+ * Validates that a file exists and is readable
+ */
+function ensureReadableFile(filePath) {
+    try {
+        fs.accessSync(filePath, fs.constants.R_OK);
+        if (!fs.statSync(filePath).isFile()) {
+            throw new Error(`Not a file: ${filePath}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Cannot read file: ${filePath}`);
+    }
+}
+/**
+ * Ensures output file doesn't exist and creates directory if needed
+ */
+function ensureOutputDoesNotExist(filePath, createDir = true) {
+    if (fs.existsSync(filePath)) {
+        throw new Error(`Output already exists: ${filePath}`);
+    }
+    if (createDir) {
+        const dir = path.dirname(filePath);
+        if (dir && dir !== "." && !fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+/**
+ * Parses lyric file and extracts metadata (title, artist, lyrics)
+ */
+function parseLyricFile(lyricFilePath) {
+    const lyricText = readFileTextTIS620(lyricFilePath);
+    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] ?? "");
+    // Discard line 3 & 4; lyrics start from line 5 (index 4)
+    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
+ */
+function buildKaraokeTrack(metadata, cursorBuffer, ticksPerBeat) {
+    const karaokeTrack = [];
+    const warnings = [];
+    karaokeTrack.push(metaEvent("trackName", 0, "Words"));
+    karaokeTrack.push(metaEvent("text", 0, "@T" + metadata.title));
+    karaokeTrack.push(metaEvent("text", 0, "@T" + metadata.artist));
+    const cursor = new CursorReader(cursorBuffer);
+    const splitter = new grapheme_splitter_1.default();
+    let previousAbsoluteTimestamp = 0;
+    // Process each lyric line
+    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;
+            // Read 2 bytes per codepoint inside grapheme
+            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;
+                }
+            }
+            // Conversion: * (ticksPerBeat / 24)
+            absoluteTimestamp = Math.floor(absoluteTimestamp * (ticksPerBeat / 24));
+            if (absoluteTimestamp < previousAbsoluteTimestamp) {
+                warnings.push("timestamp out of order - clamping");
+                absoluteTimestamp = previousAbsoluteTimestamp;
+            }
+            const relativeTimestamp = absoluteTimestamp - previousAbsoluteTimestamp;
+            karaokeTrack.push(metaEvent("text", relativeTimestamp, g));
+            previousAbsoluteTimestamp = absoluteTimestamp;
+        }
+    }
+    // Check terminator
+    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(endOfTrack(0));
+    return { track: karaokeTrack, warnings };
+}
+/**
+ * Builds additional metadata tracks (Lyric, Artist, SongTitle)
+ */
+function buildMetadataTracks(metadata) {
+    const lyricTrack = [
+        metaEvent("trackName", 0, "Lyric"),
+        metaEvent("text", 0, metadata.fullLyric),
+        endOfTrack(0),
+    ];
+    const artistTrack = [
+        metaEvent("trackName", 0, "Artist"),
+        metaEvent("text", 0, metadata.artist),
+        endOfTrack(0),
+    ];
+    const titleTrack = [
+        metaEvent("trackName", 0, "SongTitle"),
+        metaEvent("text", 0, metadata.title),
+        endOfTrack(0),
+    ];
+    return { lyricTrack, artistTrack, titleTrack };
+}
+/**
+ * Main conversion function: converts NCN files (.mid + .lyr + .cur) to .kar format
+ */
+function convertNcnToKar(options) {
+    const warnings = [];
+    // Validate input files
+    ensureReadableFile(options.inputMidi);
+    ensureReadableFile(options.inputLyr);
+    ensureReadableFile(options.inputCur);
+    ensureOutputDoesNotExist(options.outputKar);
+    // Parse MIDI
+    const midi = (0, midi_file_1.parseMidi)(fs.readFileSync(options.inputMidi));
+    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 file
+    const metadata = parseLyricFile(options.inputLyr);
+    // Build karaoke track
+    const cursorBuffer = fs.readFileSync(options.inputCur);
+    const { track: karaokeTrack, warnings: karaokeWarnings } = buildKaraokeTrack(metadata, cursorBuffer, ticksPerBeat);
+    warnings.push(...karaokeWarnings);
+    // Build metadata tracks
+    const { lyricTrack, artistTrack, titleTrack } = buildMetadataTracks(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);
+    fs.writeFileSync(options.outputKar, Buffer.from(outBytes));
+    // Optionally append to titles.txt
+    if (options.appendTitles) {
+        const titlesFile = options.titlesFile || path.join(path.dirname(options.outputKar), "titles.txt");
+        fs.appendFileSync(titlesFile, `${path.basename(options.outputKar)}\t${metadata.title}\t${metadata.artist}\n`, "utf8");
+    }
+    return {
+        success: true,
+        outputFile: options.outputKar,
+        warnings,
+        metadata
+    };
+}
+/**
+ * CLI-compatible function that uses hard-coded paths (for backward compatibility)
+ */
+function convertWithDefaults(inputMidi, inputLyr, inputCur, outputKar) {
+    const result = convertNcnToKar({
+        inputMidi,
+        inputLyr,
+        inputCur,
+        outputKar,
+        appendTitles: true
+    });
+    if (result.warnings.length > 0) {
+        result.warnings.forEach(w => console.warn(`[warn] ${w}`));
+    }
+    console.log("✅ Done");
+    console.log(`- Output: ${result.outputFile}`);
+    console.log(`- Title: ${result.metadata.title}`);
+    console.log(`- Artist: ${result.metadata.artist}`);
+}

package/examples/NextJSComponent.tsx

@@ -0,0 +1,175 @@
+/**
+ * Example Next.js Client Component for EMK to KAR conversion
+ * This demonstrates how to use file-coder in a Next.js app
+ */
+
+'use client';
+
+import { useState } from 'react';
+import { 
+  convertEmkFileToKar, 
+  convertEmkFilesBatch,
+  type BrowserEmkToKarResult 
+} from 'file-coder/client';
+
+export default function EmkConverter() {
+  const [converting, setConverting] = useState(false);
+  const [result, setResult] = useState<BrowserEmkToKarResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+
+    setConverting(true);
+    setError(null);
+    setResult(null);
+
+    try {
+      // Convert and auto-download the KAR file
+      const conversionResult = await convertEmkFileToKar(file, {
+        autoDownload: true
+      });
+
+      setResult(conversionResult);
+      console.log('✓ Converted:', conversionResult.metadata.title);
+      console.log('✓ Artist:', conversionResult.metadata.artist);
+      
+      if (conversionResult.warnings.length > 0) {
+        console.warn('Warnings:', conversionResult.warnings);
+      }
+    } catch (err: any) {
+      setError(err.message);
+      console.error('Conversion failed:', err);
+    } finally {
+      setConverting(false);
+    }
+  };
+
+  const handleBatchUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const files = Array.from(e.target.files || []);
+    if (files.length === 0) return;
+
+    setConverting(true);
+    setError(null);
+
+    try {
+      // Convert multiple files
+      const results = await convertEmkFilesBatch(files, {
+        autoDownload: true
+      });
+
+      const successCount = results.filter(r => r.success).length;
+      console.log(`✓ Converted ${successCount}/${files.length} files`);
+      
+      results.forEach(r => {
+        if (r.success) {
+          console.log(`  ✓ ${r.fileName}: ${r.metadata.title}`);
+        } else {
+          console.error(`  ✗ ${r.fileName}: ${r.warnings.join(', ')}`);
+        }
+      });
+    } catch (err: any) {
+      setError(err.message);
+      console.error('Batch conversion failed:', err);
+    } finally {
+      setConverting(false);
+    }
+  };
+
+  return (
+    <div className="max-w-2xl mx-auto p-6">
+      <h1 className="text-3xl font-bold mb-6">EMK to KAR Converter</h1>
+      
+      {/* Single file upload */}
+      <div className="mb-8">
+        <h2 className="text-xl font-semibold mb-3">Convert Single File</h2>
+        <input
+          type="file"
+          accept=".emk"
+          onChange={handleFileUpload}
+          disabled={converting}
+          className="block w-full text-sm text-gray-500
+            file:mr-4 file:py-2 file:px-4
+            file:rounded-full file:border-0
+            file:text-sm file:font-semibold
+            file:bg-blue-50 file:text-blue-700
+            hover:file:bg-blue-100
+            disabled:opacity-50"
+        />
+      </div>
+
+      {/* Batch upload */}
+      <div className="mb-8">
+        <h2 className="text-xl font-semibold mb-3">Convert Multiple Files</h2>
+        <input
+          type="file"
+          accept=".emk"
+          multiple
+          onChange={handleBatchUpload}
+          disabled={converting}
+          className="block w-full text-sm text-gray-500
+            file:mr-4 file:py-2 file:px-4
+            file:rounded-full file:border-0
+            file:text-sm file:font-semibold
+            file:bg-green-50 file:text-green-700
+            hover:file:bg-green-100
+            disabled:opacity-50"
+        />
+      </div>
+
+      {/* Status */}
+      {converting && (
+        <div className="bg-blue-50 border border-blue-200 rounded p-4 mb-4">
+          <p className="text-blue-800">Converting... Please wait.</p>
+        </div>
+      )}
+
+      {error && (
+        <div className="bg-red-50 border border-red-200 rounded p-4 mb-4">
+          <p className="text-red-800 font-semibold">Error:</p>
+          <p className="text-red-700">{error}</p>
+        </div>
+      )}
+
+      {result && result.success && (
+        <div className="bg-green-50 border border-green-200 rounded p-4">
+          <p className="text-green-800 font-semibold mb-2">✓ Conversion Successful!</p>
+          <div className="text-sm text-green-700">
+            <p><strong>Title:</strong> {result.metadata.title}</p>
+            <p><strong>Artist:</strong> {result.metadata.artist}</p>
+            <p><strong>File:</strong> {result.fileName}</p>
+            {result.metadata.code && (
+              <p><strong>Code:</strong> {result.metadata.code}</p>
+            )}
+            {result.warnings.length > 0 && (
+              <div className="mt-2">
+                <p className="font-semibold">Warnings:</p>
+                <ul className="list-disc list-inside">
+                  {result.warnings.map((w, i) => (
+                    <li key={i}>{w}</li>
+                  ))}
+                </ul>
+              </div>
+            )}
+          </div>
+        </div>
+      )}
+
+      {/* Info */}
+      <div className="mt-8 p-4 bg-gray-50 rounded">
+        <h3 className="font-semibold mb-2">About</h3>
+        <p className="text-sm text-gray-600">
+          This converter processes .emk (Extreme Karaoke) files and converts them
+          to .kar (MIDI Karaoke) format. The converted files will automatically
+          download to your device.
+        </p>
+        <p className="text-sm text-gray-600 mt-2">
+          Supports Thai lyrics (TIS-620 encoding) and maintains proper timing
+          information for karaoke display.
+        </p>
+      </div>
+    </div>
+  );
+}
+

package/libs/emk/client-decoder.ts

@@ -0,0 +1,142 @@
+
+/**
+ * @fileoverview Main decoding logic for .emk (Extreme Karaoke) files.
+ * This file is now intended for CLIENT-SIDE use.
+ */
+'use client';
+
+import { inflate } from 'pako';
+
+const XOR_KEY = Buffer.from([0xAF, 0xF2, 0x4C, 0x9C, 0xE9, 0xEA, 0x99, 0x43]);
+const MAGIC_SIGNATURE = '.SFDS';
+
+export interface DecodedEmkParts {
+  header?: Buffer;
+  songInfo?: Buffer;
+  midi?: Buffer;
+  lyric?: Buffer;
+  cursor?: Buffer;
+}
+
+function xorDecrypt(data: Buffer): Buffer {
+  const decrypted = Buffer.alloc(data.length);
+  for (let i = 0; i < data.length; i++) {
+    decrypted[i] = data[i] ^ XOR_KEY[i % XOR_KEY.length];
+  }
+  return decrypted;
+}
+
+function looksLikeText(buf: Buffer): boolean {
+  const sample = buf.subarray(0, Math.min(64, buf.length));
+  for (let i = 0; i < sample.length; i++) {
+    const c = sample[i];
+    // Check for common text characters (ASCII, line endings, Thai)
+    if (c === 0x0a || c === 0x0d || c === 0x09 || (c >= 0x20 && c <= 0x7e) || c >= 0x80) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Decodes an .emk file buffer into its constituent parts on the client-side.
+ * This uses `pako` for zlib decompression in the browser.
+ * @param fileBuffer The raw Buffer from the .emk file.
+ */
+export function decodeEmk(fileBuffer: Buffer): DecodedEmkParts {
+  const decryptedBuffer = xorDecrypt(fileBuffer);
+
+  const magic = decryptedBuffer.subarray(0, MAGIC_SIGNATURE.length).toString('utf-8');
+  if (magic !== MAGIC_SIGNATURE) {
+    throw new Error(`Invalid EMK file signature. Expected '${MAGIC_SIGNATURE}' but got '${magic}'.`);
+  }
+
+  const result: DecodedEmkParts = {};
+  const inflatedParts: Buffer[] = [];
+
+  for (let i = 0; i < decryptedBuffer.length - 2; i++) {
+    const b0 = decryptedBuffer[i];
+    
+    // Zlib streams start with 0x78
+    if (b0 !== 0x78) continue;
+
+    try {
+      // Attempt to inflate from this point to the end of the buffer
+      const inflatedUint8 = inflate(decryptedBuffer.subarray(i));
+      const inflated = Buffer.from(inflatedUint8);
+      inflatedParts.push(inflated);
+      // This is a naive scan; a successful inflation doesn't mean we can skip.
+      // The original data is a series of concatenated zlib streams. We must find them all.
+    } catch (e: any) {
+       // This is expected for many positions, as not every 0x78 starts a valid stream.
+    }
+  }
+
+  if (inflatedParts.length < 3) {
+    throw new Error(`Invalid EMK structure: expected at least 3 zlib blocks, found ${inflatedParts.length}.`);
+  }
+
+  for (const inflated of inflatedParts) {
+    const asciiPrefix = inflated.subarray(0, 16).toString('ascii');
+
+    if (asciiPrefix.startsWith('SIGNATURE=')) {
+      result.header = inflated;
+    } else if (asciiPrefix.startsWith('CODE=')) {
+      result.songInfo = inflated;
+    } else if (inflated.subarray(0, 4).toString('ascii') === 'MThd') {
+      result.midi = inflated;
+    } else if (looksLikeText(inflated)) {
+      if (!result.lyric) {
+        result.lyric = inflated;
+      } else {
+        result.cursor = inflated;
+      }
+    } else {
+      if (!result.cursor) {
+        result.cursor = inflated;
+      }
+    }
+  }
+
+  if (!result.midi) throw new Error('MIDI data block not found in EMK file.');
+  if (!result.lyric) throw new Error('Lyric data block not found in EMK file.');
+  if (!result.cursor) throw new Error('Cursor data block not found in EMK file.');
+
+  if (!result.songInfo) {
+    result.songInfo = Buffer.from('CODE=\nTITLE=Unknown Title\nARTIST=Unknown Artist');
+  }
+
+  return result;
+}
+
+
+/**
+ * Parses the "song info" block from a Buffer.
+ * This is safe to run on the client as it's pure JS.
+ * @param songInfoBuffer The buffer containing the song info data.
+ * @returns A record containing TITLE, ARTIST, and CODE.
+ */
+export function parseSongInfo(songInfoBuffer: Buffer | undefined): Record<string, string> {
+  if (!songInfoBuffer) return {};
+  try {
+    // Use TextDecoder, which is available in modern browsers.
+    const text = new TextDecoder('windows-874', { fatal: false }).decode(songInfoBuffer);
+    const lines = text.split(/\r?\n/);
+    const info: Record<string, string> = {};
+    for (const line of lines) {
+      const parts = line.split('=');
+      if (parts.length >= 2) {
+        const key = parts[0].trim().toUpperCase();
+        const value = parts.slice(1).join('=').trim();
+        if (key === 'TITLE' || key === 'ARTIST' || key === 'CODE') {
+           info[key] = value;
+        }
+      }
+    }
+    return info;
+  } catch (e) {
+    console.error("Failed to parse song info", e);
+    return {};
+  }
+}