simc-ast-builder/dist/index.js

Parser and AST generator for SimulationCraft files

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConditionOptimizer = void 0;
exports.generateAST = generateAST;
exports.optimize = optimize;
exports.parse = parse;
const parser_1 = require("./parser");
const types_1 = require("./types");
const ConditionOptimizer_1 = require("./utils/ConditionOptimizer");
/**
 * Generate an Abstract Syntax Tree (AST) from SimC code with optimization
 *
 * @param input - The SimC code to parse
 * @param options - Parser options
 * @returns A SyntaxTree containing the parsed AST and any errors
 *
 * @example
 * ```typescript
 * import { generateAST } from 'simc-parser';
 *
 * const code = 'actions=frost_strike,if=runic_power>=80';
 * const result = generateAST(code);
 * console.log(result.root);
 * ```
 */
function generateAST(input, options = {}) {
    try {
        // Parse the input
        const ast = parse(input);
        // Apply optimizations based on options
        const optimizationOptions = options.optimizations;
        // Apply optimizations with provided options or default behavior
        // If the enabled flag is explicitly set to false, skip optimization
        const skipOptimization = (optimizationOptions === null || optimizationOptions === void 0 ? void 0 : optimizationOptions.enabled) === false;
        const optimizedAst = skipOptimization
            ? ast
            : optimize(ast, optimizationOptions || types_1.DEFAULT_OPTIMIZER_OPTIONS);
        return {
            errors: [], // We'll collect any errors in the real implementation
            root: optimizedAst,
        };
    }
    catch (error) {
        // Handle parsing errors
        return {
            errors: [
                {
                    message: error instanceof Error ? error.message : String(error),
                    severity: "error",
                },
            ],
            root: {
                kind: "error",
                message: error instanceof Error ? error.message : String(error),
            },
        };
    }
}
/**
 * Optimize an AST node (primarily for condition optimization)
 *
 * @param node - The AST node to optimize
 * @param options - Optimization options
 * @returns The optimized AST node
 *
 * @example
 * ```typescript
 * import { parse, optimize } from 'simc-parser';
 *
 * const code = 'actions=frost_strike,if=runic_power>=80&(buff.killing_machine.up|!talent.obliteration)';
 * const ast = parse(code);
 *
 * // Optimize with default options
 * const optimizedAst = optimize(ast);
 *
 * // With specific optimization options
 * const customOptimizedAst = optimize(ast, {
 *   doubleNegation: true,
 *   deMorgansLaw: false,
 *   commonSubexpressions: true
 * });
 * ```
 */
function optimize(node, options = types_1.DEFAULT_OPTIMIZER_OPTIONS) {
    try {
        const optimizer = new ConditionOptimizer_1.ConditionOptimizer(options);
        // Only optimize expression nodes
        if (node.kind === "expression") {
            return optimizer.optimize(node);
        }
        return node;
    }
    catch (error) {
        // In case of error, return the original node
        return node;
    }
}
/**
 * Parse SimC code into an AST without optimization
 *
 * @param input - The SimC code to parse
 * @returns The parsed AST node
 *
 * @example
 * ```typescript
 * import { parse } from 'simc-parser';
 *
 * const code = 'actions=frost_strike,if=runic_power>=80';
 * const ast = parse(code);
 * console.log(ast);
 * ```
 */
function parse(input) {
    try {
        const parser = new parser_1.Parser();
        return parser.parse(input);
    }
    catch (error) {
        // In case of error, return a basic error node
        return {
            kind: "error",
            message: error instanceof Error ? error.message : String(error),
        };
    }
}
/**
 * Streamlined exports for main API surface
 */
__exportStar(require("./parser"), exports);
__exportStar(require("./types"), exports);
var ConditionOptimizer_2 = require("./utils/ConditionOptimizer");
Object.defineProperty(exports, "ConditionOptimizer", { enumerable: true, get: function () { return ConditionOptimizer_2.ConditionOptimizer; } });
//# sourceMappingURL=index.js.map