lyrics-ime-typing-engine 1.0.1

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 toshi7878
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

package/dist/build/build-map-lines.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltImeLine, Options, RawMapLine } from "../type";
+export declare const buildImeLines: (mapData: RawMapLine[], options: Options) => Promise<BuiltImeLine[]>;

package/dist/build/build-map-lines.js

@@ -0,0 +1,59 @@
+import { normalizeTypingText } from "../normalize-word";
+import { zip } from "../utils/array";
+export const buildImeLines = async (mapData, options) => {
+    const { minLineDuration = 5 } = options;
+    let lineWords = [];
+    let lineTimes = [];
+    const lines = [];
+    for (const [i, currentLine] of mapData.entries()) {
+        const nextLine = mapData[i + 1];
+        const nextToNextLine = mapData[i + 2];
+        const normalizedTypingLyrics = normalizeTypingText(deleteRubyTag(currentLine.lyrics), options);
+        const isTypingLine = isValidTypingLine(normalizedTypingLyrics, currentLine.word);
+        if (isTypingLine) {
+            lineWords.push(normalizedTypingLyrics);
+            lineTimes.push(Number(currentLine.time));
+        }
+        const shouldBreakLine = shouldCreateNewLine(lineWords, minLineDuration, nextLine, getNextTime(nextLine, nextToNextLine), lineTimes);
+        if (shouldBreakLine) {
+            const lastTime = nextLine ? Number(nextLine.time) : Number(currentLine.time) + 10; // 次の行がない場合は10秒後
+            const WordsWithTimes = zip(lineTimes, lineWords).map(([time, word], index) => {
+                const nextTime = lineTimes[index + 1];
+                return {
+                    startTime: time,
+                    word,
+                    endTime: nextTime ? nextTime : lastTime,
+                };
+            });
+            lines.push(WordsWithTimes);
+            lineWords = [];
+            lineTimes = [];
+        }
+    }
+    console.log(lines);
+    return lines;
+};
+const isValidTypingLine = (formattedLyrics, word) => {
+    return formattedLyrics !== "" && formattedLyrics !== "end" && word.replace(/\s/g, "") !== "";
+};
+const getNextTime = (nextLine, lineAfterNext) => {
+    if (!nextLine)
+        return 0;
+    return lineAfterNext && nextLine.word.replace(/\s/g, "") === "" ? Number(lineAfterNext.time) : Number(nextLine.time);
+};
+const shouldCreateNewLine = (lineChars, minLineDuration, nextLine, nextTime, lineTimes) => {
+    return lineChars.length > 0 && (!nextLine || minLineDuration < nextTime - (lineTimes?.[0] ?? 0));
+};
+const deleteRubyTag = (text) => {
+    const rubyMatches = text.match(/<*ruby(?: .+?)?>.*?<.*?\/ruby*>/g);
+    if (!rubyMatches)
+        return text;
+    let result = text;
+    for (const rubyTag of rubyMatches) {
+        const start = rubyTag.indexOf(">") + 1;
+        const end = rubyTag.indexOf("<rt>");
+        const rubyText = rubyTag.slice(start, end);
+        result = result.replace(rubyTag, rubyText);
+    }
+    return result;
+};

package/dist/build/build-words.d.ts

@@ -0,0 +1,7 @@
+import type { BuiltImeLine } from "../type";
+export declare const buildImeWords: (lines: BuiltImeLine[], generateLyricsWithReadings: (comparisonLyrics: string[][]) => Promise<{
+    lyrics: string[];
+    readings: string[];
+}>, { insertEnglishSpaces }: {
+    insertEnglishSpaces?: boolean;
+}) => Promise<string[][][][]>;

package/dist/build/build-words.js

