adofai 2.9.11 → 2.9.12

package/README.md

@@ -0,0 +1,20 @@
+# 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adofai",
-  "version": "2.9.11",
+  "version": "2.9.12",
   "main": "index.js",
   "scripts": {
     "build": "webpack",

package/src/parser/ArrayBufferParser.ts

@@ -1,128 +1,101 @@
-const BOM = new Uint8Array([0xef, 0xbb, 0xbf]);
-const COMMA = new Uint8Array([44]); // ASCII for ','
-
-export function stripBOM(buffer: ArrayBuffer): ArrayBuffer {
-  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: ArrayBuffer): ArrayBuffer {
-  const view = new Uint8Array(buffer);
-  let builder: Uint8Array[] = [];
-  let last: "other" | "string" | "escape" | "comma" = "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 normalizeJsonString(text: string): string {
-  const encoder = new TextEncoder();
-  const encoded = encoder.encode(text);
-  const normalizedBuffer = normalizeJsonArrayBuffer(encoded.buffer);
-  const decoder = new TextDecoder('utf-8');
-  return decoder.decode(normalizedBuffer);
-}
-
-export function decodeStringFromUTF8BOM(buffer: ArrayBuffer): string {
-  const strippedBuffer = stripBOM(buffer);
-  const decoder = new TextDecoder('utf-8');
-  return decoder.decode(strippedBuffer);
-}
-
-export function encodeStringAsUTF8BOM(text: string): ArrayBuffer {
-  const encoder = new TextEncoder();
-  const encoded = encoder.encode(text);
-  const bomAndText = new Uint8Array(BOM.length + encoded.length);
-  bomAndText.set(BOM, 0);
-  bomAndText.set(encoded, BOM.length);
-  return bomAndText.buffer;
-}
-
-export function decodeJsonFromString(text: string): any {
-  return JSON.parse(normalizeJsonString(text));
-}
-
-export function decodeJsonFromArrayBuffer(buffer: ArrayBuffer): any {
-  return JSON.parse(
-    decodeStringFromUTF8BOM(normalizeJsonArrayBuffer(stripBOM(buffer))),
-  );
-}
-
-export function encodeJsonAsString(obj: any): string {
-  return JSON.stringify(obj);
-}
-
-export function encodeJsonAsArrayBufferUTF8BOM(obj: any): ArrayBuffer {
-  return encodeStringAsUTF8BOM(encodeJsonAsString(obj));
-}
-
-export function parse(text: string): any {
-  return decodeJsonFromString(text);
-}
-
-export function stringify(obj: any): string {
-  return encodeJsonAsString(obj);
-}
-
-export default { parse, stringify };
+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<ArrayBuffer | string, any> {
+  parse(input: ArrayBuffer | string): any {
+    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: any): string {
+    return JSON.stringify(obj);
+  }
+}
+
+export function stripBOM(buffer: ArrayBuffer): ArrayBuffer {
+  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: ArrayBuffer): ArrayBuffer {
+  const view = new Uint8Array(buffer);
+  let builder: Uint8Array[] = [];
+  let last: "other" | "string" | "escape" | "comma" = "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: ArrayBuffer): string {
+  const strippedBuffer = stripBOM(buffer);
+  const decoder = new TextDecoder('utf-8');
+  return decoder.decode(strippedBuffer);
+}
+
+export default ArrayBufferParser;

package/src/parser/BufferParser.ts

@@ -1,3 +1,5 @@
+import Parser from "./Parser";
+import StringParser from "./StringParser";
 
 let BOM: Buffer;
 let COMMA: Buffer;
@@ -7,12 +9,23 @@ try {
   COMMA = Buffer.from(",");
 } catch (e) {
   console.warn('Buffer is not available in current environment, try to use ArrayBufferParser');
-  
-  // Provide dummy implementations to avoid errors during module loading
   BOM = { equals: () => false, subarray: () => null } as any;
   COMMA = { equals: () => false, subarray: () => null } as any;
 }
 
+export class BufferParser extends Parser<Buffer | string, any> {
+  parse(input: Buffer | string): any {
+    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: any): string {
+    return JSON.stringify(obj);
+  }
+}
+
 export function stripBOM(buffer: Buffer): Buffer {
   if (buffer.length >= 3 && BOM.equals(buffer.subarray(0, 3))) {
     return buffer.subarray(3)
@@ -73,44 +86,8 @@ export function normalizeJsonBuffer(text: Buffer): Buffer {
   return Buffer.concat(builder)
 }
 
-export function normalizeJsonString(text: string): string {
-  return normalizeJsonBuffer(Buffer.from(text, "utf-8")).toString("utf-8")
-}
-
 export function decodeStringFromUTF8BOM(buffer: Buffer): string {
   return stripBOM(buffer).toString("utf-8")
 }
 
-export function encodeStringAsUTF8BOM(text: string): Buffer {
-  return Buffer.concat([BOM, stripBOM(Buffer.from(text, "utf-8"))])
-}
-
-export function decodeJsonFromString(text: string): any {
-  return JSON.parse(normalizeJsonString(text))
-}
-
-export function decodeJsonFromBuffer(buffer: Buffer): any {
-  return JSON.parse(
-    decodeStringFromUTF8BOM(normalizeJsonBuffer(stripBOM(buffer))),
-  )
-}
-
-export function encodeJsonAsString(obj: any): string {
-  return JSON.stringify(obj)
-}
-
-export function encodeJsonAsBufferUTF8BOM(obj: any): Buffer {
-  return encodeStringAsUTF8BOM(encodeJsonAsString(obj))
-}
-
-export function parse(text: string): any {
-  return decodeJsonFromString(text)
-}
-
-export function stringify(obj: any): string {
-  return encodeJsonAsString(obj)
-}
-
-export default {parse,stringify}
-
-//BufferParser by Yqloss
+export default BufferParser;

package/src/parser/Parser.ts

@@ -1,26 +1,6 @@
-import StringParser from './StringParser';
-
-class Parser {
-    static parseError(f: string) {
-        return f;
-    }
-
-    /**
-        * @param {string} t - Input Content
-        * @param {object} provider - Third-party JSON Parser
-        * @returns {object} ADOFAI File Object
-    */
-    static parseAsObject(t: string, provider?: any) {
-        return (typeof provider == 'undefined' ? StringParser : provider).parse(Parser.parseAsText(t));
-    }
-
-    /**
-        * @param {string} t - Input Content
-        * @returns {string} ADOFAI File Content
-    */
-    static parseAsText(t: string) {
-        return this.parseError(t);
-    }
+abstract class Parser<TInput = any, TOutput = any> {
+    abstract parse(input: TInput): TOutput;
+    abstract stringify(obj: TOutput): TInput;
 }
 
-export default Parser
+export default Parser;

package/src/parser/StringParser.ts

@@ -1,23 +1,16 @@
-class StringParser {
-    static parse(text: string | null, reviver?: (key: string, value: any) => any): any {
-        if (text == null) return null;
-        const result = new ParserX(text).parseValue();
-        if (typeof reviver === "function") {
-            return this._applyReviver("", result, reviver);
-        }
-        return result;
-    }
+import Parser from "./Parser";
 
-    static parsePartially(text: string | null, upToSection: string | null, reviver?: (key: string, value: any) => any): any {
+class StringParser extends Parser<string, any> {
+    parse(text: string | null, reviver?: (key: string, value: any) => any): any {
         if (text == null) return null;
-        const result = new ParserX(text, upToSection).parseValue();
+        const result = new ParserX(text).parseValue();
         if (typeof reviver === "function") {
-            return this._applyReviver("", result, reviver);
+            return StringParser._applyReviver("", result, reviver);
         }
         return result;
     }
 
-    static stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string {
+    stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string {
         const serializer = new Serializer(replacer, space);
         return serializer.serialize(value);
     }
@@ -26,12 +19,12 @@ class StringParser {
         if (value && typeof value === "object") {
             if (Array.isArray(value)) {
                 for (let i = 0; i < value.length; i++) {
-                    value[i] = this._applyReviver(i.toString(), value[i], reviver);
+                    value[i] = StringParser._applyReviver(i.toString(), value[i], reviver);
                 }
             } else {
                 for (const prop in value) {
                     if (Object.prototype.hasOwnProperty.call(value, prop)) {
-                        value[prop] = this._applyReviver(prop, value[prop], reviver);
+                        value[prop] = StringParser._applyReviver(prop, value[prop], reviver);
                     }
                 }
             }

package/src/parser/index.ts

@@ -0,0 +1,28 @@
+import StringParser from './StringParser';
+import { LevelOptions, ParseProvider } from '../structure';
+
+class BaseParser {
+    static parseError(f: string) {
+        return f;
+    }
+
+    /**
+        * @param {string} t - Input Content
+        * @param {object} provider - ParserProvider
+        * @returns {LevelOptions} ADOFAI File Object
+    */
+    static parseAsObject(t: string, provider?: ParseProvider): LevelOptions {
+        const parser = provider || new StringParser();
+        return parser.parse(BaseParser.parseAsText(t)) as LevelOptions;
+    }
+
+    /**
+        * @param {string} t - Input Content
+        * @returns {string} ADOFAI File Content
+    */
+    static parseAsText(t: string) {
+        return this.parseError(t);
+    }
+}
+
+export default BaseParser;

package/src/parser.ts

@@ -1,4 +1,4 @@
-import Parser from "./parser/Parser";
+import Parser from "./parser/index";
 import BufferParser from './parser/BufferParser';
 import ArrayBufferParser from "./parser/ArrayBufferParser";
 import StringParser from "./parser/StringParser";

package/src/structure/Level.ts

@@ -1,7 +1,7 @@
 import { AdofaiEvent, LevelOptions, EventCallback, GuidCallback, Tile, ParseProvider } from './interfaces';
 import pathData from '../pathdata';
 import exportAsADOFAI from '../format'
-import Parser from '../parser';
+import BaseParser from '../parser';
 import effectProcessor from '../effectProcessor';
 import * as presets from '../presets';
 
@@ -40,7 +40,7 @@ export class Level {
             switch (typeof opt) {
                 case 'string':
                     try {
-                        options = Parser.parseAsObject(opt, this._provider) as LevelOptions;
+                        options = BaseParser.parseAsObject(opt, this._provider) as LevelOptions;
                     } catch (e) {
                         reject(e);
                         return;