typengine 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shuhei Akutagawa
+
+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/README.md

@@ -0,0 +1,34 @@
+# Typengine
+
+Core library for building typing apps/games on any JavaScript runtime.
+
+## Usage (draft)
+
+```ts
+import { Sentence, createJapaneseSentenceDefinition } from "typengine";
+
+const definition = createJapaneseSentenceDefinition("寿司", "すし");
+const sentence = new Sentence(definition);
+
+sentence.input("s");
+sentence.input("u");
+sentence.input("s");
+const result = sentence.input("i");
+// result example:
+// {
+//   accepted: boolean; // whether this keystroke was accepted
+// }
+```
+
+```ts
+import { Session, Sentence, createJapaneseSentenceDefinition } from "typengine";
+
+const sentences = [
+  new Sentence(createJapaneseSentenceDefinition("寿司", "すし")),
+  new Sentence(createJapaneseSentenceDefinition("天ぷら", "てんぷら")),
+];
+
+const session = new Session(sentences);
+session.start();
+session.input("s");
+```

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+//#region lib/input.d.ts
+
+type InputResult = {
+  accepted: boolean;
+};
+//#endregion
+//#region lib/types.d.ts
+type CharacterDefinition = {
+  reading: string;
+  patterns: string[];
+};
+type SentenceDefinition = {
+  text: string;
+  reading: string;
+  characters: CharacterDefinition[];
+};
+//#endregion
+//#region lib/character.d.ts
+type CharacterOptions = {
+  onCharacterStarted?: (payload: {
+    startedAt: number;
+  }) => void;
+  onCharacterTyped?: (payload: {
+    typedAt: number;
+    key: string;
+  }) => void;
+  onCharacterMistyped?: (payload: {
+    typedAt: number;
+    key: string;
+  }) => void;
+  onCharacterCompleted?: (payload: {
+    completedAt: number;
+  }) => void;
+};
+declare class Character {
+  readonly definition: CharacterDefinition;
+  private readonly options;
+  private state;
+  constructor(definition: CharacterDefinition, options?: CharacterOptions);
+  start(): void;
+  input(value: string): InputResult;
+  get typed(): string;
+  get remainingPatterns(): string[];
+  get previewPattern(): string;
+  get completed(): boolean;
+}
+//#endregion
+//#region lib/sentence.d.ts
+type SentenceOptions = {
+  onSentenceStarted?: (payload: {
+    startedAt: number;
+  }) => void;
+  onSentenceCompleted?: (payload: {
+    completedAt: number;
+  }) => void;
+  onCharacterStarted?: (payload: {
+    startedAt: number;
+  }) => void;
+  onCharacterTyped?: (payload: {
+    typedAt: number;
+    key: string;
+  }) => void;
+  onCharacterMistyped?: (payload: {
+    typedAt: number;
+    key: string;
+  }) => void;
+  onCharacterCompleted?: (payload: {
+    completedAt: number;
+  }) => void;
+};
+declare class Sentence {
+  readonly definition: SentenceDefinition;
+  private readonly characters;
+  private readonly options;
+  constructor(definition: SentenceDefinition, options?: SentenceOptions);
+  start(): void;
+  input(value: string): InputResult;
+  get typed(): string;
+  get currentCharacter(): Character | null;
+  get position(): number;
+  get completed(): boolean;
+  get previewPattern(): string;
+  get text(): string;
+  get reading(): string;
+}
+//#endregion
+//#region lib/session.d.ts
+type SessionOptions = {
+  onSessionStarted?: (payload: {
+    startedAt: number;
+  }) => void;
+  onSessionCompleted?: (payload: {
+    completedAt: number;
+  }) => void;
+};
+type SessionInputResult = {
+  accepted: boolean;
+};
+declare class Session {
+  readonly sentences: Sentence[];
+  private readonly options;
+  constructor(sentences: Sentence[], options?: SessionOptions);
+  start(): void;
+  input(value: string): SessionInputResult;
+  get currentSentence(): Sentence | null;
+  get position(): number;
+  get completed(): boolean;
+}
+//#endregion
+//#region lib/createJapaneseSentenceDefinition.d.ts
+declare const createJapaneseSentenceDefinition: (text: string, reading: string) => SentenceDefinition;
+//#endregion
+export { Character, type CharacterDefinition, type CharacterOptions, type InputResult, Sentence, type SentenceDefinition, type SentenceOptions, Session, type SessionInputResult, type SessionOptions, createJapaneseSentenceDefinition };

package/dist/index.js

