@karaplay/file-coder 1.1.0

package/dist/kar-reader.browser.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Browser-compatible KAR file reader
+ * Reads and validates .kar files from buffers
+ */
+export interface KarFileInfo {
+    isValid: boolean;
+    header: {
+        format?: number;
+        numTracks?: number;
+        ticksPerBeat?: number;
+    };
+    tracks: KarTrack[];
+    metadata: {
+        title?: string;
+        artist?: string;
+        hasKaraokeTrack: boolean;
+        hasLyricTrack: boolean;
+    };
+}
+export interface KarTrack {
+    name?: string;
+    events: number;
+    hasText: boolean;
+    hasLyrics: boolean;
+    textEvents: string[];
+}
+/**
+ * Reads and parses a KAR file from buffer
+ */
+export declare function readKarBuffer(buffer: Buffer): KarFileInfo;
+/**
+ * Validates that a KAR buffer has the expected structure
+ */
+export declare function validateKarBuffer(buffer: Buffer): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Extracts lyrics from a KAR buffer
+ */
+export declare function extractLyricsFromKarBuffer(buffer: Buffer): string[];
+/**
+ * Helper to read File object as KAR
+ */
+export declare function readKarFile(file: File): Promise<KarFileInfo>;

package/dist/kar-reader.browser.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Browser-compatible KAR file reader
+ * Reads and validates .kar files from buffers
+ */
+'use client';
+/**
+ * Browser-compatible KAR file reader
+ * Reads and validates .kar files from buffers
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readKarBuffer = readKarBuffer;
+exports.validateKarBuffer = validateKarBuffer;
+exports.extractLyricsFromKarBuffer = extractLyricsFromKarBuffer;
+exports.readKarFile = readKarFile;
+const midi_file_1 = require("midi-file");
+const iconv = __importStar(require("iconv-lite"));
+/**
+ * Reads and parses a KAR file from buffer
+ */
+function readKarBuffer(buffer) {
+    const midi = (0, midi_file_1.parseMidi)(buffer);
+    const info = {
+        isValid: true,
+        header: {
+            format: midi.header.format,
+            numTracks: midi.header.numTracks,
+            ticksPerBeat: midi.header.ticksPerBeat
+        },
+        tracks: [],
+        metadata: {
+            hasKaraokeTrack: false,
+            hasLyricTrack: false
+        }
+    };
+    // Process each track
+    for (const track of midi.tracks || []) {
+        const trackInfo = {
+            events: track.length,
+            hasText: false,
+            hasLyrics: false,
+            textEvents: []
+        };
+        for (const event of track) {
+            // Handle different event types
+            if (event.type === 'trackName' && 'text' in event) {
+                trackInfo.name = event.text;
+            }
+            else if (event.type === 'text' && 'text' in event) {
+                trackInfo.hasText = true;
+                const text = event.text;
+                trackInfo.textEvents.push(text);
+                // Check for karaoke markers
+                if (text.startsWith('@T')) {
+                    if (!info.metadata.title) {
+                        info.metadata.title = text.substring(2);
+                    }
+                    else if (!info.metadata.artist) {
+                        info.metadata.artist = text.substring(2);
+                    }
+                }
+            }
+            else if (event.type === 'lyrics' && 'text' in event) {
+                trackInfo.hasLyrics = true;
+                trackInfo.textEvents.push(event.text);
+            }
+            else if (event.type === 'unknownMeta' && 'data' in event) {
+                // Handle TIS-620 encoded text events
+                const data = event.data;
+                if (data && data.length > 0) {
+                    try {
+                        const buffer = Buffer.from(data);
+                        const text = iconv.decode(buffer, 'tis-620');
+                        trackInfo.hasText = true;
+                        trackInfo.textEvents.push(text);
+                        if (text.startsWith('@T')) {
+                            if (!info.metadata.title) {
+                                info.metadata.title = text.substring(2);
+                            }
+                            else if (!info.metadata.artist) {
+                                info.metadata.artist = text.substring(2);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Ignore decode errors
+                    }
+                }
+            }
+        }
+        // Identify special tracks
+        if (trackInfo.name === 'Words') {
+            info.metadata.hasKaraokeTrack = true;
+        }
+        else if (trackInfo.name === 'Lyric') {
+            info.metadata.hasLyricTrack = true;
+        }
+        else if (trackInfo.name === 'SongTitle' && trackInfo.textEvents.length > 0) {
+            info.metadata.title = trackInfo.textEvents[0];
+        }
+        else if (trackInfo.name === 'Artist' && trackInfo.textEvents.length > 0) {
+            info.metadata.artist = trackInfo.textEvents[0];
+        }
+        info.tracks.push(trackInfo);
+    }
+    return info;
+}
+/**
+ * Validates that a KAR buffer has the expected structure
+ */
+function validateKarBuffer(buffer) {
+    const errors = [];
+    const warnings = [];
+    try {
+        const info = readKarBuffer(buffer);
+        // Check basic structure
+        if (!info.header.ticksPerBeat) {
+            errors.push('Missing ticksPerBeat in header');
+        }
+        if (info.tracks.length === 0) {
+            errors.push('No tracks found in file');
+        }
+        // Check for karaoke tracks
+        if (!info.metadata.hasKaraokeTrack) {
+            warnings.push('No "Words" karaoke track found');
+        }
+        if (!info.metadata.hasLyricTrack) {
+            warnings.push('No "Lyric" track found');
+        }
+        if (!info.metadata.title) {
+            warnings.push('No title metadata found');
+        }
+        if (!info.metadata.artist) {
+            warnings.push('No artist metadata found');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    catch (error) {
+        errors.push(`Failed to read KAR buffer: ${error.message}`);
+        return {
+            valid: false,
+            errors,
+            warnings
+        };
+    }
+}
+/**
+ * Extracts lyrics from a KAR buffer
+ */
+function extractLyricsFromKarBuffer(buffer) {
+    const info = readKarBuffer(buffer);
+    const lyrics = [];
+    for (const track of info.tracks) {
+        if (track.name === 'Words' || track.hasText) {
+            for (const text of track.textEvents) {
+                // Skip metadata markers
+                if (!text.startsWith('@')) {
+                    lyrics.push(text);
+                }
+            }
+        }
+    }
+    return lyrics;
+}
+/**
+ * Helper to read File object as KAR
+ */
+async function readKarFile(file) {
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    return readKarBuffer(buffer);
+}

package/dist/kar-reader.d.ts

@@ -0,0 +1,42 @@
+/**
+ * KAR file reader utility
+ * Reads and validates .kar (MIDI karaoke) files
+ */
+export interface KarFileInfo {
+    isValid: boolean;
+    header: {
+        format?: number;
+        numTracks?: number;
+        ticksPerBeat?: number;
+    };
+    tracks: KarTrack[];
+    metadata: {
+        title?: string;
+        artist?: string;
+        hasKaraokeTrack: boolean;
+        hasLyricTrack: boolean;
+    };
+}
+export interface KarTrack {
+    name?: string;
+    events: number;
+    hasText: boolean;
+    hasLyrics: boolean;
+    textEvents: string[];
+}
+/**
+ * Reads and parses a KAR file
+ */
+export declare function readKarFile(filePath: string): KarFileInfo;
+/**
+ * Validates that a KAR file has the expected structure
+ */
+export declare function validateKarFile(filePath: string): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Extracts lyrics from a KAR file
+ */
+export declare function extractLyricsFromKar(filePath: string): string[];

package/dist/kar-reader.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * KAR file reader utility
+ * Reads and validates .kar (MIDI karaoke) files
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readKarFile = readKarFile;
+exports.validateKarFile = validateKarFile;
+exports.extractLyricsFromKar = extractLyricsFromKar;
+const fs = __importStar(require("fs"));
+const midi_file_1 = require("midi-file");
+const iconv = __importStar(require("iconv-lite"));
+/**
+ * Reads and parses a KAR file
+ */
+function readKarFile(filePath) {
+    const buffer = fs.readFileSync(filePath);
+    const midi = (0, midi_file_1.parseMidi)(buffer);
+    const info = {
+        isValid: true,
+        header: {
+            format: midi.header.format,
+            numTracks: midi.header.numTracks,
+            ticksPerBeat: midi.header.ticksPerBeat
+        },
+        tracks: [],
+        metadata: {
+            hasKaraokeTrack: false,
+            hasLyricTrack: false
+        }
+    };
+    // Process each track
+    for (const track of midi.tracks || []) {
+        const trackInfo = {
+            events: track.length,
+            hasText: false,
+            hasLyrics: false,
+            textEvents: []
+        };
+        for (const event of track) {
+            // Handle different event types
+            if (event.type === 'trackName' && 'text' in event) {
+                trackInfo.name = event.text;
+            }
+            else if (event.type === 'text' && 'text' in event) {
+                trackInfo.hasText = true;
+                const text = event.text;
+                trackInfo.textEvents.push(text);
+                // Check for karaoke markers
+                if (text.startsWith('@T')) {
+                    if (!info.metadata.title) {
+                        info.metadata.title = text.substring(2);
+                    }
+                    else if (!info.metadata.artist) {
+                        info.metadata.artist = text.substring(2);
+                    }
+                }
+            }
+            else if (event.type === 'lyrics' && 'text' in event) {
+                trackInfo.hasLyrics = true;
+                trackInfo.textEvents.push(event.text);
+            }
+            else if (event.type === 'unknownMeta' && 'data' in event) {
+                // Handle TIS-620 encoded text events
+                const data = event.data;
+                if (data && data.length > 0) {
+                    try {
+                        const buffer = Buffer.from(data);
+                        const text = iconv.decode(buffer, 'tis-620');
+                        trackInfo.hasText = true;
+                        trackInfo.textEvents.push(text);
+                        if (text.startsWith('@T')) {
+                            if (!info.metadata.title) {
+                                info.metadata.title = text.substring(2);
+                            }
+                            else if (!info.metadata.artist) {
+                                info.metadata.artist = text.substring(2);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Ignore decode errors
+                    }
+                }
+            }
+        }
+        // Identify special tracks
+        if (trackInfo.name === 'Words') {
+            info.metadata.hasKaraokeTrack = true;
+        }
+        else if (trackInfo.name === 'Lyric') {
+            info.metadata.hasLyricTrack = true;
+        }
+        else if (trackInfo.name === 'SongTitle' && trackInfo.textEvents.length > 0) {
+            info.metadata.title = trackInfo.textEvents[0];
+        }
+        else if (trackInfo.name === 'Artist' && trackInfo.textEvents.length > 0) {
+            info.metadata.artist = trackInfo.textEvents[0];
+        }
+        info.tracks.push(trackInfo);
+    }
+    return info;
+}
+/**
+ * Validates that a KAR file has the expected structure
+ */
+function validateKarFile(filePath) {
+    const errors = [];
+    const warnings = [];
+    try {
+        const info = readKarFile(filePath);
+        // Check basic structure
+        if (!info.header.ticksPerBeat) {
+            errors.push('Missing ticksPerBeat in header');
+        }
+        if (info.tracks.length === 0) {
+            errors.push('No tracks found in file');
+        }
+        // Check for karaoke tracks
+        if (!info.metadata.hasKaraokeTrack) {
+            warnings.push('No "Words" karaoke track found');
+        }
+        if (!info.metadata.hasLyricTrack) {
+            warnings.push('No "Lyric" track found');
+        }
+        if (!info.metadata.title) {
+            warnings.push('No title metadata found');
+        }
+        if (!info.metadata.artist) {
+            warnings.push('No artist metadata found');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    catch (error) {
+        errors.push(`Failed to read KAR file: ${error.message}`);
+        return {
+            valid: false,
+            errors,
+            warnings
+        };
+    }
+}
+/**
+ * Extracts lyrics from a KAR file
+ */
+function extractLyricsFromKar(filePath) {
+    const info = readKarFile(filePath);
+    const lyrics = [];
+    for (const track of info.tracks) {
+        if (track.name === 'Words' || track.hasText) {
+            for (const text of track.textEvents) {
+                // Skip metadata markers
+                if (!text.startsWith('@')) {
+                    lyrics.push(text);
+                }
+            }
+        }
+    }
+    return lyrics;
+}

package/dist/ncntokar.browser.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Browser-compatible NCN to KAR converter
+ * Works with File API and ArrayBuffers instead of fs
+ */
+export interface BrowserConversionOptions {
+    midiBuffer: Buffer;
+    lyricBuffer: Buffer;
+    cursorBuffer: Buffer;
+    outputFileName?: string;
+}
+export interface BrowserConversionResult {
+    success: boolean;
+    karBuffer: Buffer;
+    fileName: string;
+    metadata: {
+        title: string;
+        artist: string;
+        fullLyric: string;
+        lines: string[];
+    };
+    warnings: string[];
+}
+/**
+ * Reads text from buffer as TIS-620 (Thai encoding)
+ */
+export declare function readBufferTextTIS620(buffer: Buffer): 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 createMetaEvent(subtype: string, deltaTime: number, text: string): any;
+/**
+ * Creates an end-of-track MIDI event
+ */
+export declare function createEndOfTrack(deltaTime?: number): any;
+/**
+ * Simple cursor reader for browser
+ */
+export declare class BrowserCursorReader {
+    private buf;
+    private off;
+    constructor(buf: Buffer);
+    readU16LE(): number | null;
+    readU8(): number | null;
+    remaining(): number;
+}
+/**
+ * Parses lyric buffer to extract metadata (title, artist, lyrics)
+ */
+export declare function parseLyricBuffer(lyricBuffer: Buffer): {
+    title: string;
+    artist: string;
+    fullLyric: string;
+    lines: string[];
+};
+/**
+ * Builds karaoke track with timing information (browser version)
+ */
+export declare function buildKaraokeTrackBrowser(metadata: {
+    title: string;
+    artist: string;
+    fullLyric: string;
+    lines: string[];
+}, cursorBuffer: Buffer, ticksPerBeat: number): {
+    track: any[];
+    warnings: string[];
+};
+/**
+ * Builds additional metadata tracks (Lyric, Artist, SongTitle)
+ */
+export declare function buildMetadataTracksBrowser(metadata: {
+    title: string;
+    artist: string;
+    fullLyric: string;
+}): {
+    lyricTrack: any[];
+    artistTrack: any[];
+    titleTrack: any[];
+};
+/**
+ * Browser-compatible NCN to KAR conversion
+ * Works with buffers instead of file paths
+ */
+export declare function convertNcnToKarBrowser(options: BrowserConversionOptions): BrowserConversionResult;
+/**
+ * Helper to convert File to Buffer for browser use
+ */
+export declare function fileToBuffer(file: File): Promise<Buffer>;
+/**
+ * Helper to download buffer as file in browser
+ */
+export declare function downloadBuffer(buffer: Buffer, fileName: string, mimeType?: string): void;