adofai 2.9.7 → 2.9.9

package/package.json

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

package/src/parser/ArrayBufferParser.ts

@@ -0,0 +1,128 @@
+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 };

package/src/parser/BufferParser.ts

@@ -1,5 +1,17 @@
-const BOM = Buffer.of(0xef, 0xbb, 0xbf)
-const COMMA = Buffer.from(",")
+
+let BOM: Buffer;
+let COMMA: Buffer;
+
+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');
+  
+  // Provide dummy implementations to avoid errors during module loading
+  BOM = { equals: () => false, subarray: () => null } as any;
+  COMMA = { equals: () => false, subarray: () => null } as any;
+}
 
 export function stripBOM(buffer: Buffer): Buffer {
   if (buffer.length >= 3 && BOM.equals(buffer.subarray(0, 3))) {

package/src/parser/Parser.ts

@@ -0,0 +1,26 @@
+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);
+    }
+}
+
+export default Parser

package/src/parser/StringParser.ts

@@ -1,167 +1,144 @@
-class ADOFAIX {
+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()
-  
-      // Apply reviver function if provided (similar to JSON.parse)
-      if (typeof reviver === "function") {
-        return this._applyReviver("", result, reviver)
-      }
-  
-      return result
+        if (text == null) return null
+
+        const result = new ParserX(text).parseValue()
+
+        // Apply reviver function if provided (similar to JSON.parse)
+        if (typeof reviver === "function") {
+            return this._applyReviver("", result, reviver)
+        }
+
+        return result
     }
-  
+
     static parsePartially(text: string | null, upToSection: string | null, reviver?: (key: string, value: any) => any): any {
-      if (text == null) return null
-  
-      const result = new ParserX(text, upToSection).parseValue()
-  
-      if (typeof reviver === "function") {
-        return this._applyReviver("", result, reviver)
-      }
-  
-      return result
+        if (text == null) return null
+
+        const result = new ParserX(text, upToSection).parseValue()
+
+        if (typeof reviver === "function") {
+            return this._applyReviver("", result, reviver)
+        }
+
+        return result
     }
-  
+
     static stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string {
-      const serializer = new Serializer(replacer, space)
-      return serializer.serialize(value)
+        const serializer = new Serializer(replacer, space)
+        return serializer.serialize(value)
     }
