tja-parser 0.1.0

package/src/class/Item.ts

@@ -0,0 +1,27 @@
+import * as math from 'mathjs';
+
+export class Item {
+    private timing: math.Fraction;
+
+    constructor(timing: math.Fraction) {
+        this.timing = timing;
+    }
+
+    setTiming(timing: math.Fraction){
+        this.timing = math.fraction(timing);
+    }
+
+    getTiming() {
+        return math.fraction(this.timing);
+    }
+
+    getTimingMS() {
+        return this.timing.valueOf();
+    }
+
+    toJSON(){
+        return {
+            timing: this.getTimingMS()
+        }
+    }
+}

package/src/class/Note.ts

@@ -0,0 +1,172 @@
+import { Item } from "./Item.js";
+import * as math from 'mathjs';
+
+export abstract class Note extends Item {
+    static parse(char: string): Note | null {
+        if (char === "0") {
+            return new EmptyNote(Note.Type.EMPTY, math.fraction(0), math.fraction(0));
+        }
+        else if (char === "1") {
+            return new HitNote(Note.Type.DON_SMALL, math.fraction(0), math.fraction(0));
+        }
+        else if (char === "2") {
+            return new HitNote(Note.Type.KA_SMALL, math.fraction(0), math.fraction(0));
+        }
+        else if (char === "3") {
+            return new HitNote(Note.Type.DON_BIG, math.fraction(0), math.fraction(0));
+        }
+        else if (char === "4") {
+            return new HitNote(Note.Type.KA_BIG, math.fraction(0), math.fraction(0));
+        }
+        else if (char === "5") {
+            return new RollNote(Note.Type.ROLL_SMALL, math.fraction(0), math.fraction(0), math.fraction(0));
+        }
+        else if (char === "6") {
+            return new RollNote(Note.Type.ROLL_BIG, math.fraction(0), math.fraction(0), math.fraction(0));
+        }
+        else if (char === "7") {
+            return new BalloonNote(0, math.fraction(0), math.fraction(0), math.fraction(0));
+        }
+        else if (char === "8") {
+            return new RollEndNote(math.fraction(0), math.fraction(0));
+        }
+        return null;
+    }
+
+    protected type: Note.Type;
+    private delay: math.Fraction;
+    private scroll: number = 1;
+    private bpm: number = 160;
+    private noteLength: number = 1;
+    constructor(type: Note.Type, timing: math.Fraction, delay: math.Fraction) {
+        super(timing);
+        this.type = type;
+        this.delay = delay;
+    }
+
+    getScroll() {
+        return this.scroll;
+    }
+    setScroll(scroll: number) {
+        this.scroll = scroll;
+    }
+    getBPM() {
+        return this.bpm;
+    }
+    setBpm(bpm: number) {
+        this.bpm = bpm;
+    }
+    getDelay() {
+        return math.fraction(this.delay);
+    }
+    setDelay(delay: math.Fraction) {
+        this.delay = math.fraction(delay);
+    }
+    getNoteLength(){
+        return this.noteLength;
+    }
+    setNoteLength(noteLength: number){
+        this.noteLength = noteLength;
+    }
+
+    toJSON(){
+        return {
+            ...super.toJSON(),
+            type: this.type,
+            delay: this.delay.valueOf(),
+            scroll: this.scroll,
+            bpm: this.bpm,
+            noteLength: this.noteLength
+        }
+    }
+}
+
+export namespace Note {
+    export enum Type {
+        EMPTY,
+        DON_SMALL,
+        KA_SMALL,
+        DON_BIG,
+        KA_BIG,
+        ROLL_SMALL,
+        ROLL_BIG,
+        BALLOON,
+        ROLL_END
+    }
+
+    export type HitType = Type.DON_SMALL | Type.KA_SMALL | Type.DON_BIG | Type.KA_BIG;
+    export type RollType = Type.ROLL_SMALL | Type.ROLL_BIG | Type.BALLOON;
+}
+
+export class HitNote extends Note {
+    declare type: Note.HitType;
+    constructor(type: Note.HitType, timing: math.Fraction, delay: math.Fraction) {
+        super(type, timing, delay);
+    }
+}
+
+export class RollNote extends Note {
+    declare type: Note.RollType;
+    end: math.Fraction;
+    constructor(type: Note.RollType, timing: math.Fraction, end: math.Fraction, delay: math.Fraction) {
+        super(type, timing, delay);
+        this.end = end;
+    }
+
+    getEnd(){
+        return math.fraction(this.end);
+    }
+    setEnd(end: math.Fraction){
+        this.end = math.fraction(end);
+    }
+
+    toJSON(){
+        return {
+            ...super.toJSON(),
+            end: this.end.valueOf()
+        }
+    }
+}
+
+export class BalloonNote extends RollNote {
+    declare type: Note.Type.BALLOON;
+    private count: number;
+    constructor(count: number, timing: math.Fraction, end: math.Fraction, delay: math.Fraction) {
+        super(Note.Type.BALLOON, timing, end, delay);
+        this.count = count;
+    }
+
+    getCount(){
+        return this.count;
+    }
+    setCount(count: number){
+        this.count = count;
+    }
+
+    toJSON(){
+        return {
+            ...super.toJSON(),
+            count: this.count
+        }
+    }
+}
+
+/**
+ * `EmptyNote`는 파싱 과정에서만 사용합니다.
+ */
+export class EmptyNote extends Note {
+    declare type: Note.Type.EMPTY;
+    constructor(type: Note.Type.EMPTY, timing: math.Fraction, delay: math.Fraction) {
+        super(type, timing, delay);
+    }
+}
+
+/**
+ * `RollEndNote`는 파싱 과정에서만 사용합니다.
+ */
+export class RollEndNote extends Note {
+    declare type: Note.Type.ROLL_END;
+    constructor(timing: math.Fraction, delay: math.Fraction) {
+        super(Note.Type.ROLL_END, timing, delay);
+    }
+}

