adofai 2.9.7

package/.babelrc

@@ -0,0 +1,5 @@
+{
+    "presets": [
+        "@babel/preset-env"
+    ]
+}

package/index.ts

@@ -0,0 +1,12 @@
+import pathData from './src/pathdata'
+import * as Parsers from './src/parser'
+import Level,* as Structure from './src/structure'
+import * as Presets from './src/presets'
+
+export {
+    pathData,
+    Parsers,
+    Level,
+    Structure,
+    Presets
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "adofai",
+  "version": "2.9.7",
+  "main": "index.js",
+  "scripts": {
+    "build": "webpack",
+    "tsc": "tsc",
+    "dev": "webpack --mode=development"
+  },
+  "keywords": ["adofai", "adofai-js", "adofai-ts", "adofai-ts-lib"],
+  "author": "Xbodwf",
+  "license": "BSD-3-Clause",
+  "homepage": "https://xbodwf.github.io/packages/adofai-js/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Xbodwf/ADOFAI-JS.git"
+  },
+  "bugs": "https://github.com/Xbodwf/ADOFAI-JS/issues",
+  "description": "A Javascript library for ADOFAI levels.",
+  "devDependencies": {
+    "@babel/core": "^7.27.1",
+    "@babel/preset-env": "^7.27.2",
+    "@types/node": "^20.11.0",
+    "babel-loader": "^10.0.0",
+    "install": "^0.13.0",
+    "ts-loader": "^9.5.1",
+    "typescript": "^5.3.3",
+    "webpack": "^5.99.9",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/src/effectProcessor.ts

@@ -0,0 +1,82 @@
+import * as presets from './presets'
+
+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
+*/
+function clearDecorations(tiles: Tile[]): Tile[] {
+  if (!Array.isArray(tiles)) {
+    throw new Error('Arguments are not supported.');
+  }
+  
+  return tiles.map(tile => {
+    const newTile = { ...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: string[], tiles: Tile[]): Tile[] {
+  return tiles.map(tile => {
+    const newTile = { ...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: string[], tiles: Tile[]): Tile[] {
+  return tiles.map(tile => {
+    const newTile = { ...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/src/format.ts

@@ -0,0 +1,69 @@
+/**
+    * @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: any, indent: number = 0, isRoot: boolean = false): string {
+
+  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 as Record<string, any>)[key], 2)
+    ).join(',\n');
+    
+    return '{\n' + objectItems + '\n}';
+  }
+  
+  const objectItems = keys.map(key => 
+    spaces + '  ' + JSON.stringify(key) + ': ' + exportAsADOFAI((obj as Record<string, any>)[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: any): string {
+  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 as Record<string, any>)[key])
+  ).join(', ');
+  
+  return '{' + entries + '}';
+}
+
+export default exportAsADOFAI;

package/src/parser/BufferParser.ts

@@ -0,0 +1,102 @@
+const BOM = Buffer.of(0xef, 0xbb, 0xbf)
+const COMMA = Buffer.from(",")
+
+export function stripBOM(buffer: Buffer): Buffer {
+  if (buffer.length >= 3 && BOM.equals(buffer.subarray(0, 3))) {
+    return buffer.subarray(3)
+  }
+  return buffer
+}
+
+export function normalizeJsonBuffer(text: Buffer): Buffer {
+  let builder: Buffer[] = []
+  let last: "other" | "string" | "escape" | "comma" = "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 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}

package/src/parser/StringParser.ts

@@ -0,0 +1,168 @@
+class ADOFAIX {
+    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
+    }
+  
+    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
+    }
+  
+    static stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string {
+      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)
+            }
+          }
+        }
+      }
+      return reviver(key, value)
+    }
+  }
+  
+  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,
+    }
+  
+    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()
+      }
+    }
+  
+    parseValue(): any {
+      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
+      }
+    }
+
+    // Placeholder for other methods that would be in the Parser class
+    private get nextToken(): number {
+      // Implementation would go here
+      return 0;
+    }
+
+    private read(): number {
+      // Implementation would go here
+      return 0;
+    }
+
+    private peek(): number {
+      // Implementation would go here
+      return 0;
+    }
+
+    private parseByToken(token: number): any {
+      // Implementation would go here
+      return null;
+    }
+  }
+
+  class Serializer {
+    constructor(replacer?: (key: string, value: any) => any, space?: string | number) {
+      // 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);
+    }
+}
+
+export default StringParser

package/src/parser.ts

@@ -0,0 +1,4 @@
+import StringParser from "./parser/StringParser";
+import BufferParser from './parser/BufferParser';
+
+export {StringParser, BufferParser}

package/src/pathdata.ts

@@ -0,0 +1,20 @@
+interface PathDataTable {
+    [key: string]: number;
+}
+
+const pathDataTable: PathDataTable = { "R": 0, "p": 15, "J": 30, "E": 45, "T": 60, "o": 75, "U": 90, "q": 105, "G": 120, "Q": 135, "H": 150, "W": 165, "L": 180, "x": 195, "N": 210, "Z": 225, "F": 240, "V": 255, "D": 270, "Y": 285, "B": 300, "C": 315, "M": 330, "A": 345, "5": 555, "6": 666, "7": 777, "8": 888, "!": 999 };
+
+/**
+    * @param {string} pathdata - PathData from ADOFAI
+    * @returns {Array<number>} Converted AngleData
+*/
+function parseToangleData(pathdata: string): number[] {
+    let pt = Array.from(String(pathdata));
+    let result: number[] = pt.map(t => (pathDataTable as Record<string, number>)[t]);
+    return result;
+}
+
+export default {
+    pathDataTable,
+    parseToangleData
+}

package/src/presets.ts

@@ -0,0 +1,85 @@
+export interface Preset {
+    type: 'include'|'exclude'|"special";
+    events: string[];
+    [key: string]: any;
+}
+
+export const preset_noeffect: Preset = {
+    type: 'exclude', events: [
+        'Flash',
+        'SetFilter',
+        'SetFilterAdvanced',
+        'HallOfMirrors',
+        'Bloom',
+        'ScalePlanets',
+        'ScreenTile',
+        'ScreenScroll',
+        'ShakeScreen'
+    ]
+};
+
+export const preset_noholds: Preset = {
+    type: 'exclude', events: [
+        'Hold',
+    ]
+}
+
+export const preset_nomovecamera: Preset = {
+    type: 'exclude', events: [
+        'MoveCamera',
+    ]
+}
+
+export const preset_noeffect_completely: Preset = {
+    type: 'exclude', events: [
+        "AddDecoration",
+        "AddText",
+        "AddObject",
+        "Checkpoint",
+        "SetHitsound",
+        "PlaySound",
+        "SetPlanetRotation",
+        "ScalePlanets",
+        "ColorTrack",
+        "AnimateTrack",
+        "RecolorTrack",
+        "MoveTrack",
+        "PositionTrack",
+        "MoveDecorations",
+        "SetText",
+        "SetObject",
+        "SetDefaultText",
+        "CustomBackground",
+        "Flash",
+        "MoveCamera",
+        "SetFilter",
+        "HallOfMirrors",
+        "ShakeScreen",
+        "Bloom",
+        "ScreenTile",
+        "ScreenScroll",
+        "SetFrameRate",
+        "RepeatEvents",
+        "SetConditionalEvents",
+        "EditorComment",
+        "Bookmark",
+        "Hold",
+        "SetHoldSound",
+        //"MultiPlanet",
+        //"FreeRoam",
+        //"FreeRoamTwirl",
+        //"FreeRoamRemove",
+        "Hide",
+        "ScaleMargin",
+        "ScaleRadius"
+    ]
+}
+
+export const preset_inner_no_deco: Preset = {
+    type: "special", events: [
+        "MoveDecorations",
+        "SetText",
+        "SetObject",
+        "SetDefaultText"
+    ]
+}