-  
+
     // Helper method for reviver function
     static _applyReviver(key: string, value: any, reviver: (key: string, value: any) => any): any {
-      if (value && typeof value === "object") {
-        if (Array.isArray(value)) {
-          const arrValue = value as any[];
-          for (let i = 0; i < arrValue.length; i++) {
-            arrValue[i] = this._applyReviver(i.toString(), arrValue[i], reviver)
-          }
-        } else {
-          const objValue = value as Record<string, any>;
-          for (const prop in objValue) {
-            if (Object.prototype.hasOwnProperty.call(objValue, prop)) {
-              objValue[prop] = this._applyReviver(prop, objValue[prop], reviver)
+        if (value && typeof value === "object") {
+            if (Array.isArray(value)) {
+                const arrValue = value as any[];
+                for (let i = 0; i < arrValue.length; i++) {
+                    arrValue[i] = this._applyReviver(i.toString(), arrValue[i], reviver)
+                }
+            } else {
+                const objValue = value as Record<string, any>;
+                for (const prop in objValue) {
+                    if (Object.prototype.hasOwnProperty.call(objValue, prop)) {
+                        objValue[prop] = this._applyReviver(prop, objValue[prop], reviver)
+                    }
+                }
             }
-          }
         }
-      }
-      return reviver(key, value)
+        return reviver(key, value)
     }
-  }
-  
-  class ParserX {
+}
+
+class ParserX {
     static WHITE_SPACE = " \t\n\r\uFEFF"
     static WORD_BREAK = ' \t\n\r{}[],:\"'
-  
+
     static TOKEN = {
-      NONE: 0,
-      CURLY_OPEN: 1,
-      CURLY_CLOSE: 2,
-      SQUARED_OPEN: 3,
-      SQUARED_CLOSE: 4,
-      COLON: 5,
-      COMMA: 6,
-      STRING: 7,
-      NUMBER: 8,
-      TRUE: 9,
-      FALSE: 10,
-      NULL: 11,
+        NONE: 0,
+        CURLY_OPEN: 1,
+        CURLY_CLOSE: 2,
+        SQUARED_OPEN: 3,
+        SQUARED_CLOSE: 4,
+        COLON: 5,
+        COMMA: 6,
+        STRING: 7,
+        NUMBER: 8,
+        TRUE: 9,
+        FALSE: 10,
+        NULL: 11,
     }
-  
+
     private json: string;
     private position: number;
     private endSection: string | null;
-  
+
     constructor(jsonString: string, endSection: string | null = null) {
-      this.json = jsonString
-      this.position = 0
-      this.endSection = endSection
-  
-      // Skip BOM if present
-      if (this.peek() === 0xfeff) {
-        this.read()
-      }
+        this.json = jsonString
+        this.position = 0
+        this.endSection = endSection
+
+        // Skip BOM if present
+        if (this.peek() === 0xfeff) {
+            this.read()
+        }
     }
-  
+
     parseValue(): any {
-      return this.parseByToken(this.nextToken)
+        return this.parseByToken(this.nextToken)
     }
-  
+
     parseObject(): Record<string, any> | null {
-      const obj: Record<string, any> = {}
-      this.read() // consume '{'
-  
-      while (true) {
-        let nextToken
-        do {
-          nextToken = this.nextToken
-          if (nextToken === ParserX.TOKEN.NONE) {
-            return null
-          }
-          if (nextToken === ParserX.TOKEN.CURLY_CLOSE) {
-            return obj
-          }
-        } while (nextToken === ParserX.TOKEN.COMMA)
-
-        // Rest of the parser implementation would go here
-        // This is a placeholder for the remaining parser code
-      }
+        const obj: Record<string, any> = {}
+        this.read() // consume '{'
+
+        while (true) {
+            let nextToken
+            do {
+                nextToken = this.nextToken
+                if (nextToken === ParserX.TOKEN.NONE) {
+                    return null
+                }
+                if (nextToken === ParserX.TOKEN.CURLY_CLOSE) {
+                    return obj
+                }
+            } while (nextToken === ParserX.TOKEN.COMMA)
+
+            // Rest of the parser implementation would go here
+            // This is a placeholder for the remaining parser code
+        }
     }
 
     // Placeholder for other methods that would be in the Parser class
     private get nextToken(): number {
-      // Implementation would go here
-      return 0;
+        // Implementation would go here
+        return 0;
     }
 
     private read(): number {
-      // Implementation would go here
-      return 0;
+        // Implementation would go here
+        return 0;
     }
 
     private peek(): number {
-      // Implementation would go here
-      return 0;
+        // Implementation would go here
+        return 0;
     }
 
     private parseByToken(token: number): any {
-      // Implementation would go here
-      return null;
+        // Implementation would go here
+        return null;
     }
-  }
+}
 
-  class Serializer {
+class Serializer {
     constructor(replacer?: (key: string, value: any) => any, space?: string | number) {
-      // Implementation would go here
+        // Implementation would go here
     }
 
     serialize(value: any): string {
-      // Implementation would go here
-      return "";
-    }
-  }
-  
-class StringParser {
-    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' ? ADOFAIX : provider).parse(StringParser.parseAsText(t));
-    }
-
-    /**
-        * @param {string} t - Input Content
-        * @returns {string} ADOFAI File Content
-    */
-    static parseAsText(t: string) {
-        return this.parseError(t);
+        // Implementation would go here
+        return "";
     }
 }
 

package/src/parser.ts

@@ -1,4 +1,7 @@
-import StringParser from "./parser/StringParser";
+import Parser from "./parser/Parser";
 import BufferParser from './parser/BufferParser';
+import ArrayBufferParser from "./parser/ArrayBufferParser";
+import StringParser from "./parser/StringParser";
 
-export {StringParser, BufferParser}
+export {StringParser, BufferParser, ArrayBufferParser}
+export default Parser;

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 {StringParser} from '../parser';
+import Parser 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 = StringParser.parseAsObject(opt, this._provider);
+                        options = Parser.parseAsObject(opt, this._provider);
                     } catch (e) {
                         reject(e);
                         return;

package/src/structure/interfaces.ts

@@ -4,8 +4,8 @@ export interface AdofaiEvent {
 }
 
 export interface LevelOptions {
-    pathData: string;
-    angleData: number[];
+    pathData?: string;
+    angleData?: number[];
     actions: AdofaiEvent[];
     settings: Record<string, any>;
     decorations: AdofaiEvent[];

package/test/index.html

@@ -1,7 +1,7 @@
 <input type="file" id="inputFile">
 <button id="export">Export as ADOFAI</button>
-<script src="../dist/adofai.min.js"></script>
-<script>
+<script type="module">
+    import * as ADOFAI from '../dist/index.js'
     let fl, reader;
     document.querySelector('#inputFile').addEventListener('change', f => {
         fl = f.target.files[0];