@@ -0,0 +1,492 @@
+//#region lib/input.ts
+const input = (state, value) => {
+	if (state.remainingPatterns.some((pattern) => pattern.length === 0)) return { accepted: false };
+	const nextPatterns = state.remainingPatterns.filter((pattern) => pattern.startsWith(value)).map((pattern) => pattern.slice(value.length));
+	if (nextPatterns.length === 0) return { accepted: false };
+	state.remainingPatterns = nextPatterns;
+	state.typedValue += value;
+	return { accepted: true };
+};
+
+//#endregion
+//#region lib/character.ts
+var Character = class {
+	definition;
+	options;
+	state;
+	constructor(definition, options = {}) {
+		this.definition = definition;
+		this.options = options;
+		this.state = {
+			remainingPatterns: [...definition.patterns],
+			typedValue: ""
+		};
+	}
+	start() {
+		this.options.onCharacterStarted?.({ startedAt: Date.now() });
+	}
+	input(value) {
+		const result = input(this.state, value);
+		const typedAt = Date.now();
+		if (!result.accepted) {
+			this.options.onCharacterMistyped?.({
+				typedAt,
+				key: value
+			});
+			return result;
+		}
+		this.options.onCharacterTyped?.({
+			typedAt,
+			key: value
+		});
+		if (this.completed) this.options.onCharacterCompleted?.({ completedAt: typedAt });
+		return result;
+	}
+	get typed() {
+		return this.state.typedValue;
+	}
+	get remainingPatterns() {
+		return [...this.state.remainingPatterns];
+	}
+	get previewPattern() {
+		const [pattern] = this.state.remainingPatterns;
+		return `${this.state.typedValue}${pattern ?? ""}`;
+	}
+	get completed() {
+		return this.state.remainingPatterns.some((pattern) => pattern.length === 0);
+	}
+};
+
+//#endregion
+//#region lib/sentence.ts
+var Sentence = class {
+	definition;
+	characters;
+	options;
+	constructor(definition, options = {}) {
+		this.definition = definition;
+		this.options = options;
+		const characterOptions = {
+			onCharacterStarted: options.onCharacterStarted,
+			onCharacterTyped: options.onCharacterTyped,
+			onCharacterMistyped: options.onCharacterMistyped,
+			onCharacterCompleted: options.onCharacterCompleted
+		};
+		this.characters = definition.characters.map((character) => new Character(character, characterOptions));
+	}
+	start() {
+		const current = this.currentCharacter;
+		if (!current) throw new Error("Cannot start an empty sentence.");
+		this.options.onSentenceStarted?.({ startedAt: Date.now() });
+		current.start();
+	}
+	input(value) {
+		const current = this.currentCharacter;
+		if (!current) throw new Error("Cannot input to a completed sentence.");
+		const result = current.input(value);
+		if (!result.accepted) return result;
+		if (!current.completed) return result;
+		const next = this.currentCharacter;
+		if (next) {
+			next.start();
+			return result;
+		}
+		this.options.onSentenceCompleted?.({ completedAt: Date.now() });
+		return result;
+	}
+	get typed() {
+		return this.characters.map((character) => character.typed).join("");
+	}
+	get currentCharacter() {
+		return this.characters[this.position] ?? null;
+	}
+	get position() {
+		for (let index = 0; index < this.characters.length; index += 1) if (!this.characters[index].completed) return index;
+		return -1;
+	}
+	get completed() {
+		return this.position < 0;
+	}
+	get previewPattern() {
+		return this.characters.map((character) => character.previewPattern).join("");
+	}
+	get text() {
+		return this.definition.text;
+	}
+	get reading() {
+		return this.definition.reading;
+	}
+};
+
+//#endregion
+//#region lib/session.ts
+var Session = class {
+	sentences;
+	options;
+	constructor(sentences, options = {}) {
+		if (sentences.length === 0) throw new Error("Session requires at least one sentence.");
+		this.sentences = sentences;
+		this.options = options;
+	}
+	start() {
+		const current = this.currentSentence;
+		if (!current) throw new Error("Cannot start a completed session.");
+		this.options.onSessionStarted?.({ startedAt: Date.now() });
+		current.start();
+	}
+	input(value) {
+		const current = this.currentSentence;
+		if (!current) throw new Error("Cannot input to a completed session.");
+		const result = current.input(value);
+		if (!result.accepted) return result;
+		if (!current.completed) return result;
+		const next = this.currentSentence;
+		if (next) {
+			next.start();
+			return result;
+		}
+		this.options.onSessionCompleted?.({ completedAt: Date.now() });
+		return result;
+	}
+	get currentSentence() {
+		return this.sentences[this.position] ?? null;
+	}
+	get position() {
+		for (let index = 0; index < this.sentences.length; index += 1) if (!this.sentences[index].completed) return index;
+		return -1;
+	}
+	get completed() {
+		return this.position < 0;
+	}
+};
+
+//#endregion
+//#region lib/createJapaneseSentenceDefinition.ts
+const KANA_ROMAJI_MAP = {
+	あ: ["a"],
+	い: ["i"],
+	う: ["u"],
+	え: ["e"],
+	お: ["o"],
+	か: ["ka"],
+	き: ["ki"],
+	く: ["ku"],
+	け: ["ke"],
+	こ: ["ko"],
+	さ: ["sa"],
+	し: ["shi", "si"],
+	す: ["su"],
+	せ: ["se"],
+	そ: ["so"],
+	た: ["ta"],
+	ち: ["chi", "ti"],
+	つ: ["tsu", "tu"],
+	て: ["te"],
+	と: ["to"],
+	な: ["na"],
+	に: ["ni"],
+	ぬ: ["nu"],
+	ね: ["ne"],
+	の: ["no"],
+	は: ["ha"],
+	ひ: ["hi"],
+	ふ: ["fu", "hu"],
+	へ: ["he"],
+	ほ: ["ho"],
+	ま: ["ma"],
+	み: ["mi"],
+	む: ["mu"],
+	め: ["me"],
+	も: ["mo"],
+	や: ["ya"],
+	ゆ: ["yu"],
+	よ: ["yo"],
+	ら: ["ra"],
+	り: ["ri"],
+	る: ["ru"],
+	れ: ["re"],
+	ろ: ["ro"],
+	わ: ["wa"],
+	を: ["wo", "o"],
+	ん: ["n"],
+	が: ["ga"],
+	ぎ: ["gi"],
+	ぐ: ["gu"],
+	げ: ["ge"],
+	ご: ["go"],
+	ざ: ["za"],
+	じ: ["ji", "zi"],
+	ず: ["zu"],
+	ぜ: ["ze"],
+	ぞ: ["zo"],
+	だ: ["da"],
+	ぢ: ["ji", "di"],
+	づ: ["zu", "du"],
+	で: ["de"],
+	ど: ["do"],
+	ば: ["ba"],
+	び: ["bi"],
+	ぶ: ["bu"],
+	べ: ["be"],
+	ぼ: ["bo"],
+	ぱ: ["pa"],
+	ぴ: ["pi"],
+	ぷ: ["pu"],
+	ぺ: ["pe"],
+	ぽ: ["po"],
+	きゃ: [
+		"kya",
+		"kilya",
+		"kixya"
+	],
+	きゅ: [
+		"kyu",
+		"kilyu",
+		"kixyu"
+	],
+	きょ: [
+		"kyo",
+		"kilyo",
+		"kixyo"
+	],
+	ぎゃ: [
+		"gya",
+		"gilya",
+		"gixya"
+	],
+	ぎゅ: [
+		"gyu",
+		"gilyu",
+		"gixyu"
+	],
+	ぎょ: [
+		"gyo",
+		"gilyo",
+		"gixyo"
+	],
+	しゃ: [
+		"sha",
+		"sya",
+		"shilya",
+		"shixya",
+		"silya",
+		"sixya"
+	],
+	しゅ: [
+		"shu",
+		"syu",
+		"shilyu",
+		"shixyu",
+		"silyu",
+		"sixyu"
+	],
+	しょ: [
+		"sho",
+		"syo",
+		"shilyo",
+		"shixyo",
+		"silyo",
+		"sixyo"
+	],
+	じゃ: [
+		"ja",
+		"jya",
+		"zya",
+		"jilya",
+		"jixya",
+		"zilya",
+		"zixya"
+	],
+	じゅ: [
+		"ju",
+		"jyu",
+		"zyu",
+		"jilyu",
+		"jixyu",
+		"zilyu",
+		"zixyu"
+	],
+	じょ: [
+		"jo",
+		"jyo",
+		"zyo",
+		"jilyo",
+		"jixyo",
+		"zilyo",
+		"zixyo"
+	],
+	ちゃ: [
+		"cha",
+		"cya",
+		"tya",
+		"chilya",
+		"chixya",
+		"tilya",
+		"tixya"
+	],
+	ちゅ: [
+		"chu",
+		"cyu",
+		"tyu",
+		"chilyu",
+		"chixyu",
+		"tilyu",
+		"tixyu"
+	],
+	ちょ: [
+		"cho",
+		"cyo",
+		"tyo",
+		"chilyo",
+		"chixyo",
+		"tilyo",
+		"tixyo"
+	],
+	にゃ: [
+		"nya",
+		"nilya",
+		"nixya"
+	],
+	にゅ: [
+		"nyu",
+		"nilyu",
+		"nixyu"
+	],
+	にょ: [
+		"nyo",
+		"nilyo",
+		"nixyo"
+	],
+	ひゃ: [
+		"hya",
+		"hilya",
+		"hixya"
+	],
+	ひゅ: [
+		"hyu",
+		"hilyu",
+		"hixyu"
+	],
+	ひょ: [
+		"hyo",
+		"hilyo",
+		"hixyo"
+	],
+	みゃ: [
+		"mya",
+		"milya",
+		"mixya"
+	],
+	みゅ: [
+		"myu",
+		"milyu",
+		"mixyu"
+	],
+	みょ: [
+		"myo",
+		"milyo",
+		"mixyo"
+	],
+	りゃ: [
+		"rya",
+		"rilya",
+		"rixya"
+	],
+	りゅ: [
+		"ryu",
+		"rilyu",
+		"rixyu"
+	],
+	りょ: [
+		"ryo",
+		"rilyo",
+		"rixyo"
+	],
+	びゃ: [
+		"bya",
+		"bilya",
+		"bixya"
+	],
+	びゅ: [
+		"byu",
+		"bilyu",
+		"bixyu"
+	],
+	びょ: [
+		"byo",
+		"bilyo",
+		"bixyo"
+	],
+	ぴゃ: [
+		"pya",
+		"pilya",
+		"pixya"
+	],
+	ぴゅ: [
+		"pyu",
+		"pilyu",
+		"pixyu"
+	],
+	ぴょ: [
+		"pyo",
+		"pilyo",
+		"pixyo"
+	]
+};
+const SMALL_TSU_PATTERNS = [
+	"ltu",
+	"ltsu",
+	"xtu",
+	"xtsu"
+];
+const SMALL_TSU_CONSONANTS = new Set([
+	"k",
+	"s",
+	"t",
+	"h",
+	"m",
+	"y",
+	"r",
+	"w"
+]);
+const createSmallTsuCharacterDefinition = (nextPatterns) => {
+	const consonantPatterns = /* @__PURE__ */ new Set();
+	if (nextPatterns) for (const pattern of nextPatterns) {
+		const consonant = pattern[0];
+		if (consonant && SMALL_TSU_CONSONANTS.has(consonant)) consonantPatterns.add(consonant);
+	}
+	return {
+		reading: "っ",
+		patterns: [...SMALL_TSU_PATTERNS, ...consonantPatterns]
+	};
+};
+const createJapaneseSentenceDefinition = (text, reading) => {
+	const characters = [];
+	for (let index = 0; index < reading.length; index += 1) {
+		const char = reading[index];
+		const nextChar = reading[index + 1];
+		if (char === "っ") {
+			const nextPatterns = nextChar ? KANA_ROMAJI_MAP[nextChar] : void 0;
+			characters.push(createSmallTsuCharacterDefinition(nextPatterns));
+			continue;
+		}
+		const digraph = nextChar ? `${char}${nextChar}` : null;
+		const digraphCandidates = digraph ? KANA_ROMAJI_MAP[digraph] : void 0;
+		const candidates = digraphCandidates ?? KANA_ROMAJI_MAP[char];
+		if (!candidates) throw new Error(`Unsupported hiragana: ${char}`);
+		const readingUnit = digraphCandidates && nextChar ? `${char}${nextChar}` : char;
+		if (digraphCandidates) index += 1;
+		characters.push({
+			reading: readingUnit,
+			patterns: candidates
+		});
+	}
+	return {
+		text,
+		reading,
+		characters
+	};
+};
+
+//#endregion
+export { Character, Sentence, Session, createJapaneseSentenceDefinition };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "typengine",
+  "version": "0.0.2",
+  "description": "Core library for building typing apps and games.",
+  "keywords": [
+    "japanese",
+    "keyboard",
+    "romaji",
+    "typing",
+    "typing-game",
+    "typing-practice"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20251226.1",
+    "oxfmt": "^0.20.0",
+    "oxlint": "^1.35.0",
+    "tsdown": "^0.15.12",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "node --test lib/**/*.test.ts",
+    "typecheck": "tsgo --noEmit",
+    "lint": "oxlint . && oxfmt --check .",
+    "fix": "oxlint . --fix && oxfmt --write .",
+    "ready": "pnpm fix && pnpm typecheck && pnpm test",
+    "ready:check": "pnpm lint && pnpm typecheck && pnpm test"
+  }
+}