package/src/class/Song.ts

@@ -0,0 +1,88 @@
+import { Course } from './Course.js';
+import type { Difficulty } from '../types.js';
+import { MetadataParseException } from '../exception/ParseException.js';
+
+export class Song {
+    /**
+     * @throws {MetadataParseException}
+     */
+    static parse(tja: string): Song {
+        const lines = tja.split('\n').map((e) => e.trim()).filter((e) => e);
+
+        const metadata = new this.Metadata();
+        const song = new Song(metadata);
+
+        let i = 0;
+        for (; i < lines.length; i++) {
+            if (lines[i].startsWith('COURSE')) {
+                break;
+            }
+            const parsedMetadata = this.parseMetadata(lines[i]);
+            metadata[parsedMetadata.key] = parsedMetadata.value;
+        }
+
+        let courseTja: string[] = [];
+        for (; i < lines.length; i++) {
+            courseTja.push(lines[i]);
+            if (lines[i].startsWith('#END')) {
+                const course = Course.parse(courseTja, song);
+                song.course[course.difficulty] = course;
+                courseTja = [];
+            }
+        };
+
+        return song;
+    }
+
+    /**
+     * @throws {MetadataParseException}
+     */
+    static parseMetadata(line: string): { key: string, value: string } {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex < 0) {
+            throw new MetadataParseException(line);
+        }
+        const key = line.slice(0, colonIndex).toLowerCase();
+        const value = line.slice(colonIndex + 1);
+        return {
+            key: key.trim(),
+            value: value.trim()
+        }
+    }
+
+    metadata: Song.Metadata;
+    course: Partial<Record<Difficulty, Course>> = {};
+
+    constructor(metadata: Song.Metadata) {
+        this.metadata = metadata;
+    }
+
+    /**
+     * `metadata`에서 bpm을 가져옴.
+     * `metadata`에 bpm이 존재하지 않으면 `160`을 반환.
+     */
+    getBPM(){
+        return Number(this.metadata.bpm) || 160;
+    }
+
+    toJSON(){
+        return {
+            metadata: this.metadata,
+            course: this.course
+        }
+    }
+}
+
+export namespace Song {
+    export class Metadata {
+        title?: string;
+        subtitle?: string;
+        bpm?: number;
+        offset?: number;
+        wave?: string;
+        songvol?: number;
+        sevol?: number;
+        demostart?: number;
+        [key: string]: string | number | undefined;
+    }
+}

package/src/exception/ParseException.ts

@@ -0,0 +1,13 @@
+import { TjaException } from './TjaException.js';
+
+export class ParseException extends TjaException {
+    line?: string;
+
+    constructor(line?: string) {
+        super();
+        this.line = line;
+    }
+};
+export class MetadataParseException extends ParseException { };
+export class CourseParseException extends ParseException { };
+export class UnknownCourseDifficultyException extends CourseParseException { };

package/src/exception/TjaException.ts

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

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './class/Song.js';
+export * from './class/Course.js';
+
+export type * from './types.js';

package/src/types.ts

@@ -0,0 +1 @@
+export type Difficulty = 'easy' | 'normal' | 'hard' | 'oni' | 'edit';

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "include": [
+        "./src/**/*.ts"
+    ],
+    "compilerOptions": {
+        "target": "ESNext",
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "removeComments": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./dist"
+    },
+    "exclude": [
+        "./node_modules",
+        "**/node_modules/*"
+    ]
+}