adofai 2.13.0 → 2.13.2

package/README.md

@@ -1,112 +1,112 @@
-# ADOFAI
-
-A Javascript library for ADOFAI levels.
-
-## Usage
-Preview / Edit the `.adofai` file.
-
-Re_ADOJAS(A Level Player of ADOFAI) uses `adofai` to parse ADOFAI Level file.
-
-## Installation
-
-```bash
-npm install adofai
-# or
-yarn add adofai
-# or
-pnpm install adofai
-```
-
-if you want to display highlight of adofai file, you can use `Rhythm Game Syntax Highlighter` vscode extension.
-
-## Got Started
-
-### Import
-
-For Commonjs:
-```ts
-const adofai = require('adofai');
-```
-
-For ES6 Modules:
-```ts
-import * as adofai from 'adofai';
-```
-
-### Create a Level
-
-```ts
-const file = new adofai.Level(adofaiFileContent);
-
-//or
-
-const parser = new adofai.Parsers.StringParser();
-const file = new adofai.Level(adofaiFileContent,parser);
-
-//The advantage of the latter over the former is that it pre-initializes the Parser, avoiding multiple instantiations.
-```
-
-Format:
-```ts
-class Level {
-    constructor(opt: string | LevelOptions, provider?: ParseProvider)
- }
-
-```
-Available ParseProviders: 
-`StringParser` `ArrayBufferParser` `BufferParser`
-
-
-Usually,only `StringParser` is needed.
-but you can use `BufferParser` to parse ADOFAI files in Node environment.
-
-On browser, you can also use `ArrayBuffer` to parse ADOFAI files.
-(`BufferParser` is not available in browser,but you can use browserify `Buffer` to polyfill)
-
-### Load Level
-```ts
-file.on('load'() => {
-    //logic...
-})
-file.load()
-```
-
-or you can use `then()`
-```ts
-file.load().then(() => {
-
-})
-```
-
-### Export Level
-```ts
-type FileType = 'string'|'object'
-
-file.export(type: FileType = 'string',indent?:number,useAdofaiStyle:boolean = true)
-```
-
-method `export()` returns a Object or String.
-
-Object: return ADOFAI Object.
-String: return ADOFAI String.
-
-```ts
-import fs from 'fs'
-type FileType = 'string'|'object'
-
-const content = file.export('string',null,true);
-fs.writeFileSync('output.adofai',content)
-```
-
-
-## Data Operation
-
-See interfaces to see all data.
-
-```ts
-//Get AngleDatas:
-const angleDatas = file.angleData;
-
-
-
+# ADOFAI
+
+A Javascript library for ADOFAI levels.
+
+## Usage
+Preview / Edit the `.adofai` file.
+
+Re_ADOJAS(A Level Player of ADOFAI) uses `adofai` to parse ADOFAI Level file.
+
+## Installation
+
+```bash
+npm install adofai
+# or
+yarn add adofai
+# or
+pnpm install adofai
+```
+
+if you want to display highlight of adofai file, you can use `Rhythm Game Syntax Highlighter` vscode extension.
+
+## Got Started
+
+### Import
+
+For Commonjs:
+```ts
+const adofai = require('adofai');
+```
+
+For ES6 Modules:
+```ts
+import * as adofai from 'adofai';
+```
+
+### Create a Level
+
+```ts
+const file = new adofai.Level(adofaiFileContent);
+
+//or
+
+const parser = new adofai.Parsers.StringParser();
+const file = new adofai.Level(adofaiFileContent,parser);
+
+//The advantage of the latter over the former is that it pre-initializes the Parser, avoiding multiple instantiations.
+```
+
+Format:
+```ts
+class Level {
+    constructor(opt: string | LevelOptions, provider?: ParseProvider)
+ }
+
+```
+Available ParseProviders: 
+`StringParser` `ArrayBufferParser` `BufferParser`
+
+
+Usually,only `StringParser` is needed.
+but you can use `BufferParser` to parse ADOFAI files in Node environment.
+
+On browser, you can also use `ArrayBuffer` to parse ADOFAI files.
+(`BufferParser` is not available in browser,but you can use browserify `Buffer` to polyfill)
+
+### Load Level
+```ts
+file.on('load'() => {
+    //logic...
+})
+file.load()
+```
+
+or you can use `then()`
+```ts
+file.load().then(() => {
+
+})
+```
+
+### Export Level
+```ts
+type FileType = 'string'|'object'
+
+file.export(type: FileType = 'string',indent?:number,useAdofaiStyle:boolean = true)
+```
+
+method `export()` returns a Object or String.
+
+Object: return ADOFAI Object.
+String: return ADOFAI String.
+
+```ts
+import fs from 'fs'
+type FileType = 'string'|'object'
+
+const content = file.export('string',null,true);
+fs.writeFileSync('output.adofai',content)
+```
+
+
+## Data Operation
+
+See interfaces to see all data.
+
+```ts
+//Get AngleDatas:
+const angleDatas = file.angleData;
+
+
+
 ```

package/dist/src/effectProcessor.d.ts

@@ -0,0 +1,32 @@
+interface Tile {
+    addDecorations?: any[];
+    actions?: Action[];
+    [key: string]: any;
+}
+interface Action {
+    eventType: string;
+    [key: string]: any;
+}
+/**
+    * @param {Array} tiles ADOFAI Tiles from ADOFAI.Level
+    * @returns {Array} new Tiles
+*/
+declare function clearDecorations(tiles: Tile[]): Tile[];
+/**
+    * @param {Array} eventTypes Eventlist to remove
+    * @param {Array} tiles ADOFAI Tiles from ADOFAI.Level
+    * @returns {Array} new Tiles
+*/
+declare function clearEvents(eventTypes: string[], tiles: Tile[]): Tile[];
+/**
+    * @param {Array} eventTypes Eventlist to keep
+    * @param {Array} tiles ADOFAI Tiles from ADOFAI.Level
+    * @returns {Array} new Tiles
+*/
+declare function keepEvents(eventTypes: string[], tiles: Tile[]): Tile[];
+declare const effectProcessor: {
+    clearDecorations: typeof clearDecorations;
+    clearEvents: typeof clearEvents;
+    keepEvents: typeof keepEvents;
+};
+export default effectProcessor;

package/dist/src/effectProcessor.js

@@ -0,0 +1,54 @@
+import * as presets from './presets';
+/**
+    * @param {Array} tiles ADOFAI Tiles from ADOFAI.Level
+    * @returns {Array} new Tiles
+*/
+function clearDecorations(tiles) {
+    if (!Array.isArray(tiles)) {
+        throw new Error('Arguments are not supported.');
+    }
+    return tiles.map(tile => {
+        const newTile = Object.assign({}, tile);
+        if (newTile.hasOwnProperty('addDecorations')) {
+            newTile.addDecorations = [];
+        }
+        if (Array.isArray(newTile.actions)) {
+            newTile.actions = newTile.actions.filter(action => !presets.preset_inner_no_deco.events.includes(action.eventType));
+        }
+        return newTile;
+    });
+}
+/**
+    * @param {Array} eventTypes Eventlist to remove
+    * @param {Array} tiles ADOFAI Tiles from ADOFAI.Level
+    * @returns {Array} new Tiles
+*/
+function clearEvents(eventTypes, tiles) {
+    return tiles.map(tile => {
+        const newTile = Object.assign({}, tile);
+        if (Array.isArray(newTile.actions)) {
+            newTile.actions = newTile.actions.filter(action => !eventTypes.includes(action.eventType));
+        }
+        return newTile;
+    });
+}
+/**
+    * @param {Array} eventTypes Eventlist to keep
+    * @param {Array} tiles ADOFAI Tiles from ADOFAI.Level
+    * @returns {Array} new Tiles
+*/
+function keepEvents(eventTypes, tiles) {
+    return tiles.map(tile => {
+        const newTile = Object.assign({}, tile);
+        if (Array.isArray(newTile.actions)) {
+            newTile.actions = newTile.actions.filter(action => eventTypes.includes(action.eventType));
+        }
+        return newTile;
+    });
+}
+const effectProcessor = {
+    clearDecorations,
+    clearEvents,
+    keepEvents
+};
+export default effectProcessor;

package/dist/src/format.d.ts

@@ -0,0 +1,8 @@
+/**
+    * @param {object} obj - JSON Object
+    * @param {number} indent - No usage
+    * @param {boolean} isRoot - Is JSON the Root?
+    * @returns ADOFAI File Content or Object
+*/
+declare function exportAsADOFAI(obj: any, indent?: number, isRoot?: boolean): string;
+export default exportAsADOFAI;

package/dist/src/format.js

@@ -0,0 +1,44 @@
+/**
+    * @param {object} obj - JSON Object
+    * @param {number} indent - No usage
+    * @param {boolean} isRoot - Is JSON the Root?
+    * @returns ADOFAI File Content or Object
+*/
+function exportAsADOFAI(obj, indent = 0, isRoot = false) {
+    if (typeof obj !== 'object' || obj === null) {
+        return JSON.stringify(obj);
+    }
+    if (Array.isArray(obj)) {
+        const allPrimitives = obj.every(item => typeof item !== 'object' || item === null);
+        if (allPrimitives) {
+            return '[' + obj.map(item => exportAsADOFAI(item)).join(',') + ']';
+        }
+        const spaces = ' '.repeat(indent);
+        const arrayItems = obj.map(item => spaces + '  ' + formatAsSingleLine(item)).join(',\n');
+        return '[\n' + arrayItems + '\n' + spaces + ']';
+    }
+    const spaces = ' '.repeat(indent);
+    const keys = Object.keys(obj);
+    if (isRoot) {
+        const objectItems = keys.map(key => '  ' + JSON.stringify(key) + ': ' + exportAsADOFAI(obj[key], 2)).join(',\n');
+        return '{\n' + objectItems + '\n}';
+    }
+    const objectItems = keys.map(key => spaces + '  ' + JSON.stringify(key) + ': ' + exportAsADOFAI(obj[key], indent + 2)).join(',\n');
+    return '{\n' + objectItems + '\n' + spaces + '}';
+}
+/**
+    * @param {Array} obj Eventlist to keep
+    * @returns {string} JSON formated as singleline
+*/
+function formatAsSingleLine(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return exportAsADOFAI(obj);
+    }
+    if (Array.isArray(obj)) {
+        return '[' + obj.map(formatAsSingleLine).join(',') + ']';
+    }
+    const keys = Object.keys(obj);
+    const entries = keys.map(key => JSON.stringify(key) + ': ' + formatAsSingleLine(obj[key])).join(', ');
+    return '{' + entries + '}';
+}
+export default exportAsADOFAI;

package/dist/src/parser/ArrayBufferParser copy.d.ts

@@ -0,0 +1,9 @@
+import Parser from "./Parser";
+export declare class ArrayBufferParser extends Parser<ArrayBuffer | string, any> {
+    parse(input: ArrayBuffer | string): any;
+    stringify(obj: any): string;
+}
+export declare function stripBOM(buffer: ArrayBuffer): ArrayBuffer;
+export declare function normalizeJsonArrayBuffer(buffer: ArrayBuffer): ArrayBuffer;
+export declare function decodeStringFromUTF8BOM(buffer: ArrayBuffer): string;
+export default ArrayBufferParser;

package/dist/src/parser/ArrayBufferParser copy.js

@@ -0,0 +1,98 @@
+import Parser from "./Parser";
+import StringParser from "./StringParser";
+const BOM = new Uint8Array([0xef, 0xbb, 0xbf]);
+const COMMA = new Uint8Array([44]); // ASCII for ','
+export class ArrayBufferParser extends Parser {
+    parse(input) {
+        if (typeof input === "string") {
+            return StringParser.prototype.parse.call(StringParser.prototype, input);
+        }
+        else {
+            return StringParser.prototype.parse.call(StringParser.prototype, decodeStringFromUTF8BOM(normalizeJsonArrayBuffer(stripBOM(input))));
+        }
+    }
+    stringify(obj) {
+        return JSON.stringify(obj);
+    }
+}
+export function stripBOM(buffer) {
+    const view = new Uint8Array(buffer);
+    if (view.length >= 3 && view[0] === BOM[0] && view[1] === BOM[1] && view[2] === BOM[2]) {
+        return buffer.slice(3);
+    }
+    return buffer;
+}
+export function normalizeJsonArrayBuffer(buffer) {
+    const view = new Uint8Array(buffer);
+    let builder = [];
+    let last = "other";
+    let from = 0;
+    for (let i = 0; i < view.length; i++) {
+        const charCode = view[i];
+        if (last == "escape") {
+            last = "string";
+        }
+        else {
+            switch (charCode) {
+                case 34: // "
+                    switch (last) {
+                        case "string":
+                            last = "other";
+                            break;
+                        case "comma":
+                            builder.push(COMMA);
+                        default:
+                            last = "string";
+                            break;
+                    }
+                    break;
+                case 92: // \
+                    if (last === "string")
+                        last = "escape";
+                    break;
+                case 44: // ,
+                    builder.push(view.subarray(from, i));
+                    from = i + 1;
+                    if (last === "other")
+                        last = "comma";
+                    break;
+                case 93: // ]
+                case 125: // }
+                    if (last === "comma")
+                        last = "other";
+                    break;
+                case 9: // \t
+                case 10: // \n
+                case 11: // \v
+                case 12: // \f
+                case 13: // \r
+                case 32: // space
+                    break;
+                default:
+                    if (last === "comma") {
+                        builder.push(COMMA);
+                        last = "other";
+                    }
+                    break;
+            }
+        }
+    }
+    builder.push(view.subarray(from));
+    let totalLength = 0;
+    for (const arr of builder) {
+        totalLength += arr.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of builder) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result.buffer;
+}
+export function decodeStringFromUTF8BOM(buffer) {
+    const strippedBuffer = stripBOM(buffer);
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(strippedBuffer);
+}
+export default ArrayBufferParser;

package/dist/src/parser/BufferParser copy.d.ts

@@ -0,0 +1,9 @@
+import Parser from "./Parser";
+export declare class BufferParser extends Parser<Buffer | string, any> {
+    parse(input: Buffer | string): any;
+    stringify(obj: any): string;
+}
+export declare function stripBOM(buffer: Buffer): Buffer;
+export declare function normalizeJsonBuffer(text: Buffer): Buffer;
+export declare function decodeStringFromUTF8BOM(buffer: Buffer): string;
+export default BufferParser;

package/dist/src/parser/BufferParser copy.js

@@ -0,0 +1,92 @@
+import Parser from "./Parser";
+import StringParser from "./StringParser";
+let BOM;
+let COMMA;
+try {
+    BOM = Buffer.of(0xef, 0xbb, 0xbf);
+    COMMA = Buffer.from(",");
+}
+catch (e) {
+    console.warn('Buffer is not available in current environment, try to use ArrayBufferParser');
+    BOM = { equals: () => false, subarray: () => null };
+    COMMA = { equals: () => false, subarray: () => null };
+}
+export class BufferParser extends Parser {
+    parse(input) {
+        if (typeof input === "string") {
+            return StringParser.prototype.parse.call(StringParser.prototype, input);
+        }
+        else {
+            return StringParser.prototype.parse.call(StringParser.prototype, decodeStringFromUTF8BOM(normalizeJsonBuffer(stripBOM(input))));
+        }
+    }
+    stringify(obj) {
+        return JSON.stringify(obj);
+    }
+}
+export function stripBOM(buffer) {
+    if (buffer.length >= 3 && BOM.equals(buffer.subarray(0, 3))) {
+        return buffer.subarray(3);
+    }
+    return buffer;
+}
+export function normalizeJsonBuffer(text) {
+    let builder = [];
+    let last = "other";
+    let from = 0;
+    text.forEach((charCode, i) => {
+        if (last == "escape") {
+            last = "string";
+        }
+        else {
+            switch (charCode) {
+                case 34:
+                    switch (last) {
+                        case "string":
+                            last = "other";
+                            break;
+                        case "comma":
+                            builder.push(COMMA);
+                        default:
+                            last = "string";
+                            break;
+                    }
+                    break;
+                case 92:
+                    if (last === "string")
+                        last = "escape";
+                    break;
+                case 44:
+                    builder.push(text.subarray(from, i));
+                    from = i + 1;
+                    if (last === "other")
+                        last = "comma";
+                    break;
+                case 93:
+                case 125:
+                    if (last === "comma")
+                        last = "other";
+                    break;
+                case 9:
+                case 10:
+                case 11:
+                case 12:
+                case 13:
+                case 32:
+                    break;
+                default:
+                    if (last === "comma") {
+                        builder.push(COMMA);
+                        last = "other";
+                    }
+                    break;
+            }
+        }
+    });
+    builder.push(text.subarray(from));
+    return Buffer.concat(builder);
+}
+export function decodeStringFromUTF8BOM(buffer) {
+    return stripBOM(buffer).toString("utf-8");
+}
+export default BufferParser;

package/dist/src/parser/BufferParserX.d.ts

@@ -0,0 +1,23 @@
+import Parser from "./Parser";
+/**
+ * 用于解析和序列化 ArrayBuffer 数据的解析器
+ */
+declare class BufferParserX extends Parser<ArrayBuffer, any> {
+    /**
+     * 解析 ArrayBuffer 为对象
+     * @param buffer 输入的 ArrayBuffer
+     * @param reviver 可选的 reviver 函数
+     */
+    parse(buffer: ArrayBuffer, reviver?: (key: string, value: any) => any): any;
+    /**
+     * 序列化对象为 ArrayBuffer
+     * @param value 要序列化的对象
+     * @param replacer 可选的 replacer 函数
+     * @param space 可选的缩进
+     */
+    stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): ArrayBuffer;
+    private static _decodeUtf8;
+    private static _encodeUtf8;
+    private static _applyReviver;
+}
+export default BufferParserX;

package/dist/src/parser/BufferParserX.js

@@ -0,0 +1,77 @@
+import Parser from "./Parser";
+import { ParserX, Serializer } from "./StringParser";
+/**
+ * 用于解析和序列化 ArrayBuffer 数据的解析器
+ */
+class BufferParserX extends Parser {
+    /**
+     * 解析 ArrayBuffer 为对象
+     * @param buffer 输入的 ArrayBuffer
+     * @param reviver 可选的 reviver 函数
+     */
+    parse(buffer, reviver) {
+        if (!buffer)
+            return null;
+        const text = BufferParserX._decodeUtf8(buffer);
+        const result = new StringParserX(text).parseValue();
+        if (typeof reviver === "function") {
+            return BufferParserX._applyReviver("", result, reviver);
+        }
+        console.log(result);
+        return result;
+    }
+    /**
+     * 序列化对象为 ArrayBuffer
+     * @param value 要序列化的对象
+     * @param replacer 可选的 replacer 函数
+     * @param space 可选的缩进
+     */
+    stringify(value, replacer, space) {
+        const serializer = new SerializerX(replacer, space);
+        const str = serializer.serialize(value);
+        return BufferParserX._encodeUtf8(str);
+    }
+    static _decodeUtf8(buffer) {
+        return new TextDecoder().decode(new Uint8Array(buffer));
+    }
+    static _encodeUtf8(str) {
+        return new TextEncoder().encode(str).buffer;
+    }
+    static _applyReviver(key, value, reviver) {
+        if (value && typeof value === "object") {
+            if (Array.isArray(value)) {
+                for (let i = 0; i < value.length; i++) {
+                    value[i] = BufferParserX._applyReviver(i.toString(), value[i], reviver);
+                }
+            }
+            else {
+                for (const prop in value) {
+                    if (Object.prototype.hasOwnProperty.call(value, prop)) {
+                        value[prop] = BufferParserX._applyReviver(prop, value[prop], reviver);
+                    }
+                }
+            }
+        }
+        return reviver(key, value);
+    }
+}
+// StringParserX 仅用于内部解析字符串，逻辑与 StringParser 类似，但只暴露 parseValue 方法
+class StringParserX {
+    constructor(text) {
+        // @ts-ignore
+        this.parser = new ParserX(text);
+    }
+    parseValue() {
+        return this.parser.parseValue();
+    }
+}
+class SerializerX {
+    constructor(replacer, space) {
+        // @ts-ignore
+        this.serializer = new Serializer(replacer, space);
+    }
+    serialize(obj) {
+        return this.serializer.serialize(obj);
+    }
+}
+export default BufferParserX;

package/dist/src/parser/FileParser.d.ts

@@ -0,0 +1,9 @@
+import StringParser from './StringParser';
+declare abstract class FileParser<TOutput = any> {
+    protected fileContent: string;
+    protected parser: StringParser;
+    preload(filePath: string): Promise<void>;
+    parse(): TOutput;
+    stringify(obj: TOutput): string;
+}
+export default FileParser;