sonolus-pjsekai-js 1.1.12 → 1.2.0

package/dist/usc/convert.cjs

@@ -26,8 +26,8 @@ const uscToLevelData = (usc, offset = 0) => {
         };
         if (intermediate.sim) {
             const beat = intermediate.data[core_1.EngineArchetypeDataName.Beat];
-            if (typeof beat !== "number")
-                throw new Error("Unexpected beat");
+            if (typeof beat !== 'number')
+                throw new Error('Unexpected beat');
             const intermediates = timeToIntermediates.get(beat);
             if (intermediates) {
                 intermediates.push(intermediate);
@@ -44,7 +44,7 @@ const uscToLevelData = (usc, offset = 0) => {
         for (const [name, value] of Object.entries(intermediate.data)) {
             if (value === undefined)
                 continue;
-            if (typeof value === "number") {
+            if (typeof value === 'number') {
                 entity.data.push({
                     name,
                     value,
@@ -59,12 +59,12 @@ const uscToLevelData = (usc, offset = 0) => {
         }
     };
     append({
-        archetype: "Initialization",
+        archetype: 'Initialization',
         data: {},
         sim: false,
     });
     append({
-        archetype: "Stage",
+        archetype: 'Stage',
         data: {},
         sim: false,
     });
@@ -74,7 +74,7 @@ const uscToLevelData = (usc, offset = 0) => {
     for (const intermediates of timeToIntermediates.values()) {
         for (let i = 1; i < intermediates.length; i++) {
             append({
-                archetype: "SimLine",
+                archetype: 'SimLine',
                 data: {
                     a: intermediates[i - 1],
                     b: intermediates[i],
@@ -126,18 +126,18 @@ const single = (object, append) => {
         archetype: object.direction
             ? object.trace
                 ? object.critical
-                    ? "CriticalTraceFlickNote"
-                    : "NormalTraceFlickNote"
+                    ? 'CriticalTraceFlickNote'
+                    : 'NormalTraceFlickNote'
                 : object.critical
-                    ? "CriticalFlickNote"
-                    : "NormalFlickNote"
+                    ? 'CriticalFlickNote'
+                    : 'NormalFlickNote'
             : object.trace
                 ? object.critical
-                    ? "CriticalTraceNote"
-                    : "NormalTraceNote"
+                    ? 'CriticalTraceNote'
+                    : 'NormalTraceNote'
                 : object.critical
-                    ? "CriticalTapNote"
-                    : "NormalTapNote",
+                    ? 'CriticalTapNote'
+                    : 'NormalTapNote',
         data: {
             [core_1.EngineArchetypeDataName.Beat]: object.beat,
             lane: object.lane,
@@ -157,57 +157,30 @@ const slide = (object, append) => {
     for (const [i, connection] of connections.entries()) {
         if (i === 0) {
             switch (connection.type) {
-                case "start": {
-                    let archetype;
-                    let sim = true;
-                    if ("judgeType" in connection) {
-                        if (connection.judgeType === "none") {
-                            archetype = "IgnoredSlideStartNote";
-                            sim = false;
-                        }
-                        else if (connection.judgeType === "trace") {
-                            if (connection.critical) {
-                                archetype = "CriticalTraceSlideStartNote";
-                            }
-                            else {
-                                archetype = "NormalTraceSlideStartNote";
-                            }
-                        }
-                        else {
-                            if (connection.critical) {
-                                archetype = "CriticalSlideStartNote";
-                            }
-                            else {
-                                archetype = "NormalSlideStartNote";
-                            }
-                        }
-                    }
-                    else {
-                        archetype = connection.trace
+                case 'start': {
+                    const ci = {
+                        archetype: connection.trace
                             ? connection.critical
-                                ? "CriticalSlideTraceNote"
-                                : "NormalSlideTraceNote"
+                                ? 'CriticalSlideTraceNote'
+                                : 'NormalSlideTraceNote'
                             : connection.critical
-                                ? "CriticalSlideStartNote"
-                                : "NormalSlideStartNote";
-                    }
-                    const ci = {
-                        archetype,
+                                ? 'CriticalSlideStartNote'
+                                : 'NormalSlideStartNote',
                         data: {
                             [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                             lane: connection.lane,
                             size: connection.size,
                         },
-                        sim,
+                        sim: true,
                         ease: connection.ease,
                     };
                     cis.push(ci);
                     joints.push(ci);
                     continue;
                 }
-                case "ignore": {
+                case 'ignore': {
                     const ci = {
-                        archetype: "IgnoredSlideTickNote",
+                        archetype: 'IgnoredSlideTickNote',
                         data: {
                             [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                             lane: connection.lane,
@@ -221,28 +194,28 @@ const slide = (object, append) => {
                     continue;
                 }
                 default:
-                    throw new Error("Unexpected slide start");
+                    throw new Error('Unexpected slide start');
             }
         }
         if (i === connections.length - 1) {
             switch (connection.type) {
-                case "end": {
+                case 'end': {
                     const ci = {
                         archetype: connection.direction
                             ? connection.trace
                                 ? connection.critical
-                                    ? "CriticalTraceFlickNote"
-                                    : "NormalTraceFlickNote"
+                                    ? 'CriticalTraceFlickNote'
+                                    : 'NormalTraceFlickNote'
                                 : connection.critical
-                                    ? "CriticalSlideEndFlickNote"
-                                    : "NormalSlideEndFlickNote"
+                                    ? 'CriticalSlideEndFlickNote'
+                                    : 'NormalSlideEndFlickNote'
                             : connection.trace
                                 ? connection.critical
-                                    ? "CriticalSlideEndTraceNote"
-                                    : "NormalSlideEndTraceNote"
+                                    ? 'CriticalSlideEndTraceNote'
+                                    : 'NormalSlideEndTraceNote'
                                 : connection.critical
-                                    ? "CriticalSlideEndNote"
-                                    : "NormalSlideEndNote",
+                                    ? 'CriticalSlideEndNote'
+                                    : 'NormalSlideEndNote',
                         data: {
                             [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                             lane: connection.lane,
@@ -256,9 +229,9 @@ const slide = (object, append) => {
                     ends.push(ci);
                     continue;
                 }
-                case "ignore": {
+                case 'ignore': {
                     const ci = {
-                        archetype: "IgnoredSlideTickNote",
+                        archetype: 'IgnoredSlideTickNote',
                         data: {
                             [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                             lane: connection.lane,
@@ -272,13 +245,13 @@ const slide = (object, append) => {
                     continue;
                 }
                 default:
-                    throw new Error("Unexpected slide end");
+                    throw new Error('Unexpected slide end');
             }
         }
         switch (connection.type) {
-            case "ignore": {
+            case 'ignore': {
                 const ci = {
-                    archetype: "IgnoredSlideTickNote",
+                    archetype: 'IgnoredSlideTickNote',
                     data: {
                         [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                         lane: connection.lane,
@@ -291,15 +264,15 @@ const slide = (object, append) => {
                 joints.push(ci);
                 break;
             }
-            case "tick": {
+            case 'tick': {
                 const ci = {
                     archetype: connection.trace
                         ? connection.critical
-                            ? "CriticalSlideTraceNote"
-                            : "NormalSlideTraceNote"
+                            ? 'CriticalSlideTraceNote'
+                            : 'NormalSlideTraceNote'
                         : connection.critical
-                            ? "CriticalSlideTickNote"
-                            : "NormalSlideTickNote",
+                            ? 'CriticalSlideTickNote'
+                            : 'NormalSlideTickNote',
                     data: {
                         [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                         lane: connection.lane,
@@ -312,9 +285,9 @@ const slide = (object, append) => {
                 joints.push(ci);
                 break;
             }
-            case "hidden": {
+            case 'hidden': {
                 const ci = {
-                    archetype: "HiddenSlideTickNote",
+                    archetype: 'HiddenSlideTickNote',
                     data: {
                         [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                     },
@@ -324,11 +297,11 @@ const slide = (object, append) => {
                 attaches.push(ci);
                 break;
             }
-            case "attach": {
+            case 'attach': {
                 const ci = {
                     archetype: connection.critical
-                        ? "CriticalAttachedSlideTickNote"
-                        : "NormalAttachedSlideTickNote",
+                        ? 'CriticalAttachedSlideTickNote'
+                        : 'NormalAttachedSlideTickNote',
                     data: {
                         [core_1.EngineArchetypeDataName.Beat]: connection.beat,
                     },
@@ -339,7 +312,7 @@ const slide = (object, append) => {
                 break;
             }
             default:
-                throw new Error("Unexpected slide tick");
+                throw new Error('Unexpected slide tick');
         }
     }
     const connectors = [];
@@ -350,15 +323,15 @@ const slide = (object, append) => {
             continue;
         const head = joints[i - 1];
         if (!head.ease)
-            throw new Error("Unexpected missing ease");
+            throw new Error('Unexpected missing ease');
         connectors.push({
             archetype: object.active
                 ? object.critical
-                    ? "CriticalActiveSlideConnector"
-                    : "NormalActiveSlideConnector"
+                    ? 'CriticalActiveSlideConnector'
+                    : 'NormalActiveSlideConnector'
                 : object.critical
-                    ? "CriticalSlideConnector"
-                    : "NormalSlideConnector",
+                    ? 'CriticalSlideConnector'
+                    : 'NormalSlideConnector',
             data: {
                 start,
                 end,
@@ -384,70 +357,11 @@ const slide = (object, append) => {
         append(connector);
     }
 };
-const guide = (object, append) => {
-    const critical = object.color === "yellow" ? true : false;
-    // midpoints를 slide의 connections 형태로 변환
-    const connections = object.midpoints.map((midpoint, i) => {
-        if (i === 0) {
-            return {
-                type: "start",
-                beat: midpoint.beat,
-                lane: midpoint.lane,
-                size: midpoint.size,
-                trace: false,
-                critical: false,
-                ease: midpoint.ease === "out"
-                    ? "out"
-                    : midpoint.ease === "linear"
-                        ? "linear"
-                        : midpoint.ease === "in"
-                            ? "in"
-                            : "linear",
-            };
-        }
-        else if (i === object.midpoints.length - 1) {
-            return {
-                type: "end",
-                beat: midpoint.beat,
-                lane: midpoint.lane,
-                size: midpoint.size,
-                trace: false,
-                critical: false,
-                direction: undefined,
-            };
-        }
-        else {
-            return {
-                type: "tick",
-                beat: midpoint.beat,
-                lane: midpoint.lane,
-                size: midpoint.size,
-                trace: false,
-                critical: false,
-                ease: midpoint.ease === "out"
-                    ? "out"
-                    : midpoint.ease === "linear"
-                        ? "linear"
-                        : midpoint.ease === "in"
-                            ? "in"
-                            : "linear",
-            };
-        }
-    });
-    const slideObj = {
-        type: "slide",
-        active: true,
-        critical,
-        connections,
-    };
-    slide(slideObj, append);
-};
 const handlers = {
     bpm,
     single,
     timeScale,
     slide,
-    guide,
 };
 const getConnections = (object) => {
     if (!object.active)
@@ -459,7 +373,7 @@ const getConnections = (object) => {
     const start = Math.max(Math.ceil(min / 0.5) * 0.5, Math.floor(min / 0.5 + 1) * 0.5);
     for (let beat = start; beat < max; beat += 0.5) {
         connections.push({
-            type: "hidden",
+            type: 'hidden',
             beat,
         });
     }

package/dist/usc/convert.d.cts

@@ -1,3 +1,3 @@
-import { LevelData } from "@sonolus/core";
-import { USC } from "./index.cjs";
+import { LevelData } from '@sonolus/core';
+import { USC } from './index.cjs';
 export declare const uscToLevelData: (usc: USC, offset?: number) => LevelData;

package/dist/usc/index.cjs

@@ -1,18 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.USCFade = exports.USCColor = void 0;
-exports.USCColor = {
-    neutral: 0,
-    red: 1,
-    green: 2,
-    blue: 3,
-    yellow: 4,
-    purple: 5,
-    cyan: 6,
-    black: 7,
-};
-exports.USCFade = {
-    in: 2,
-    out: 0,
-    none: 1,
-};

package/dist/usc/index.d.cts

@@ -2,16 +2,16 @@ export type USC = {
     offset: number;
     objects: USCObject[];
 };
-export type USCObject = USCBpmChange | USCTimeScaleChange | USCSingleNote | USCSlideNote | USCGuideNote;
+export type USCObject = USCBpmChange | USCTimeScaleChange | USCSingleNote | USCSlideNote;
 type BaseUSCObject = {
     beat: number;
 };
 export type USCBpmChange = BaseUSCObject & {
-    type: "bpm";
+    type: 'bpm';
     bpm: number;
 };
 export type USCTimeScaleChange = BaseUSCObject & {
-    type: "timeScale";
+    type: 'timeScale';
     timeScale: number;
 };
 type BaseUSCNote = BaseUSCObject & {
@@ -19,42 +19,42 @@ type BaseUSCNote = BaseUSCObject & {
     size: number;
 };
 export type USCSingleNote = BaseUSCNote & {
-    type: "single";
+    type: 'single';
     trace: boolean;
     critical: boolean;
-    direction?: "left" | "up" | "right";
+    direction?: 'left' | 'up' | 'right';
 };
 export type USCConnectionStartNote = BaseUSCNote & {
-    type: "start";
+    type: 'start';
     trace: boolean;
     critical: boolean;
-    ease: "out" | "linear" | "in";
+    ease: 'outin' | 'out' | 'linear' | 'in' | 'inout';
 };
 export type USCConnectionIgnoreNote = BaseUSCNote & {
-    type: "ignore";
-    ease: "out" | "linear" | "in";
+    type: 'ignore';
+    ease: 'outin' | 'out' | 'linear' | 'in' | 'inout';
 };
 export type USCConnectionTickNote = BaseUSCNote & {
-    type: "tick";
+    type: 'tick';
     trace: boolean;
     critical: boolean;
-    ease: "out" | "linear" | "in";
+    ease: 'outin' | 'out' | 'linear' | 'in' | 'inout';
 };
 export type USCConnectionHiddenNote = BaseUSCObject & {
-    type: "hidden";
+    type: 'hidden';
 };
 export type USCConnectionAttachNote = BaseUSCObject & {
-    type: "attach";
+    type: 'attach';
     critical: boolean;
 };
 export type USCConnectionEndNote = BaseUSCNote & {
-    type: "end";
+    type: 'end';
     trace: boolean;
     critical: boolean;
-    direction?: "left" | "up" | "right";
+    direction?: 'left' | 'up' | 'right';
 };
 export type USCSlideNote = {
-    type: "slide";
+    type: 'slide';
     active: boolean;
     critical: boolean;
     connections: [
@@ -63,30 +63,4 @@ export type USCSlideNote = {
         USCConnectionEndNote | USCConnectionIgnoreNote
     ];
 };
-export declare const USCColor: {
-    neutral: number;
-    red: number;
-    green: number;
-    blue: number;
-    yellow: number;
-    purple: number;
-    cyan: number;
-    black: number;
-};
-export type USCColor = keyof typeof USCColor;
-export type USCGuideMidpointNote = BaseUSCNote & {
-    ease: "out" | "linear" | "in" | "inOut" | "outIn";
-};
-export declare const USCFade: {
-    in: number;
-    out: number;
-    none: number;
-};
-export type USCFade = keyof typeof USCFade;
-export type USCGuideNote = {
-    type: "guide";
-    color: USCColor;
-    fade: USCFade;
-    midpoints: USCGuideMidpointNote[];
-};
 export {};

package/dist/usc/revert.cjs

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uscToUSC = void 0;
+/**
+ * B 타입의 USC Easing 값을 A 타입으로 변환합니다.
+ * 'inout'은 'in'으로, 'outin'은 'out'으로 매핑됩니다.
+ * @param ease B 타입의 Easing 값
+ * @returns A 타입의 Easing 값
+ */
+/**
+ * B 타입의 USC 슬라이드 연결 노드를 A 타입으로 변환합니다.
+ * @param connection B 타입의 연결 노트
+ * @returns A 타입의 연결 노트
+ */
+const convertConnection = (connection) => {
+    switch (connection.type) {
+        case 'start':
+            if (connection.judgeType === 'none') {
+                return {
+                    type: 'ignore',
+                    beat: connection.beat,
+                    lane: connection.lane,
+                    size: connection.size,
+                    ease: connection.ease,
+                };
+            }
+            return {
+                type: 'start',
+                beat: connection.beat,
+                lane: connection.lane,
+                size: connection.size,
+                critical: connection.critical,
+                trace: connection.judgeType === 'trace',
+                ease: connection.ease,
+            };
+        case 'tick':
+            // B타입 tick 노트의 critical 유무에 따라 A타입의 tick 또는 hidden으로 분기합니다.
+            if (connection.critical !== undefined) {
+                return {
+                    type: 'tick',
+                    beat: connection.beat,
+                    lane: connection.lane,
+                    size: connection.size,
+                    critical: connection.critical,
+                    // A타입의 tick 노트는 trace 속성을 가지지만 B타입에는 없습니다.
+                    // 따라서 false로 기본값을 설정합니다.
+                    trace: false,
+                    ease: connection.ease,
+                };
+            }
+            else {
+                return {
+                    type: 'ignore',
+                    beat: connection.beat,
+                    lane: connection.lane,
+                    size: connection.size,
+                    ease: connection.ease,
+                };
+            }
+        case 'attach':
+            return {
+                type: 'attach',
+                beat: connection.beat,
+                critical: connection.critical ?? false,
+            };
+        case 'end':
+            if (connection.judgeType === 'none') {
+                return {
+                    type: 'ignore',
+                    beat: connection.beat,
+                    lane: connection.lane,
+                    size: connection.size,
+                    // A타입의 ignore 노트는 ease 속성이 필요하지만, B의 end 노트는 없습니다.
+                    // 따라서 'linear'를 기본값으로 사용합니다.
+                    ease: 'linear',
+                };
+            }
+            return {
+                type: 'end',
+                beat: connection.beat,
+                lane: connection.lane,
+                size: connection.size,
+                critical: connection.critical,
+                trace: connection.judgeType === 'trace',
+                direction: connection.direction,
+            };
+    }
+};
+/**
+ * B 타입의 USC 객체를 A 타입 USC 객체로 변환합니다.
+ * @param uscB B 타입 USC 객체
+ * @returns A 타입 USC 객체
+ */
+const uscToUSC = (uscB) => {
+    const newObjects = [];
+    for (const object of uscB.objects) {
+        switch (object.type) {
+            case 'bpm':
+                newObjects.push({
+                    type: 'bpm',
+                    beat: object.beat,
+                    bpm: object.bpm,
+                });
+                break;
+            case 'single':
+                newObjects.push({
+                    type: 'single',
+                    beat: object.beat,
+                    lane: object.lane,
+                    size: object.size,
+                    critical: object.critical,
+                    trace: object.trace,
+                    // B타입의 'none' 방향은 A타입에 없으므로 undefined로 처리합니다.
+                    direction: object.direction === 'none' ? undefined : object.direction,
+                });
+                break;
+            case 'slide':
+                {
+                    const newSlide = {
+                        type: 'slide',
+                        // B타입의 모든 slide는 A타입의 active slide로 간주합니다.
+                        active: true,
+                        critical: object.critical,
+                        connections: object.connections.map(convertConnection),
+                    };
+                    newObjects.push(newSlide);
+                }
+                break;
+            case 'timeScaleGroup':
+                // B타입의 timeScaleGroup을 A타입의 개별 timeScale 변경점으로 변환합니다.
+                for (const change of object.changes) {
+                    newObjects.push({
+                        type: 'timeScale',
+                        beat: change.beat,
+                        timeScale: change.timeScale,
+                    });
+                }
+                break;
+            case 'guide':
+                {
+                    // B타입의 guide를 A타입의 비활성(active: false) 슬라이드로 변환합니다.
+                    const guideConnections = object.midpoints.map((midpoint) => ({
+                        type: 'ignore',
+                        beat: midpoint.beat,
+                        lane: midpoint.lane,
+                        size: midpoint.size,
+                        ease: midpoint.ease,
+                    }));
+                    const newGuideSlide = {
+                        type: 'slide',
+                        active: false,
+                        // B타입의 guide color가 'yellow'이면 critical로 판단합니다.
+                        critical: object.color === 'yellow',
+                        connections: guideConnections,
+                    };
+                    newObjects.push(newGuideSlide);
+                }
+                break;
+            // 'damage' 노트는 A타입에 없으므로 무시합니다.
+            case 'damage':
+                break;
+        }
+    }
+    return {
+        offset: uscB.offset,
+        objects: newObjects,
+    };
+};
+exports.uscToUSC = uscToUSC;

package/dist/usc/revert.d.cts

@@ -0,0 +1,8 @@
+import * as B from './ccIndex.cjs';
+import * as A from './index.cjs';
+/**
+ * B 타입의 USC 객체를 A 타입 USC 객체로 변환합니다.
+ * @param uscB B 타입 USC 객체
+ * @returns A 타입 USC 객체
+ */
+export declare const uscToUSC: (uscB: B.USC) => A.USC;