@@ -0,0 +1,60 @@
+import { zip } from "../utils/array";
+export const buildImeWords = async (lines, generateLyricsWithReadings, { insertEnglishSpaces = false }) => {
+    const comparisonLyrics = lines.map((line) => {
+        const lyrics = line.flatMap((chunk) => chunk.word.split(" ")).filter((char) => char !== "");
+        if (insertEnglishSpaces) {
+            return insertSpacesEng(lyrics);
+        }
+        return lyrics;
+    });
+    const lyricsWithReadings = await generateLyricsWithReadings(comparisonLyrics);
+    return mergeWordsWithReadingReplacements({ lyricsWithReadings, comparisonLyrics });
+};
+const insertSpacesEng = (words) => {
+    const insertedSpaceWords = words;
+    for (const [i, currentWord] of insertedSpaceWords.entries()) {
+        const isCurrentWordAllHankaku = /^[!-~]*$/.test(currentWord);
+        const nextWord = insertedSpaceWords[i + 1];
+        if (isCurrentWordAllHankaku && nextWord && nextWord[0]) {
+            if (/^[!-~]*$/.test(nextWord[0])) {
+                insertedSpaceWords[i] = insertedSpaceWords[i] + " ";
+            }
+        }
+    }
+    return insertedSpaceWords;
+};
+const mergeWordsWithReadingReplacements = ({ lyricsWithReadings, comparisonLyrics, }) => {
+    const repl = parseRepl(lyricsWithReadings);
+    // 第1段階: 文字列内の漢字をプレースホルダーに置換
+    const markedLyrics = comparisonLyrics.map((lyrics) => lyrics.map((lyric) => {
+        let marked = lyric;
+        if (/[一-龥]/.test(lyric)) {
+            for (const [m, replItem] of repl.entries()) {
+                marked = marked.replace(RegExp(replItem[0] ?? "", "g"), `\t@@${m}@@\t`);
+            }
+        }
+        return marked;
+    }));
+    // 第2段階: プレースホルダーを読み配列に変換
+    const result = markedLyrics.map((lyrics) => lyrics.map((lyric) => {
+        const tokens = lyric.split("\t").filter((x) => x !== "");
+        return tokens.map((token) => {
+            if (token.slice(0, 2) === "@@" && token.slice(-2) === "@@") {
+                const index = parseFloat(token.slice(2));
+                const replItem = repl[index];
+                return replItem ?? [token];
+            }
+            return [token];
+        });
+    }));
+    return result;
+};
+const parseRepl = (tokenizedWords) => {
+    const repl = new Set();
+    for (const [lyric, reading] of zip(tokenizedWords.lyrics, tokenizedWords.readings)) {
+        if (/[一-龥]/.test(lyric)) {
+            repl.add([lyric, reading]);
+        }
+    }
+    return Array.from(repl).sort((a, b) => (b[0]?.length ?? 0) - (a[0]?.length ?? 0));
+};

package/dist/build/modules.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltImeWord, WordResult } from "../type";
+export declare const getTotalNotes: (words: BuiltImeWord[]) => number;
+export declare const createFlatWords: (words: BuiltImeWord[]) => string[];
+export declare const createInitWordResults: (flatWords: string[]) => WordResult[];

package/dist/build/modules.js

@@ -0,0 +1,14 @@
+export const getTotalNotes = (words) => {
+    return words.flat(2).reduce((acc, word) => acc + (word?.[0]?.length ?? 0), 0);
+};
+export const createFlatWords = (words) => {
+    return words.flat(1).map((word) => {
+        return word.map((chars) => chars[0]).join("");
+    });
+};
+export const createInitWordResults = (flatWords) => {
+    return Array.from({ length: flatWords.length }, () => ({
+        inputs: [],
+        evaluation: "Skip",
+    }));
+};

package/dist/evaluete/evaluate-ime-input.d.ts

@@ -0,0 +1,18 @@
+import type { Options, WordResult } from "../type";
+type EvaluateInputResult = {
+    wordResultUpdates: Array<{
+        index: number;
+        result: WordResult;
+    }>;
+    nextWordIndex?: number;
+    typeCountDelta: number;
+    typeCountStatsDelta: number;
+    notificationsToAppend: string[];
+};
+export declare const evaluateImeInput: (input: string, typingWord: {
+    expectedWords: string[][][];
+    currentWordIndex: number;
+}, wordResults: WordResult[], map: {
+    flatWords: string[];
+}, options: Omit<Options, "minLineDuration">) => EvaluateInputResult;
+export {};

package/dist/evaluete/evaluate-ime-input.js

