kipphi 2.0.0 → 2.0.1

package/time.ts

@@ -1,245 +1,55 @@
-import { EventType, type BPMSegmentData, type TimeT } from "./chartTypes";
-import { EventEndNode, EventNodeLike, EventNodeSequence, EventStartNode, type AnyEN, type ENOrHead, type ENOrTail } from "./event";
-import { JumpArray } from "./jumparray";
-import { NodeType } from "./util";
-
-
-/// #declaration:global
-
+import { TimeT } from "./chartTypes";
+import { err } from "./env";
 /**
- * 
+ * @static @final
  */
-class BPMStartNode extends EventStartNode {
-    spb: number;
-    cachedStartIntegral?: number;
-    override cachedIntegral?: number;
-    override next: BPMEndNode | BPMNodeLike<NodeType.TAIL>;
-    override previous: BPMEndNode | BPMNodeLike<NodeType.HEAD>;
-    constructor(startTime: TimeT, bpm: number) {
-        super(startTime, bpm);
-        this.spb = 60 / bpm;
-    }
-    override getIntegral(beats: number): number {
-        return (beats - TimeCalculator.toBeats(this.time)) * 60 / this.value;
-    }
-    /**
-     * may only used with a startnode whose next is not tail
-     * @returns 
-     */
-    override getFullIntegral(): number {
-        return (TimeCalculator.toBeats(this.next.time) - TimeCalculator.toBeats(this.time)) * 60 / this.value;
-    }
-    /*
-    static connect(node1: BPMStartNode, node2: BPMEndNode | Tailer<EventStartNode>): void;
-    static connect(node1: BPMEndNode | Header<BPMStartNode>, node2: BPMStartNode): void;
-    static connect(node1: EventNode | Header<EventNode>, node2: EventNode | Tailer<EventNode>): void {
-        super.connect(node1, node2);
-    }
-    */
-}
-class BPMEndNode extends EventEndNode {
-    spb: number;
-    override previous: BPMStartNode;
-    override next: BPMStartNode;
-    constructor(endTime: TimeT) {
-        super(endTime, null);
-    }
-    // @ts-expect-error
-    get value(): number {
-        return this.previous.value
-    }
-    set value(val) {}
-}
-
-interface BPMNodeLike<T extends NodeType> extends EventNodeLike<T> {
-    next: [BPMStartNode, null, BNOrTail][T] | null;
-    previous: [null, BPMStartNode, BNOrHead][T] | null;
-}
-type BPMNode = BPMStartNode | BPMEndNode;
-type AnyBN = (BPMNode | BPMNodeLike<NodeType.TAIL> | BPMNodeLike<NodeType.HEAD>);
-type BNOrTail = BPMNode | BPMNodeLike<NodeType.TAIL>;
-type BNOrHead = BPMNode | BPMNodeLike<NodeType.HEAD>;
-
-/**
- * 拥有与事件类似的逻辑
- * 每对节点之间代表一个BPM相同的片段
- * 片段之间BPM可以发生改变
- */
-
-export class BPMSequence extends EventNodeSequence {
-    override head: BPMNodeLike<NodeType.HEAD>;
-    override tail: BPMNodeLike<NodeType.TAIL>;
-    /** 从拍数访问节点 */
-    override jump: JumpArray<AnyEN>;
-    /** 以秒计时的跳数组，处理从秒访问节点 */
-    secondJump: JumpArray<AnyBN>;
-    constructor(bpmList: BPMSegmentData[], public duration: number) {
-        super(EventType.bpm, null);
-        let curPos: BPMNodeLike<NodeType.HEAD> | BPMEndNode = this.head;
-        let next = bpmList[0];
-        this.listLength = bpmList.length;
-        for (let i = 1; i < bpmList.length; i++) {
-            const each = next;
-            next = bpmList[i];
-            const startNode = new BPMStartNode(each.startTime, each.bpm);
-            const endNode = new BPMEndNode(next.startTime);
-            BPMStartNode.connect(startNode, endNode);
-            BPMStartNode.connect(curPos, startNode);
-            curPos = endNode;
-        }
-        const last = new BPMStartNode(next.startTime, next.bpm)
-        BPMStartNode.connect(curPos, last);
-        BPMStartNode.connect(last, this.tail);
-        this.initJump();
-    }
-    override initJump(): void {
-        console.log(this)
-        this.effectiveBeats = TimeCalculator.toBeats(this.tail.previous.time)
-        if (this.effectiveBeats !== 0) {
-            super.initJump(); // 为0可以跳过jumpArray，用不到
-            // 只有一个BPM片段就会这样
-        }
-        this.updateSecondJump();
-    }
-    updateSecondJump(): void {
-        let integral = 0;
-        // 计算积分并缓存到BPMNode
-        let node: BPMStartNode = this.head.next;
-        while (true) {
-            node.cachedStartIntegral = integral;
-            if (node.next.type === NodeType.TAIL) {
-                break;
-            }
-            const endNode = <BPMEndNode>(<BPMStartNode>node).next;
-            integral += node.getFullIntegral();
-            node.cachedIntegral = integral;
-
-            node = endNode.next;
-        }
-        node.cachedStartIntegral = integral;
-        if (this.effectiveBeats  === 0) {
-            return;
-        }
-        const originalListLength = this.listLength;
-        this.secondJump = new JumpArray<AnyBN>(
-            this.head,
-            this.tail,
-            originalListLength,
-            this.duration,
-            (node: BPMStartNode) => {
-                if (node.type === NodeType.TAIL) {
-                    return [null, null];
-                }
-                if (node.type === NodeType.HEAD) {
-                    return [0, node.next];
-                }
-                const endNode = <BPMEndNode>(<BPMStartNode>node).next;
-                const time = node.cachedIntegral;
-                const nextNode = endNode.next;
-                if (nextNode.next.type === NodeType.TAIL) {
-                    return [time, nextNode.next]; // Tailer代替最后一个StartNode去占位
-                } else {
-                    return [time, nextNode];
-                }
-            },
-            (node: BPMStartNode, seconds: number) => {
-                return node.cachedIntegral > seconds ? false : (<BPMEndNode>node.next).next;
-            }
-        );
-    }
-    override updateJump(from: ENOrHead, to: ENOrTail): void {
-        super.updateJump(from, to);
-        this.updateSecondJump();
-    }
-
-    getNodeBySeconds(seconds: number): BPMStartNode {
-        if (this.effectiveBeats === 0) {
-            return this.tail.previous
-        }
-        const node = this.secondJump.getNodeAt(seconds);
-        if (node.type === NodeType.TAIL) {
-            return node.previous;
-        }
-        return node as BPMStartNode;
-    }
-    dumpBPM(): BPMSegmentData[] {
-        let cur = this.head.next;
-        const ret: BPMSegmentData[] = [];
-        while (true) {
-            ret.push({
-                bpm: cur.value,
-                startTime: cur.time
-            })
-            const end = cur.next;
-            if (end.type === NodeType.TAIL) {
-                break;
-            }
-            cur = end.next;
-        } 
-        return ret;
-    }
-}
-
-/**
- * @alias TC
- */
-export class TimeCalculator {
-    bpmList: BPMSegmentData[];
-    bpmSequence: BPMSequence;
-    duration: number;
-
-    constructor() {
-    }
-
-    update() {
-        let bpmList = this.bpmList;
-        this.bpmSequence = new BPMSequence(bpmList, this.duration);
-    }
-    toSeconds(beats: number) {
-        const node: BPMStartNode = this.bpmSequence.getNodeAt(beats);
-        return node.cachedStartIntegral + node.getIntegral(beats)
-    }
-    segmentToSeconds(beats1: number, beats2: number): number {
-        let ret = this.toSeconds(beats2) - this.toSeconds(beats1)
-        if (ret < 0) {
-            console.warn("segmentToSeconds的第二个参数需大于第一个！", "得到的参数：", arguments)
-        }
-        return ret
-    }
-    secondsToBeats(seconds: number) {
-        const node = this.bpmSequence.getNodeBySeconds(seconds);
-        // console.log("node:", node)
-        const beats = (seconds - node.cachedStartIntegral) / node.spb;
-        return TimeCalculator.toBeats(node.time) + beats
-    }
+export default class TC {
+    private constructor() {}
     static toBeats(beaT: TimeT): number {
-        if (!beaT) debugger
         return beaT[0] + beaT[1] / beaT[2]
     }
     static getDelta(beaT1: TimeT, beaT2: TimeT): number {
         return this.toBeats(beaT1) - this.toBeats(beaT2)
     }
+    /**
+     * @returns beaT1 == beaT2
+     */
     static eq(beaT1: TimeT, beaT2: TimeT): boolean {
         return beaT1[0] === beaT2 [0] && beaT1[1] * beaT2[2] === beaT1[2] * beaT2[1] // 这里曾经把两个都写成beaT1，特此留念（
     }
+    /** @returns beaT1 > beaT2 */
     static gt(beaT1:TimeT, beaT2: TimeT): boolean {
         return beaT1[0] > beaT2[0] || beaT1[0] === beaT2[0] && beaT1[1] * beaT2[2] > beaT1[2] * beaT2[1]
     }
+    /** @returns beaT1 < beaT2 */
     static lt(beaT1:TimeT, beaT2: TimeT): boolean {
         return beaT1[0] < beaT2[0] || beaT1[0] === beaT2[0] && beaT1[1] * beaT2[2] < beaT1[2] * beaT2[1]
     }
+    /** @returns beaT1 != beaT2 */
     static ne(beaT1:TimeT, beaT2: TimeT): boolean {
         return beaT1[0] !== beaT2[0] || beaT1[1] * beaT2[2] !== beaT1[2] * beaT2[1]
     }
+    /**
+     * @returns beaT1 + beaT2
+     */
     static add(beaT1: TimeT, beaT2: TimeT): TimeT {
         return [beaT1[0] + beaT2[0], beaT1[1] * beaT2[2] + beaT1[2] * beaT2[1], beaT1[2] * beaT2[2]]
     }
+    /**
+     * @returns beaT1 - beaT2
+     */
     static sub(beaT1: TimeT, beaT2: TimeT): TimeT {
         return [beaT1[0] - beaT2[0], beaT1[1] * beaT2[2] - beaT1[2] * beaT2[1], beaT1[2] * beaT2[2]]
     }
+    /**
+     * @returns Ratio(a 2-number tuple) = beaT1 / beaT2
+     */
     static div(beaT1: TimeT, beaT2: TimeT): [number, number] {
         return [(beaT1[0] * beaT1[2] + beaT1[1]) * beaT2[2], (beaT2[0] * beaT2[2] + beaT2[1]) * beaT1[2]]
     }
+    /**
+     * @returns beaT1 * [numerator, denominator]
+     */
     static mul(beaT: TimeT, ratio: [number, number]): TimeT {
         // 将带分数beaT: TimeT乘一个分数[number, number]得到一个新的带分数returnval: TimeT，不要求这个带分数分子不超过分母，但所有的数都是整数
         // （输入的两个元组都是整数元组）
@@ -251,6 +61,7 @@ export class TimeCalculator {
         } else {
             return [Math.floor(b0nume / denominator), beaT[1] * numerator + remainder * beaT[2], beaT[2] * denominator]
         }
+        
     }
     /**
      * 原地规范化时间元组，但仍然返回这个元组，方便使用
@@ -259,7 +70,7 @@ export class TimeCalculator {
      */
     static validateIp(beaT: TimeT): TimeT {
         if (beaT === undefined || beaT[2] === 0) {
-            throw new Error("Invalid time" + beaT.valueOf());
+            throw err.INVALID_TIME_TUPLE(beaT);
         }
         if (beaT[1] >= beaT[2]) {
             const quotient = Math.floor(beaT[1] / beaT[2]);
@@ -283,8 +94,17 @@ export class TimeCalculator {
         }
         return beaT;
     }
+    /**
+     * 相加并约简
+     */
     static vadd(beaT1: TimeT, beaT2: TimeT) { return this.validateIp(this.add(beaT1, beaT2)); }
+    /**
+     * 相减并约简
+     */
     static vsub(beaT1: TimeT, beaT2: TimeT) { return this.validateIp(this.sub(beaT1, beaT2)); }
+    /**
+     * 相乘并约简
+     */
     static vmul(beaT: TimeT, ratio: [number, number]): TimeT { return this.validateIp(this.mul(beaT, ratio)); }
     static gcd(a: number, b: number): number {
         if (a === 0 || b === 0) {
@@ -297,12 +117,4 @@ export class TimeCalculator {
         }
         return a;
     }
-    dump(): BPMSegmentData[] {
-        return this.bpmSequence.dumpBPM();
-    }
-}
-
-export const TC = TimeCalculator;
-
-
-/// #enddeclaration
+}

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     // Environment setup & latest features
-    "lib": ["ES2017"],
+    "lib": ["ES2021"],
     "target": "ES2016",
     "module": "es2020",
     "moduleDetection": "force",
@@ -16,7 +16,6 @@
     "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
 
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,

package/util.ts

@@ -1,4 +1,4 @@
-import type { RGB } from "./chartTypes";
+import type { RGB, TimeT } from "./chartTypes";
 
 /// #declaration:global
 
@@ -9,6 +9,22 @@ export enum NodeType {
 }
 
 export type TupleCoord = [x: number, y: number]
+/**
+ * 检查值的类型
+ * @param value 
+ * @param type 为字符串时，用typeof检测，为构造函数时，用instanceof检测，为数组时，识别为元组类型。
+ */
+export const checkType = (value: unknown, type: string | (string | typeof Function)[] | typeof Function) => {
+    if (Array.isArray(type)) {
+        return Array.isArray(value)
+        && value.length === type.length
+        && type.every((t, i) => checkType(value[i], t))
+    } else if (typeof type === "string") {
+        return typeof value === type
+    } else {
+        return value instanceof type
+    }
+}
 
 export const rgb2hex = (rgb: RGB) => {
     return rgb[0] << 16 | rgb[1] << 8 | rgb[2];
@@ -23,4 +39,8 @@ export const numberToRatio = (num: number): [number, number] => {
     return [Math.round(num * 10000), 10000]
 }
 
+
+export const toTimeString = (beaT: TimeT): string =>
+    `${beaT[0]}:${beaT[1]}/${beaT[2]}`;
+
 /// #enddeclaration

package/version.ts

@@ -2,7 +2,7 @@
 
 /// #declaration:global
 
-export const VERSION = 200;
+export const VERSION = 201;
 
 
 /// #enddeclaration