@@ -0,0 +1,143 @@
+import { normalizeTypingText } from "../normalize-word";
+import { kanaToHira } from "../utils/string";
+export const evaluateImeInput = (input, typingWord, wordResults, map, options) => {
+    let remainingInput = normalizeInputText(input, options);
+    const wordResultUpdates = [];
+    const notificationsToAppend = [];
+    let nextWordIndex;
+    let typeCountDelta = 0;
+    let typeCountStatsDelta = 0;
+    const { currentWordIndex, expectedWords } = typingWord;
+    if (currentWordIndex >= map.flatWords.length) {
+        return {
+            wordResultUpdates,
+            nextWordIndex,
+            typeCountDelta,
+            typeCountStatsDelta,
+            notificationsToAppend,
+        };
+    }
+    for (const [i, targetWords] of expectedWords.entries()) {
+        if (i < currentWordIndex)
+            continue;
+        if (!remainingInput)
+            break;
+        const correct = evaluateInputAgainstTarget(remainingInput, targetWords);
+        if (correct.evaluation === "None") {
+            const prevEvaluation = wordResults[i - 1]?.evaluation;
+            const isPrevFailure = prevEvaluation === "None" || prevEvaluation === "Skip";
+            const currentResult = wordResults[i];
+            if (!currentResult)
+                continue;
+            const result = isPrevFailure
+                ? { inputs: [], evaluation: "Skip" }
+                : { inputs: [...currentResult.inputs, remainingInput], evaluation: "None" };
+            wordResultUpdates.push({ index: i, result });
+            wordResults[i] = result;
+            continue;
+        }
+        const prevResultEntry = [...wordResults.entries()]
+            .reverse()
+            .find(([index, result]) => i > index && result.evaluation !== "Skip");
+        const [prevIndex, prevResult] = prevResultEntry ?? [];
+        if (prevIndex !== undefined && prevResult?.evaluation === "None") {
+            const fixedText = getBeforeTarget(prevResult.inputs[prevResult.inputs.length - 1] ?? "", correct.correcting);
+            const result = {
+                evaluation: "None",
+                inputs: [...prevResult.inputs.slice(0, -1), fixedText].filter((v) => v !== ""),
+            };
+            wordResultUpdates.push({ index: prevIndex, result });
+            wordResults[prevIndex] = result;
+        }
+        const lyricsIndex = remainingInput.indexOf(correct.correcting);
+        remainingInput = remainingInput.slice(lyricsIndex + correct.correcting.length);
+        {
+            const result = { inputs: [correct.correcting], evaluation: correct.evaluation };
+            wordResultUpdates.push({ index: i, result });
+            wordResults[i] = result;
+        }
+        const joinedJudgeWord = targetWords.map((chars) => chars[0]).join("");
+        const isGood = correct.evaluation === "Good";
+        const wordTypeCount = joinedJudgeWord.length / (isGood ? 1.5 : 1);
+        nextWordIndex = i + 1;
+        typeCountDelta += wordTypeCount;
+        typeCountStatsDelta += Math.round(wordTypeCount);
+        notificationsToAppend.push(`${i}: ${correct.evaluation}! ${correct.correcting}`);
+    }
+    return {
+        wordResultUpdates,
+        nextWordIndex,
+        typeCountDelta,
+        typeCountStatsDelta,
+        notificationsToAppend,
+    };
+};
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& はマッチした部分文字列を示します
+}
+function evaluateInputAgainstTarget(input, targetWords) {
+    let evaluation = "Great";
+    let correcting = "";
+    let reSearchFlag = false;
+    let remainingInput = input;
+    for (const [i, judgedWord] of targetWords.entries()) {
+        for (const [m, target] of judgedWord.entries()) {
+            let search = remainingInput.search(escapeRegExp(target));
+            // Great判定
+            if (m === 0) {
+                if (i === 0 && search > 0) {
+                    remainingInput = remainingInput.slice(search);
+                    search = 0;
+                }
+                if (search === 0) {
+                    correcting += target;
+                    remainingInput = remainingInput.slice(target.length);
+                    break;
+                }
+            }
+            if (search > 0 && correcting) {
+                reSearchFlag = true;
+            }
+            // 最後の候補でGood/None判定
+            if (m === judgedWord.length - 1) {
+                const commentHira = kanaToHira(remainingInput.toLowerCase());
+                const targetHira = kanaToHira(target.toLowerCase());
+                let replSearch = commentHira.search(escapeRegExp(targetHira));
+                if (i === 0 && replSearch > 0) {
+                    remainingInput = remainingInput.slice(replSearch);
+                    replSearch = 0;
+                }
+                if (replSearch > 0 && i && correcting) {
+                    reSearchFlag = true;
+                }
+                if (replSearch === 0) {
+                    correcting += remainingInput.slice(0, target.length);
+                    remainingInput = remainingInput.slice(target.length);
+                    evaluation = "Good";
+                    break;
+                }
+                if (reSearchFlag) {
+                    // 再帰的に再判定
+                    return evaluateInputAgainstTarget(remainingInput, targetWords);
+                }
+                return { correcting, evaluation: "None", currentComment: remainingInput };
+            }
+        }
+    }
+    return { correcting, evaluation, currentComment: remainingInput };
+}
+const normalizeInputText = (text, options) => {
+    let normalizedText = text;
+    normalizedText = normalizeTypingText(normalizedText, options);
+    //全角の前後のスペースを削除
+    normalizedText = normalizedText.replace(/(\s+)([^!-~])/g, "$2").replace(/([^!-~])(\s+)/g, "$1");
+    //テキストの末尾が半角ならば末尾に半角スペース追加
+    if (/[!-~]$/.test(normalizedText)) {
+        normalizedText = normalizedText + " ";
+    }
+    return normalizedText;
+};
+function getBeforeTarget(str, target) {
+    const index = str.indexOf(target);
+    return index !== -1 ? str.slice(0, index) : "";
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { buildImeLines } from "./build/build-map-lines";
+export { buildImeWords } from "./build/build-words";
+export { createFlatWords, createInitWordResults, getTotalNotes } from "./build/modules";
+export { evaluateImeInput } from "./evaluete/evaluate-ime-input";
+export { getExpectedWords } from "./timer/get-expected-word";
+export type { BuiltImeLine, BuiltImeWord, Options, RawMapLine, WordResult, } from "./type";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { buildImeLines } from "./build/build-map-lines";
+export { buildImeWords } from "./build/build-words";
+export { createFlatWords, createInitWordResults, getTotalNotes } from "./build/modules";
+export { evaluateImeInput } from "./evaluete/evaluate-ime-input";
+export { getExpectedWords } from "./timer/get-expected-word";

package/dist/normalize-word.d.ts

@@ -0,0 +1,5 @@
+export declare const normalizeTypingText: (text: string, options: {
+    isCaseSensitive: boolean;
+    includeRegexPattern: string;
+    enableIncludeRegex: boolean;
+}) => string;

package/dist/normalize-word.js

@@ -0,0 +1,48 @@
+const REGEX_LIST = ["^-ぁ-んゔ", "ァ-ンヴ", "一-龥", "\\w", "\\d", " ", "々%&@&=+ー～~\u00C0-\u00FF"];
+const HANGUL = ["\uAC00-\uD7AF\u1100-\u11FF\u3130-\u318F\uFFA0-\uFFDC\uFFA0-\uFFDC"];
+const CYRILLIC_ALPHABET = ["\u0400-\u04FF"];
+const LYRICS_FORMAT_REGEX = REGEX_LIST.concat(HANGUL).concat(CYRILLIC_ALPHABET); // TODO: .concat(this.customRegex);
+const FILTER_SYMBOLS = "×";
+export const normalizeTypingText = (text, options) => {
+    let normalizedText = text;
+    normalizedText = normalizedText.replace(/<[^>]*?style>[\s\S]*?<[^>]*?\/style[^>]*?>/g, ""); //styleタグ全体削除
+    normalizedText = normalizedText.replace(/[（(].*?[)）]/g, ""); //()（）の歌詞を削除
+    normalizedText = normalizedText.replace(/<[^>]*>(.*?)<[^>]*?\/[^>]*>/g, "$1"); //HTMLタグの中の文字を取り出す
+    normalizedText = normalizedText.replace(/<[^>]*>/, "");
+    normalizedText = normalizeSymbols(normalizedText);
+    if (options.isCaseSensitive) {
+        normalizedText = normalizedText.normalize("NFKC");
+    }
+    else {
+        normalizedText = normalizedText.normalize("NFKC").toLowerCase();
+    }
+    // アルファベットと全角文字の間にスペースを追加
+    normalizedText = normalizedText.replace(/([a-zA-Z])([ぁ-んゔァ-ンヴ一-龥])/g, "$1 $2"); // アルファベットの後に日本語文字がある場合
+    normalizedText = normalizedText.replace(/([ぁ-んゔァ-ンヴ一-龥])([a-zA-Z])/g, "$1 $2"); // 日本語文字の後にアルファベットがある場合
+    normalizedText = normalizedText.replace(new RegExp(FILTER_SYMBOLS, "g"), ""); //記号削除 TODO: ホワイトリストに含まれる機能はFILTERしない
+    if (options.enableIncludeRegex) {
+        normalizedText = normalizedText.replace(new RegExp(`[${LYRICS_FORMAT_REGEX.concat([options.includeRegexPattern.replace(/./g, "\\$&")]).join("")}]`, "g"), ""); //regexListに含まれていない文字を削除
+    }
+    else {
+        normalizedText = normalizedText.replace(new RegExp(`[${LYRICS_FORMAT_REGEX.join("")}]`, "g"), ""); //regexListに含まれていない文字を削除
+    }
+    return normalizedText;
+};
+const normalizeSymbols = (text) => {
+    return text
+        .replaceAll("…", "...")
+        .replaceAll("‥", "..")
+        .replaceAll("･", "・")
+        .replaceAll("“", '"')
+        .replaceAll("”", '"')
+        .replaceAll("’", "'")
+        .replaceAll("〜", "～")
+        .replaceAll("｢", "「")
+        .replaceAll("｣", "」")
+        .replaceAll("､", "、")
+        .replaceAll("｡", "。")
+        .replaceAll("－", "ー")
+        .replaceAll("　", " ")
+        .replaceAll(/ {2,}/g, " ")
+        .trim();
+};

package/dist/timer/get-expected-word.d.ts

@@ -0,0 +1,2 @@
+import { BuiltImeWord } from "../type";
+export declare const getExpectedWords: (count: number, words: BuiltImeWord[]) => string[][][];

package/dist/timer/get-expected-word.js

@@ -0,0 +1,3 @@
+export const getExpectedWords = (count, words) => {
+    return words.slice(0, count).flat(1);
+};

package/dist/type.d.ts

@@ -0,0 +1,22 @@
+export interface RawMapLine<TOptions = unknown> {
+    time: string | number;
+    lyrics: string;
+    word: string;
+    options?: TOptions;
+}
+export type BuiltImeLine = {
+    startTime: number;
+    word: string;
+    endTime: number;
+}[];
+export type BuiltImeWord = string[][][];
+export type WordResult = {
+    inputs: string[];
+    evaluation: "Great" | "Good" | "Skip" | "None";
+};
+export type Options = {
+    minLineDuration?: number;
+    isCaseSensitive: boolean;
+    includeRegexPattern: string;
+    enableIncludeRegex: boolean;
+};

package/dist/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/array.d.ts

@@ -0,0 +1 @@
+export declare const zip: <T, U>(arr1: T[], arr2: U[]) => [T, U][];

package/dist/utils/array.js

@@ -0,0 +1,5 @@
+export const zip = (arr1, arr2) => {
+    const length = Math.min(arr1.length, arr2.length);
+    // biome-ignore lint/style/noNonNullAssertion: <lengthが同じ前提>
+    return Array.from({ length }, (_, i) => [arr1[i], arr2[i]]);
+};

package/dist/utils/string.d.ts

@@ -0,0 +1 @@
+export declare const kanaToHira: (text: string) => string;

package/dist/utils/string.js

@@ -0,0 +1,11 @@
+export const kanaToHira = (text) => {
+    return text
+        .replaceAll(/[\u30A1-\u30F6]/g, (match) => {
+        const codePoint = match.codePointAt(0);
+        if (codePoint === undefined)
+            return match;
+        const chr = codePoint - 0x60;
+        return String.fromCodePoint(chr);
+    })
+        .replaceAll("ヴ", "ゔ");
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "lyrics-ime-typing-engine",
+  "description": "A typing engine designed for music-based typing games. Provides time-tagged typing map generation and kana/roma input evaluation synchronized with music playback.",
+  "version": "1.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "keywords": [],
+  "author": "toshi7878",
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.7",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Toshi7878/lyrics-ime-typing-engine",
+    "directory": "lyrics-ime-typing-engine"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "biome check --diagnostic-level=warn --reporter=summary",
+    "check:fix": "biome check --diagnostic-level=warn --reporter=summary --write",
+    "typecheck": "tsc --noEmit",
+    "upload": "pnpm build && pnpm publish",
+    "version:patch": "pnpm version patch",
+    "version:minor": "pnpm version minor",
+    "version:major": "pnpm version major",
+    "push:tags": "git push --follow-tags"
+  }
+}